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á. # Transmita vídeo para seu stream de vídeo do Kinesis Para executar o aplicativo de amostra, você precisa das seguintes informações: + O nome do streaming que você criou na seção [Pré-requisitos](producersdk-cpp-rpi-prerequisites.md). + As credenciais da conta (ID de chave de acesso e chave de acesso secreta) que você criou em [Crie um usuário do IAM com permissão para gravar no Kinesis Video Streams](producersdk-cpp-rpi-iam.md). + GStreamer é capaz de localizar o `kvssink` plugin. Consulte [Baixe e crie o SDK do produtor de C\$1\$1 do Kinesis Video Streams](producersdk-cpp-rpi-download.md) para obter mais informações. 1. Defina as credenciais e a região. ``` export AWS_ACCESS_KEY_ID=YourAccessKey export AWS_SECRET_ACCESS_KEY=YourSecretKey export AWS_DEFAULT_REGION=us-west-2 ``` Para outros métodos de autenticação, consulte[Forneça credenciais para `kvssink`](examples-gstreamer-plugin-parameters.md#credentials-to-kvssink). **nota** O SDK do produtor de C\$1\$1 usa a região Oeste dos EUA (Oregon) (`us-west-2`) por padrão. Para usar o padrão, Região da AWS crie seu stream de vídeo do Kinesis na região Oeste dos EUA (Oregon). Para usar uma região diferente para seu stream de vídeo do Kinesis, defina a seguinte variável de ambiente para sua região (por exemplo,*us-east-1*): ``` export AWS_DEFAULT_REGION=us-east-1 ``` 1. Dependendo da mídia de entrada, escolha uma das seguintes opções: ------ #### [ Sample GStreamer video ] Esse GStreamer pipeline gera um stream de vídeo de teste ao vivo com um padrão de teste padrão executado a 10 quadros por segundo com uma resolução de 640x480 pixels. Uma sobreposição é adicionada exibindo a hora e a data atuais do sistema. O vídeo é então codificado no formato H.264 e os quadros-chave são gerados no máximo a cada 10 quadros, resultando em uma duração de fragmento (também conhecida como tamanho de grupo de imagens (GoP)) de 1 segundo. O kvssink pega o stream de vídeo codificado em H.264, o empacota no formato de contêiner Matroska (MKV) e o carrega no stream de vídeo do Kinesis. Execute este comando: . ``` gst-launch-1.0 -v videotestsrc is-live=true \ ! video/x-raw,framerate=10/1,width=640,height=480 \ ! clockoverlay time-format="%a %B %d, %Y %I:%M:%S %p" \ ! x264enc bframes=0 key-int-max=10 \ ! h264parse \ ! kvssink stream-name="YourStreamName" ``` Para interromper o GStreamer pipeline, selecione a janela do terminal e pressione **CTRL\$1C**. O exemplo de GStreamer pipeline de vídeo tem a seguinte aparência: ![\[Imagem do padrão de teste padrão com carimbo de data e hora sobreposto.\]](http://docs.aws.amazon.com/pt_br/kinesisvideostreams/latest/dg/images/sample-video.png) ------ #### [ USB web cam ] Execute o comando a seguir para GStreamer detectar automaticamente sua câmera USB: ``` gst-launch-1.0 autovideosrc \ ! videoconvert \ ! video/x-raw,format=I420,width=640,height=480 \ ! x264enc bframes=0 key-int-max=45 tune=zerolatency byte-stream=true speed-preset=ultrafast \ ! h264parse \ ! video/x-h264,stream-format=avc,alignment=au,profile=baseline \ ! kvssink stream-name="YourStreamname" ``` Para interromper o GStreamer pipeline, selecione a janela do terminal e pressione **CTRL\$1C**. Em vez de permitir a GStreamer detecção automática, você pode usar `v4l2src` com um identificador de dispositivo específico. Execute este comando: . ``` gst-device-monitor-1.0 ``` Na saída, você verá alguns dispositivos e o início de um GStreamer pipeline de como usar o dispositivo: ``` Device found: name : H264 USB Camera: USB Camera class : Video/Source caps : video/x-h264, stream-format=(string)byte-stream, alignment=(string)au, width=(int)1920, height=(int)1080, pixel-aspect-ratio=(fraction)1/1, colorimetry=(string){ 2:4:7:1 }, framerate=(fraction){ 30/1, 25/1, 15/1 }; ... properties: device.path = /dev/video4 udev-probed = false device.api = v4l2 v4l2.device.driver = uvcvideo v4l2.device.card = "H264\ USB\ Camera:\ USB\ Camera" v4l2.device.bus_info = usb-3f980000.usb-1.3 v4l2.device.version = 265767 (0x00040e27) v4l2.device.capabilities = 2216689665 (0x84200001) v4l2.device.device_caps = 69206017 (0x04200001) gst-launch-1.0 v4l2src device=/dev/video4 ! ... ``` Para interromper o GStreamer pipeline, selecione a janela do terminal e pressione **CTRL\$1C**. ------ #### [ Raspberry Pi camera module 1 ] Se você estiver usando o módulo de câmera Pi 1 ou o módulo de câmera Pi 2 com`bcm2835-v4l2`, use o seguinte: ``` gst-launch-1.0 v4l2src device=/dev/video0 \ ! videoconvert \ ! video/x-raw,format=I420,width=640,height=480 \ ! x264enc bframes=0 key-int-max=45 bitrate=500 tune=zerolatency \ ! h264parse ! video/x-h264,stream-format=avc,alignment=au,profile=baseline \ ! kvssink stream-name="YourStreamname" ``` Para interromper o GStreamer pipeline, selecione a janela do terminal e pressione **CTRL\$1C**. ------ #### [ Raspberry Pi camera module 2 or 3 ] Se você estiver usando a `libcamera` pilha moderna, use o seguinte GStreamer pipeline: ``` gst-launch-1.0 libcamerasrc \ ! video/x-raw,width=640,height=480,framerate=30/1,format=I420 \ ! videoconvert \ ! x264enc speed-preset=ultrafast tune=zerolatency byte-stream=true key-int-max=75 \ ! video/x-h264,level='(string)4' \ ! h264parse \ ! video/x-h264,stream-format=avc,alignment=au,width=640,height=480,framerate=30/1 \ ! kvssink stream-name="YourStreamname" ``` Para interromper o GStreamer pipeline, selecione a janela do terminal e pressione **CTRL\$1C**. ------ #### [ Sample RTSP camera ] Neste exemplo, usamos para Gst-Rtsp-Server hospedar localmente um feed de câmera RTSP de demonstração. Em seguida, construímos um GStreamer pipeline para fazer o upload desse feed de câmera RTSP para o stream de vídeo especificado do Kinesis. **Para configurar Gst-Rtsp-Server em seu Raspberry Pi** 1. Instale as bibliotecas de dependências necessárias para criar o Gst-Rtsp-Server projeto. Verifique se você também tem os pré-requisitos do software instalados. Digite o seguinte em seu terminal: ``` sudo apt-get update sudo apt-get install libgstrtspserver-1.0 ``` 1. Baixe a versão 1.22 do GStreamer em seu Raspberry Pi. ``` git clone https://gitlab.freedesktop.org/gstreamer/gstreamer.git --single-branch -b 1.22 ``` 1. Altere os diretórios para o diretório de exemplos no gst-rtsp-server. ``` cd gstreamer cd subprojects cd gst-rtsp-server cd examples ``` 1. Compile o test-launch.c em um executável chamado test-launch usando o gcc. ``` gcc -o test-launch test-launch.c `pkg-config --cflags --libs gstreamer-rtsp-server-1.0` ``` 1. Execute o executável com os seguintes argumentos. Observação: GStreamer pode levar algum tempo para carregar pela primeira vez. ``` ./test-launch "videotestsrc is-live=true ! video/x-raw,height=480,width=640,framerate=10/1 ! videoconvert ! x264enc tune=zerolatency bitrate=512 key-int-max=25 bframes=0 ! h264parse ! rtph264pay ! name=pay0 pt=96" ``` A seguinte saída deverá ser mostrada: ``` stream ready at rtsp://127.0.0.1:8554/test ``` 1. Verifique o stream de vídeo RTSP. Você pode usar qualquer visualizador RTSP. Por exemplo, reprodutor de mídia VLC. Para usar o media player VLC para ver sua transmissão ao vivo, abra um novo terminal e digite: ``` sudo apt-get install vlc ``` para instalar o reprodutor de mídia VLC. Em seguida, digite: ``` vlc rtsp://127.0.0.1:8554/test ``` Uma janela do VLC deve aparecer com a transmissão ao vivo. Caso contrário, verifique se o executável test-launch ainda está em execução e verifique se há erros na saída. Outra forma de verificar o fluxo RTSP é usando o utilitário gst-discoverer-1.0. Tipo: ``` gst-discoverer-1.0 "rtsp://127.0.0.1:8554/test" ``` A saída esperada é semelhante a esta: ``` Analyzing rtsp://127.0.0.1:8554/test Done discovering rtsp://127.0.0.1:8554/test Properties: Duration: 99:99:99.999999999 Seekable: no Live: yes unknown #0: application/x-rtp video #1: H.264 (Constrained Baseline Profile) Stream ID: 359314d7d4bba383223927d7e57d4244d0800e629c626be81c505055c62170e2/video:0:0:RTP:AVP:96 Width: 640 Height: 480 Depth: 24 Frame rate: 10/1 Pixel aspect ratio: 1/1 Interlaced: false Bitrate: 0 Max bitrate: 0 ``` **Para enviar o feed RTSP para seu Kinesis Video Stream usando kvssink** Esse GStreamer pipeline é usado `rtspsrc` para se conectar ao servidor RTSP para buscar o fluxo de vídeo RTP. Ele passa os quadros para o`rtph264depay`, que extrai os quadros de vídeo codificados em H.264 dos pacotes RTP. `h264parse`agrupa os quadros de vídeo em um formato `kvssink` que possa entender. `kvssink`pega o stream de vídeo codificado em H.264, o empacota no formato de contêiner Matroska (MKV) e o carrega no seu stream de vídeo do Kinesis. Execute este comando: . ``` gst-launch-1.0 -v rtspsrc location="rtsp://127.0.0.1:8554/test" short-header=true \ ! rtph264depay \ ! h264parse \ ! video/x-h264,format=avc,alignment=au \ ! kvssink stream-name="YourStreamName" ``` Para interromper o GStreamer pipeline, selecione a janela do terminal e pressione **CTRL\$1C**. ------ ## Utilize hardware Alguns modelos de Raspberry Pi vêm com codificadores H.264 acelerados por hardware. Você pode usá-los no lugar de`x264enc`, que é um codificador de software. 1. Certifique-se de que os GStreamer plug-ins estejam instalados: ``` sudo apt-get install gstreamer1.0-tools gstreamer1.0-plugins-bad ``` 1. Tipo: ``` gst-inspect-1.0 | grep h264 ``` Determine se os seguintes elementos estão disponíveis: + omxh264enc + v4l2h264enc Se estiverem disponíveis, você poderá usá-los. Aqui estão alguns exemplos de funis usando esses elementos: **`omxh264enc`:** ``` gst-launch-1.0 v4l2src device=/dev/video0 \ ! videoconvert \ ! video/x-raw,format=I420,width=640,height=480 \ ! omxh264enc control-rate=2 target-bitrate=512000 periodicity-idr=45 inline-header=FALSE \ ! h264parse ! video/x-h264,stream-format=avc,alignment=au,profile=baseline \ ! kvssink stream-name="raspberry" ``` **`v4l2h264enc`e`v4l2convert`:** ``` gst-launch-1.0 libcamerasrc \ ! video/x-raw,width=640,height=480,framerate=30/1,format=I420 \ ! v4l2convert \ ! v4l2h264enc extra-controls="controls,repeat_sequence_header=1" \ ! video/x-h264,level='(string)4' \ ! h264parse \ ! video/x-h264,stream-format=avc,alignment=au,width=640,height=480,framerate=30/1 \ ! kvssink stream-name="test-stream" ``` ## Problemas de tempo de execução A seguir estão alguns problemas de tempo de execução encontrados com frequência e como solucioná-los. ### Não existe esse elemento “xxxxxxxxx” Se você receber um erro como o seguinte, significa que está faltando um GStreamer plug-in: ``` WARNING: erroneous pipeline: no element "videoconvert" ``` **Resolução:** Com base no elemento ausente, determine a ação apropriada: + `kvssink`: Consulte [Baixe e crie o SDK do produtor de C\$1\$1 do Kinesis Video Streams](producersdk-cpp-rpi-download.md). + `libcamerasrc`: Consulte [Erro “Falha na ativação do buffer pool”](#rpi-troubleshoot-buffer) para instalar o `libcamerasrc` GStreamer elemento. + `omxh264enc`ou`v4l2h264enc`: Siga [Pré-requisitos de instalação do software](producersdk-cpp-rpi-software.md) para instalar todas as GStreamer bibliotecas. Se você instalou todos eles e esses elementos não aparecem, isso significa que seu Raspberry Pi não tem o hardware. `x264enc`Em vez disso, use o codificador de software. + Outros: siga [Pré-requisitos de instalação do software](producersdk-cpp-rpi-software.md) para instalar todas as GStreamer bibliotecas. Diferentes GStreamer elementos são encontrados nos vários grupos de GStreamer plugins (bons, ruins, feios), então certifique-se de instalar todos eles. ### Erro “Falha na ativação do buffer pool” Se você receber um erro como o seguinte, significa que o pipeline que está sendo usado está sendo usado`v4l2src`, mas deve ser usado `libcamerasrc` em vez disso. ``` ERROR bufferpool gstbufferpool.c:572:gst_buffer_pool_set_active:source:pool0:src start failed WARN v4l2src gstv4l2src.c:976:gst_v4l2src_decide_allocation: error: Failed to allocate required memory. WARN v4l2src gstv4l2src.c:976:gst_v4l2src_decide_allocation: error: Buffer pool activation failed WARN basesrc gstbasesrc.c:3352:gst_base_src_prepare_allocation: Subclass failed to decide allocation Error received from element source: Failed to allocate required memory. WARN basesrc gstbasesrc.c:3132:gst_base_src_loop: error: Internal data stream error. Debugging information: ../sys/v4l2/gstv4l2src.c(976): gst_v4l2src_decide_allocation (): /GstPipeline:live-kinesis-pipeline/GstV4l2Src:source: Buffer pool activation failed WARN basesrc gstbasesrc.c:3132:gst_base_src_loop: error: streaming stopped, reason not-negotiated (-4) ``` Por exemplo, se você estiver usando o seguinte pipeline com o módulo de câmera 2 sem `libcamerasrc` instalado, poderá encontrar esse erro ao GStreamer tentar detectar automaticamente quais elementos usar. ``` gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink ``` **Resolução:** Certifique-se de que `libcamerasrc` esteja instalado e use-o como elemento de origem, em vez de`v4l2src`. Digite o seguinte para instalar o `libcamerasrc` GStreamer elemento: ``` sudo apt-get update sudo apt-get install gstreamer1.0-libcamera ``` Uma vez `libcamerasrc` instalado, se você estiver usando o `autovideosrc` elemento, GStreamer deve alternar automaticamente para usar a fonte correta `libcamerasrc` em vez de`v4l2src`. ### Erro de ônibus Se você receber um erro de barramento logo após a inicialização `kvssink` (normalmente, na época em que a chamada HTTP é `PutMedia` concluída), isso significa que seu Raspberry Pi não suporta acesso desalinhado à memória. Os registros terão a seguinte aparência: ``` INFO Camera camera.cpp:1197 configuring streams: (0) 640x480-YUV420 INFO RPI pisp.cpp:1450 Sensor: /base/axi/pcie@120000/rp1/i2c@88000/imx708@1a - Selected sensor format: 1536x864-SBGGR10_1X10 - Selected CFE format: 1536x864-PC1B [INFO ] kinesisVideoStreamFormatChanged(): Stream format changed. [DEBUG] setRequestHeader(): Appending header to request: user-agent -> AWS-SDK-KVS-CPP-CLIENT/3.4.2/1.5.3 GCC/12.2.0 Linux/6.6.51+rpt-rpi-v8 aarch64 CPPSDK [DEBUG] setRequestHeader(): Appending header to request: x-amzn-stream-name -> demo-stream [DEBUG] setRequestHeader(): Appending header to request: x-amzn-producer-start-timestamp -> 1732012345.678 [DEBUG] setRequestHeader(): Appending header to request: x-amzn-fragment-acknowledgment-required -> 1 [DEBUG] setRequestHeader(): Appending header to request: x-amzn-fragment-timecode-type -> ABSOLUTE [DEBUG] setRequestHeader(): Appending header to request: transfer-encoding -> chunked [DEBUG] setRequestHeader(): Appending header to request: connection -> keep-alive [INFO ] putStreamResultEvent(): Put stream result event. New upload handle 0 [WARN ] notifyDataAvailable(): [demo-stream] Failed to un-pause curl with error: 43. Curl object 0xe2f6f418 Bus error ``` O Kinesis Video Streams PIC usa acesso não alinhado à memória para otimizar o uso da memória, o que não é suportado por todos os dispositivos. **Resolução:** Para usar o SDK no modo de acesso à memória alinhada, você precisa definir explicitamente o `ALIGNED_MEMORY_MODEL` CMake sinalizador como `ON` ao compilar`kvssink`, já que o padrão é. `OFF` Consulte [Baixe e crie o SDK do produtor de C\$1\$1 do Kinesis Video Streams](producersdk-cpp-rpi-download.md) para obter instruções mais detalhadas. ### O timestamp congela e o oleoduto para Ao usar `x264enc` em um GStreamer pipeline, você pode encontrar situações em que o cronograma do pipeline diminua significativamente ou pare completamente em alguns segundos. Isso ocorre porque as configurações `x264enc` padrão podem introduzir uma alta latência de codificação, que excede a capacidade do buffer de entrada padrão. Como resultado, o buffer de entrada se enche, fazendo com que os elementos a montante se bloqueiem e a tubulação pare. Para obter mais informações, consulte a [documentação do GStreamer ](https://gstreamer.freedesktop.org/documentation/x264/index.html?gi-language=c). **Resolução:** Configure `x264enc` com a opção `zerolatency` de ajuste. Isso reduz significativamente a latência da codificação, otimizando para cenários em tempo real, garantindo que os quadros sejam processados e produzidos mais rapidamente. Exemplo de configuração: ``` ... ! x264enc tune=zerolatency byte-stream=true speed-preset=ultrafast bframes=0 key-int-max=60 ! ... ``` **nota** Embora essa solução evite efetivamente a paralisação da tubulação, ela pode afetar a eficiência e a qualidade da codificação. Para cenários que exigem baixa latência e alta qualidade, considere abordagens alternativas, como usar otimizações de hardware ou encontrar uma webcam que produza H.264 diretamente, ignorando essa etapa de codificação. Para obter mais informações, consulte [Utilize hardware](#producersdk-cpp-rpi-utilize). ### Não é possível executar vários pipelines do mesmo `v4l2` dispositivo ao mesmo tempo Dispositivos como o só `/dev/video0` podem ser acessados por um processo por vez. Se vários processos tentarem acessá-lo ao mesmo tempo, o segundo espera até que o primeiro seja concluído. **Resolução:** Crie um dispositivo de loopback, permitindo que vários processos usem a interface de loopback ao mesmo tempo. Para obter mais informações, consulte [Stack Exchange](https://raspberrypi.stackexchange.com/questions/19630/take-picam-image-while-motion-is-running/19897#19897). ### Erro interno do fluxo de dados Ao criar um GStreamer pipeline, você conecta elementos vinculando o bloco de origem de um elemento ao coletor de outro elemento. Esse processo de vinculação permite o fluxo de dados do elemento de origem para o elemento coletor, formando um pipeline de dados. A mensagem de erro “Falha no link do teclado” no registro GStreamer indica que houve um problema ao tentar estabelecer uma conexão (link) entre os blocos de dois elementos em seu pipeline. ``` Pad link failed Error received from element udpsrc0: Internal data stream error. ``` **Resolução:** Determine quais elementos não estão se vinculando entre si. Para reduzir o escopo da tubulação, remova os elementos da tubulação. Substitua o elemento mais à direita por `fakesink` e remova os elementos um de cada vez. Talvez seja necessário ajustar os elementos [capsfilter](https://gstreamer.freedesktop.org/documentation/coreelements/capsfilter.html?gi-language=c) e and/or alterar quais elementos seu pipeline usa. Casos comuns são a solicitação de um `framerate` ou `resolution` que a câmera não suporta. Use `gst-device-monitor-1.0` no terminal para obter o suporte `framerates``resolutions`, `formats` e. Você pode usar o GStreamer elemento de [escala de vídeo](https://gstreamer.freedesktop.org/documentation/videoconvertscale/videoscale.html?gi-language=c) para ajustar a resolução do vídeo e a taxa de vídeo para ajustar a [taxa de quadros do vídeo](https://gstreamer.freedesktop.org/documentation/videorate/?gi-language=c). Para inspecionar os formatos suportados para um GStreamer elemento individual, digite `gst-inspect-1.0 element-name` no terminal.