

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Ricerca di volti in una raccolta in streaming video
<a name="collections-streaming"></a>

È possibile utilizzare Video Amazon Rekognition per rilevare e riconoscere i volti da una raccolta in streaming video. Con Amazon Rekognition Video puoi creare uno stream processor [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)() per avviare e gestire l'analisi dei video in streaming. 

Per rilevare un volto noto in un flusso video (ricerca di volti), Video Amazon Rekognition utilizza Flusso di video Amazon Kinesis per ricevere ed elaborare un flusso video. I risultati delle analisi vengono generati da Video Amazon Rekognition a un flusso di dati Kinesis e quindi letti dall'applicazione client. 

Per usare Video Amazon Rekognition con un video in streaming, l'applicazione deve implementare quanto segue:
+ Un flusso video Kinesis per l'invio di video in streaming ad Video Amazon Rekognition. Per ulteriori informazioni, consulta la [Guida per gli sviluppatori di Flusso di video Amazon Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/what-is-kinesis-video.html). 
+ Un elaboratore di flussi Video Amazon Rekognition per gestire l'analisi del video in streaming. Per ulteriori informazioni, consulta [Panoramica delle operazioni del processore di streaming Video Amazon Rekognition](streaming-video.md#using-rekognition-video-stream-processor).
+ Un utente di Kinesis Data Stream per leggere i risultati dell'analisi che Video Amazon Rekognition invia al flusso di dati Kinesis. Per ulteriori informazioni, consulta [Utenti di Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/amazon-kinesis-consumers.html). 

Questa sezione contiene informazioni sulla scrittura di un'applicazione che crea lo il flusso video Kinesis e altre risorse necessarie, trasmette video in Video Amazon Rekognition e riceve i risultati dell'analisi.

**Topics**
+ [Configurazione delle risorse Video Amazon Rekognition e Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md)
+ [Ricerca di volti in un video in streaming](rekognition-video-stream-processor-search-faces.md)
+ [Streaming tramite un GStreamer plugin](streaming-using-gstreamer-plugin.md)
+ [Risoluzione dei problemi dello streaming di video](streaming-video-troubleshooting.md)

# Configurazione delle risorse Video Amazon Rekognition e Amazon Kinesis
<a name="setting-up-your-amazon-rekognition-streaming-video-resources"></a>

 Le seguenti procedure descrivono i passaggi da seguire per effettuare il provisioning del flusso video Kinesis e altre risorse utilizzate per riconoscere i volti in un video in streaming.

## Prerequisiti
<a name="streaming-video-prerequisites"></a>

Per eseguire questa procedura, è necessario aver installato il. AWS SDK per Java Per ulteriori informazioni, consulta [Nozioni di base su Amazon Rekognition](getting-started.md). Il dispositivo Account AWS che usi deve disporre delle autorizzazioni di accesso all'API Amazon Rekognition. Per ulteriori informazioni, consulta la sezione [Operazioni definite da Amazon Rekognition](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions) nella *Guida per l'utente IAM*. 

**Per riconoscere volti in un flusso video (SDK AWS)**

