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 doUse a biblioteca de produtores de C++, você examina o código no equipamento de teste C++ (tst/ProducerTestFixture.he 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:

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:

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<StreamDefinition>(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:

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 doStreamDefinition:

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:

Se você tiver dados privados do codec para a faixa de áudio, poderá transmiti-los ao chamar a addTrack função. 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 usandoKinesisVideoStream::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::nanoseconds>(
                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));

O objeto Frame tem os seguintes campos:

Para obter mais informações sobre o formato de quadro, consulte Modelo de dados do Kinesis Video Streams.

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 MKV os fragmentos mantenham carimbos de data/hora de quadros monotonicamente crescentes e que quaisquer dois fragmentos não se sobreponham. Por exemplo, o MKV timestamp do primeiro quadro de um fragmento deve sempre ser maior do que o MKV timestamp do último quadro do fragmento anterior.

PutFrameHelper tem os seguintes campos:

Métricas de acesso e registro de métricas

O produtor de C++ SDK inclui funcionalidade para métricas e registro de métricas.

Você pode usar as getKinesisVideoStreamMetrics API operações getKinesisVideoMetrics e 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:

O objeto PStreamMetrics preenchido por getKinesisVideoStreamMetrics contém as seguintes informações:

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

Depois de interromper a transmissão, você pode liberá-la invocando o seguinte: API

kinesis_video_producer_->freeStream(kinesis_video_stream);