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á.

Geração automatizada de imagens em tempo real

O Amazon Kinesis Video Streams oferece a capacidade de transcodificar e entregar imagens. O Kinesis Video Streams extrai automaticamente imagens de dados de vídeo em tempo real e entrega as imagens para seu bucket Amazon S3 especificado. A implementação da extração automatizada de imagens em tempo real envolve as seguintes etapas:

Os procedimentos a seguir fornecem instruções para concluir cada uma dessas etapas.

Se você estiver usando uma chave gerenciada pelo cliente, certifique-se de que a função que executa as PutMedia chamadas (carregador) tenha as seguintes permissões que são necessárias para criptografar e descriptografar dados e para acessar o bucket do Amazon S3.

Para obter mais informações, consulte Como começo a usar a criptografia no lado do servidor?.

O Kinesis Video Streams só gerará e entregará imagens para fragmentos que tenham a tag de geração de imagem. Todos os metadados de fragmentos adicionais fornecidos junto com as tags de geração de imagem do Amazon S3 serão salvos como metadados do Amazon S3.

Veja a seguir um exemplo de como é a estrutura das tags de metadados do fragmento usando o mkvinfo utilitário. A tag de geração de imagem é uma tag simples MKV com uma chave de AWS_KINESISVIDEO_IMAGE_GENERATION e nenhum valor. Para obter mais informações, consulte Exemplo de tags de vídeo na documentação do Matroska.

|+ Tags
| + Tag
|  // MANDATORY: Predefined MKV tag to trigger image generation for the fragment
|  + Simple
|   + Name: AWS_KINESISVIDEO_IMAGE_GENERATION

|  // OPTIONAL: S3 prefix which will be set as prefix for generated image.
|  + Simple
|   + Name: AWS_KINESISVIDEO_IMAGE_PREFIX 
|   + String: image_prefix_in_s3 // 256 bytes max

| // OPTIONAL: Key value pairs that will be persisted as S3 Image object metadata.
|  + Simple
|   + Name: CUSTOM_KEY_1 // Max 128 bytes
|   + String: CUSTOM_VALUE_1 // Max 256 bytes
|  + Simple
|   + Name: CUSTOM_KEY_2 // Max 128 bytes
|   + String: CUSTOM_VALUE_2 // Max 256 bytes

Adicionar tags de geração de imagens a fragmentos

O Kinesis Video Streams gera e entrega imagens somente para fragmentos que têm a tag de geração de imagem. O Kinesis Video Streams reconhece essas tags MKV especiais e inicia o fluxo de trabalho de geração de imagens com base na configuração de processamento de imagem do stream.

Ao usar o SDK do Kinesis Video Streams Producer para fazer upload de mídia, você putKinesisVideoEventMetadata usa o método para adicionar a tag de geração de imagem a cada fragmento que você deseja marcar. Um novo fragmento começa quando putFrame é chamado com um quadro contendo o keyframe sinalizador.

Se você estiver enviando um vídeo pré-gravado, ele poderá ser carregado em uma taxa diferente da taxa em que foi gravado, dependendo da velocidade da sua rede. Recomendamos que você use o timestamp Producer para configurar a geração de imagens se quiser gerar imagens em intervalos regulares com base nos timestamps originais do vídeo, e não usar os timestamps do servidor gerados com base na taxa na qual o Amazon Kinesis Video Streams recebeu seu vídeo.

Para ver um exemplo completo desse código, consulte o exemplo VideoOnlyRealtimeStreamingSamplede código em GitHub.

// Setup sample frame
MEMSET(frameBuffer, 0x00, frameSize);
frame.frameData = frameBuffer;
frame.version = FRAME_CURRENT_VERSION;
frame.trackId = DEFAULT_VIDEO_TRACK_ID;
frame.duration = HUNDREDS_OF_NANOS_IN_A_SECOND / DEFAULT_FPS_VALUE;
frame.decodingTs = defaultGetTime(); // current time
frame.presentationTs = frame.decodingTs;

Frame eofr = EOFR_FRAME_INITIALIZER;

