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á.
# Use o SDK do produtor de C\$1\$1 no Raspberry Pi
O Raspberry Pi é um computador pequeno e barato que pode ser usado para ensinar e aprender habilidades básicas de programação de computadores. Este tutorial descreve como você pode configurar e usar o SDK do produtor de C\$1\$1 do Amazon Kinesis Video Streams em um dispositivo Raspberry Pi. As etapas também incluem como verificar a instalação usando o aplicativo de GStreamer demonstração.
**Topics**
+ [Pré-requisitos](producersdk-cpp-rpi-prerequisites.md)
+ [Crie um usuário do IAM com permissão para gravar no Kinesis Video Streams](producersdk-cpp-rpi-iam.md)
+ [Conecte seu Raspberry Pi à sua rede Wi-Fi](producersdk-cpp-rpi-wifi.md)
+ [Conecte-se remotamente ao seu Raspberry Pi](producersdk-cpp-rpi-connect.md)
+ [Configurar a câmera Raspberry Pi](producersdk-cpp-rpi-camera.md)
+ [Pré-requisitos de instalação do software](producersdk-cpp-rpi-software.md)
+ [Baixe e crie o SDK do produtor de C\$1\$1 do Kinesis Video Streams](producersdk-cpp-rpi-download.md)
+ [Transmita vídeo para seu stream de vídeo do Kinesis](producersdk-cpp-rpi-run.md)
+ [Reproduza mídia do seu stream de vídeo do Kinesis](producersdk-cpp-rpi-playback.md)
+ [Solução de problemas de compilação no SDK do produtor de C\$1\$1 para Raspberry Pi](troubleshoot-rpi.md)
# Pré-requisitos
Antes de configurar o SDK do produtor de C\$1\$1 em seu Raspberry Pi, verifique se você tem os seguintes pré-requisitos:
+ Um dispositivo Raspberry Pi com a seguinte configuração:
+ Versão da placa: 3 Model B ou posterior.
+ Um [módulo de câmera](https://www.raspberrypi.com/documentation/accessories/camera.html) conectado ou uma câmera USB conectada (webcam).
+ Um cartão SD com uma capacidade de pelo menos 8 GB.
+ O sistema operacional Raspbian (versão do kernel 4.9 ou posterior) instalado. Você pode baixar a imagem mais recente do sistema operacional Raspberry Pi (anteriormente chamado de Raspbian) no site do [Raspberry Pi](https://www.raspberrypi.com/software/). Siga as instruções do Raspberry Pi para [instalar a imagem obtida por download em um cartão SD](https://www.raspberrypi.com/documentation/computers/getting-started.html#install-an-operating-system).
+ E Conta da AWS com um stream de vídeo do Kinesis. Para obter mais informações, consulte [Conceitos básicos do Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/getting-started.html).
# Crie um usuário do IAM com permissão para gravar no Kinesis Video Streams
Se você ainda não tiver feito isso, configure um usuário AWS Identity and Access Management (IAM) com permissões para gravar em um stream de vídeo do Kinesis.
Esses procedimentos têm como objetivo ajudá-lo a começar rapidamente a usar um par de chaves de AWS acesso. Os dispositivos podem usar certificados X.509 para se conectar. AWS IoT Consulte [Controlando o acesso aos recursos do Kinesis Video Streams usando AWS IoT](how-iot.md) para obter mais informações sobre como configurar seu dispositivo para usar a autenticação baseada em certificado.
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 menu de navegação à esquerda, escolha **Users** (Usuários).
1. Para criar um usuário, selecione **Add user** (Adicionar usuário).
1. Forneça um **Nome do usuário** para o usuário, como **kinesis-video-raspberry-pi-producer**.
1. Em **Access type** (Tipo de acesso), selecione **Programmatic Access** (Acesso programático).
1. Escolha **Próximo: Permissões**.
1. Em **Definir permissões para kinesis-video-raspberry-pi -producer**, escolha **Anexar políticas existentes diretamente**.
1. Selecione **Criar política**. A página **Create policy** (Criar política) é aberta em uma nova guia do navegador da web.
1. Selecione a guia **JSON**.
1. Copie a política JSON a seguir e cole-a na área de texto. Essa política dá permissão ao usuário para criar e gravar dados nos streams de vídeo do Kinesis.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"kinesisvideo:DescribeStream",
"kinesisvideo:CreateStream",
"kinesisvideo:GetDataEndpoint",
"kinesisvideo:PutMedia"
],
"Resource": [
"*"
]
}]
}
```
------
1. Selecione **Revisar política**.
1. Forneça um **Nome** para sua política, como **kinesis-video-stream-write-policy**.
1. Selecione **Criar política**.
1. Retorne à guia **Add user** (Adicionar usuário) no navegador e selecione **Refresh** (Atualizar).
1. Na caixa de pesquisa, digite o nome da política que você criou.
1. Marque a caixa de seleção ao lado da sua nova política na lista.
1. Escolha **Próximo: revisar**.
1. Escolha **Criar usuário**.
1. O console exibe a **Access key ID** (ID de chave de acesso) para o novo usuário. Selecione **Show** (Mostrar) para exibir a **Secret access key** (Chave de acesso secreta). Registre esses valores; eles são necessários quando o aplicativo é configurado.
# Conecte seu Raspberry Pi à sua rede Wi-Fi
Se você estiver usando um monitor e um teclado anexados, prossiga para [Configurar a câmera Raspberry Pi](producersdk-cpp-rpi-camera.md).
Essas instruções foram escritas para ajudá-lo a configurar seu Raspberry Pi quando executado no modo *headless*, ou seja, sem um teclado, monitor ou cabo de rede conectado. Siga as instruções abaixo para configurar seu Raspberry Pi para tentar se conectar automaticamente à rede especificada, permitindo que sua máquina host possa se conectar via SSH a ela.
1. No computador, crie um arquivo chamado `wpa_supplicant.conf`.
1. Copie o texto a seguir e cole-o no `wpa_supplicant.conf` arquivo:
```
country=US
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
ssid="Your Wi-Fi SSID"
scan_ssid=1
key_mgmt=WPA-PSK
psk="Your Wi-Fi Password"
}
```
Substitua os valores `ssid` e `psk` pelas informações da sua rede Wi-Fi.
1. Copie o arquivo `wpa_supplicant.conf` no cartão SD. Ele deve ser copiado na raiz do volume `boot`.
1. Insira o cartão SD no Raspberry Pi e ligue o dispositivo. Isso conecta a rede Wi-Fi e o SSH é habilitado.
# Conecte-se remotamente ao seu Raspberry Pi
Se você estiver usando um monitor e um teclado anexados, prossiga para [Configurar a câmera Raspberry Pi](producersdk-cpp-rpi-camera.md).
Essas instruções foram escritas para ajudá-lo a configurar seu Raspberry Pi quando executado no modo *headless*, ou seja, sem um teclado, monitor ou cabo de rede conectado. Siga as instruções abaixo para localizar seu Raspberry Pi em sua rede e conecte-o SSH a partir de sua máquina host.
1. Antes de se conectar remotamente ao dispositivo Raspberry Pi, execute uma das ações a seguir para determinar seu endereço IP:
+ Se tiver acesso ao roteador Wi-fi da rede, verifique os dispositivos Wi-Fi conectados. Localize o dispositivo chamado `Raspberry Pi` para encontrar o endereço IP do seu dispositivo.
+ Se não tiver acesso ao roteador Wi-fi da rede, você pode usar outro software para localizar os dispositivos nessa rede. O [Fing](https://www.fing.com/) é um aplicativo popular disponível para dispositivos Android e iOS. Você pode usar a versão gratuita desse aplicativo para encontrar os endereços IP dos dispositivos na sua rede.
1. Quando você sabe o endereço IP do dispositivo Raspberry Pi, é possível usar qualquer aplicativo de terminal para conexão.
+ No macOS ou Linux, use `ssh`:
```
ssh pi@
```
+ No Windows, use [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), um cliente SSH gratuito para Windows.
Para obter uma nova instalação do Raspbian, o nome de usuário é **pi** e a senha é **raspberry**. Recomendamos que você [altere a senha padrão](https://www.raspberrypi.com/documentation/computers/configuration.html#change-user-password-nonint).
# Configurar a câmera Raspberry Pi
Siga estas etapas para configurar o [módulo da câmera Raspberry Pi](https://www.raspberrypi.com/documentation/accessories/camera.html) para enviar vídeo do dispositivo para um stream de vídeo do Kinesis.
**nota**
Se você estiver usando uma webcam USB, vá para[Pré-requisitos de instalação do software](producersdk-cpp-rpi-software.md).
------
#### [ Camera module 1 ]
Siga estas instruções para atualizar o arquivo dos módulos, ativar a interface da câmera e verificar a funcionalidade da câmera. A atualização do arquivo de módulos informa ao Raspberry Pi quais módulos do kernel devem ser carregados no momento da inicialização. O driver da câmera não é carregado por padrão para conservar recursos do sistema em dispositivos Raspberry Pi que não estão usando uma câmera.
1. Abra um editor para fazer alterações no arquivo dos módulos. Abra o terminal e use o seguinte comando para editar o arquivo usando o `nano` editor:
```
sudo nano /etc/modules
```
1. Adicione a seguinte linha ao final do arquivo, se ainda não houver uma:
```
bcm2835-v4l2
```
1. Salve o arquivo e saia do editor. Para salvar e sair usando o `nano` editor, use Ctrl\$1X.
1. Reinicie o Raspberry Pi:
```
sudo reboot
```
1. Ao reiniciar o dispositivo, conecte-o novamente por meio do aplicativo de terminal se estiver se conectando remotamente.
1. Aberto `raspi-config`:
```
sudo raspi-config
```
1. Escolha **Opções de interface**, **Câmera antiga**. **Em versões mais antigas do sistema operacional Raspbian, essa opção de menu pode estar em **Opções de interface**, Câmera.**
Habilite a câmera se ainda não estiver habilitada e reinicie se solicitado.
1. Verifique se a câmera está funcionando digitando o seguinte comando:
```
raspistill -v -o test.jpg
```
Se sua câmera estiver configurada corretamente, esse comando captura uma imagem da câmera, a salva em um arquivo chamado `test.jpg` e exibe mensagens informativas.
------
#### [ Camera module 2 or 3 ]
Se você estiver usando um módulo de câmera 2, use `bcm2835-v4l2` (antigo) ou `libcamera` (moderno). No entanto, a `libcamera` pilha é recomendada para obter melhor suporte e recursos. Siga as etapas abaixo para confirmar que `libcamera` está up-to-date no seu sistema.
1. [A libcamera](https://www.raspberrypi.com/documentation/computers/camera_software.html#libcamera) deve vir pré-instalada no seu Raspberry Pi. Verifique se há atualizações e atualize para a versão mais recente para obter correções de erros e atualizações de segurança. Abra o terminal e digite os seguintes comandos:
```
sudo apt-get update
sudo apt-get upgrade
```
1. Reinicie o sistema para que as atualizações entrem em vigor.
```
sudo reboot
```
1. Teste sua câmera. Este aplicativo inicia um stream de pré-visualização da câmera e o exibe na tela.
```
libcamera-hello
```
Se você tiver problemas com o módulo da câmera, consulte a [documentação do Raspberry Pi](https://raspberrypi.com/documentation/computers/camera_software.html#troubleshooting) para solucionar problemas.
------
# Pré-requisitos de instalação do software
O SDK do produtor de C\$1\$1 exige que você instale os seguintes pré-requisitos de software no Raspberry Pi.
1. Atualize a lista de pacotes e instale as bibliotecas necessárias para criar o SDK. Abra o terminal e digite os seguintes comandos:
```
sudo apt-get update
sudo apt-get install -y \
automake \
build-essential \
cmake \
git \
gstreamer1.0-plugins-base-apps \
gstreamer1.0-plugins-bad \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-ugly \
gstreamer1.0-tools \
gstreamer1.0-omx-generic \
libcurl4-openssl-dev \
libgstreamer1.0-dev \
libgstreamer-plugins-base1.0-dev \
liblog4cplus-dev \
libssl-dev \
pkg-config
```
1. Se você estiver usando a `libcamera` pilha, instale também o `libcamerasrc` GStreamer plug-in. Este GStreamer plugin não vem instalado por padrão.
```
sudo apt-get install gstreamer1.0-libcamera
```
1. Copie o arquivo PEM a seguir em `/etc/ssl/cert.pem`:
```
sudo curl https://www.amazontrust.com/repository/AmazonRootCA1.pem -o /etc/ssl/AmazonRootCA1.pem
sudo chmod 644 /etc/ssl/AmazonRootCA1.pem
```
# Baixe e crie o SDK do produtor de C\$1\$1 do Kinesis Video Streams
Siga os procedimentos abaixo para baixar e criar o SDK do produtor de C\$1\$1 do [Kinesis Video Streams](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp). Verifique se você instalou os pré-requisitos do software; veja essas etapas[Pré-requisitos de instalação do software](producersdk-cpp-rpi-software.md).
1. Navegue até o diretório de download. Abra um terminal e mude para o diretório de download de sua preferência.
Por exemplo:
```
cd ~/Downloads
```
1. Clone o repositório do SDK. Use o `git clone` comando para baixar o SDK do GitHub repositório. Tipo:
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git --single-branch -b master kvs-producer-sdk-cpp
```
Esse comando clona somente uma única ramificação (a `master` ramificação), reduzindo o tamanho e o tempo de download. Ele também coloca o conteúdo baixado em uma pasta chamada `kvs-producer-sdk-cpp` dentro do diretório atual.
1. Verifique o download. Quando o processo de clonagem estiver concluído, liste o conteúdo da `kvs-producer-sdk-cpp` pasta para verificar se o SDK foi baixado.
```
ls kvs-producer-sdk-cpp
```
1. Prepare um diretório de compilação. Tipo:
```
mkdir -p kvs-producer-sdk-cpp/build
cd kvs-producer-sdk-cpp/build
```
1. Configure a compilação. Execute o `cmake` comando a seguir para configurar o ambiente de compilação com opções específicas:
```
cmake .. -DBUILD_GSTREAMER_PLUGIN=ON -DBUILD_DEPENDENCIES=OFF -DALIGNED_MEMORY_MODEL=ON
```
[CMake](https://cmake.org/cmake/help/latest/manual/cmake.1.html)usa as seguintes opções para gerar as opções apropriadas`Makefiles`:
+ Usando a pasta do projeto (`..`) como diretório de origem.
+ Usando o diretório atual (`.`) (`build/`) para a saída da compilação.
+ `-DBUILD_GSTREAMER_PLUGIN=ON`permite a construção do GStreamer plugin kvssink.
+ `-DBUILD_DEPENDENCIES=OFF`desativa a criação de dependências externas a partir da fonte. O projeto encontrará e usará as dependências externas instaladas na etapa anterior.
+ `-DALIGNED_MEMORY_MODEL=ON`desativa o modelo de memória desalinhada. O acesso desalinhado à memória não é suportado por determinados dispositivos Raspberry Pi.
**nota**
Para obter uma lista completa dos CMake argumentos, consulte[Baixe e configure o código da biblioteca do produtor C\$1\$1](producersdk-cpp-download.md).
1. Crie o projeto. Depois de configurar a compilação, use o `make` comando para compilar usando o `Makefile` gerado por. `cmake`
```
make -j$(nproc)
```
O `-j` argumento to `make` permite que ele execute vários trabalhos de compilação em paralelo. Para reduzir os tempos de compilação, use o `nproc` comando para calcular dinamicamente o número de núcleos de CPU no seu Raspberry Pi.
1. Confirme se `libgstkvssink.so` está presente.
Listar os arquivos no diretório atual.
**Aviso:**
```
ls
```
**Resposta:**
```
CMakeCache.txt dependency kvs_gstreamer_sample
CMakeFiles kvs_gstreamer_audio_video_sample kvssink_gstreamer_sample
Makefile kvs_gstreamer_file_uploader_sample libKinesisVideoProducer.so
cmake_install.cmake kvs_gstreamer_multistream_sample libgstkvssink.so
```
1. Confirme se isso GStreamer pode ser carregado`kvssink`.
Defina a variável de `GST_PLUGIN_PATH` ambiente para o diretório que contém`libgstkvssink.so`.
```
export GST_PLUGIN_PATH=`pwd`
```
Tenha GStreamer carga`kvssink`:
```
gst-inspect-1.0 kvssink
```
Você deve ver alguma documentação sobre`kvssink`. Use as teclas de seta para navegar e pressione `q` para sair.
1. (**Opcional**) Atualize o script de inicialização do shell para incluir a configuração da variável de `GST_PLUGIN_PATH` ambiente. Isso garante que `GST_PLUGIN_PATH` seja configurado corretamente durante uma nova sessão de terminal. Em dispositivos Raspberry Pi, o script de inicialização do shell é. `~/.bashrc`
Execute o comando a seguir para anexar o comando ao final do script de inicialização do shell.
```
echo "export GST_PLUGIN_PATH=~/Downloads/kvs-producer-sdk-cpp/build" >> ~/.bashrc
```
Digite o seguinte para executar o script de inicialização do shell ou fechar o shell atual e abrir um novo.
```
source ~/.bashrc
```
Confirme `GST_PLUGIN_PATH` se está definido e você pode carregar`kvssink`.
```
echo $GST_PLUGIN_PATH
```
```
gst-inspect-1.0 kvssink
```
# 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.
# Reproduza mídia do seu stream de vídeo do Kinesis
Abra o console do [Kinesis Video](https://console.aws.amazon.com//kinesisvideo/home/) Streams e **selecione o nome do stream para o** stream que você criou.
O streaming de vídeo enviado do Raspberry Pi aparecerá no console.
**nota**
Pode levar alguns segundos até que o vídeo apareça no console.
Depois que a transmissão estiver sendo reproduzida, você poderá experimentar os seguintes recursos no console:
+ Na seção **Video preview** (Visualização de vídeo), use os controles de navegação para retroceder ou avançar rapidamente pelo streaming.
+ Na seção **Informações do stream**, revise o codec, a resolução e a taxa de bits do stream. Os valores de resolução e taxa de bits são definidos propositalmente como baixos no Raspberry Pi para minimizar o uso da largura de banda neste tutorial.
Para ver as CloudWatch métricas da Amazon que estão sendo criadas para seu stream, selecione **View stream metrics in CloudWatch**.
+ Em **Data retention period** (Período de retenção de dados), observe que o streaming de vídeo é retido por um dia. Você pode editar esse valor e defini-lo como **No data retention** (Sem retenção de dados) ou definir um valor de um dia a vários anos.
+ Em **Criptografia do lado do servidor**, observe que seus dados estão sendo criptografados em repouso usando uma chave mantida pelo AWS Key Management Service ().AWS KMS
## Problemas de reprodução
A seguir estão alguns problemas de reprodução encontrados com frequência e como solucioná-los.
### Sem mídia, mas há Acks PERSISTENTES nos registros
Se você ver PERSISTED Acks nos registros, o Kinesis Video Streams ingeriu e armazenou com sucesso a mídia que foi carregada por. `kvssink` Os acks recebidos do Kinesis Video Streams têm essa aparência. No JSON, veja o valor da `"EventType"` chave.
```
{"EventType":"RECEIVED","FragmentTimecode":252200,"FragmentNumber":"12345678901234567890123456724587702494771079511"}
{"EventType":"BUFFERING","FragmentTimecode":252467,"FragmentNumber":"12345678901234567890123456781729223736853277017"}
{"EventType":"RECEIVED","FragmentTimecode":252467,"FragmentNumber":"12345678901234567890123456781729223736853277017"}
{"EventType":"BUFFERING","FragmentTimecode":253000,"FragmentNumber":"12345678901234567890123456738870744847093249408"}
{"EventType":"PERSISTED","FragmentTimecode":252200,"FragmentNumber":"12345678901234567890123456724587702494771079511"}
{"EventType":"PERSISTED","FragmentTimecode":252467,"FragmentNumber":"1234567890123456789012345671729223736853277017"}
```
**Resolução:**
Aguarde um ou dois minutos no console do Kinesis Video Streams e use a seta dupla para a direita. Se nenhuma mídia aparecer, verifique se sua transmissão está sendo enviada para a região correta e revise a grafia do nome da transmissão. Você pode encontrar essas informações nos registros.
Consulte [Forneça uma região para `kvssink`](examples-gstreamer-plugin-parameters.md#kvssink-region) para obter mais informações sobre como o kvssink determina qual região usar.
### A mídia leva muito tempo para ser carregada no Console de gerenciamento da AWS
**Importante**
A experiência de reprodução do console é diferente da experiência de reprodução do HLS e do DASH. Use o exemplo da [página da web hospedada](https://aws-samples.github.io/amazon-kinesis-video-streams-media-viewer/) pelo media player GitHub para testar a reprodução também. O código-fonte da página da web pode ser encontrado [aqui.](https://github.com/aws-samples/amazon-kinesis-video-streams-media-viewer)
A mídia pode carregar lentamente no console devido à baixa largura de banda da rede ou a um dispositivo restrito, mas também pode estar relacionada à codificação e fragmentação do vídeo.
**Fundamentos da codificação de vídeo:**
+ Os codificadores H.264 e H.265 usam quadros-chave (I-Frames) e quadros previstos (P-Frames) para uma compressão eficiente.
+ Os quadros-chave contêm dados completos da imagem, enquanto os quadros P contêm apenas alterações dos quadros anteriores.
+ O “intervalo de quadros-chave” determina a frequência com que os quadros-chave ocorrem no fluxo de vídeo.
**Fragmentação no streaming:**
+ No Kinesis Video Streams, novos fragmentos começam com cada quadro-chave. Para obter mais informações, consulte [Modelo de dados do Kinesis Video Streams](how-data.md).
+ *O comprimento do fragmento (em segundos) pode ser estimado como: *intervalo de quadros-chave ÷ taxa de quadros**
**Exemplo:**
Para um stream com um intervalo de quadros-chave de 30 e uma taxa de quadros de 15 fps:
Comprimento do fragmento = 30 ÷ 15 = 2 segundos
Devido aos intervalos maiores de quadros-chave, fragmentos mais longos aumentam a latência na mídia de streaming.
**Resolução:**
Para melhorar os tempos de carregamento, considere reduzir o intervalo do quadro-chave. Isso criará fragmentos mais curtos, diminuindo a latência, mas também aumentará o tamanho do arquivo de vídeo.
Para o `x264enc` GStreamer elemento, você pode definir explicitamente o intervalo do quadro-chave por meio da propriedade: `key-int-max`
```
x264enc bframes=0 key-int-max=60
```
Ao analisar a saída do log, observe com que frequência o cliente de upload recebe ACKs do Kinesis Video Streams. Quanto mais quadros-chave são gerados, mais ACKs são retornados.
### A mídia está distorcida ou tem artefatos
Para solucionar esse problema, verifique se todos os cabos estão bem conectados. Analise a saída de `libcamera-hello` (ou `raspistill` para câmeras Pi antigas) dos módulos de câmera.
Em seu GStreamer pipeline, `kvssink` substitua por `autovideosink` ou `matroskamux` `filesink` e. Por exemplo:
```
... x264enc tune=zerolatency speed-preset=ultrafast bframes=0 key-int-max=60 byte-stream=true ! h264parse ! matroskamux ! filesink location=output.mkv
```
Examine o arquivo de saída `filesink` ou o reprodutor de mídia que se abre durante o uso `autovideosink` para ver se os artefatos também estão lá.
Analise também a saída do seguinte pipeline:
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
Adicionar elementos ao seu pipeline, como [dewarp](https://gstreamer.freedesktop.org/documentation/opencv/dewarp.html?gi-language=c), pode corrigir as saídas da câmera fish eye.
Revise os codecs de saída compatíveis com sua câmera e ajuste os elementos conforme necessário.
Por exemplo, se sua câmera USB suportar apenas saída JPEG, você precisará usar os `jpegdec` elementos `jpegparse` e para transformar a mídia antes de codificá-la em H.264 usando. `x264enc` Procure ajuda nos GStreamer fóruns para outros usuários com pipelines e/ou configurações de webcam semelhantes.
# Solução de problemas de compilação no SDK do produtor de C\$1\$1 para Raspberry Pi
Se você encontrar um problema de compilação e quiser tentar CMake argumentos diferentes, certifique-se de executar uma compilação limpa. Exclua as `build` pastas `open-source``dependency`, e antes de tentar novamente.
## Crie problemas com o OpenSSL
Se você receber uma saída semelhante à seguinte, isso indica que o OpenSSL detectou incorretamente a arquitetura do sistema.
```
crypto/md5/md5-aarch64.S: Assembler messages:
crypto/md5/md5-aarch64.S:3: Error: unrecognized symbol type ""
crypto/md5/md5-aarch64.S:6: Error: bad instruction `stp x19,x20,[sp,#-80]!'
crypto/md5/md5-aarch64.S:7: Error: bad instruction `stp x21,x22,[sp,#16]'
crypto/md5/md5-aarch64.S:8: Error: bad instruction `stp x23,x24,[sp,#32]'
crypto/md5/md5-aarch64.S:9: Error: bad instruction `stp x25,x26,[sp,#48]'
```
Neste exemplo, ele está tentando criar uma versão de 64 bits (`linux-aarch64`) quando esse Raspberry Pi é na verdade 32 bits. Alguns dispositivos Raspberry Pi têm um kernel de 64 bits, mas um espaço de usuário de 32 bits.
Determine para qual arquitetura o OpenSSL está tentando construir. Você pode encontrar a linha de registro durante a `configure` etapa do OpenSSL:
```
[ 33%] Performing update step for 'project_libopenssl'
-- Already at requested tag: OpenSSL_1_1_1t
[ 44%] No patch step for 'project_libopenssl'
[ 55%] Performing configure step for 'project_libopenssl'
Operating system: x86_64-whatever-linux2
Configuring OpenSSL version 1.1.1t (0x1010114fL) for linux-x86_64
Using os-specific seed configuration
Creating configdata.pm
Creating Makefile
```
Verifique a arquitetura do seu sistema:
+ Revise o número de bits do kernel: execute `uname -m`
+ Revise a quantidade de bits do espaço do usuário: execute `getconf LONG_BIT`
Você também pode revisar as informações da CPU com `cat /proc/cpuinfo` nossos `lscpu` comandos.
**Resolução:**
Para resolver esse problema, adicione o seguinte CMake argumento ao compilar, para garantir que o OpenSSL seja compilado corretamente para a arquitetura ARM de 32 bits:
```
-DBUILD_OPENSSL_PLATFORM=linux-armv4
```
## Solucionar problemas `kvssink` de carregamento no GStreamer
Confirme `GST_PLUGIN_PATH`
Certifique-se de que a variável de `GST_PLUGIN_PATH` ambiente em sua sessão de shell atual aponte para o diretório que contém`kvssink`. As variáveis de ambiente são específicas da sessão, então você precisará defini-las para cada nova sessão. Para tornar essa alteração permanente, consulte “Atualize o script de inicialização do shell para incluir a configuração da variável de ambiente GST\$1PLUGIN\$1PATH”.
**Erro: Não é possível abrir o arquivo de objeto compartilhado: Esse arquivo ou diretório não existe**
Se você encontrar o erro`Cannot open shared object file: No such file or directory`, execute o seguinte comando:
```
gst-inspect-1.0 /path/to/libgstkvssink.so
```
Se você receber a seguinte saída, isso indica que o vinculador dinâmico não consegue localizar as bibliotecas necessárias para`kvssink`. Isso geralmente ocorre devido a:
+ Mudando `kvssink` para um local diferente de onde foi construído.
+ Compilação cruzada para a arquitetura de CPU errada.
+ Falta uma dependência necessária.
**Saída**:
```
WARNING: erroneous pipeline: no element "kvssink"
error while loading shared libraries: libcproducer.so: cannot open shared object file: No such file or directory
```
**Resolução:**
Para **bibliotecas movidas**, adicione o diretório que contém as bibliotecas ausentes `LD_LIBRARY_PATH` a.
No diretório raiz do repositório original, você pode localizar a biblioteca ausente usando o `find` utilitário. No terminal, digite:
```
find . -name "*libcproducer*"
```
**Saída**:
```
./build/dependency/libkvscproducer/kvscproducer-src/libcproducer.so
```
O separador de caminho de arquivo em dispositivos Linux é`:`. O comando abaixo acrescenta um novo caminho de pasta à variável de `LD_LIBRARY_PATH` ambiente existente, preservando todos os valores anteriores.
No seu terminal, digite:
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/build/dependency/libkvscproducer/kvscproducer-src
```
**Importante**
As variáveis de ambiente são específicas da sessão. Para manter as alterações nas sessões, modifique o script de inicialização do seu shell.
Talvez você também precise adicionar o `open-source/local/lib` ao seu`$LD_LIBRARY_PATH`.
**Erro:. /path/to/libcproducer.so.1:** cabeçalho ELF inválido
Se você receber esse erro ao carregar **bibliotecas compartilhadas**, pode ser devido a links simbólicos quebrados (`symlinks`). Os links simbólicos podem ser interrompidos se o sistema operacional da máquina host não corresponder ao da máquina alvo. Por exemplo, compilação cruzada em um MacBook para um Raspberry Pi.
Outra causa possível é que os binários criados eram para a arquitetura errada. Por exemplo, se os binários foram criados para x86 (o Raspberry Pi usa ARM). CPUs
Navegue até o local da biblioteca especificado no erro e digite: `ls -la` para inspecionar a biblioteca`symlinks`.
**Resposta:**
```
drwxr-xr-x 16 me staff 512 Sep 10 17:16 .
drwxr-xr-x 7 me staff 224 Jan 6 23:46 ..
drwxr-xr-x 4 me staff 128 Sep 10 17:16 engines-1.1
-rwxr-xr-x 1 me staff 2294496 Sep 10 17:16 libcrypto.1.1.so
-rw-r--r-- 1 me staff 4002848 Sep 10 17:16 libcrypto.a
lrwxr-xr-x 1 me staff 19 Sep 10 17:16 libcrypto.so -> libcrypto.1.1.so
-rwxr-xr-x 1 me staff 631176 Sep 10 17:12 liblog4cplus-2.0.3.so
lrwxr-xr-x 1 me staff 24 Sep 10 17:12 liblog4cplus.so -> liblog4cplus-2.0.3.so
-rwxr-xr-x 1 me staff 1012 Sep 10 17:12 liblog4cplus.a
-rwxr-xr-x 1 me staff 694328 Sep 10 17:12 liblog4cplusU-2.0.3.so
lrwxr-xr-x 1 me staff 25 Sep 10 17:12 liblog4cplusU.dylib -> liblog4cplusU-2.0.3.so
-rwxr-xr-x 1 me staff 1017 Sep 10 17:12 liblog4cplusU.a
-rwxr-xr-x 1 me staff 536416 Sep 10 17:16 libssl.1.1.so
-rw-r--r-- 1 me staff 795184 Sep 10 17:16 libssl.a
lrwxr-xr-x 1 me staff 16 Sep 10 17:16 libssl.so -> libssl.1.1.so
drwxr-xr-x 6 me staff 192 Sep 10 17:16 pkgconfig
```
No exemplo de saída acima, `symlinks` eles não estão quebrados. Broken `symlinks` não terá flechas apontando para seus alvos.
**Resolução:**
Há duas opções para corrigir os links simbólicos:
+ **Recomendado:** Recrie o `symlink` com o `ln` comando. Tipo:
```
ln -s /path/to/actual/library /path/to/symlink
```
+ Copie o arquivo real da biblioteca e renomeie-o para corresponder ao`symlink`.
**nota**
Essa opção leva ao aumento do uso do armazenamento.
Como prática recomendada, compile no mesmo sistema operacional usando ferramentas como o Docker para evitar problemas de compilação cruzada.
**Dependências ausentes:**
Se o nome da biblioteca ausente começar com`libkvs`, consulte a seção “bibliotecas movidas” acima para instalar as bibliotecas do Kinesis Video Streams do dispositivo host para o dispositivo de destino.
Caso contrário, siga [Pré-requisitos de instalação do software](producersdk-cpp-rpi-software.md) para garantir que todos os pré-requisitos do software de código aberto estejam instalados no dispositivo de destino.