

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Pesquisando faces em uma coleção em um vídeo de streaming
<a name="collections-streaming"></a>

Você pode usar o Amazon Rekognition Video para detectar e reconhecer faces de uma coleção em streaming de vídeo. Com o Amazon Rekognition Video, você pode criar um [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)processador de streaming () para iniciar e gerenciar a análise do streaming de vídeo. 

Para detectar um rosto conhecido em um stream de vídeo (pesquisa facial), o Amazon Rekognition Video usa o Amazon Kinesis Video Streams para receber e processar um stream de vídeo. Os resultados da análise são enviados do Amazon Rekognition Video para um fluxo de dados do Kinesis e depois lidos pelo seu aplicativo cliente. 

Para usar o Amazon Rekognition Video com streaming de vídeo, seu aplicativo precisa implementar o seguinte:
+ Um stream de vídeo do Kinesis para enviar streaming de vídeo para o Amazon Rekognition Video. Para obter mais informações, consulte o [Guia do desenvolvedor do Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/what-is-kinesis-video.html). 
+ Um processador de stream do Amazon Rekognition Video para gerenciar a análise do streaming de vídeo. Para obter mais informações, consulte [Visão geral das operações do processador de stream do Amazon Rekognition Video](streaming-video.md#using-rekognition-video-stream-processor).
+ Um consumidor de fluxo de dados do Kinesis para ler os resultados da análise que o Amazon Rekognition Video envia para o fluxo de dados do Kinesis. Para obter mais informações, consulte [Consumidores do Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/amazon-kinesis-consumers.html). 

Esta seção contém informações sobre como escrever um aplicativo que cria o stream de vídeo do Kinesis e outros recursos necessários, transmite vídeos para o Amazon Rekognition Video e recebe os resultados da análise.

**Topics**
+ [Configurando seus recursos do Amazon Rekognition Video e do Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md)
+ [Pesquisanda faces em um streaming de vídeo](rekognition-video-stream-processor-search-faces.md)
+ [Streaming usando um GStreamer plug-in](streaming-using-gstreamer-plugin.md)
+ [Solução de problemas de streaming de vídeo](streaming-video-troubleshooting.md)

# Configurando seus recursos do Amazon Rekognition Video e do Amazon Kinesis
<a name="setting-up-your-amazon-rekognition-streaming-video-resources"></a>

 Os procedimentos a seguir descrevem as etapas que você executa para provisionar o stream de vídeo do Kinesis e outros recursos usados para reconhecer faces em um streaming de vídeo.

## Pré-requisitos
<a name="streaming-video-prerequisites"></a>

Para executar esse procedimento, você precisa ter o AWS SDK para Java instalado. Para obter mais informações, consulte [Comece a usar o Amazon Rekognition](getting-started.md). O Conta da AWS que você usa deve ter permissões de acesso à API do Amazon Rekognition. Para obter mais informações, consulte [Ações definidas pelo Amazon Rekognition](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions) no *Guia do usuário do IAM*. 

**Para reconhecer faces em um fluxo de vídeo (AWS SDK)**

1. Se você ainda não o fez, crie um perfil de serviço do IAM para dar ao Amazon Rekognition Video acesse aos seus streams de vídeo do Kinesis e aos seus streams de dados do Kinesis. Anote o ARN. Para obter mais informações, consulte [Dando acesso a streams usando AmazonRekognitionServiceRole](api-streaming-video-roles.md#api-streaming-video-roles-all-stream).

1. [Crie uma coleção](create-collection-procedure.md) e anote o identificador da coleção que você usou.

1. [Faça a indexação das faces](add-faces-to-collection-procedure.md) que deseja pesquisar na coleção que você criou na etapa 2.

1. [Crie um stream de vídeo do Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/gs-createstream.html) e anote o nome de recurso da Amazon (ARN) do stream.

1. [Crie um fluxo de dados do Kinesis](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html). Prefixe o nome do stream *AmazonRekognition*e anote o ARN do stream.

Em seguida, você pode [criar o processador de stream de pesquisa facial](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor) e [iniciar o processador de stream](rekognition-video-stream-processor-search-faces.md#streaming-video-starting-stream-processor) usando o nome do processador de stream que você escolheu.

**nota**  
 Você deve iniciar o processador de stream somente depois de verificar se você pode ingerir mídia no stream de vídeo do Kinesis. 

## Streaming de vídeo para o Amazon Rekognition Video
<a name="video-streaming-kinesisvideostreams-stream"></a>

Para transmitir vídeo para o Amazon Rekognition Video, você usa o SDK do Amazon Kinesis Video Streams para criar e usar um stream de vídeo do Kinesis. A operação `PutMedia` grava *fragmentos* de dados de vídeo em um stream de vídeo do Kinesis que o Amazon Rekognition Video consome. Cada fragmento de dados de vídeo geralmente tem de 2 a 10 segundos de duração e contém uma sequência independente de quadros de vídeo. O Amazon Rekognition Video oferece suporte a vídeos codificados em H.264, que podem ter três tipos de quadros (I, B e P). Para obter mais informações, consulte [Inter Frame](https://en.wikipedia.org/wiki/Inter_frame). O primeiro quadro no fragmento deve ser um I-frame. Um I-frame pode ser decodificado independentemente de qualquer outro quadro. 

Quando os dados de vídeo chegam ao stream de vídeo do Kinesis, o Kinesis Video Streams atribui um número exclusivo ao fragmento. Para ver um exemplo, consulte [Exemplo de PutMedia API](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html).
+  Se você estiver transmitindo de uma fonte codificada em Matroska (MKV), use a [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)operação para transmitir o vídeo de origem para o stream de vídeo do Kinesis que você criou. Para obter mais informações, consulte [Exemplo de PutMedia API](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html). 
+  Se você estiver transmitindo da câmera de um dispositivo, consulte [Streaming usando um GStreamer plug-in](streaming-using-gstreamer-plugin.md).

# Conceder ao Amazon Rekognition Video acesso aos seus recursos
<a name="api-streaming-video-roles"></a>

Você usa uma função de serviço AWS Identity and Access Management (IAM) para dar ao Amazon Rekognition Video acesso de leitura aos streams de vídeo do Kinesis. Se você estiver usando um processador de stream de pesquisa facial, você usa um perfil de serviço do IAM para dar ao Amazon Rekognition Video acesse de gravação aos fluxos de dados do Kinesis. Se você estiver usando um processador de stream de monitoramento de segurança, use os perfis do IAM para dar ao Amazon Rekognition Video acesso ao bucket do Amazon S3 e a um tópico do Amazon SNS.

## Fornecer acesso a processadores de stream de pesquisa facial
<a name="api-streaming-video-roles-single-stream"></a>

Você pode criar uma política de permissões que permita ao Amazon Rekognition Video acessar streams de vídeo individuais do Kinesis e streams de dados do Kinesis.

**Para dar ao Amazon Rekognition Video acesso a um processador de stream de pesquisa facial**

1. [ Crie uma nova política de permissões com o editor de políticas IAM JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) e use a política a seguir. Substitua `video-arn` pelo ARN do stream de vídeo do Kinesis desejado. Se você estiver usando um processador de stream de pesquisa facial, substitua o `data-arn` pelo ARN do fluxo de dados Kinesis desejado.

1. [Crie um perfil de serviço do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console) ou atualize um perfil de serviço do IAM existente. Use as informações a seguir para criar o perfil de serviço do IAM:

   1. Escolha **Rekognition** como o nome de serviço.

   1. Escolha **Rekognition** para o caso de uso da função de serviço.

   1. Anexe a política de permissões que você criou na etapa 1.

1. Anote o ARN da função de serviço. Ele é necessário para iniciar as operações de análise de vídeo.

## Dando acesso a streams usando AmazonRekognitionServiceRole
<a name="api-streaming-video-roles-all-stream"></a>

 Como opção alternativa para configurar o acesso aos streams de vídeo e fluxos de dados do Kinesis, você pode usar a política de permissões da `AmazonRekognitionServiceRole`. O IAM fornece o caso de uso do perfil de serviço *Rekognition* que, quando usado com a política de permissões `AmazonRekognitionServiceRole`, pode gravar em vários streams de dados do Kinesis e ler todos os seus streams de vídeo do Kinesis. Para dar ao Amazon Rekognition Video acesso de gravação a vários streams de dados do Kinesis, você pode prefixar os nomes dos streams de dados do Kinesis com —por exemplo,. *AmazonRekognition*`AmazonRekognitionMyDataStreamName` 

**Para dar ao Amazon Rekognition Video acesso ao seu stream de vídeo do Kinesis e ao fluxo de dados do Kinesis**

1. [Crie um perfil de serviço do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console). Use as informações a seguir para criar o perfil de serviço do IAM:

   1. Escolha **Rekognition** como o nome de serviço.

   1. Escolha **Rekognition** para o caso de uso da função de serviço.

   1. Escolha a política de **AmazonRekognitionServiceRole**permissões, que dá ao Amazon Rekognition Video acesso de gravação aos streams de dados do Kinesis *AmazonRekognition*prefixados e acesso de leitura a todos os seus streams de vídeo do Kinesis.

1. Para garantir que você Conta da AWS esteja seguro, limite o escopo do acesso do Rekognition apenas aos recursos que você está usando. Isso pode ser feito anexando uma política de confiança à suo perfil de serviço do IAM. Para obter informações sobre como fazer isso, consulte [Prevenção contra o ataque do “substituto confuso” em todos os serviços](cross-service-confused-deputy-prevention.md).

1. Observe o nome de recurso da Amazon (ARN) da função de serviço. Ele é necessário para iniciar as operações de análise de vídeo.

# Pesquisanda faces em um streaming de vídeo
<a name="rekognition-video-stream-processor-search-faces"></a>

O Amazon Rekognition Video pode pesquisar faces em uma coleção que correspondam às faces detectadas em um vídeo de streaming. Para obter mais informações sobre coleções, consulte [Pesquisa de faces em uma coleção](collections.md).

**Topics**
+ [Criação do processador de stream de pesquisa facial Amazon Rekognition Video](#streaming-video-creating-stream-processor)
+ [Iniciando o processador de stream de pesquisa facial do Amazon Rekognition Video](#streaming-video-starting-stream-processor)
+ [Usando processadores de stream para pesquisa facial (exemplo de Java V2)](#using-stream-processors-v2)
+ [Usando processadores de stream para pesquisa facial (exemplo de Java V1)](#using-stream-processors)
+ [Lendo os resultados da análise de streaming de vídeo](streaming-video-kinesis-output.md)
+ [Exibindo resultados do Rekognition com o Kinesis Video Streams localmente](displaying-rekognition-results-locally.md)
+ [Entender o registro de quadros JSON de reconhecimento facial do Kinesis](streaming-video-kinesis-output-reference.md)

O diagrama a seguir mostra como o Amazon Rekognition Video detecta e reconhece faces em um streaming de vídeo.

![\[Diagrama do fluxo de trabalho para usar o Amazon Rekognition Video para processar streams de vídeo do Amazon Kinesis.\]](http://docs.aws.amazon.com/pt_br/rekognition/latest/dg/images/VideoRekognitionStream.png)


## Criação do processador de stream de pesquisa facial Amazon Rekognition Video
<a name="streaming-video-creating-stream-processor"></a>

Antes de poder analisar um streaming de vídeo, você cria um processador de streaming de vídeo Amazon Rekognition Video (). [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html) O processador de stream contém informações sobre o fluxo de dados do Kinesis e o stream de vídeo do Kinesis. Ele também contém o identificador para a coleção que contém as faces que você deseja reconhecer no streaming de vídeo de entrada. Você também especifica um nome para o processador de fluxo. Veja a seguir um exemplo de JSON para a solicitação `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
              }
       }
}
```

Esta é uma resposta de exemplo de `CreateStreamProcessor`.

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

## Iniciando o processador de stream de pesquisa facial do Amazon Rekognition Video
<a name="streaming-video-starting-stream-processor"></a>

Inicie a análise de streaming de vídeo chamando [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html) com o nome do processador de fluxo que você especificou em `CreateStreamProcessor`. Veja a seguir um exemplo de JSON para a solicitação `StartStreamProcessor`.

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

Se o processador de fluxo iniciar com êxito, uma resposta HTTP 200 é retornada, junto com um corpo JSON vazio.

## Usando processadores de stream para pesquisa facial (exemplo de Java V2)
<a name="using-stream-processors-v2"></a>

O código de exemplo a seguir mostra como chamar várias operações do processador de stream, como [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), usando o AWS SDK for Java versão 2.

Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo [aqui](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.");
    }
}
```

## Usando processadores de stream para pesquisa facial (exemplo de Java V1)
<a name="using-stream-processors"></a>

O código de exemplo a seguir mostra como chamar várias operações do processador de fluxo, como [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), usando o Java V1. O exemplo inclui uma classe de gerenciador de processador de fluxo (StreamManager) que fornece métodos para chamar operações do processador de fluxo. A classe inicial (Starter) cria um StreamManager objeto e chama várias operações. 

**Para configurar o exemplo:**

1. Defina os valores dos campos de membro de classe Starter para seus valores desejados.

1. Na função de classe Starter `main`, exclua a função chamada de função desejada.

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

# Lendo os resultados da análise de streaming de vídeo
<a name="streaming-video-kinesis-output"></a>

Você pode usar a biblioteca de cliente do Amazon Kinesis Data Streams para consumir os resultados da análise que são enviados para o stream de saída do Amazon Kinesis Data Streams. Para obter mais informações, consulte [Ler dados de um Kinesis Data Stream](https://docs.aws.amazon.com/streams/latest/dev/building-consumers.html). O Amazon Rekognition Video coloca um registro de quadro JSON para cada quadro analisado no stream de saída do Kinesis. O Amazon Rekognition Video não analisa cada quadro que é passado para ele pelo stream de vídeo do Kinesis. 

Um registro de quadro enviado para um fluxo de dados do Kinesis contém informações sobre em qual fragmento de stream de vídeo do Kinesis o quadro está, onde o quadro está no fragmento e faces que são reconhecidas no quadro. Ele também inclui informações de status para o processador de fluxo. Para obter mais informações, consulte [Entender o registro de quadros JSON de reconhecimento facial do Kinesis](streaming-video-kinesis-output-reference.md).

A biblioteca do Amazon Kinesis Video Streams Parser contém exemplos de testes que consomem os resultados do Amazon Rekognition Video e os integram ao stream de vídeo original do Kinesis. Para obter mais informações, consulte [Exibindo resultados do Rekognition com o Kinesis Video Streams localmente](displaying-rekognition-results-locally.md).

O Amazon Rekognition Video transmite informações de análise do Amazon Rekognition Video para o fluxo de dados do Kinesis. Veja a seguir um exemplo de JSON para um único registro. 

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

No exemplo de JSON, observe:
+ **InputInformation**— Informações sobre o stream de vídeo do Kinesis usado para transmitir vídeo para o Amazon Rekognition Video. Para obter mais informações, consulte [InputInformation](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-inputinformation).
+ **StreamProcessorInformation**— Informações de status do processador de streaming de vídeo Amazon Rekognition Video. O único valor possível para o campo `Status` é RUNNING. Para obter mais informações, consulte [StreamProcessorInformation](streaming-video-kinesis-output-reference-streamprocessorinformation.md).
+ **FaceSearchResponse**— Contém informações sobre rostos no streaming de vídeo que correspondem aos rostos na coleção de entrada. [FaceSearchResponse](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-facesearchresponse)contém um [DetectedFace](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-detectedface) objeto, que é uma face que foi detectada no quadro de vídeo analisado. Para cada face detectada, a matriz `MatchedFaces` contém uma matriz de objetos de faces correspondentes ([MatchedFace](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-facematch)) encontradas na coleção de entrada, juntamente com uma pontuação de semelhança. 

## Mapeando o stream de vídeo do Kinesis para o fluxo de dados do Kinesis
<a name="mapping-streams"></a>

Talvez você queira mapear os quadros do stream de vídeo do Kinesis para os quadros analisados que são enviados para o fluxo de dados do Kinesis. Por exemplo, durante a exibição de um streaming de vídeo, você pode querer exibir caixas ao redor das faces de pessoas reconhecidas. As coordenadas da caixa delimitadora são enviadas como parte do Registro de Reconhecimento Facial do Kinesis para o fluxo de dados do Kinesis. Para exibir a caixa delimitadora corretamente, você precisa mapear as informações de tempo enviadas com o Kinesis Face Recognition Record com os quadros correspondentes no stream de vídeo de origem do Kinesis.

A técnica usada para mapear o stream de vídeo do Kinesis para o fluxo de dados do Kinesis depende se você está transmitindo mídia ao vivo (como um vídeo ao vivo) ou se você está transmitindo mídia arquivada (como um vídeo armazenado).

### Mapeamento quando você está transmitindo mídia ao vivo
<a name="mapping-streaming-video"></a>

**Para mapear um quadro de stream de vídeo do Kinesis para um quadro de fluxo de dados do Kinesis**

1. Defina o parâmetro `FragmentTimeCodeType` de entrada da [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)operação como`RELATIVE`. 

1. Chame `PutMedia` para entregar mídia ao vivo no stream de vídeo do Kinesis.

1. Ao receber um registro de reconhecimento facial do Kinesis do fluxo de dados do Kinesis, armazene os valores de `ProducerTimestamp` e `FrameOffsetInSeconds` do campo [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo).

1. Calcule o carimbo de data/hora que corresponde ao quadro do stream de vídeo do Kinesis adicionando os valores de `FrameOffsetInSeconds` e do campo `ProducerTimestamp` juntos. 

### Mapeando quando você está transmitindo mídia arquivada
<a name="map-stored-video"></a>

**Para mapear um quadro de stream de vídeo do Kinesis para um quadro de fluxo de dados do Kinesis**

1. Ligue [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)para entregar mídia arquivada ao stream de vídeo do Kinesis.

1. Quando você receber um objeto `Acknowledgement` da resposta da operação `PutMedia`, armazene o valor do campo `FragmentNumber` do campo [Payload (Carga)](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html#API_dataplane_PutMedia_ResponseSyntax). `FragmentNumber` é o número do fragmento para o cluster do MKV. 

1. Ao receber um Kinesis Face Recognition Record do fluxo de dados do Kinesis, armazene o valor do campo `FrameOffsetInSeconds` no campo [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo). 

1. Calcule o mapeamento usando os valores `FragmentNumber` e `FrameOffsetInSeconds` que você armazenou nas etapas 2 e 3. `FrameOffsetInSeconds` é o deslocamento no fragmento com o `FragmentNumber` específico que é enviado para o fluxo de dados do Amazon Kinesis. Para obter mais informações sobre como obter os quadros de vídeo para um determinado número de fragmento, consulte Mídia arquivada do [Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_Operations_Amazon_Kinesis_Video_Streams_Archived_Media.html).

# Exibindo resultados do Rekognition com o Kinesis Video Streams localmente
<a name="displaying-rekognition-results-locally"></a>

 [Você pode ver os resultados do Amazon Rekognition Video exibidos em seu feed do Amazon Kinesis Video Streams usando os exemplos de testes da Amazon Kinesis Video Streams Parser Library fornecidos em - Rekognition Examples. KinesisVideo ](https://github.com/aws/amazon-kinesis-video-streams-parser-library#kinesisvideo---rekognition-examples) Ele `KinesisVideoRekognitionIntegrationExample` exibe caixas delimitadoras sobre os rostos detectados e renderiza o vídeo localmente. JFrame Esse processo pressupõe que você tenha conectado com êxito uma entrada de mídia da câmera de um dispositivo a um stream de vídeo do Kinesis e iniciado um processador Amazon Rekognition Stream. Para obter mais informações, consulte [Streaming usando um GStreamer plug-in](streaming-using-gstreamer-plugin.md). 

## Etapa 1: Instalando a biblioteca do Kinesis Video Streams Parser
<a name="step-1-install-parser-library"></a>

 Para criar um diretório e baixar o repositório Github, execute o seguinte comando: 

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

 Navegue até o diretório da biblioteca e execute o seguinte comando do Maven para realizar uma instalação limpa: 

```
$ mvn clean install
```

## Etapa 2: Configurando o teste de exemplo de integração entre Kinesis Video Streams e Rekognition
<a name="step-2-configure-kinesis-video-rekognition-example-test"></a>

 Abra o arquivo `KinesisVideoRekognitionIntegrationExampleTest.java`. Remova `@Ignore` a direita após o cabeçalho da classe. Preencha os campos de dados com as informações dos seus recursos do Amazon Kinesis e do Amazon Rekognition. Para obter mais informações, consulte [Configurando seus recursos do Amazon Rekognition Video e do Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md). Se você estiver transmitindo vídeo para seu stream de vídeo do Kinesis, remova o parâmetro `inputStream`. 

 Veja o exemplo de código a seguir: 

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

## Etapa 3: Executando o teste de exemplo de integração entre Kinesis Video Streams e Rekognition
<a name="step-3-run-kinesis-video-rekognition-example-test"></a>

 Certifique-se de que seu stream de vídeo do Kinesis esteja recebendo entrada de mídia se você estiver transmitindo para ele e comece a analisar seu stream com um processador Amazon Rekognition Video Stream em execução. Para obter mais informações, consulte [Visão geral das operações do processador de stream do Amazon Rekognition Video](streaming-video.md#using-rekognition-video-stream-processor). Execute a `KinesisVideoRekognitionIntegrationExampleTest` aula como um JUnit teste. Depois de um pequeno atraso, uma nova janela é aberta com um feed de vídeo do seu stream de vídeo do Kinesis com caixas delimitadoras desenhadas sobre faces detectadas. 

**nota**  
 As faces na coleção usada neste exemplo devem ter a ID de imagem externa (o nome do arquivo) especificada nesse formato para que os rótulos das caixas delimitadoras exibam texto significativo: PersonName 1-Confiável, PersonName 2-Intruso, 3-Neutro, etc. PersonName Os rótulos também podem ser codificados por cores e são personalizáveis no arquivo.java. FaceType 

# Entender o registro de quadros JSON de reconhecimento facial do Kinesis
<a name="streaming-video-kinesis-output-reference"></a>

O Amazon Rekognition Video pode reconhecer faces em um streaming de vídeo. Para cada quadro analisado, o Amazon Rekognition Video gera um registro de quadro JSON em um fluxo de dados do Kinesis. O Amazon Rekognition Video não analisa cada quadro que é passado para ele pelo stream de vídeo do Kinesis. 

O registro de quadros JSON contém informações sobre o stream de entrada e de saída, o status do processador de fluxo e informações sobre faces que são reconhecidas no quadro analisado. Esta seção contém informações de referência para o registro de quadros JSON.

A seguir está a sintaxe JSON para um registro de fluxo de dados do Kinesis. Para obter mais informações, consulte [Trabalhando com eventos de streaming de vídeo](streaming-video.md).

**nota**  
A API Amazon Rekognition Video funciona comparando as faces em seu stream de entrada com uma coleção de faces e retornando as correspondências mais próximas encontradas, junto com uma pontuação de similaridade.

```
{
    "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 JSON
<a name="streaming-video-kinesis-output-reference-processorresult"></a>

O registro JSON inclui informações sobre um quadro processado pelo Amazon Rekognition Video. O registro inclui informações sobre o streaming de vídeo, o status do quadro analisado e informações sobre faces que são reconhecidas no quadro.

**InputInformation**

Informações sobre o stream de vídeo do Kinesis usado para transmitir vídeo para o Amazon Rekognition Video.

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

**StreamProcessorInformation**

Informações sobre o processador de stream do Amazon Rekognition Video. Isso inclui informações de status para o status atual do processador de fluxo.

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

**FaceSearchResponse**

Informações sobre as faces detectadas em um quadro de streaming de vídeo e as faces correspondentes encontradas na coleção de entrada.

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

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

Informações sobre um stream de vídeo de origem usado pelo Amazon Rekognition Video. Para obter mais informações, consulte [Trabalhando com eventos de streaming de vídeo](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>

Informações sobre o stream de vídeo do Kinesis que transmite o vídeo de origem para o Amazon Rekognition Video. Para obter mais informações, consulte [Trabalhando com eventos de streaming de vídeo](streaming-video.md).

**StreamArn**

O nome de recurso da Amazon (ARN) do stream de vídeo do Kinesis.

Tipo: string 

**FragmentNumber**

O fragmento de streaming de vídeo que contém o quadro que esse registro representa.

Tipo: string

**ProducerTimestamp**

O time stamp do Unix do lado do produtor do fragmento. Para obter mais informações, consulte [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Tipo: número

**ServerTimestamp**

O time stamp do Unix do lado do servidor do fragmento. Para obter mais informações, consulte [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Tipo: número

**FrameOffsetInSeconds**

O deslocamento do quadro (em segundos) dentro do fragmento.

Tipo: número 

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

Informações de status sobre o processador de fluxo.

**Status**

O status atual do processador de fluxo. O único valor possível é RUNNING.

Tipo: string

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

Informações sobre uma face detectada em um quadro de streaming de vídeo e as faces em uma coleção que correspondem à face detectada. Você especifica a coleção em uma chamada para [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html). Para obter mais informações, consulte [Trabalhando com eventos de streaming de vídeo](streaming-video.md). 

**DetectedFace**

Detalhes de uma face detectada em um quadro de vídeo analisado.

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

**MatchedFaces**

Uma matriz dos detalhes de faces em uma coleção que corresponda à face detectada na `DetectedFace`.

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

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

Informações sobre uma face detectada em um quadro de streaming de vídeo. As faces correspondentes na coleção de entrada estão disponíveis no campo do objeto [MatchedFace](#streaming-video-kinesis-output-reference-facematch).

**BoundingBox**

A caixa delimitadora coordena para uma face que é detectada dentro de um quadro de vídeo analisado. O BoundingBox objeto tem as mesmas propriedades do BoundingBox objeto usado para análise de imagem.

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

**Confiança**

O nível de confiança (1-100) que o Amazon Rekognition Video tem de que a face detectada é, na verdade, uma face. 1 é a confiança mais baixa, 100 é a mais alta.

Tipo: número

**Pontos de referência**

Uma matriz de pontos de referência faciais.

Tipo: Matriz de objetos de [pontos de referência](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Landmark.html)

**Pose**

Indica a pose da face conforme determinada pelos seus eixos lateral, vertical e longitudinal.

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

**Qualidade**

Identifica o brilho a nitidez da imagem da face. 

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

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

Informações sobre uma face que corresponde a uma face detectada em um quadro de vídeo analisado.

**Rosto**

Informações sobre a correspondência de uma face na coleção de entrada que corresponde à face no objeto [DetectedFace](#streaming-video-kinesis-output-reference-detectedface). 

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

**Semelhança**

O nível de confiança (1-100) com o qual as faces coincidem. 1 é a confiança mais baixa, 100 é a mais alta.

Tipo: número 

# Streaming usando um GStreamer plug-in
<a name="streaming-using-gstreamer-plugin"></a>

O Amazon Rekognition Video pode analisar uma transmissão de vídeo ao vivo a partir da câmera de um dispositivo. Para acessar a entrada de mídia de uma fonte de dispositivo, você precisa instalar GStreamer. GStreamer é um software de estrutura multimídia de terceiros que conecta fontes de mídia e ferramentas de processamento em canais de fluxo de trabalho. Você também precisa instalar o [Plug-in de produtor do Amazon Kinesis Video Streams](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) para Gstreamer. Esse processo pressupõe que você tenha configurado com êxito seus recursos do Amazon Rekognition Video e do Amazon Kinesis. Para obter mais informações, consulte [Configurando seus recursos do Amazon Rekognition Video e do Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md).

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

 Baixe e instale o Gstreamer, um software de plataforma multimídia de terceiros. Você pode usar um software de gerenciamento de pacotes como o Homebrew ([Gstreamer no Homebrew](https://formulae.brew.sh/formula/gstreamer)) ou obtê-lo diretamente no [site do Freedesktop](https://gstreamer.freedesktop.org/download/). 

 Verifique a instalação bem-sucedida do Gstreamer iniciando um feed de vídeo com uma fonte de teste do seu terminal de linha de comando. 

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

## Etapa 2: Instale o plug-in Kinesis Video Streams Producer
<a name="step-2-install-kinesis-video-plugin"></a>

 Nesta seção, você fará o download da [Amazon Kinesis Video Streams Producer Library](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) e instalará o plug-in Kinesis Video Streams Gstreamer. 

 Crie um diretório e clone o código-fonte do repositório Github. Certifique-se de incluir o parâmetro `--recursive`. 

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

Siga as [instruções fornecidas pela biblioteca](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/README.md) para configurar e criar o projeto. Certifique-se de usar os comandos específicos da plataforma para seu sistema operacional. Use o parâmetro `-DBUILD_GSTREAMER_PLUGIN=ON` ao executar `cmake` para instalar o plug-in Kinesis Video Streams Gstreamer. Esse projeto requer os seguintes pacotes adicionais que estão incluídos na instalação: GCC ou Clang, Curl, Openssl e Log4cplus. Se sua compilação falhar devido à falta de um pacote, verifique se o pacote está instalado e em seu PATH. Se você encontrar um erro "não é possível executar o programa compilado em C" durante a compilação, execute o comando de compilação novamente. Às vezes, o compilador C correto não é encontrado. 

 Verifique a instalação do plug-in Kinesis Video Streams executando o comando a seguir. 

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

 As informações a seguir, como detalhes de fábrica e do plug-in, devem aparecer: 

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

## Etapa 3: Execute o Gstreamer com o plugin Kinesis Video Streams
<a name="step-3-run-gstreamer-with-kinesis-video-plugin"></a>

 Antes de começar a transmitir da câmera de um dispositivo para o Kinesis Video Streams, talvez seja necessário converter a fonte de mídia em um codec aceitável para o Kinesis Video Streams. Para determinar as especificações e os recursos de formato dos dispositivos atualmente conectados à sua máquina, execute o comando a seguir.

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

 Para começar a transmitir, inicie o Gstreamer com o comando de exemplo a seguir e adicione suas credenciais e informações do Amazon Kinesis Video Streams. Você deve usar as chaves de acesse e a região para o perfil de serviço do IAM que você criou ao [conceder ao Amazon Rekognition acesse aos seus streams do Kinesis](https://docs.aws.amazon.com/rekognition/latest/dg/api-streaming-video-roles.html#api-streaming-video-roles-all-stream). Para obter mais informações sobre chaves de acesso, consulte [Gerenciando chaves de acesso para usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) no *Guia do usuário do IAM*. Além disso, você pode ajustar os parâmetros do argumento do formato de vídeo conforme exigido pelo seu uso e disponíveis no seu 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 obter mais comandos de inicialização, consulte [Exemplos de comandos de GStreamer inicialização](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-gstreamer-plugin.html#examples-gstreamer-plugin-launch). 

**nota**  
 Se o comando de inicialização terminar com um erro de não negociação, verifique a saída do Device Monitor e certifique-se de que os valores dos parâmetros `videoconvert` sejam recursos válidos do seu dispositivo. 

 Você verá um feed de vídeo da câmera do seu dispositivo no stream de vídeo do Kinesis após alguns segundos. Para começar a detectar e combinar faces com o Amazon Rekognition, inicie seu processador de stream do Amazon Rekognition Video. Para obter mais informações, consulte [Visão geral das operações do processador de stream do Amazon Rekognition Video](streaming-video.md#using-rekognition-video-stream-processor). 

# Solução de problemas de streaming de vídeo
<a name="streaming-video-troubleshooting"></a>

Este tópico fornece informações sobre solução de problemas para usar o Amazon Rekognition Video com streaming de vídeos.

**Topics**
+ [Não sei se meu processador de fluxo foi criado com êxito](#ts-streaming-video-create-sp)
+ [Eu não sei se configurei corretamente o meu processador de fluxos](#ts-configured-sp)
+ [Meu processador de fluxos não está retornando resultados](#ts-streaming-video-no-results-from-sp)
+ [O estado do meu processador de fluxos é FAILED](#ts-failed-state)
+ [Meu processador de fluxos não está retornando os resultados esperados](#w2aac27c79c27c15)

## Não sei se meu processador de fluxo foi criado com êxito
<a name="ts-streaming-video-create-sp"></a>

Use o AWS CLI comando a seguir para obter uma lista dos processadores de stream e seu status atual.

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

Você pode obter detalhes adicionais usando o AWS CLI comando a seguir. Substitua `stream-processor-name` pelo nome do processador de fluxos necessário.

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

## Eu não sei se configurei corretamente o meu processador de fluxos
<a name="ts-configured-sp"></a>

Se seu código não estiver gerando os resultados da análise do Amazon Rekognition Video, seu processador de stream pode não estar configurado corretamente. Faça o seguinte para confirmar se o processador de fluxos está configurado corretamente e pode produzir resultados.

**Para determinar se sua solução está configurada corretamente**

1. Execute o comando a seguir para confirmar se o processador de fluxos está no estado de execução. Altere `stream-processor-name` para o nome do processador de fluxos. O processador de fluxos estará em execução se o valor de `Status` for `RUNNING`. Se o status for `RUNNING` e você não estiver obtendo resultados, consulte [Meu processador de fluxos não está retornando resultados](#ts-streaming-video-no-results-from-sp). Se o status for `FAILED`, consulte [O estado do meu processador de fluxos é FAILED](#ts-failed-state).

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

1. Se seu processador de stream estiver em execução, execute o seguinte PowerShell comando ou Bash para ler dados do stream de dados de saída do Kinesis. 

   **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. Use a [ferramenta Decode](https://www.base64decode.org/) no site Base64 Decode para decodificar a saída em uma string legível. Para obter mais informações, consulte [Etapa 3: Obter o registro](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#get-records).

1. Se os comandos funcionarem e você vir os resultados da detecção de face no fluxo de dados do Kinesis, sua solução estará configurada corretamente. Se ocorrer uma falha no comando, verifique as outras sugestões de solução de problemas e consulte [Conceder ao Amazon Rekognition Video acesso aos seus recursos](api-streaming-video-roles.md).

Como alternativa, você pode usar o AWS Lambda blueprint kinesis-process-record "" para registrar mensagens do stream de dados do Kinesis CloudWatch para visualização contínua. Isso acarreta custos adicionais para AWS Lambda e. CloudWatch 

## Meu processador de fluxos não está retornando resultados
<a name="ts-streaming-video-no-results-from-sp"></a>

O processador de fluxos pode não retornar resultados por vários motivos. 

### Motivo 1: seu processador de fluxo não está configurado corretamente
<a name="w2aac27c79c27c11b5"></a>

Seu processador de fluxos pode não estar configurado corretamente. Para obter mais informações, consulte [Eu não sei se configurei corretamente o meu processador de fluxos](#ts-configured-sp).

### Motivo 2: Seu processador de fluxos não está no estado RUNNING
<a name="w2aac27c79c27c11b7"></a>

**Para solucionar o status de um processador de fluxos**

1. Verifique o status do processador de stream com o AWS CLI comando a seguir.

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

1. Se o valor de `Status` for `STOPPED`, inicie o processador de fluxos com o seguinte comando:

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

1. Se o valor de `Status` for `FAILED`, consulte [O estado do meu processador de fluxos é FAILED](#ts-failed-state).

1. Se o valor de `Status` for `STARTING`, aguarde 2 minutos e verifique o status repetindo a etapa 1. Se o valor de Status ainda for `STARTING`, faça o seguinte:

   1. Exclua o processador de fluxos com o seguinte comando.

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

   1. Crie um novo processador de fluxos com a mesma configuração. Para obter mais informações, consulte [Trabalhando com eventos de streaming de vídeo](streaming-video.md).

   1. Se você ainda estiver tendo problemas, entre em contato com o AWS Support.

1. Se o valor de `Status` for `RUNNING`, consulte [Motivo 3: Não há dados ativos no stream de vídeo do Kinesis](#ts-no-data).

### Motivo 3: Não há dados ativos no stream de vídeo do Kinesis
<a name="ts-no-data"></a>

**Para verificar se há dados ativos no stream de vídeo do Kinesis**

1. Faça login no e abra Console de gerenciamento da AWS o console do Amazon Kinesis Video Streams [https://console.aws.amazon.com/kinesisvideo/](https://console.aws.amazon.com/kinesisvideo/)em.

1. Selecione o stream de vídeo Kinesis que é a entrada para o processador de stream Amazon Rekognition.

1. Se a pré-visualização indicar **Sem dados no stream**, então não há dados no stream de entrada para o Amazon Rekognition Video processar.

Para obter informações sobre a produção de vídeo com o Kinesis Video Streams, consulte Bibliotecas do [Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk.html)Producer. 

## O estado do meu processador de fluxos é FAILED
<a name="ts-failed-state"></a>

Você pode verificar o estado de um processador de stream usando o AWS CLI comando a seguir.

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

Se o valor de Status for FAILED, verifique as informações de solução de problemas para as seguintes mensagens de erro.

### Erro: "Acesso negado à função"
<a name="w2aac27c79c27c13b9"></a>

O perfil do IAM usado pelo processador de stream não existe ou o Amazon Rekognition Video não tem permissão para assumir a função.

**Para solucionar problemas de acesso ao perfil do IAM**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação à esquerda, selecione **Roles (Funções)** e confirme se a função existe. 

1. Se a função existir, verifique se a função tem a política de *AmazonRekognitionServiceRole*permissões.

1. Se a função não existir ou não tiver as permissões corretas, consulte [Conceder ao Amazon Rekognition Video acesso aos seus recursos](api-streaming-video-roles.md).

1. Inicie o processador de stream com o AWS CLI comando a seguir.

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

### Erro: "Access denied to Kinesis Video (Acesso negado ao vídeo do Kinesis) *ou* Access denied to Kinesis Data (Acesso negado aos dados do Kinesis)"
<a name="w2aac27c79c27c13c11"></a>

A função não tem acesso às operações `GetMedia` e `GetDataEndpoint` da API do Kinesis Video Streams. Também pode não ter acesso às operações `PutRecord` e `PutRecords` da API Kinesis Data Streams 

**Para solucionar problemas de permissões da API**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Abra a função e verifique se ela tem a seguinte política de permissões associada.

1. Se qualquer uma das permissões estiver ausente, atualize a política. Para obter mais informações, consulte [Conceder ao Amazon Rekognition Video acesso aos seus recursos](api-streaming-video-roles.md).

### Erro: “*input-video-stream-name*O stream não existe”
<a name="w2aac27c79c27c13c13"></a>

A entrada de stream de vídeo do Kinesis para o processador de stream não existe ou não está configurada corretamente. 

**Para solucionar problemas do stream de vídeo do Kinesis**

1. Use o seguinte comando para confirmar se o stream existe. 

   ```
   aws kinesisvideo list-streams
   ```

1. Se o stream existir, verifique o seguinte.
   + O nome de recurso da Amazon (ARN) é igual ao ARN do stream de entrada para o processador de fluxos.
   + O stream de vídeo do Kinesis está na mesma região do processador de stream.

   Se o processador de stream não estiver configurado corretamente, exclua-o com o AWS CLI comando a seguir.

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

1. Crie um novo processador de fluxos com o stream de vídeo desejado do Kinesis. Para obter mais informações, consulte [Criação do processador de stream de pesquisa facial Amazon Rekognition Video](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor).

### Erro: "Coleção não encontrada"
<a name="w2aac27c79c27c13c15"></a>

A coleção Amazon Rekognition usada pelo processador de stream para combinar faces não existe ou a coleção errada está sendo usada.

**Para confirmar a coleção**

1. Use o AWS CLI comando a seguir para determinar se a coleção necessária existe. `region`Mude para a AWS região na qual você está executando seu processador de stream.

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

   Se a coleção necessária não existir, crie uma nova coleção e adicione informações de faces. Para obter mais informações, consulte [Pesquisa de faces em uma coleção](collections.md).

1. Em sua chamada para [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html), verifique se o valor do parâmetro de entrada `CollectionId` está correto.

1. Inicie o processador de stream com o AWS CLI comando a seguir.

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

### Erro: “Transmissão *output-kinesis-data-stream-name* na conta *account-id* não encontrada”
<a name="w2aac27c79c27c13c17"></a>

O stream de dados de saída do Kinesis usado pelo processador de stream não existe na sua região Conta da AWS ou não está na mesma AWS região do seu processador de stream.

**Para solucionar problemas no fluxo de dados do Kinesis**

1. Use o AWS CLI comando a seguir para determinar se o stream de dados do Kinesis existe. `region`Mude para a AWS região na qual você está usando seu processador de stream.

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

1. Se o fluxo de dados do Kinesis existir, verifique se o nome do stream é igual ao nome do stream de saída usado pelo processador de fluxos.

1. Se o stream de dados do Kinesis não existir, ele poderá existir em outra AWS região. O fluxo de dados do Kinesis deve estar na mesma região que o processador de fluxos.

1. Se necessário, crie um novo fluxo de dados do Kinesis. 

   1. Crie um fluxo de dados do Kinesis com o mesmo nome que o usado pelo processador de fluxos. Para obter mais informações, consulte [ Etapa 1: Criar um fluxo de dados](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html).

   1. Inicie o processador de stream com o AWS CLI comando a seguir.

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

## Meu processador de fluxos não está retornando os resultados esperados
<a name="w2aac27c79c27c15"></a>

Se o processador de fluxos não estiver retornando as correspondências de face esperadas, use as informações a seguir.
+ [Pesquisa de faces em uma coleção](collections.md)
+ [Recomendações para a configuração da câmera (streaming de vídeo)](recommendations-camera-streaming-video.md)