while(defaultGetTime() > streamStopTime) {
    frame.index = frameIndex;
    frame.flags = fileIndex % DEFAULT_KEY_FRAME_INTERVAL == 0 ? FRAME_FLAG_KEY_FRAME : FRAME_FLAG_NONE;
    frame.size = SIZEOF(frameBuffer);

    CHK_STATUS(readFrameData(&frame, frameFilePath));

    // 1. End the previous fragment
    if (frame.flags == FRAME_FLAG_KEY_FRAME && !firstFrame) {
        putKinesisVideoFrame(streamHandle, &eofr);
    }

    // 2. putFrame call
    CHK_STATUS(putKinesisVideoFrame(streamHandle, &frame));

    if (frame.flags == FRAME_FLAG_KEY_FRAME) {
        // 3. Adding the image generation tag
        CHK_STATUS(putKinesisVideoEventMetadata(streamHandle, STREAM_EVENT_TYPE_IMAGE_GENERATION, NULL);)

        // 4. Adding fragment metadata
        for (n = 1; n <= 5; n++) {
            SNPRINTF(metadataKey, METADATA_MAX_KEY_LENGTH, "SAMPLE_KEY_%d", n);
            SNPRINTF(metadataValue, METADATA_MAX_VALUE_LENGTH, "SAMPLE_VALUE_%d", frame.index + n);
            CHK_STATUS(putKinesisVideoFragmentMetadata(streamHandle, metadataKey, metadataValue, FALSE));
        }
    }
    defaultThreadSleep(frame.duration);

    frame.decodingTs += frame.duration;
    frame.presentationTs = frame.decodingTs;
    frameIndex++;
    fileIndex++;
    fileIndex = fileIndex % NUMBER_OF_FRAME_FILES;
    firstFrame = TRUE;
}

// 5. End the final fragment
putKinesisVideoFrame(streamHandle, &eofr);

Os elementos do código de exemplo para configurar quadros de amostra são explicados a seguir:

Usando as amostras para adicionar tags de geração de imagens

Você pode usar o kvs_gstreamer_audio_video_sample no C++ Producer SDK se quiser uma opção de linha de comando para adicionar tags de geração de imagem. Ative esse recurso adicionando o -e both argumento -e image ou, conforme mostrado no exemplo a seguir.

./kvs_gstreamer_audio_video_sample stream-name \
  -f video-to-upload.mp4 \
  -e both

Para obter mais informações sobre esse aplicativo de amostra, consulte o Amazon Kinesis Video Streams CPP GStreamer Producer, o plug-in e o JNI README em. GitHub

Caminho do objeto Amazon S3 (imagem)

O caminho do objeto do S3 descreve a localização no bucket configurado do S3 onde a imagem gerada será entregue. Ele usa o seguinte formato:

ImagePrefix_AccountID_StreamName_ImageTimecode_RandomID.file-extension

Os elementos do caminho do objeto são definidos da seguinte forma:

Neste exemplo, o caminho do objeto para as imagens geradas terá a seguinte aparência:

111122223333_demo-stream_16907729324_f20f9add-75e7-4399-a30f-fc7aefb1bab7.jpg

Recuperação de metadados de imagem

Você pode usar o console do S3 ou a CLI para recuperar os metadados das imagens geradas.

O Kinesis Video Streams define o número do fragmento, a data e hora do produtor e do servidor e os metadados do tipo de conteúdo da imagem gerada, todos formatados como metadados de objetos do Amazon S3. Se alguma tag MKV adicional estiver presente, essas tags também serão adicionadas como metadados de objetos do Amazon S3. O exemplo a seguir mostra como usar o comando da API head-object do Amazon S3 para recuperar os metadados do objeto. A resposta inclui os metadados criados pelo Kinesis Video Streams.

aws s3api head-object --bucket my-bucket-name --key 111122223333_demo-stream_1690707290324_f20f9add-7e57-4399-a30f-fc7aefb1bab7.jpg
{
    "AcceptRanges": "bytes",
    "LastModified": "2023-07-30T08:54:51+00:00",
    "ContentLength": 22693,
    "ETag": "\"63e03cb6d57f77e2db984c1d344b1083\"",
    "ContentType": "image/jpeg",
    "ServerSideEncryption": "AES256",
    "Metadata": {
        "aws_kinesisvideo_producer_timestamp": "1690707290324",
        "aws_kinesisvideo_server_timestamp": "1690707289209",
        "aws_kinesisvideo_fragment_number": "91343852333182036507421233921329142742245756394"
    }
}

Para obter mais informações sobre metadados de objetos do S3, consulte. https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html

Recomendações de URI do Amazon S3 para proteção contra limitação

Se você gravar milhares de imagens no Amazon S3, há o risco de limitação. Para obter mais informações, consulte S3 Prefix Put Request Limits.

Um prefixo do Amazon S3 começa com um limite PUT de 3.500 solicitações PUT por segundo e aumentará gradualmente com o tempo para prefixos exclusivos. Evite usar datas e horários como prefixos do Amazon S3. Os dados codificados por tempo afetarão um prefixo por vez e também mudarão regularmente, invalidando os aumentos de prefixo anteriores.

Para permitir uma escalabilidade mais rápida e consistente do Amazon S3, recomendamos adicionar um prefixo aleatório, como um código hexadecimal ou UUID ao URI de destino do Amazon S3. Por exemplo, prefixos de código hexadecimal naturalmente dividirão suas solicitações aleatoriamente entre 16 prefixos diferentes (um prefixo para cada caractere hexadecimal exclusivo), o que permitirá 56.000 solicitações PUT por segundo após a escalabilidade automática do Amazon S3.