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á.
# Escreva e examine o código
Nesta seção do[Use a biblioteca de produtores de C\+\+](producer-sdk-cpp.md), você examina o código no equipamento de teste C\+\+ (`tst/ProducerTestFixture.h`e em outros arquivos). Você fez download desse código na seção anterior.
O exemplo de C \+\+ **Platform Independent** mostra o seguinte padrão de codificação:
+ Crie uma instância de `KinesisVideoProducer` para acessar o Kinesis Video Streams.
+ Crie uma instância de `KinesisVideoStream`. Isso cria um stream de vídeo do Kinesis em seu Conta da AWS caso ainda não exista um stream com o mesmo nome.
+ Chame `putFrame` em `KinesisVideoStream` para cada quadro de dados (à medida que ele se tornar disponível) para enviá-lo ao streaming.
As seções a seguir fornecem mais informações sobre esse padrão de codificação.
## Crie uma instância de KinesisVideoProducer
Você cria um objeto `KinesisVideoProducer` chamando o método `KinesisVideoProducer::createSync`. O exemplo a seguir cria `KinesisVideoProducer` no arquivo `ProducerTestFixture.h`:
```
kinesis_video_producer_ = KinesisVideoProducer::createSync(move(device_provider_),
move(client_callback_provider_),
move(stream_callback_provider_),
move(credential_provider_),
defaultRegion_);
```
O método `createSync` usa os seguintes parâmetros:
+ Um objeto `DeviceInfoProvider`, que retorna um objeto `DeviceInfo` contendo informações sobre o dispositivo ou a configuração de armazenamento.
**nota**
Você deve configurar o tamanho do armazenamento de conteúdo usando o parâmetro `deviceInfo.storageInfo.storageSize`. Seus streamings de conteúdo compartilham o armazenamento de conteúdo. Para determinar o requisito de tamanho do storage, multiplique o tamanho médio do quadro pelo número de quadros armazenados para a duração máxima de todos os streamings. Em seguida, multiplique por 1,2 para considerar a desfragmentação. Por exemplo, suponha que o aplicativo tem a seguinte configuração:
Três streamings
3 minutos de duração máxima
Cada streaming é de 30 quadros por segundo (FPS)
Cada quadro tem 10.000 KB de tamanho
O requisito de armazenamento de conteúdo para esse aplicativo é **3 (streams) \* 3 (minutos) \* 60 (segundos em um minuto) \* 10000 (kb) \* 1,2 (permissão de desfragmentação) = 194,4** Mb \~ 200 Mb.
+ Um objeto `ClientCallbackProvider`, que retorna ponteiros de função que relatam eventos específicos do cliente.
+ Um objeto `StreamCallbackProvider`, que retorna ponteiros de função que são chamados de volta quando ocorrem eventos específicos de streaming.
+ Um `CredentialProvider` objeto que fornece acesso às variáveis de ambiente de AWS credenciais.
+ O Região da AWS (“us-west-2"). O endpoint de serviço é determinado a partir da região.
## Crie uma instância de KinesisVideoStream
Você cria um objeto `KinesisVideoStream` chamando o método `KinesisVideoProducer::CreateStream` com um parâmetro `StreamDefinition`. O exemplo cria o `KinesisVideoStream` no arquivo `ProducerTestFixture.h` com o tipo de trilha como vídeo e com o ID da trilha como 1:
```
auto stream_definition = make_unique(stream_name,
hours(2),
tags,
"",
STREAMING_TYPE_REALTIME,
"video/h264",
milliseconds::zero(),
seconds(2),
milliseconds(1),
true,
true,
true);
return kinesis_video_producer_->createStream(move(stream_definition));
```
O objeto `StreamDefinition` tem os seguintes campos:
+ Nome do stream.
+ Período de retenção de dados.
+ Tags do streaming. Essas tags podem ser usadas por aplicativos de consumo para encontrar o streaming correto ou obter mais informações sobre o streaming. As tags também podem ser visualizadas no Console de gerenciamento da AWS.
+ AWS KMS chave de criptografia para o stream. Para obter mais informações, consulte [Proteção de dados no Kinesis Video Streams](how-kms.md).
+ Tipo de streaming. Atualmente, o único valor válido é `STREAMING_TYPE_REALTIME`.
+ Tipo de conteúdo de mídia.
+ Latência de mídia. Esse valor não é usado atualmente e deve ser definido como 0.
+ Duração da reprodução de cada fragmento.
+ Escala de código de hora da mídia.
+ Se a mídia usa ou não fragmentação de keyframe.
+ Se a mídia usa ou não códigos de hora.
+ Se a mídia usa ou não horas absolutas de fragmento.
## Adicionar uma faixa de áudio ao stream de vídeo do Kinesis
Você pode adicionar detalhes da faixa de áudio a uma definição de fluxo de faixa de vídeo usando o `addTrack` método do`StreamDefinition`:
```
stream_definition->addTrack(DEFAULT_AUDIO_TRACKID, DEFAULT_AUDIO_TRACK_NAME, DEFAULT_AUDIO_CODEC_ID, MKV_TRACK_INFO_TYPE_AUDIO);
```
O `addTrack` método requer os seguintes parâmetros:
+ ID da faixa (como uma para áudio). Esse valor deve ser exclusivo e diferente de zero.
+ Nome da faixa definido pelo usuário (por exemplo, “áudio” para a faixa de áudio).
+ ID do codec para essa faixa (por exemplo, para a faixa de áudio “A\_AAC”).
+ Tipo de faixa (por exemplo, use o valor enum de MKV\_TRACK\_INFO\_TYPE\_AUDIO para áudio).
Se tiver dados privados do codec para a trilha de áudio, você poderá transmiti-los ao chamar a função addTrack. Você também pode enviar os dados privados do codec depois de criar o KinesisVideoStream objeto enquanto chama o método start in KinesisVideoStream.
## Coloque um quadro no stream de vídeo do Kinesis
Você insere mídia no stream de vídeo do Kinesis usando`KinesisVideoStream::putFrame`, passando um `Frame` objeto que contém o cabeçalho e os dados de mídia. O exemplo chama `putFrame` no arquivo `ProducerApiTest.cpp`:
```
frame.duration = FRAME_DURATION_IN_MICROS * HUNDREDS_OF_NANOS_IN_A_MICROSECOND;
frame.size = SIZEOF(frameBuffer_);
frame.frameData = frameBuffer_;
MEMSET(frame.frameData, 0x55, frame.size);
while (!stop_producer_) {
// Produce frames
timestamp = std::chrono::duration_cast(
std::chrono::system_clock::now().time_since_epoch()).count() / DEFAULT_TIME_UNIT_IN_NANOS;
frame.index = index++;
frame.decodingTs = timestamp;
frame.presentationTs = timestamp;
// Key frame every 50th
frame.flags = (frame.index % 50 == 0) ? FRAME_FLAG_KEY_FRAME : FRAME_FLAG_NONE;
...
EXPECT_TRUE(kinesis_video_stream->putFrame(frame));
```
**nota**
O exemplo anterior do produtor de C\+\+ envia um buffer de dados de teste. Em uma situação real, você precisa obter o buffer e o tamanho do quadro dos dados do quadro em uma fonte de mídia (como uma câmera).
O objeto `Frame` tem os seguintes campos:
+ Índice de quadros. Este deve ser um valor incremental monotônico.
+ Sinalizadores associados ao quadro. Por exemplo, se o codificador fosse configurado para produzir um keyframe, esse quadro receberia o sinalizador `FRAME_FLAG_KEY_FRAME`.
+ Carimbo de data/hora de decodificação.
+ Carimbo de data e hora da apresentação.
+ Duração do quadro (para unidades de 100 ns).
+ Tamanho do quadro em bytes.
+ Dados de quadro.
Para obter mais informações sobre o formato de quadro, consulte [Modelo de dados do Kinesis Video Streams](how-data.md).
## Coloque um KinesisVideoFrame em uma faixa específica de KinesisVideoStream
Você pode usar a `PutFrameHelper` classe para colocar dados do quadro em uma faixa específica. Primeiro, chame o `getFrameDataBuffer` para obter um ponteiro para um dos buffers pré-alocados para preencher os dados. `KinesisVideoFrame` Em seguida, você pode chamar o `putFrameMultiTrack` para enviar o `KinesisVideoFrame` junto com o valor booleano para indicar o tipo de dados do quadro. Use true (verdadeiro) se forem dados de vídeo ou false (falso) se o quadro tiver dados de áudio. O `putFrameMultiTrack` método usa um mecanismo de enfileiramento para garantir que os fragmentos MKV mantenham carimbos de data e hora de quadros monotonicamente crescentes e que quaisquer dois fragmentos não se sobreponham. Por exemplo, o timestamp MKV do primeiro quadro de um fragmento deve sempre ser maior do que o timestamp MKV do último quadro do fragmento anterior.
`PutFrameHelper` tem os seguintes campos:
+ Número máximo de quadros de áudio na fila.
+ Número máximo de quadros de vídeo na fila.
+ Tamanho a ser alocado para um único quadro de áudio.
+ Tamanho a ser alocado para um único quadro de vídeo.
## Métricas de acesso e registro de métricas
O SDK do produtor de C\+\+ inclui funcionalidade para métricas e registro de métricas.
Você pode usar as operações `getKinesisVideoMetrics` e da `getKinesisVideoStreamMetrics` API para recuperar informações sobre o Kinesis Video Streams e seus streams ativos.
O código a seguir é do arquivo `kinesis-video-pic/src/client/include/com/amazonaws/kinesis/video/client/Include.h`.
```
/**
* Gets information about the storage availability.
*
* @param 1 CLIENT_HANDLE - the client object handle.
* @param 2 PKinesisVideoMetrics - OUT - Kinesis Video metrics to be filled.
*
* @return Status of the function call.
*/
PUBLIC_API STATUS getKinesisVideoMetrics(CLIENT_HANDLE, PKinesisVideoMetrics);
/**
* Gets information about the stream content view.
*
* @param 1 STREAM_HANDLE - the stream object handle.
* @param 2 PStreamMetrics - Stream metrics to fill.
*
* @return Status of the function call.
*/
PUBLIC_API STATUS getKinesisVideoStreamMetrics(STREAM_HANDLE, PStreamMetrics);
```
O objeto `PClientMetrics` preenchido por `getKinesisVideoMetrics` contém as seguintes informações:
+ **contentStoreSize:** o tamanho geral em bytes do armazenamento de conteúdo (a memória usada para armazenar dados de streaming).
+ **contentStoreAvailableTamanho:** a memória disponível no armazenamento de conteúdo, em bytes.
+ **contentStoreAllocatedTamanho:** A memória alocada no armazenamento de conteúdo.
+ **totalContentViewsTamanho:** a memória total usada para a visualização do conteúdo. A visualização do conteúdo é uma série de índices de informações no armazenamento de conteúdo.
+ **totalFrameRate:** o número agregado de quadros por segundo em todos os fluxos ativos.
+ **totalTransferRate:** o total de bits por segundo (bps) enviados em todos os fluxos.
O objeto `PStreamMetrics` preenchido por `getKinesisVideoStreamMetrics` contém as seguintes informações:
+ **currentViewDuration:** a diferença em unidades de 100 ns entre a cabeça da visualização do conteúdo (quando os quadros são codificados) e a posição atual (quando os dados do quadro são enviados para o Kinesis Video Streams).
+ **overallViewDuration:** a diferença em unidades de 100 ns entre a parte superior da visualização do conteúdo (quando os quadros são codificados) e a parte final (quando os quadros são apagados da memória, seja porque o espaço total alocado para a visualização do conteúdo foi excedido ou porque uma `PersistedAck` mensagem é recebida do Kinesis Video Streams e os quadros conhecidos por persistirem são liberados).
+ **currentViewSize:** o tamanho em bytes da visualização do conteúdo do cabeçalho (quando os quadros são codificados) até a posição atual (quando os quadros são enviados para o Kinesis Video Streams).
+ **overallViewSize:** o tamanho total em bytes da visualização do conteúdo.
+ **currentFrameRate:** a última taxa medida do stream, em quadros por segundo.
+ **currentTransferRate:** a última taxa medida do fluxo, em bytes por segundo.
## Desgaste
Se quiser enviar os bytes restantes em um buffer e aguardar o `ACK`, você poderá usar o `stopSync`:
```
kinesis_video_stream->stopSync();
```
Ou você pode chamar `stop` para encerrar o streaming:
```
kinesis_video_stream->stop();
```
Após interromper o streaming, você pode liberá-lo chamando a seguinte API:
```
kinesis_video_producer_->freeStream(kinesis_video_stream);
```