1. Se non l'hai già fatto, crea un ruolo di servizio IAM per consentire ad Video Amazon Rekognition di accedere ai tuoi flussi video Kinesis e ai tuoi flussi di dati Kinesis. Prendi nota dell'ARN. Per ulteriori informazioni, consulta [Concedere l'accesso agli stream utilizzando AmazonRekognitionServiceRole](api-streaming-video-roles.md#api-streaming-video-roles-all-stream).

1. [Creare una raccolta](create-collection-procedure.md) e prendere nota dell'identificatore di raccolta utilizzato.

1. [Indicizzare i volti](add-faces-to-collection-procedure.md) che si desidera cercare nella raccolta creata alla fase 2.

1. [Crea un flusso video Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/gs-createstream.html) e prendi nota del relativo nome della risorsa Amazon (ARN).

1. [Crea un flusso di dati Kinesis](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html). Anteponi il nome dello stream con *AmazonRekognition*e annota l'ARN dello stream.

Puoi quindi [creare l'elaboratore di flussi per la ricerca di volti](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor) e [avviarlo](rekognition-video-stream-processor-search-faces.md#streaming-video-starting-stream-processor) usando il nome dell'elaboratore di flussi che hai scelto.

**Nota**  
 È consigliabile avviare l'elaboratore di flussi solo dopo aver verificato la possibilità di importare contenuti multimediali nel flusso video Kinesis. 

## Streaming di video in Video Amazon Rekognition
<a name="video-streaming-kinesisvideostreams-stream"></a>

Per lo streaming di video in Video Amazon Rekognition, utilizzerai l'SDK di Flusso di video Amazon Kinesis per creare e utilizzare un flusso video Kinesis. L'operazione `PutMedia` scrive *frammenti* di dati video in un flusso video Kinesis utilizzato da Video Amazon Rekognition. Ogni frammento di dati video dura in genere da 2 a 10 secondi e contiene una sequenza compatta di fotogrammi video. Video Amazon Rekognition supporta video con codifica H.264, che possono avere tre tipi di fotogrammi (I, B e P). Per ulteriori informazioni, consulta [Interframe](https://en.wikipedia.org/wiki/Inter_frame). Il primo fotogramma nel frammento deve essere un fotogramma I. Un fotogramma I può essere decodificato indipendentemente da qualsiasi altro fotogramma. 

Man mano che i dati video giungono nel flusso video Kinesis, Kinesis Video Streams assegna un numero univoco al frammento. [Per un esempio, vedi PutMedia Esempio di API.](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html)
+  Se stai eseguendo lo streaming da una sorgente codificata Matroska (MKV), usa l'[PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)operazione per trasmettere il video sorgente nel flusso video Kinesis che hai creato. [Per ulteriori informazioni, consulta Esempio di API. PutMedia ](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html) 
+  Se stai eseguendo lo streaming dalla fotocamera di un dispositivo, consulta [Streaming tramite un GStreamer plugin](streaming-using-gstreamer-plugin.md).

# Concessione ad Video Amazon Rekognition dell'accesso alle risorse
<a name="api-streaming-video-roles"></a>

Utilizzi un ruolo di servizio AWS Identity and Access Management (IAM) per consentire ad Amazon Rekognition Video l'accesso in lettura ai flussi video Kinesis. Se utilizzi un elaboratore di flussi per la ricerca di volti, utilizzi un ruolo di servizio IAM per consentire ad Video Amazon Rekognition l'accesso in scrittura ai flussi di dati Kinesis. Se utilizzi un elaboratore di flussi per il monitoraggio della sicurezza, utilizzi i ruoli IAM per consentire ad Video Amazon Rekognition di accedere al tuo bucket Amazon S3 e a un argomento di Amazon SNS.

## Concessione dell'accesso agli elaboratori di flussi per la ricerca di volti
<a name="api-streaming-video-roles-single-stream"></a>

Puoi creare una policy di autorizzazione che consenta ad Video Amazon Rekognition di accedere ai singoli flussi video Kinesis e ai flussi di dati Kinesis.

**Per consentire ad Video Amazon Rekognition di accedere a un elaboratore di flussi per la ricerca di volti**

1. [ Crea una nuova policy di autorizzazione con l'editor delle policy JSON IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) e utilizza la policy seguente. Sostituisci `video-arn` con l'ARN del flusso video Kinesis desiderato. Se utilizzi un elaboratore di flussi per la ricerca di volti, sostituisci `data-arn` con l'ARN del flusso di dati Kinesis desiderato.

1. [Crea un ruolo di servizio IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console) o aggiornane uno esistente. Per creare il ruolo di servizio IAM, utilizza le informazioni seguenti:

   1. Scegli **Rekognition** come nome del servizio.

   1. Scegli **Rekognition** come caso d'uso del ruolo del servizio.

   1. Collega la policy di autorizzazione creata nella fase 1.

1. Prendere nota dell'ARN del ruolo del servizio. necessario per avviare le operazioni di analisi video.

## Concedere l'accesso agli stream utilizzando AmazonRekognitionServiceRole
<a name="api-streaming-video-roles-all-stream"></a>

 Come opzione alternativa per configurare l'accesso ai flussi video e ai flussi di dati di Kinesis, puoi utilizzare la policy di autorizzazione `AmazonRekognitionServiceRole`. IAM fornisce il caso d'uso del ruolo di servizio *Rekognition* che, se usato con la policy di autorizzazione `AmazonRekognitionServiceRole`, è in grado di scrivere su più flussi di dati Kinesis e leggere da tutti i flussi video Kinesis. Per consentire ad Amazon Rekognition Video l'accesso in scrittura a più flussi di dati Kinesis, puoi anteporre ai nomi dei flussi di dati Kinesis —ad esempio,. *AmazonRekognition*`AmazonRekognitionMyDataStreamName` 

**Per consentire ad Video Amazon Rekognition di accedere al flusso video Kinesis e al flusso di dati Kinesis**

1. [Crea un ruolo di servizio IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console). Per creare il ruolo di servizio IAM, utilizza le informazioni seguenti:

   1. Scegli **Rekognition** come nome del servizio.

   1. Scegli **Rekognition** come caso d'uso del ruolo del servizio.

   1. Scegli la politica di **AmazonRekognitionServiceRole**autorizzazione, che consente ad Amazon Rekognition Video di accedere in scrittura ai flussi di dati Kinesis con *AmazonRekognition*prefisso e accesso in lettura a tutti i tuoi flussi video Kinesis.

1. Per garantire la tua Account AWS sicurezza, limita l'ambito di accesso di Rekognition alle sole risorse che stai utilizzando. Questo può essere fatto associando una policy di attendibilità al ruolo di servizio IAM. Per informazioni su come fare, consulta [Prevenzione del problema "confused deputy" tra servizi](cross-service-confused-deputy-prevention.md).

1. Prendere nota del valore nome della risorsa Amazon (ARN) del ruolo di servizio, necessario per avviare le operazioni di analisi video.

# Ricerca di volti in un video in streaming
<a name="rekognition-video-stream-processor-search-faces"></a>

Video Amazon Rekognition può cercare i volti in una raccolta che corrispondono a quelli rilevati in un video in streaming. Per ulteriori informazioni sulle raccolte, consulta [Ricerca di volti in una raccolta](collections.md).

**Topics**
+ [Creazione dell'elaboratore di flussi per la ricerca di volti Video Amazon Rekognition](#streaming-video-creating-stream-processor)
+ [Avvio dell'elaboratore di flussi per la ricerca di volti Video Amazon Rekognition](#streaming-video-starting-stream-processor)
+ [Utilizzo dell'elaboratore di flussi per la ricerca di volti (esempio Java V2)](#using-stream-processors-v2)
+ [Utilizzo dell'elaboratore di flussi per la ricerca di volti (esempio Java V1)](#using-stream-processors)
+ [Lettura dei risultati delle analisi di video in streaming](streaming-video-kinesis-output.md)
+ [Visualizzazione locale dei risultati di Rekognition con Kinesis Video Streams](displaying-rekognition-results-locally.md)
+ [Comprendere il frame record JSON di riconoscimento facciale Kinesis](streaming-video-kinesis-output-reference.md)

Il seguente diagramma mostra in che modo Video Amazon Rekognition rileva e riconosce i volti in un video in streaming.

![\[Diagramma del flusso di lavoro per l'utilizzo di Amazon Rekognition Video per elaborare flussi video da Amazon Kinesis.\]](http://docs.aws.amazon.com/it_it/rekognition/latest/dg/images/VideoRekognitionStream.png)


## Creazione dell'elaboratore di flussi per la ricerca di volti Video Amazon Rekognition
<a name="streaming-video-creating-stream-processor"></a>

Prima di poter analizzare un video in streaming, devi creare uno stream processor Amazon Rekognition Video (). [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html) L'elaboratore di flussi contiene informazioni sul flusso di dati Kinesis e sul flusso video Kinesis. Contiene inoltre l'identificatore della raccolta che include i volti da riconoscere nel video in streaming di input. È inoltre necessario specificare un nome per l'elaboratore di flussi. Di seguito è riportato un esempio di JSON per la richiesta `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
              }
       }
}
```

Di seguito è riportata una risposta di esempio da `CreateStreamProcessor`.

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

## Avvio dell'elaboratore di flussi per la ricerca di volti Video Amazon Rekognition
<a name="streaming-video-starting-stream-processor"></a>

Per iniziare ad analizzare il video in streaming, chiamare [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html) con il nome dell'elaboratore di flussi specificato in `CreateStreamProcessor`. Di seguito è riportato un esempio di JSON per la richiesta `StartStreamProcessor`.

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

All'avvio dell'elaboratore di flussi viene restituita una risposta HTTP 200, insieme a un corpo JSON vuoto.

## Utilizzo dell'elaboratore di flussi per la ricerca di volti (esempio Java V2)
<a name="using-stream-processors-v2"></a>

Il codice di esempio seguente mostra come chiamare varie operazioni dello stream processor, ad esempio [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)e [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html), utilizzando l' AWS SDK for Java versione 2.

Questo codice è tratto dal repository degli esempi GitHub di AWS Documentation SDK. Guarda l'esempio completo [qui](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.");
    }
}
```

## Utilizzo dell'elaboratore di flussi per la ricerca di volti (esempio Java V1)
<a name="using-stream-processors"></a>

Il codice di esempio seguente mostra come chiamare varie operazioni dello stream processor, ad esempio [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)and [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html), utilizzando Java V1. L'esempio include una classe stream processor manager (StreamManager) che fornisce metodi per chiamare le operazioni dello stream processor. La classe starter (Starter) crea un StreamManager oggetto e chiama varie operazioni. 

**Per configurare l'esempio:**

1. Impostare i valori dei campi membro della classe Starter sui valori desiderati.

1. Nella funzione classe Starter `main`, rimuovere il commento dalla chiamata della funzione desiderata.

### 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());
        }
    }
}
```

# Lettura dei risultati delle analisi di video in streaming
<a name="streaming-video-kinesis-output"></a>

È possibile utilizzare la libreria del client di Flusso di dati Amazon Kinesis per utilizzare i risultati delle analisi inviati al flusso di output di Flusso di dati Amazon Kinesis. Per ulteriori informazioni, consulta [Lettura di dati da un flusso di dati Kinesis](https://docs.aws.amazon.com/streams/latest/dev/building-consumers.html). Video Amazon Rekognition posiziona un record di fotogramma JSON per ogni fotogramma analizzato nel flusso di output di Kinesis. Video Amazon Rekognition non analizza tutti i fotogrammi che gli vengono trasmessi tramite il flusso video Kinesis. 

Un record di fotogramma inviato a un flusso di dati Kinesis contiene informazioni sul frammento del flusso video Kinesis in cui si trova il fotogramma, la sua posizione nel frammento e i volti riconosciuti al suo interno. Include inoltre le informazioni sullo stato dell'elaboratore di flussi. Per ulteriori informazioni, consulta [Comprendere il frame record JSON di riconoscimento facciale Kinesis](streaming-video-kinesis-output-reference.md).

La libreria parser di Flusso di video Amazon Kinesis contiene test di esempio che utilizzano i risultati di Video Amazon Rekognition e li integra con il flusso video Kinesis originale. Per ulteriori informazioni, consulta [Visualizzazione locale dei risultati di Rekognition con Kinesis Video Streams](displaying-rekognition-results-locally.md).

Video Amazon Rekognition trasmette le informazioni delle analisi di Video Amazon Rekognition al flusso di dati Kinesis. Di seguito è riportato un esempio di JSON per un singolo record. 

```
{
  "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"
          }
        }
      ]
    }
  ]
}
```

Nell'esempio JSON, tenere presente quanto segue:
+ **InputInformation**— Informazioni sullo stream video Kinesis utilizzato per lo streaming di video in Amazon Rekognition Video. Per ulteriori informazioni, consulta [InputInformation](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-inputinformation).
+ **StreamProcessorInformation**— Informazioni sullo stato dello stream processor Amazon Rekognition Video. L'unico valore possibile per il campo `Status` è RUNNING. Per ulteriori informazioni, consulta [StreamProcessorInformation](streaming-video-kinesis-output-reference-streamprocessorinformation.md).
+ **FaceSearchResponse**— Contiene informazioni sui volti nel video in streaming che corrispondono ai volti nella raccolta di input. [FaceSearchResponse](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-facesearchresponse)contiene un [DetectedFace](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-detectedface) oggetto, ossia un volto rilevato nel fotogramma video analizzato. Per ogni volto rilevato, la matrice `MatchedFaces` contiene una serie di oggetti di volti corrispondenti ([MatchedFace](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-facematch)) individuati nella raccolta di input, oltre a un punteggio di somiglianza. 

## Mappatura del flusso video Kinesis al flusso di dati Kinesis
<a name="mapping-streams"></a>

È possibile mappare i fotogrammi del flusso video Kinesis ai fotogrammi analizzati inviati al flusso di dati Kinesis. Ad esempio, durante la visualizzazione di un video in streaming, è possibile visualizzare riquadri intorno ai volti delle persone riconosciute. Le coordinate del riquadro di delimitazione vengono inviate come parte del record di riconoscimento del volto Kinesis al flusso di dati Kinesis. Per visualizzare correttamente il riquadro di delimitazione, è necessario mappare le informazioni di data e ora inviate al record di riconoscimento del volto Kinesis ai corrispondenti fotogrammi nel flusso video Kinesis di origine.

La tecnica utilizzata per mappare il flusso video Kinesis al flusso di dati Kinesis varia a seconda che si riproducano in streaming file multimediali live (ad esempio, un video in streaming live) oppure file multimediali archiviati (ad esempio, un video memorizzato).

### Mappatura in caso di streaming di file multimediali live
<a name="mapping-streaming-video"></a>

**Per mappare un fotogramma del flusso video Kinesis a un fotogramma del flusso di dati Kinesis**

1. Imposta il parametro `FragmentTimeCodeType` di input dell'[PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)operazione su`RELATIVE`. 

1. Chiamare `PutMedia` per trasmettere contenuti multimediali live nel flusso video Kinesis.

1. Quando si riceve un record di riconoscimento del volto Kinesis dal flusso di dati Kinesis, archiviare i valori di `ProducerTimestamp` e `FrameOffsetInSeconds` dal campo [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo).

1. Calcolare il timestamp corrispondente al fotogramma del flusso video Kinesis aggiungendo insieme i valori dei campi `ProducerTimestamp` e `FrameOffsetInSeconds`. 

### Mappatura in caso di streaming di file multimediali archiviati
<a name="map-stored-video"></a>

**Per mappare un fotogramma del flusso video Kinesis a un fotogramma del flusso di dati Kinesis**

1. Chiama [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)per inviare contenuti multimediali archiviati nel flusso video Kinesis.

1. Quando si riceve un oggetto `Acknowledgement` dalla risposta dell'operazione `PutMedia`, archiviare il valore del campo `FragmentNumber` dal campo [Payload](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html#API_dataplane_PutMedia_ResponseSyntax). `FragmentNumber` è il numero di frammento per il cluster MKV. 

1. Quando si riceve un record di riconoscimento del volto Kinesis dal flusso di dati Kinesis, archiviare il valore del campo `FrameOffsetInSeconds` dal campo [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo). 

1. Calcolare la mappatura utilizzando i valori `FrameOffsetInSeconds` e `FragmentNumber` archiviati nelle fasi 2 e 3. `FrameOffsetInSeconds` è l'offset nel frammento con il valore `FragmentNumber` specifico inviato al flusso di dati Amazon Kinesis. Per ulteriori informazioni su come ottenere i fotogrammi video per un numero di frammento specifico, consulta [File multimediali archiviati di Flusso di video Amazon Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_Operations_Amazon_Kinesis_Video_Streams_Archived_Media.html).

# Visualizzazione locale dei risultati di Rekognition con Kinesis Video Streams
<a name="displaying-rekognition-results-locally"></a>

 [Puoi vedere i risultati di Amazon Rekognition Video visualizzati nel tuo feed da Amazon Kinesis Video Streams utilizzando i test di esempio di Amazon Kinesis Video Streams Parser Library forniti all'indirizzo - Rekognition Examples. KinesisVideo ](https://github.com/aws/amazon-kinesis-video-streams-parser-library#kinesisvideo---rekognition-examples) `KinesisVideoRekognitionIntegrationExample`Visualizza dei riquadri di delimitazione sui volti rilevati e rende il video localmente. JFrame Questo processo presuppone che tu abbia collegato correttamente un ingresso multimediale dalla fotocamera di un dispositivo a un flusso video Kinesis e avviato un elaboratore di flussi Amazon Rekognition. Per ulteriori informazioni, consulta [Streaming tramite un GStreamer plugin](streaming-using-gstreamer-plugin.md). 

## Fase 1: installazione della libreria parser Kinesis Video Streams
<a name="step-1-install-parser-library"></a>

 Per creare una directory e scaricare il repository Github, esegui il seguente comando: 

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

 Vai alla directory della libreria ed esegui il seguente comando Maven per eseguire un'installazione pulita: 

```
$ mvn clean install
```

## Fase 2: configurazione del test di esempio di integrazione tra Kinesis Video Streams e Rekognition
<a name="step-2-configure-kinesis-video-rekognition-example-test"></a>

 Apri il file `KinesisVideoRekognitionIntegrationExampleTest.java`. Rimuovi `@Ignore` subito dopo l'intestazione della classe. Compila i campi dati con le informazioni delle tue risorse Amazon Kinesis e Amazon Rekognition. Per ulteriori informazioni, consulta [Configurazione delle risorse Video Amazon Rekognition e Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md). Se stai trasmettendo video in streaming al flusso video Kinesis, rimuovi il parametro `inputStream`. 

 Consulta l'esempio di codice seguente: 

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

## Fase 3: esecuzione del test di esempio di integrazione tra Kinesis Video Streams e Rekognition
<a name="step-3-run-kinesis-video-rekognition-example-test"></a>

 Assicurati che il tuo flusso video Kinesis riceva input multimediali se stai trasmettendo ad esso e inizia ad analizzare il flusso con un elaboratore di flussi Video Amazon Rekognition in esecuzione. Per ulteriori informazioni, consulta [Panoramica delle operazioni del processore di streaming Video Amazon Rekognition](streaming-video.md#using-rekognition-video-stream-processor). Esegui la `KinesisVideoRekognitionIntegrationExampleTest` lezione come test. JUnit Dopo un breve ritardo, si apre una nuova finestra con un feed video del flusso video Kinesis con riquadri di delimitazione disegnati sui volti rilevati. 

**Nota**  
 I volti della raccolta utilizzata in questo esempio devono avere un ID immagine esterno (il nome del file) specificato in questo formato affinché le etichette dei riquadri di delimitazione visualizzino un testo significativo: PersonName 1-Trusted, PersonName 2-Intruder, 3-Neutral, ecc. PersonName Le etichette possono anche essere codificate a colori e sono personalizzabili nel file.java. FaceType 

# Comprendere il frame record JSON di riconoscimento facciale Kinesis
<a name="streaming-video-kinesis-output-reference"></a>

Video Amazon Rekognition può riconoscere i volti in un video in streaming. Per ogni fotogramma analizzato, Video Amazon Rekognition invia un record di fotogramma JSON a un flusso di dati Kinesis. Video Amazon Rekognition non analizza tutti i fotogrammi che gli vengono trasmessi tramite il flusso video Kinesis. 

Il record di fotogramma JSON contiene informazioni sul flusso di input e output, sullo stato dell'elaboratore di flussi e informazioni sui volti riconosciuti nel fotogramma analizzato. Questa sezione contiene informazioni di riferimento per il record di fotogramma JSON.

Di seguito è riportata la sintassi JSON per un record di flusso di dati Kinesis. Per ulteriori informazioni, consulta [Utilizzo degli eventi video in streaming](streaming-video.md).

**Nota**  
L'API Video Amazon Rekognition funziona confrontando i volti nel flusso di input con una raccolta di volti e restituendo le corrispondenze trovate più vicine, insieme a un punteggio di somiglianza.

```
{
    "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"
                    }
                }
            ]
        }
    ]
}
```

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

Il record JSON include informazioni su un fotogramma elaborato da Video Amazon Rekognition. Il record include informazioni sul video in streaming, lo stato del fotogramma analizzato e informazioni sui volti riconosciuti nel fotogramma.

**InputInformation**

Informazioni sul flusso video Kinesis utilizzato per lo streaming di video in Video Amazon Rekognition.

Tipo: oggetto [InputInformation](#streaming-video-kinesis-output-reference-inputinformation)

**StreamProcessorInformation**

Informazioni sull'elaboratore di flussi di Video Amazon Rekognition. Sono incluse le informazioni sullo stato attuale dell'elaboratore di flussi.

Tipo: oggetto [StreamProcessorInformation](streaming-video-kinesis-output-reference-streamprocessorinformation.md) 

**FaceSearchResponse**

Informazioni sui volti rilevati in un fotogramma video in streaming e i volti corrispondenti trovati nella raccolta di input.

Tipo: array di oggetti [FaceSearchResponse](#streaming-video-kinesis-output-reference-facesearchresponse)

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

Informazioni su un flusso video di origine utilizzato da Video Amazon Rekognition. Per ulteriori informazioni, consulta [Utilizzo degli eventi video in streaming](streaming-video.md).

**KinesisVideo**

Tipo: oggetto [KinesisVideo](#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo)

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

Informazioni sul flusso video Kinesis che esegue lo streaming del video di origine in Video Amazon Rekognition. Per ulteriori informazioni, consulta [Utilizzo degli eventi video in streaming](streaming-video.md).

**StreamArn**

Il nome della risorsa Amazon (ARN) del flusso video Kinesis.

Tipo: String 

**FragmentNumber**

Frammento del video in streaming che contiene il fotogramma rappresentato da questo record.

Tipo: String

**ProducerTimestamp**

Time stamp Unix lato produttore del frammento. Per ulteriori informazioni, consulta [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Tipo: numero

**ServerTimestamp**

Time stamp Unix lato server del frammento. Per ulteriori informazioni, consulta [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Tipo: numero

**FrameOffsetInSeconds**

Offset del fotogramma (in secondi) all'interno del frammento.

Tipo: numero 

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

Informazioni di stato sull'elaboratore di flussi.

**Stato**

Stato corrente dell'elaboratore di flussi. Un valore possibile è RUNNING.

Tipo: String

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

Informazioni su un volto rilevato in un fotogramma video in streaming e sui volti in una raccolta che corrispondono al volto rilevato. La raccolta viene specificata in una chiamata a [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html). Per ulteriori informazioni, consulta [Utilizzo degli eventi video in streaming](streaming-video.md). 

**DetectedFace**

I dettagli di un volto rilevato in un fotogramma video analizzato.

Tipo: oggetto [DetectedFace](#streaming-video-kinesis-output-reference-detectedface)

**MatchedFaces**

Una matrice di dettagli di volti per i volti in una raccolta corrispondente al volto rilevato in `DetectedFace`.

Tipo: array di oggetti [MatchedFace](#streaming-video-kinesis-output-reference-facematch)

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

Informazioni su un volto rilevato in un fotogramma di un video in streaming. I volti corrispondenti nella raccolta di input sono disponibili nel campo oggetto [MatchedFace](#streaming-video-kinesis-output-reference-facematch).

**BoundingBox**

Coordinate della cornice per un volto rilevato in un fotogramma di un video analizzato. L' BoundingBox oggetto ha le stesse proprietà dell' BoundingBox oggetto utilizzato per l'analisi delle immagini.

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

**Confidence**

Il livello di confidenza (1-100) che Video Amazon Rekognition ha sul fatto che il volto rilevato sia effettivamente un volto. 1 è la confidenza più bassa, 100 è la più alta.

Tipo: numero

**Landmarks**

Matrice di punti di riferimento del volto.

Tipo: matrice di oggetti [Landmark](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Landmark.html)

**Posa**

Indica la posa del volto definita da beccheggio, rollio e imbardata.

Tipo: oggetto [Pose](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Pose.html)

**Qualità**

Identifica la luminosità e la nitidezza dell'immagine del volto. 

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

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

Informazioni su un volto che corrisponde a un volto rilevato in un fotogramma video analizzato.

**Face**

Informazioni di corrispondenza per un volto nella raccolta di input che corrisponde al volto rilevato nell'oggetto [DetectedFace](#streaming-video-kinesis-output-reference-detectedface). 

Tipo: oggetto [Face](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Face.html) 

**Somiglianza**

Il livello di confidenza (1-100) sul fatto che i volti corrispondano. 1 è la confidenza più bassa, 100 è la più alta.

Tipo: numero 

# Streaming tramite un GStreamer plugin
<a name="streaming-using-gstreamer-plugin"></a>

Video Amazon Rekognition può analizzare un video in streaming live dalla fotocamera di un dispositivo. Per accedere all'input multimediale da una sorgente del dispositivo, è necessario installarlo GStreamer. GStreamer è un software framework multimediale di terze parti che collega fonti multimediali e strumenti di elaborazione nelle pipeline del flusso di lavoro. È inoltre necessario installare il [plugin Producer di Flusso di video Amazon Kinesis](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) per Gstreamer. Questo processo presuppone che tu abbia configurato correttamente le risorse Video Amazon Rekognition e Amazon Kinesis. Per ulteriori informazioni, consulta [Configurazione delle risorse Video Amazon Rekognition e Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md).

## Fase 1: installare Gstreamer
<a name="step-1-install-gstreamer"></a>

 Scarica e installa Gstreamer, un software di piattaforma multimediale di terze parti. Puoi utilizzare un software di gestione dei pacchetti come Homebrew ([Gstreamer su Homebrew](https://formulae.brew.sh/formula/gstreamer)) o scaricarlo direttamente [dal sito Web di Freedesktop](https://gstreamer.freedesktop.org/download/). 

 Verifica la corretta installazione di Gstreamer lanciando un feed video con un'origine di test dal tuo terminale della riga di comando. 

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

## Fase 2: installare il plugin Producer di Kinesis Video Streams
<a name="step-2-install-kinesis-video-plugin"></a>

 In questa sezione, scaricherai la [libreria Producer di Flusso di video Amazon Kinesis](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) e installerai il plugin Gstreamer di Kinesis Video Streams. 

 Crea una directory e clona il codice di origine dal repository GitHub. Assicurati di includere il parametro `--recursive`. 

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

Segui le [istruzioni fornite dalla libreria](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/README.md) per configurare e compilare il progetto. Assicurati di utilizzare i comandi specifici per la piattaforma per il sistema operativo in uso. Usa il parametro `-DBUILD_GSTREAMER_PLUGIN=ON` quando esegui `cmake` per installare il plugin Gstreamer di Kinesis Video Streams. Questo progetto richiede i seguenti pacchetti aggiuntivi inclusi nell'installazione: GCC o Clang, Curl, Openssl e Log4cplus. Se la compilazione non riesce a causa di un pacchetto mancante, verifica che il pacchetto sia installato e presente nel tuo PATH. Se riscontri l'errore "impossibile eseguire il programma compilato in C" durante la compilazione, esegui nuovamente il comando di compilazione. A volte, il compilatore C corretto non viene trovato. 

 Verifica l'installazione del plugin Kinesis Video Streams eseguendo il seguente comando. 

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

 Dovrebbero apparire le seguenti informazioni, come i dettagli di fabbrica e del plugin: 

```
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/
  
  ...
