

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Búsqueda de rostros en una colección en streaming de vídeo
<a name="collections-streaming"></a>

Puede usar Amazon Rekognition Video para detectar y reconocer rostros de una colección en vídeo en streaming. Con Amazon Rekognition Video, puede crear un procesador de transmisión [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)() para iniciar y administrar el análisis de la transmisión de vídeo. 

Para detectar un rostro conocido en una transmisión de vídeo (búsqueda de rostros), Amazon Rekognition Video utiliza Amazon Kinesis Video Streams para recibir y procesar una transmisión de vídeo. Los resultados del análisis se envían de Amazon Rekognition Video a un flujo de datos de Kinesis y, a continuación, los lee la aplicación cliente. 

Para utilizar Amazon Rekognition Video con vídeo en streaming, la aplicación tiene que implementar lo siguiente:
+ Una transmisión de vídeo de Kinesis para enviar vídeo en streaming a Amazon Rekognition Video. Para obtener más información, consulte la [Guía para desarrolladores de Amazon Kinesis Vídeo Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/what-is-kinesis-video.html). 
+ Un procesador de streaming de Amazon Rekognition Video para administrar el análisis del vídeo en streaming. Para obtener más información, consulte [Descripción general de las operaciones del procesador de transmisión de Amazon Rekognition Video](streaming-video.md#using-rekognition-video-stream-processor).
+ Un consumidor de flujos de datos de Kinesis que lea los resultados de los análisis que Amazon Rekognition Video envía al flujo de datos de Kinesis. Para obtener más información, consulte [Kinesis Data Streams Consumers](https://docs.aws.amazon.com/streams/latest/dev/amazon-kinesis-consumers.html). 

Esta sección contiene información sobre cómo crear una aplicación que cree la transmisión de vídeo de Kinesis y otros recursos necesarios, transmita vídeo a Amazon Rekognition Video y reciba los resultados del análisis.

**Topics**
+ [Configuración de los recursos de Amazon Rekognition Video y Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md)
+ [Búsqueda de rostros en una transmisión de vídeo](rekognition-video-stream-processor-search-faces.md)
+ [Transmisión mediante un GStreamer complemento](streaming-using-gstreamer-plugin.md)
+ [Solución de problemas de vídeo en streaming](streaming-video-troubleshooting.md)

# Configuración de los recursos de Amazon Rekognition Video y Amazon Kinesis
<a name="setting-up-your-amazon-rekognition-streaming-video-resources"></a>

 Los siguientes procedimientos describen los pasos que debe seguir para aprovisionar la transmisión de vídeo de Kinesis y otros recursos que se utilizan para reconocer rostros en una transmisión de vídeo.

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

Para ejecutar este procedimiento, debe tener el instalado. AWS SDK para Java Para obtener más información, consulte [Introducción a Amazon Rekognition](getting-started.md). El Cuenta de AWS que utilices debe tener permisos de acceso a la API Amazon Rekognition. Para obtener más información, consulte [Acciones definidas por Amazon Rekognition](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions) en la *Guía del usuario de IAM*. 

**Para reconocer rostros en una transmisión de vídeo (AWS SDK)**

1. Si no lo ha hecho aún, cree un rol de servicio de IAM para otorgar a Amazon Rekognition Video acceso a sus transmisiones de vídeo de Kinesis y sus flujos de datos de Kinesis. Anote el ARN. Para obtener más información, consulte [Dar acceso a las transmisiones mediante AmazonRekognitionServiceRole](api-streaming-video-roles.md#api-streaming-video-roles-all-stream).

1. [Cree una colección](create-collection-procedure.md) y anote el identificador de la colección que haya utilizado.

1. [Indexe los rostros](add-faces-to-collection-procedure.md) que desee buscar en la colección que ha creado en el paso 2.

1. [Cree una transmisión de vídeo de Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/gs-createstream.html) y anote el Nombre de recurso de Amazon (ARN) de la transmisión.

1. [Cree de un flujo de datos de Kinesis](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html). Añada el nombre de la transmisión *AmazonRekognition*y anote el ARN de la transmisión.

A continuación, puede [crear el procesador de transmisión por búsqueda de rostros](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor) e [iniciar el procesador de transmisión](rekognition-video-stream-processor-search-faces.md#streaming-video-starting-stream-processor) que haya elegido.

**nota**  
 Debe iniciar el procesador de transmisión solo después de comprobar que puede introducir contenido multimedia en la transmisión de vídeo de Kinesis. 

## Transmisión de vídeo a Amazon Rekognition Video
<a name="video-streaming-kinesisvideostreams-stream"></a>

Para transmitir vídeo a Amazon Rekognition Video, utilice el SDK de Amazon Kinesis Video Streams para crear y utilizar una transmisión de vídeo de Kinesis. La operación `PutMedia` escribe *fragmentos* de datos de vídeo de Kinesis en una transmisión de vídeo que Amazon Rekognition Video consume. Cada fragmento de datos de vídeo suele tener una longitud de 2 a 10 segundos y contiene una secuencia de fotogramas de vídeo autónoma. Amazon Rekognition Video admite vídeos cifrados en H.264, que pueden tener tres tipos de fotogramas (I, B y P). Para obtener más información, consulte [Inter Frame](https://en.wikipedia.org/wiki/Inter_frame). El primer fotograma del fragmento debe ser un I-frame. Un I-frame se puede decodificar de forma independientes de cualquier otro fotograma. 

A medida que los datos de vídeo llegan a transmisión de vídeo de Kinesis, Kinesis Video Streams asigna un número único al fragmento. [Para ver un ejemplo, consulta el ejemplo de APIPutMedia .](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html)
+  Si está transmitiendo desde una fuente codificada en Matroska (MKV), utilice la [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)operación para transmitir el vídeo de origen a la transmisión de vídeo de Kinesis que ha creado. [Para obtener más información, consulte el ejemplo de API. PutMedia ](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html) 
+  Si está transmitiendo desde la cámara de un dispositivo, consulte [Transmisión mediante un GStreamer complemento](streaming-using-gstreamer-plugin.md).

# Otorgar a Amazon Rekognition Video acceso a sus recursos
<a name="api-streaming-video-roles"></a>

Utiliza un rol de servicio AWS Identity and Access Management (IAM) para dar a Amazon Rekognition Video acceso de lectura a las transmisiones de vídeo de Kinesis. Si utiliza un procesador de secuencias de búsqueda facial, utilizará un rol de servicio de IAM para conceder a Amazon Rekognition Video acceso de escritura a los flujos de datos de Kinesis. Si utiliza un procesador de flujos de supervisión de seguridad, utiliza los roles de IAM para permitir que Amazon Rekognition Video acceda a su bucket de Amazon S3 y a un tema de Amazon SNS.

## Permitir el acceso a los procesadores de streaming mediante búsqueda facial
<a name="api-streaming-video-roles-single-stream"></a>

Puede crear una política de permisos que permita a Amazon Rekognition Video acceder a las transmisiones individuales de vídeo de Kinesis y a los flujos de datos de Kinesis.

**Para dar acceso a Amazon Rekognition Video a un procesador de secuencias de búsqueda facial**

1. [ Cree una nueva política de permisos con el editor de políticas de JSON de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) y utilice la política siguiente. Sustituya `video-arn` por el ARN de la transmisión de vídeo de Kinesis deseado. Si utiliza un procesador de secuencias de búsqueda facial, sustituya `data-arn` por el ARN del flujo de datos de Kinesis deseado.

1. [Cree un rol de servicio de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console) o actualice un rol de servicio de IAM existente. Utilice la siguiente información para crear el rol de servicio de IAM:

   1. Elija **Rekognition** para el nombre del servicio.

   1. Elija **Rekognition** para el caso de uso del rol de servicio.

   1. Adjunte la política de permisos que ha creado en el paso 1.

1. Anote el ARN del rol de servicio. Lo necesita para comenzar las operaciones de análisis de vídeo.

## Dar acceso a las transmisiones mediante AmazonRekognitionServiceRole
<a name="api-streaming-video-roles-all-stream"></a>

 Como opción alternativa para configurar el acceso a las transmisiones de vídeo y flujos de datos de Kinesis, puede utilizar la política de permisos `AmazonRekognitionServiceRole`. IAM proporciona el caso de uso del rol de servicio *Rekognition* que, cuando se usa con la política de permisos `AmazonRekognitionServiceRole`, puede escribir en varios flujo de datos de Kinesis y leer desde todas transmisiones de vídeo de Kinesis. Para conceder a Amazon Rekognition Video acceso de escritura a varias transmisiones de datos de Kinesis, puede anteponer los nombres de las transmisiones de datos de Kinesis con, por ejemplo,. *AmazonRekognition*`AmazonRekognitionMyDataStreamName` 

**Para conceder a Amazon Rekognition Video acceso a su transmisión de vídeo de Kinesis y a los flujos de datos de Kinesis**

1. [Cree un rol de servicio de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console). Utilice la siguiente información para crear el rol de servicio de IAM:

   1. Elija **Rekognition** para el nombre del servicio.

   1. Elija **Rekognition** para el caso de uso del rol de servicio.

   1. Elija la política de **AmazonRekognitionServiceRole**permisos, que otorga a Amazon Rekognition Video acceso de escritura a las transmisiones de datos de Kinesis que tienen el prefijo *AmazonRekognition*y acceso de lectura a todas sus transmisiones de vídeo de Kinesis.

1. Para garantizar su Cuenta de AWS seguridad, limite el alcance del acceso de Rekognition únicamente a los recursos que utilice. Para ello, puede adjuntar una política de confianza a su rol de servicio de IAM. Para obtener información sobre cómo hacerlo, consulte [Prevención de la sustitución confusa entre servicios](cross-service-confused-deputy-prevention.md).

1. Anote el nombre de recurso de Amazon (ARN) del rol de servicio. Lo necesita para comenzar las operaciones de análisis de vídeo.

# Búsqueda de rostros en una transmisión de vídeo
<a name="rekognition-video-stream-processor-search-faces"></a>

Amazon Rekognition Video puede buscar rostros en una colección que coincidan con rostros detectados en un vídeo en streaming. Para obtener más información sobre las colecciones, consulte [Búsqueda de rostros en una colección](collections.md).

**Topics**
+ [Creación del procesador de flujo de búsqueda de rostros de Amazon Rekognition Video](#streaming-video-creating-stream-processor)
+ [Iniciar el procesador de flujo de búsqueda de rostros de Amazon Rekognition Video](#streaming-video-starting-stream-processor)
+ [Uso de procesadores de flujo para la búsqueda de rostros (ejemplo de Java V2)](#using-stream-processors-v2)
+ [Uso de procesadores de flujo para la búsqueda de rostros (ejemplo de Java V1)](#using-stream-processors)
+ [Lectura de los resultados del análisis de vídeo en streaming](streaming-video-kinesis-output.md)
+ [Visualización local de los resultados de Rekognition con Kinesis Video Streams](displaying-rekognition-results-locally.md)
+ [Descripción del registro de fotogramas de JSON para reconocimiento facial de Kinesis](streaming-video-kinesis-output-reference.md)

El siguiente diagrama muestra cómo Amazon Rekognition Video detecta y reconoce rostros en vídeo en streaming.

![\[Diagrama del flujo de trabajo para usar Amazon Rekognition Video con el fin de procesar transmisiones de vídeo de Amazon Kinesis.\]](http://docs.aws.amazon.com/es_es/rekognition/latest/dg/images/VideoRekognitionStream.png)


## Creación del procesador de flujo de búsqueda de rostros de Amazon Rekognition Video
<a name="streaming-video-creating-stream-processor"></a>

Antes de poder analizar un vídeo en streaming, debe crear un procesador de streaming Amazon Rekognition Video (). [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html) El procesador de transmisión contiene información sobre el flujo de datos de Kinesis y la transmisión de vídeo de Kinesis. También contiene el identificador de la colección que contiene los rostros que desea reconocer en el vídeo de streaming de entrada. Además especifica un nombre para el procesador de streaming. A continuación, se muestra un ejemplo de JSON para la solicitud `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
              }
       }
}
```

A continuación se muestra un ejemplo de respuesta de `CreateStreamProcessor`.

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

## Iniciar el procesador de flujo de búsqueda de rostros de Amazon Rekognition Video
<a name="streaming-video-starting-stream-processor"></a>

Se comienza a analizar el vídeo en streaming llamando a [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html) con el nombre del procesador de streaming que especificó en `CreateStreamProcessor`. A continuación, se muestra un ejemplo de JSON para la solicitud `StartStreamProcessor`.

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

Si el procesador de streaming comienza correctamente, se devuelve una respuesta HTTP 200, junto con un cuerpo JSON vacío.

## Uso de procesadores de flujo para la búsqueda de rostros (ejemplo de Java V2)
<a name="using-stream-processors-v2"></a>

El siguiente código de ejemplo muestra cómo llamar a varias operaciones del procesador de flujo, como [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)y [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html)mediante el uso de la versión 2 del AWS SDK for Java.

Este código se ha tomado del GitHub repositorio de ejemplos del SDK de AWS documentación. Consulte el ejemplo completo [aquí](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.");
    }
}
```

## Uso de procesadores de flujo para la búsqueda de rostros (ejemplo de Java V1)
<a name="using-stream-processors"></a>

El siguiente código de ejemplo muestra cómo llamar a varias operaciones del procesador de flujos, como [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)y [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html)mediante Java V1. El ejemplo incluye una clase de administrador de procesadores de flujo (StreamManager) que proporciona métodos para llamar a las operaciones del procesador de flujo. La clase Starter (Starter) crea un StreamManager objeto y llama a varias operaciones. 

**Para configurar el ejemplo:**

1. Establezca los valores de los campos de miembro de la clase Starter a los valores que desee.

1. En la función de clase Starter `main`, quite el comentario de la llamada de función que desee.

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

# Lectura de los resultados del análisis de vídeo en streaming
<a name="streaming-video-kinesis-output"></a>

Puede utilizar la biblioteca de clientes de Amazon Kinesis Data Streams para consumir los resultados de análisis que se envían a la transmisión de salida de Amazon Kinesis Data Streams. Para obtener más información, consulte [Reading Data from a Kinesis Data Stream](https://docs.aws.amazon.com/streams/latest/dev/building-consumers.html). Amazon Rekognition Video coloca un registro de fotograma de JSON para cada fotograma analizado en la transmisión de salida de Kinesis. Amazon Rekognition Video no analiza todos los fotogramas que recibe a través de la transmisión de vídeo de Kinesis. 

Un registro de fotograma que se envía a un flujo de datos de Kinesis contiene información acerca del fragmento de flujo de datos de Kinesis en el que está el fotograma, donde está el fotograma en el fragmento y los rostros reconocidos en el fotograma. También incluye información de estado para el procesador de streaming. Para obtener más información, consulte [Descripción del registro de fotogramas de JSON para reconocimiento facial de Kinesis](streaming-video-kinesis-output-reference.md).

Amazon Kinesis Video Streams Parser Library contiene ejemplos de pruebas que consumen los resultados de Amazon Rekognition Video y los integra con la transmisión de vídeo original de Kinesis. Para obtener más información, consulte [Visualización local de los resultados de Rekognition con Kinesis Video Streams](displaying-rekognition-results-locally.md).

Amazon Rekognition Video transmite la información de análisis de Amazon Rekognition Video a los flujos de datos de Kinesis. A continuación, se muestra un ejemplo de JSON para un registro único. 

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

En el ejemplo de JSON, observe lo siguiente:
+ **InputInformation**— Información sobre la transmisión de vídeo de Kinesis que se utiliza para transmitir vídeo a Amazon Rekognition Video. Para obtener más información, consulte [InputInformation](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-inputinformation).
+ **StreamProcessorInformation**— Información de estado del procesador de transmisión de vídeo Amazon Rekognition Video. El único valor posible para el campo `Status` es RUNNING. Para obtener más información, consulte [StreamProcessorInformation](streaming-video-kinesis-output-reference-streamprocessorinformation.md).
+ **FaceSearchResponse**— Contiene información sobre los rostros del vídeo en streaming que coinciden con los rostros de la colección de entrada. [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) objeto, que es un rostro que se detectó en el fotograma de vídeo analizado. Para cada rostro detectado, la matriz `MatchedFaces` contiene un matriz de objetos de rostro coincidentes ([MatchedFace](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-facematch)) encontrados en la colección de entrada, junto con una puntuación de similitud. 

## Asignación de la secuencia de vídeo de Kinesis al flujo de datos de Kinesis
<a name="mapping-streams"></a>

Es posible que desee asignar los fotogramas de transmisión de vídeo de Kinesis a los fotogramas analizados que se envían a la flujo de datos de Kinesis. Por ejemplo, durante la visualización de un vídeo de streaming, es posible que desee mostrar cuadros alrededor de los rostros de las personas reconocidas. Las coordenadas del cuadro delimitador se envían como parte del registro de reconocimiento facial de Kinesis al flujo de datos de Kinesis. Para mostrar el cuadro delimitador correctamente, debe asignar la información temporal que se envía con el registro de reconocimiento facial de Kinesis con los fotogramas correspondientes a la transmisión de vídeo de Kinesis de origen.

La técnica que utiliza para asignar la transmisión de vídeo de Kinesis a la flujo de datos de Kinesis depende de si va a transmitir medios en directo (como un vídeo de streaming en directo) o si va a transmitir medios archivados (como un vídeo almacenado).

### Asignación cuando se transmiten medios en directo
<a name="mapping-streaming-video"></a>

**Para asignar un fotograma de transmisión de vídeo de Kinesis a un fotograma de flujo de datos de Kinesis**

1. Defina el parámetro `FragmentTimeCodeType` de entrada de la [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)operación en`RELATIVE`. 

1. Llame a `PutMedia` para enviar contenido en vivo a la transmisión de vídeo de Kinesis.

1. Cuando reciba un registro del reconocimiento facial de Kinesis de los flujos de datos de Kinesis, almacene los valores de `ProducerTimestamp` y `FrameOffsetInSeconds` del campo [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo).

1. Calcule la marca temporal correspondiente al fotograma de transmisión de vídeo de Kinesis sumando los valores del campo `ProducerTimestamp` y `FrameOffsetInSeconds`. 

### Asignación cuando se transmiten medios archivados
<a name="map-stored-video"></a>

**Para asignar un fotograma de transmisión de vídeo de Kinesis a un fotograma de flujo de datos de Kinesis**

1. Llame [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)para enviar contenido multimedia archivado a la transmisión de vídeo de Kinesis.

1. Cuando reciba un objeto `Acknowledgement` de la respuesta de la operación `PutMedia`, almacene el valor del campo `FragmentNumber` del campo [Payload](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html#API_dataplane_PutMedia_ResponseSyntax). `FragmentNumber` es el número de fragmento del clúster de MKV. 

1. Cuando reciba un registro del reconocimiento facial de Kinesis de los flujos de datos de Kinesis, almacene el valor del campo `FrameOffsetInSeconds` del campo [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo). 

1. Calcule el mapeo utilizando los valores de `FrameOffsetInSeconds` y `FragmentNumber` almacenados en los pasos 2 y 3. `FrameOffsetInSeconds` es la diferencia del fragmento con el `FragmentNumber` enviado al flujo de datos de Amazon Kinesis. Para obtener más información sobre cómo obtener los fotogramas de vídeo para un número de fragmento determinado, consulte [Medios archivados de Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_Operations_Amazon_Kinesis_Video_Streams_Archived_Media.html).

# Visualización local de los resultados de Rekognition con Kinesis Video Streams
<a name="displaying-rekognition-results-locally"></a>

 [Puede ver los resultados de Amazon Rekognition Video que se muestran en su feed de Amazon Kinesis Video Streams mediante las pruebas de ejemplo de la biblioteca de analizadores de Amazon Kinesis Video Streams que se proporcionan en Rekognition Examples. KinesisVideo ](https://github.com/aws/amazon-kinesis-video-streams-parser-library#kinesisvideo---rekognition-examples) `KinesisVideoRekognitionIntegrationExample`Muestra cuadros delimitadores sobre los rostros detectados y renderiza el vídeo de forma local. JFrame Este proceso supone que ha conectado correctamente una entrada multimedia de la cámara de un dispositivo a una transmisión de vídeo de Kinesis y ha iniciado un procesador de transmisión de Amazon Rekognition. Para obtener más información, consulte [Transmisión mediante un GStreamer complemento](streaming-using-gstreamer-plugin.md). 

## Paso 1: Instalación de Kinesis Video Streams Parser Library
<a name="step-1-install-parser-library"></a>

 Para crear un directorio y descargar el repositorio de GitHub, ejecute el siguiente comando: 

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

 Navegue hasta el directorio de la biblioteca y ejecute el siguiente comando de Maven para realizar una instalación limpia: 

```
$ mvn clean install
```

## Paso 2: Ejemplo de configuración de la prueba de integración de Kinesis Video Streams y Rekognition
<a name="step-2-configure-kinesis-video-rekognition-example-test"></a>

 Abra el archivo `KinesisVideoRekognitionIntegrationExampleTest.java`. Elimine `@Ignore` justo después del encabezado de la clase. Rellene los campos de datos con la información de sus recursos de Amazon Kinesis y Amazon Rekognition. Para obtener más información, consulte [Configuración de los recursos de Amazon Rekognition Video y Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md). Si está transmitiendo vídeo a su transmisión de vídeo de Kinesis, elimine el parámetro `inputStream`. 

 Consulte el siguiente ejemplo de código: 

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

## Paso 3: Ejemplo de ejecución de la prueba de integración de Kinesis Video Streams y Rekognition
<a name="step-3-run-kinesis-video-rekognition-example-test"></a>

 Asegúrese de que su transmisión de vídeo de Kinesis reciba entradas multimedia si está transmitiendo a ella y comience a analizar la transmisión con Amazon Rekognition Video Stream Processor en ejecución. Para obtener más información, consulte [Descripción general de las operaciones del procesador de transmisión de Amazon Rekognition Video](streaming-video.md#using-rekognition-video-stream-processor). Organiza la `KinesisVideoRekognitionIntegrationExampleTest` clase como una JUnit prueba. Tras un breve retraso, se abre una nueva ventana con una transmisión de vídeo de la transmisión de vídeo de Kinesis con cuadros delimitadores dibujados sobre las caras detectadas. 

**nota**  
 Las caras de la colección utilizada en este ejemplo deben tener un identificador de imagen externo (el nombre del archivo) especificado en este formato para que las etiquetas de los cuadros delimitadores muestren texto significativo: PersonName 1 de confianza, PersonName 2 intrusos, 3 neutrales, etc. PersonName Las etiquetas también se pueden codificar por colores y se pueden personalizar en el archivo.java. FaceType 

# Descripción del registro de fotogramas de JSON para reconocimiento facial de Kinesis
<a name="streaming-video-kinesis-output-reference"></a>

Amazon Rekognition Video puede reconocer rostros en una transmisión de vídeo. Amazon Rekognition Video coloca un registro de fotograma de JSON para cada fotograma analizado en el flujo de datos de Kinesis. Amazon Rekognition Video no analiza todos los fotogramas que recibe a través de la transmisión de vídeo de Kinesis. 

El registro de fotograma de JSON contiene información acerca del streaming de entrada y de salida, el estado del procesador de streaming e información acerca de rostros que se han reconocido en el fotograma analizado. Esta sección contiene información de referencia para el registro de fotogramas de JSON.

La siguiente es la sintaxis de JSON para un registro de flujo de datos de Kinesis. Para obtener más información, consulte [Trabajar con eventos de vídeo en streaming](streaming-video.md).

**nota**  
La API de Amazon Rekognition Video funciona comparando los rostros de la secuencia de entrada con una colección de caras y devolviendo las coincidencias más próximas que se encuentren con una puntuación de similitud.

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

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

El registro de JSON incluye información sobre un fotograma que ha procesado Amazon Rekognition Video. El registro incluye información acerca del vídeo de streaming, el estado del fotograma analizado e información acerca de rostros que se han reconocido en el fotograma.

**InputInformation**

Información sobre la transmisión de vídeo de Kinesis que se utiliza para transmitir vídeo en Amazon Rekognition Video.

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

**StreamProcessorInformation**

Información acerca del procesador de streaming de Amazon Rekognition Video. Esto incluye información de estado para el estado actual del procesador de streaming.

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

**FaceSearchResponse**

Información acerca de los rostros detectados en un fotograma de vídeo en streaming y los rostros coincidentes encontrados en la colección de entrada.

Tipo: matriz de objetos [FaceSearchResponse](#streaming-video-kinesis-output-reference-facesearchresponse)

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

Información acerca de una transmisión de vídeo de origen que utiliza Amazon Rekognition Video. Para obtener más información, consulte [Trabajar con eventos de vídeo en streaming](streaming-video.md).

**KinesisVideo**

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

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

Información sobre la transmisión de vídeo de Kinesis que transmite el vídeo de origen a Amazon Rekognition Video. Para obtener más información, consulte [Trabajar con eventos de vídeo en streaming](streaming-video.md).

**StreamArn**

El nombre de recurso de Amazon (ARN) de la transmisión de vídeo de Kinesis.

Tipo: cadena 

**FragmentNumber**

El fragmento del vídeo en streaming que contiene el fotograma que representa este registro.

Tipo: cadena

**ProducerTimestamp**

La marca temporal Unix del lado del productor del fragmento. Para obtener más información, consulte [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Tipo: Number

**ServerTimestamp**

La marca temporal Unix del lado del servidor del fragmento. Para obtener más información, consulte [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Tipo: Number

**FrameOffsetInSeconds**

El desfase del fotograma (en segundos) dentro del fragmento.

Tipo: Number 

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

Información de estado acerca del procesador de streaming.

**Estado**

El estado actual del procesador de streaming. El único valor posible es RUNNING.

Tipo: cadena

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

Información acerca de un rostro detectado en un fotograma de vídeo en streaming y los rostros de una colección que coinciden con el rostro detectado. Especifica la colección en una llamada a [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html). Para obtener más información, consulte [Trabajar con eventos de vídeo en streaming](streaming-video.md). 

**DetectedFace**

Detalles de un rostro detectado en un fotograma de vídeo analizado.

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

**MatchedFaces**

Una matriz de detalles de rostros en una colección que coincide con el rostro detectado en `DetectedFace`.

Tipo: matriz de objetos [MatchedFace](#streaming-video-kinesis-output-reference-facematch)

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

Información sobre un rostro que se detectó en un fotograma de vídeo en streaming. Los rostros coincidentes en la colección de entrada están disponibles en campo de objeto [MatchedFace](#streaming-video-kinesis-output-reference-facematch).

**BoundingBox**

Las coordenadas del cuadro delimitador de un rostro que se ha detectado dentro de un fotograma de vídeo analizado. El BoundingBox objeto tiene las mismas propiedades que el BoundingBox objeto que se utiliza para el análisis de imágenes.

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

**Confianza**

El nivel de confianza (de 1 a 100) que tiene Amazon Rekognition Video de que el rostro detectado es en realidad un rostro. 1 es la confianza más baja y 100 es la más alta.

Tipo: Number

**Referencias**

Una matriz de referencias faciales.

Tipo: matriz de objetos [Landmark](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Landmark.html)

**Postura**

Indica la postura del rostro tal como determina su cabeceo, balanceo y desviación.

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

**Calidad**

Identifica el brillo y la nitidez de la imagen del rostro. 

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

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

Información sobre un rostro que coincide con un rostro detectado en un fotograma de vídeo analizado.

**Rostro**

Información de coincidencia de rostro para un rostro en la colección de entrada que coincide con el rostro en el objeto [DetectedFace](#streaming-video-kinesis-output-reference-detectedface). 

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

**Similitud**

El nivel de confianza (de 1 a 100) con el que coinciden las caras. 1 es la confianza más baja y 100 es la más alta.

Tipo: Number 

# Transmisión mediante un GStreamer complemento
<a name="streaming-using-gstreamer-plugin"></a>

Amazon Rekognition Video puede analizar una transmisión de vídeo en directo desde la cámara de un dispositivo. Para acceder a la entrada multimedia desde la fuente de un dispositivo, es necesario instalarlo GStreamer. GStreamer es un software de marco multimedia de terceros que conecta las fuentes multimedia y las herramientas de procesamiento en los flujos de trabajo. También debe instalar el complemento [Amazon Kinesis Video Streams Producer](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) para Gstreamer. En este proceso se presupone que ha configurado correctamente los recursos de Amazon Rekognition Video y Amazon Kinesis. Para obtener más información, consulte [Configuración de los recursos de Amazon Rekognition Video y Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md).

## Paso 1: Instale Gstreamer
<a name="step-1-install-gstreamer"></a>

 Descargue e instale Gstreamer, un software de plataforma multimedia de terceros. Puede usar un software de administración de paquetes como Homebrew ([Gstreamer en Homebrew](https://formulae.brew.sh/formula/gstreamer)) u obtenerlo directamente desde el [sitio web de Freedesktop](https://gstreamer.freedesktop.org/download/). 

 Compruebe que la instalación de Gstreamer se ha realizado correctamente iniciando una transmisión de vídeo con una fuente de prueba desde su terminal de línea de comandos. 

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

## Paso 2: Instale el complemento Kinesis Video Streams Producer
<a name="step-2-install-kinesis-video-plugin"></a>

 En esta sección, descargará la [biblioteca de Amazon Kinesis Video Streams Producer](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) e instalará el complemento Kinesis Video Streams Gstreamer. 

 Cree un directorio y clone el código fuente del repositorio GitHub. Asegúrese de incluir el parámetro `--recursive`. 

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

Siga las [instrucciones de la biblioteca](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/README.md) para configurar y compilar el proyecto. Asegúrese de utilizar los comandos específicos de la plataforma para su sistema operativo. Utilice el parámetro `-DBUILD_GSTREAMER_PLUGIN=ON` cuando ejecute `cmake` para instalar el complemento Kinesis Video Streams Gstreamer. Este proyecto requiere los siguientes paquetes adicionales que se incluyen en la instalación: GCC o Clang, Curl, Openssl y Log4cplus. Si la compilación falla porque falta un paquete, compruebe que el paquete esté instalado y en su ruta. Si se produce el error «No se puede ejecutar el programa compilado en C» durante la compilación, vuelva a ejecutar el comando build. A veces, no se encuentra el compilador de C correcto. 

 Verifique la instalación del complemento Kinesis Video Streams mediante la ejecución del siguiente comando. 

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

 Debería aparecer la siguiente información, como los detalles de fábrica y 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/
  
  ...
```

## Paso 3: Ejecute Gstreamer con el complemento Kinesis Video Streams
<a name="step-3-run-gstreamer-with-kinesis-video-plugin"></a>

 Antes de empezar a transmitir desde la cámara de un dispositivo a Kinesis Video Streams, puede que necesite convertir la fuente multimedia en un códec aceptable para Kinesis Video Streams. Para determinar las especificaciones y las capacidades de formato de los dispositivos actualmente conectados a su máquina, ejecute el siguiente comando.

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

 Para iniciar la transmisión, inicie Gstreamer con el siguiente comando de ejemplo y añada sus credenciales y la información de Amazon Kinesis Video Streams. Debe usar las claves de acceso y la región del rol de servicio de IAM que creó al [conceder a Amazon Rekognition acceso a sus transmisiones de Kinesis.](https://docs.aws.amazon.com/rekognition/latest/dg/api-streaming-video-roles.html#api-streaming-video-roles-all-stream) Para obtener más información acerca de las claves de acceso, consulte [Administración de las claves de acceso de los usuarios de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) en la *Guía del usuario de IAM*. Además, puede ajustar los parámetros de los argumentos del formato de vídeo según lo requiera su uso y estén disponibles en su 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"
```

 Para obtener más comandos de inicio, consulte [Ejemplos de comandos de GStreamer lanzamiento](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-gstreamer-plugin.html#examples-gstreamer-plugin-launch). 

**nota**  
 Si el comando de lanzamiento termina con un error no relacionado con la negociación, compruebe el resultado del monitor de dispositivos y asegúrese de que los valores del parámetro `videoconvert` corresponden a las capacidades válidas de su dispositivo. 

 Verá una transmisión de vídeo de la cámara de su dispositivo en la transmisión de vídeo de Kinesis después de unos segundos. Para empezar a detectar y comparar rostros con Amazon Rekognition, inicie el procesador de transmisión Amazon Rekognition Video. Para obtener más información, consulte [Descripción general de las operaciones del procesador de transmisión de Amazon Rekognition Video](streaming-video.md#using-rekognition-video-stream-processor). 

# Solución de problemas de vídeo en streaming
<a name="streaming-video-troubleshooting"></a>

Este tema ofrece información sobre cómo solucionar problemas en el uso de Amazon Rekognition Video con vídeos en streaming.

**Topics**
+ [No sé si mi procesador de streaming se ha creado correctamente](#ts-streaming-video-create-sp)
+ [No sé si he configurado correctamente mi procesador de streaming](#ts-configured-sp)
+ [Mi procesador de streaming no está devolviendo resultados](#ts-streaming-video-no-results-from-sp)
+ [El estado de mi procesador de streaming es FAILED](#ts-failed-state)
+ [Mi procesador de streaming no está devolviendo los resultados esperados](#w2aac27c79c27c15)

## No sé si mi procesador de streaming se ha creado correctamente
<a name="ts-streaming-video-create-sp"></a>

Utilice el siguiente AWS CLI comando para obtener una lista de los procesadores de flujo y su estado actual.

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

Puede obtener detalles adicionales mediante el siguiente AWS CLI comando. Reemplace `stream-processor-name` por el nombre del procesador de streaming necesario.

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

## No sé si he configurado correctamente mi procesador de streaming
<a name="ts-configured-sp"></a>

Si el código no está devolviendo los resultados de análisis de Amazon Rekognition Video, es posible que su procesador de streaming no esté configurado correctamente. Realice lo siguiente para confirmar que su procesador de streaming se ha configurado correctamente y que puede producir resultados.

**Para determinar si su solución está configurada correctamente**

1. Ejecute el siguiente comando para confirmar que el procesador de streaming se encuentra en estado de ejecución. Cambie `stream-processor-name` por el nombre de su procesador de streaming. El procesador de streaming está en ejecución si el valor de `Status` es `RUNNING`. Si el estado es `RUNNING` y no está obteniendo resultados, consulte [Mi procesador de streaming no está devolviendo resultados](#ts-streaming-video-no-results-from-sp). Si el estado es `FAILED`, consulte [El estado de mi procesador de streaming es FAILED](#ts-failed-state).

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

1. Si su procesador de transmisiones está en ejecución, ejecute el siguiente PowerShell comando o Bash para leer los datos de la transmisión de datos de Kinesis de salida. 

   **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. Utilice la [herramienta Decode](https://www.base64decode.org/) en el sitio web de Base64 Decode para decodificar el resultado en una cadena legible para las personas. Para obtener más información, consulte el [Paso 3: Obtener el registro](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#get-records).

1. Si los comandos funcionan y ve resultados de detección de rostros en la secuencia de datos de Kinesis, la solución está configurada correctamente. Si el comando da error, compruebe las otras sugerencias de solución de problemas y consulte [Otorgar a Amazon Rekognition Video acceso a sus recursos](api-streaming-video-roles.md).

Como alternativa, puede usar el AWS Lambda plano «kinesis-process-record» para registrar los mensajes desde la transmisión de datos de Kinesis CloudWatch para una visualización continua. Esto implica costos adicionales de y. AWS Lambda CloudWatch 

## Mi procesador de streaming no está devolviendo resultados
<a name="ts-streaming-video-no-results-from-sp"></a>

Su procesador de streaming podría no devolver resultados por varios motivos. 

### Motivo 1: su procesador de streaming no está configurado correctamente
<a name="w2aac27c79c27c11b5"></a>

Su procesador de streaming podría no estar configurado correctamente. Para obtener más información, consulte [No sé si he configurado correctamente mi procesador de streaming](#ts-configured-sp).

### Motivo 2: Su procesador de streaming no está en el estado RUNNING
<a name="w2aac27c79c27c11b7"></a>

**Para solucionar el estado de un procesador de streaming**

1. Compruebe el estado del procesador de flujo con el siguiente AWS CLI comando.

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

1. Si el valor de `Status` es `STOPPED`, inicie el procesador de streaming con el siguiente comando:

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

1. Si el valor de `Status` es `FAILED`, consulte [El estado de mi procesador de streaming es FAILED](#ts-failed-state).

1. Si el valor de `Status` es `STARTING`, espere 2 minutos y compruebe el estado repitiendo el paso 1. Si el valor de Status sigue siendo `STARTING`, realice lo siguiente:

   1. Elimine el procesador de streaming con el siguiente comando.

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

   1. Cree un nuevo procesador de streaming con la misma configuración. Para obtener más información, consulte [Trabajar con eventos de vídeo en streaming](streaming-video.md).

   1. Si sigues teniendo problemas, ponte en contacto con AWS Support.

1. Si el valor de `Status` es `RUNNING`, consulte [Motivo 3: no hay datos activos en la transmisión de vídeo de Kinesis](#ts-no-data).

### Motivo 3: no hay datos activos en la transmisión de vídeo de Kinesis
<a name="ts-no-data"></a>

**Para comprobar si hay datos activos en la transmisión de vídeo de Kinesis**

1. Inicie sesión en la Consola de administración de AWS consola [https://console.aws.amazon.com/kinesisvideo/](https://console.aws.amazon.com/kinesisvideo/)de Amazon Kinesis Video Streams y ábrala en.

1. Seleccione la transmisión de vídeo de Kinesis que es la entrada para el procesador de transmisión de Amazon Rekognition.

1. Si la vista previa indica **Ningún dato en la transmisión**, significa que no hay ningún dato en la transmisión de entrada para que lo procese Amazon Rekognition Video.

Para obtener información sobre la producción de vídeo con Kinesis Video Streams, consulte [Kinesis Video Streams Producer Libraries](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk.html). 

## El estado de mi procesador de streaming es FAILED
<a name="ts-failed-state"></a>

Puede comprobar el estado de un procesador de streaming mediante el siguiente AWS CLI comando.

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

Si el valor de Status es FAILED, compruebe la información de solución de problemas de los siguientes mensajes de error.

### Error: «Acceso denegado al rol»
<a name="w2aac27c79c27c13b9"></a>

El rol de IAM que utiliza el procesador de streaming no existe o Amazon Rekognition Video no tiene permiso para asumir el rol.

**Para solucionar problemas de acceso con el rol de IAM**

1. Inicie sesión en la consola de IAM Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación izquierdo, elija **Roles** y confirme que el rol existe. 

1. Si el rol existe, compruebe que el rol tenga la política de *AmazonRekognitionServiceRole*permisos.

1. Si el rol no existe o no tiene los permiso adecuados, consulte [Otorgar a Amazon Rekognition Video acceso a sus recursos](api-streaming-video-roles.md).

1. Inicie el procesador de transmisión con el siguiente AWS CLI comando.

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

### Error: "Access denied to Kinesis Video (Acceso denegado a vídeo de Kinesis) *o* Access denied to Kinesis Data (Acceso denegado a datos de Kinesis)"
<a name="w2aac27c79c27c13c11"></a>

El rol no tiene acceso a las operaciones de API de Kinesis Video Streams `GetMedia` y `GetDataEndpoint`. Es posible que tampoco tenga acceso a las operaciones de API de Kinesis Data Streams `PutRecord` y `PutRecords`. 

**Solución de problemas de permisos de API**

1. Inicie sesión en la consola de IAM Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Abra el rol y asegúrese de que tiene la siguiente política de permisos asociada.

1. Si falta alguno de los permisos, actualice la política. Para obtener más información, consulte [Otorgar a Amazon Rekognition Video acceso a sus recursos](api-streaming-video-roles.md).

### Error: «La transmisión *input-video-stream-name* no existe»
<a name="w2aac27c79c27c13c13"></a>

La entrada de transmisión de vídeo de Kinesis para el procesador de streaming no existe o no está configurada correctamente. 

**Para solucionar problemas de la secuencia de vídeo de Kinesis**

1. Utilice el siguiente comando para confirmar que la secuencia existe. 

   ```
   aws kinesisvideo list-streams
   ```

1. Si la secuencia existe, compruebe lo siguiente.
   + El nombre de recurso de Amazon (ARN) es el mismo que el ARN de la secuencia de entrada del procesador de streaming.
   + La secuencia de vídeo de Kinesis debe encontrarse en la misma Región que el procesador de streaming.

   Si el procesador de transmisión no está configurado correctamente, elimínelo con el siguiente AWS CLI comando.

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

1. Cree un nuevo procesador de streaming con la secuencia de vídeo de Kinesis prevista. Para obtener más información, consulte [Creación del procesador de flujo de búsqueda de rostros de Amazon Rekognition Video](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor).

### Error: «Colección no encontrada»
<a name="w2aac27c79c27c13c15"></a>

La colección de Amazon Rekognition que utiliza el procesador de streaming para comparar rostros no existe, o se está utilizando la colección equivocada.

**Para confirmar la colección**

1. Use el siguiente AWS CLI comando para determinar si existe la colección requerida. Cambie `region` a la AWS región en la que está ejecutando el procesador de streaming.

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

   Si la colección necesaria no existe, cree una nueva colección y añada información de rostros. Para obtener más información, consulte [Búsqueda de rostros en una colección](collections.md).

1. En la llamada a [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html), compruebe que el valor del parámetro de entrada de `CollectionId` es correcto.

1. Inicie el procesador de transmisión con el siguiente AWS CLI comando.

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

### Error: «*account-id*No se encontró *output-kinesis-data-stream-name* la transmisión en la cuenta»
<a name="w2aac27c79c27c13c17"></a>

La transmisión de datos de Kinesis de salida que utiliza el procesador de transmisiones no existe Cuenta de AWS o no se encuentra en la misma AWS región que su procesador de transmisiones.

**Para solucionar problemas de la secuencia de datos de Kinesis**

1. Utilice el siguiente AWS CLI comando para determinar si existe la transmisión de datos de Kinesis. Cambie `region` a la AWS región en la que utiliza el procesador de transmisiones.

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

1. Si la secuencia de datos de Kinesis existe, compruebe que el nombre de la secuencia de datos de Kinesis es el mismo que el nombre de la secuencia de salida que utiliza el procesador de streaming.

1. Si la transmisión de datos de Kinesis no existe, puede que esté en otra AWS región. La secuencia de datos de Kinesis debe encontrarse en la misma Región que el procesador de streaming.

1. Si es necesario, cree una nueva secuencia de datos de Kinesis. 

   1. Cree una secuencia de datos de Kinesis con el mismo nombre que el usado por el procesador de streaming. Para obtener más información, consulte [Paso 1: Crear una secuencia de datos](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html).

   1. Inicie el procesador de transmisiones con el siguiente AWS CLI comando.

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

## Mi procesador de streaming no está devolviendo los resultados esperados
<a name="w2aac27c79c27c15"></a>

Si el procesador de streaming no está devolviendo los rostros coincidentes esperados, utilice la siguiente información.
+ [Búsqueda de rostros en una colección](collections.md)
+ [Recomendaciones de configuración de la cámara (vídeo en streaming)](recommendations-camera-streaming-video.md)