```

## Fase 3: esegui Gstreamer con il plugin Kinesis Video Streams
<a name="step-3-run-gstreamer-with-kinesis-video-plugin"></a>

 Prima di iniziare lo streaming dalla fotocamera di un dispositivo a Kinesis Video Streams, potrebbe essere necessario convertire l'origine multimediale in un codec accettabile per Kinesis Video Streams. Per determinare le specifiche e le funzionalità di formato dei dispositivi attualmente collegati al computer, esegui il seguente comando.

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

 Per iniziare lo streaming, avvia Gstreamer con il seguente comando di esempio e aggiungi le tue credenziali e le informazioni di Flusso di video Amazon Kinesis. Dovresti utilizzare le chiavi di accesso e la regione del ruolo di servizio IAM che hai creato [concedendo ad Amazon Rekognition l'accesso ai tuoi flussi Kinesis](https://docs.aws.amazon.com/rekognition/latest/dg/api-streaming-video-roles.html#api-streaming-video-roles-all-stream). Per ulteriori informazioni sulle chiavi di accesso, consulta [Gestione delle chiavi di accesso per gli utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) nella *Guida per l'utente IAM*. Inoltre, puoi regolare i parametri degli argomenti del formato video in base alle tue esigenze di utilizzo e disponibili sul tuo dispositivo. 

```
$ 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"
```

 Per ulteriori comandi di avvio, consulta [Esempi di comandi di GStreamer avvio](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-gstreamer-plugin.html#examples-gstreamer-plugin-launch). 

**Nota**  
 Se il comando di avvio termina con un errore di mancata negoziazione, controlla l'output dal monitor del dispositivo e assicurati che i valori del parametro `videoconvert` siano funzionalità valide del tuo dispositivo. 

 Dopo alcuni secondi, vedrai un feed video dalla fotocamera del tuo dispositivo sul flusso video di Kinesis. Per iniziare a rilevare e abbinare i volti con Amazon Rekognition, avvia l'elaboratore di flussi Video Amazon Rekognition. Per ulteriori informazioni, consulta [Panoramica delle operazioni del processore di streaming Video Amazon Rekognition](streaming-video.md#using-rekognition-video-stream-processor). 

# Risoluzione dei problemi dello streaming di video
<a name="streaming-video-troubleshooting"></a>

In questo argomento sono disponibili le informazioni per l'uso di Video Amazon Rekognition con i video in streaming.

**Topics**
+ [Non so se il processore di streaming è stato creato](#ts-streaming-video-create-sp)
+ [Non so se il processore di streaming è stato configurato correttamente](#ts-configured-sp)
+ [Il processore di streaming non restituisce risultati](#ts-streaming-video-no-results-from-sp)
+ [Lo stato del processore di streaming è FAILED](#ts-failed-state)
+ [Il processore di streaming non restituisce i risultati previsti](#w2aac27c79c27c15)

## Non so se il processore di streaming è stato creato
<a name="ts-streaming-video-create-sp"></a>

Usa il AWS CLI comando seguente per ottenere un elenco degli stream processor e il loro stato attuale.

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

È possibile ottenere ulteriori dettagli utilizzando il AWS CLI comando seguente. Sostituisci `stream-processor-name` con il nome processore di streaming desiderato.

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

## Non so se il processore di streaming è stato configurato correttamente
<a name="ts-configured-sp"></a>

Se il codice non restituisce i risultati dell'analisi di Video Amazon Rekognition, è possibile che l'elaboratore di flussi non sia configurato correttamente. Esegui le operazioni seguenti per verificare che il processore di streaming sia configurato correttamente e in grado di produrre risultati.

**Per determinare se la soluzione è stata configurata correttamente**

1. Eseguire il seguente comando per verificare che il processore di streaming sia in esecuzione. Sostituire `stream-processor-name` con il nome del processore di streaming. Il processore di streaming è in esecuzione se il valore di `Status` è `RUNNING`. Se lo stato è `RUNNING` e non vengono restituiti risultati, consultare [Il processore di streaming non restituisce risultati](#ts-streaming-video-no-results-from-sp). Se lo stato è `FAILED`, consultare [Lo stato del processore di streaming è FAILED](#ts-failed-state).

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

1. Se lo stream processor è in esecuzione, esegui il seguente PowerShell comando o Bash per leggere i dati dal flusso di dati Kinesis in uscita. 

   **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. Utilizzare lo [strumento di decodifica](https://www.base64decode.org/) sul sito Web di Base64 Decode per decodificare l'output in una stringa leggibile. Per ulteriori informazioni consultare [Fase 3: estrazione del record](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#get-records).

1. Se i comandi funzionano e i risultati del rilevamento facciale sono presenti nel flusso di dati Kinesis, la soluzione è configurata correttamente. Se il comando non riesce, verificare gli altri suggerimenti della risoluzione dei problemi e consultare [Concessione ad Video Amazon Rekognition dell'accesso alle risorse](api-streaming-video-roles.md).

In alternativa, puoi utilizzare il AWS Lambda modello "kinesis-process-record" per registrare i messaggi dal flusso di dati Kinesis CloudWatch per una visualizzazione continua. Ciò comporta costi aggiuntivi per e. AWS Lambda CloudWatch 

## Il processore di streaming non restituisce risultati
<a name="ts-streaming-video-no-results-from-sp"></a>

Il processore di streaming potrebbe non restituire risultati per diversi motivi. 

### Motivo 1: il processore di streaming non è configurato correttamente
<a name="w2aac27c79c27c11b5"></a>

Il processore di streaming potrebbe non essere configurato correttamente. Per ulteriori informazioni, consulta [Non so se il processore di streaming è stato configurato correttamente](#ts-configured-sp).

### Motivo 2: il processore di streaming non è nello stato RUNNING
<a name="w2aac27c79c27c11b7"></a>

**Per risolvere il problema dello stato del processore di streaming**

1. Controllate lo stato dello stream processor con il seguente AWS CLI comando.

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

1. Se il valore di `Status` è `STOPPED`, avviare del processore di streaming con il seguente comando:

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

1. Se il valore di `Status` è `FAILED`, consultare [Lo stato del processore di streaming è FAILED](#ts-failed-state).

1. Se il valore di `Status` è `STARTING`, attendere 2 minuti e controllare lo stato ripetendo la fase 1. Se il valore dello stato è ancora `STARTING`, procedere nel seguente modo:

   1. Eliminare il processore di streaming con il seguente comando.

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

   1. Creare un nuovo processore di streaming con la stessa configurazione. Per ulteriori informazioni, consulta [Utilizzo degli eventi video in streaming](streaming-video.md).

   1. Se i problemi persistono, contatta l' AWS assistenza.

1. Se il valore di `Status` è `RUNNING`, consultare [Motivo 3: non sono presenti dati attivi nel flusso video Kinesis](#ts-no-data).

### Motivo 3: non sono presenti dati attivi nel flusso video Kinesis
<a name="ts-no-data"></a>

**Per controllare se sono presenti dati attivi nel flusso video Kinesis**

1. Accedi a e apri Console di gestione AWS la console Amazon Kinesis Video [https://console.aws.amazon.com/kinesisvideo/](https://console.aws.amazon.com/kinesisvideo/)Streams all'indirizzo.

1. Seleziona il flusso video Kinesis che è l'input per l'elaboratore di flussi Amazon Rekognition.

1. Se l'anteprima indica **Dati non presenti nel flusso**, non sono presenti dati nel flusso di input per l'elaborazione di Video Amazon Rekognition.

Per informazioni su come produrre video con Kinesis Video Streams, consulta [Librerie Producer di Kinesis Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk.html). 

## Lo stato del processore di streaming è FAILED
<a name="ts-failed-state"></a>

Puoi controllare lo stato di uno stream processor utilizzando il seguente AWS CLI comando.

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

Se il valore dello stato è FAILED, verifica le informazioni della risoluzione dei problemi per i seguenti messaggi di errore.

### Errore di accesso negato al ruolo
<a name="w2aac27c79c27c13b9"></a>

Il ruolo IAM utilizzato dall'elaboratore di flussi non esiste o Video Amazon Rekognition non dispone dell'autorizzazione per assumere il ruolo.

**Per risolvere i problemi relativi all'accesso al ruolo IAM**

1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Dal riquadro di navigazione a sinistra, scegliere **Ruoli** e verificare che il ruolo esista. 

1. Se il ruolo esiste, verifica che il ruolo abbia la politica delle *AmazonRekognitionServiceRole*autorizzazioni.

1. Se il ruolo non esiste o non dispone delle autorizzazioni appropriate, vedere [Concessione ad Video Amazon Rekognition dell'accesso alle risorse](api-streaming-video-roles.md).

1. Avvia lo stream processor con il seguente AWS CLI comando.

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

### Errore di accesso negato a Kinesis Video *o* a Kinesis Data
<a name="w2aac27c79c27c13c11"></a>

Il ruolo non dispone dell'accesso alle operazioni API Kinesis Video Streams `GetMedia` e `GetDataEndpoint`. È inoltre possibile che non abbia accesso alle operazioni API Kinesis Data Streams `PutRecord` e `PutRecords`. 

**Per risolvere i problemi relativi alle autorizzazioni delle API**

1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Aprire il ruolo e verificare che sia collegata la seguente policy di autorizzazioni.

1. Se mancano le autorizzazioni, aggiornare la policy. Per ulteriori informazioni, consulta [Concessione ad Video Amazon Rekognition dell'accesso alle risorse](api-streaming-video-roles.md).

### Errore: «Lo stream *input-video-stream-name* non esiste»
<a name="w2aac27c79c27c13c13"></a>

L'input del flusso video Kinesis per l'elaboratore di flussi non esiste o non è configurato correttamente. 

**Per risolvere i problemi relativi al flusso video Kinesis**

1. Utilizzare il comando seguente per verificare che il flusso esista. 

   ```
   aws kinesisvideo list-streams
   ```

1. Se il flusso è presente, verificare quanto segue.
   + Il nome della risorsa Amazon (ARN) deve essere uguale all'ARN del flusso di input per il processore di streaming.
   + Il flusso video Kinesis è nella stessa regione dell'elaboratore di flussi.

   Se lo stream processor non è configurato correttamente, eliminalo con il seguente AWS CLI comando.

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

1. Creare un nuovo processore di streaming con il flusso video Kinesis desiderato. Per ulteriori informazioni, consulta [Creazione dell'elaboratore di flussi per la ricerca di volti Video Amazon Rekognition](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor).

### Errore di raccolta non trovata
<a name="w2aac27c79c27c13c15"></a>

La raccolta Amazon Rekognition utilizzata dall'elaboratore di flussi per il riconoscimento dei volti non esiste oppure viene utilizzata una raccolta non corretta.

**Per verificare la raccolta**

1. Utilizzate il AWS CLI comando seguente per determinare se esiste la raccolta richiesta. Passa `region` alla AWS regione in cui stai utilizzando lo stream processor.

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

   Se la raccolta non esiste, creare una nuova raccolta e aggiungere le informazioni per il riconoscimento facciale. Per ulteriori informazioni, consulta [Ricerca di volti in una raccolta](collections.md).

1. Nella chiamata a [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html), controllare che il valore del parametro di input `CollectionId` sia corretto.

1. Avvia lo stream processor con il seguente AWS CLI comando.

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

### Errore: «Stream *output-kinesis-data-stream-name* nell'account *account-id* non trovato»
<a name="w2aac27c79c27c13c17"></a>

Il flusso di dati Kinesis in uscita utilizzato dallo stream processor non esiste nella tua regione Account AWS o non si trova nella stessa AWS regione dello stream processor.

**Per risolvere i problemi relativi al flusso di dati Kinesis**

1. Usa il seguente AWS CLI comando per determinare se esiste il flusso di dati Kinesis. Passa `region` alla AWS regione in cui stai utilizzando lo stream processor.

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

1. Se il flusso di dati Kinesis esiste, verificare che il nome del flusso di dati Kinesis sia uguale al nome del flusso di output utilizzato dal processore di streaming.

1. Se il flusso di dati Kinesis non esiste, potrebbe esistere in un'altra AWS regione. Il flusso di dati Kinesis deve essere nella stessa regione del processore di streaming.

1. Se necessario, creare un nuovo flusso di dati Kinesis. 

   1. Creare un flusso di dati Kinesis con lo stesso nome del processore di flusso. Per ulteriori informazioni, consultare [Fase 1: creazione di un flusso di dati](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html).

   1. Avvia lo stream processor con il seguente AWS CLI comando.

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

## Il processore di streaming non restituisce i risultati previsti
<a name="w2aac27c79c27c15"></a>

Se il processore di streaming non restituisce le corrispondenze previste per il riconoscimento facciale, utilizza le seguenti informazioni.
+ [Ricerca di volti in una raccolta](collections.md)
+ [Raccomandazioni per le impostazioni della fotocamera (video in streaming)](recommendations-camera-streaming-video.md)