Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Utilice el SDK para productores de C\$1\$1 en Raspberry Pi
El Raspberry Pi es un equipo pequeño y económico que se puede utilizar para enseñar y aprender habilidades básicas de programación informática. En este tutorial se describe cómo configurar y utilizar el SDK para productores de C\$1\$1 de Amazon Kinesis Video Streams en un dispositivo Raspberry Pi. Los pasos también incluyen cómo verificar la instalación mediante la aplicación de GStreamer demostración.
**Topics**
+ [Requisitos previos](producersdk-cpp-rpi-prerequisites.md)
+ [Cree un usuario de IAM con permiso para escribir en Kinesis Video Streams](producersdk-cpp-rpi-iam.md)
+ [Conecte su Raspberry Pi a su red Wi-Fi](producersdk-cpp-rpi-wifi.md)
+ [Conéctate remotamente a tu Raspberry Pi](producersdk-cpp-rpi-connect.md)
+ [Configura la cámara Raspberry Pi](producersdk-cpp-rpi-camera.md)
+ [Requisitos previos de instalación del software](producersdk-cpp-rpi-software.md)
+ [Descargue y cree el SDK para productores de Kinesis Video Streams C\$1\$1](producersdk-cpp-rpi-download.md)
+ [Transmita vídeo a su transmisión de vídeo de Kinesis](producersdk-cpp-rpi-run.md)
+ [Reproduzca contenido multimedia de su transmisión de vídeo de Kinesis](producersdk-cpp-rpi-playback.md)
+ [Solución de problemas de compilación en el SDK para productores de C\$1\$1 para Raspberry Pi](troubleshoot-rpi.md)
# Requisitos previos
Antes de configurar el SDK para productores de C\$1\$1 en su Raspberry Pi, asegúrese de cumplir los siguientes requisitos previos:
+ Un dispositivo Raspberry Pi con la siguiente configuración:
+ Versión de placa: 3 Modelo B o posterior.
+ Un [módulo de cámara](https://www.raspberrypi.com/documentation/accessories/camera.html) conectado o una cámara USB (cámara web) conectada.
+ Una tarjeta SD con una capacidad de al menos 8 GB.
+ El sistema operativo Raspbian (versión de kernel 4.9 o posterior) instalado. Puedes descargar la imagen más reciente del sistema operativo Raspberry Pi (anteriormente llamado Raspbian) desde el [sitio web de Raspberry Pi](https://www.raspberrypi.com/software/). Siga las instrucciones de Raspberry Pi para [instalar la imagen descargada en una tarjeta SD](https://www.raspberrypi.com/documentation/computers/getting-started.html#install-an-operating-system).
+ Y Cuenta de AWS con una transmisión de vídeo de Kinesis. Para obtener más información, consulte [Introducción a secuencias de vídeo de Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/getting-started.html).
# Cree un usuario de IAM con permiso para escribir en Kinesis Video Streams
Si aún no lo ha hecho, configure un usuario AWS Identity and Access Management (IAM) con permisos para escribir en una transmisión de vídeo de Kinesis.
Estos procedimientos están diseñados para ayudarle a empezar rápidamente a utilizar un key pair de claves de AWS acceso. Los dispositivos pueden usar certificados X.509 para conectarse AWS IoT. Consulte [Control del acceso a los recursos de Kinesis Video Streams mediante AWS IoT](how-iot.md) para obtener más información sobre cómo configurar el dispositivo para que utilice la autenticación basada en certificados.
1. Inicie sesión en la consola de IAM Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. En el menú de navegación de la izquierda, elija **Users** (Usuarios).
1. Para crear un nuevo usuario, seleccione **Add user** (Añadir usuario).
1. Proporcione un **User name (Nombre de usuario)** descriptivo como, por ejemplo, **kinesis-video-raspberry-pi-producer**.
1. En **Access type** (Tipo de acceso), seleccione **Programmatic access** (Acceso mediante programación).
1. Elija **Siguiente: permisos**.
1. En **Establecer permisos para kinesis-video-raspberry-pi -producer**, selecciona **Adjuntar directamente las políticas existentes**.
1. Elija **Crear política**. Se abre la página **Create policy** (Crear política) en una nueva pestaña del navegador web.
1. Seleccione la pestaña **JSON**.
1. Copie la siguiente política JSON y péguela en el área de texto. Esta política otorga a su usuario permiso para crear y escribir datos en las transmisiones de vídeo de Kinesis.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"kinesisvideo:DescribeStream",
"kinesisvideo:CreateStream",
"kinesisvideo:GetDataEndpoint",
"kinesisvideo:PutMedia"
],
"Resource": [
"*"
]
}]
}
```
------
1. Elija **Revisar política**.
1. Especifique un **Name (Nombre)** para la política como, por ejemplo, **kinesis-video-stream-write-policy**.
1. Elija **Crear política**.
1. Vuelva a la pestaña **Add user** (Añadir usuario) en su navegador y elija **Refresh** (Actualizar).
1. En el cuadro de búsqueda, escriba el nombre de la política que ha creado.
1. Seleccione la casilla de verificación situada junto a la nueva política en la lista.
1. Elija **Siguiente: Revisar**.
1. Seleccione la opción **Crear usuario**.
1. La consola muestra el **Access key ID** (ID de clave de acceso) del nuevo usuario. Elija **Show** (Mostrar) para mostrar la **Secret access key** (Clave de acceso secreta). Anote estos valores, ya que son necesarios a la hora de configurar la aplicación.
# Conecte su Raspberry Pi a su red Wi-Fi
Si utiliza un monitor y teclado conectados, vaya a [Configura la cámara Raspberry Pi](producersdk-cpp-rpi-camera.md).
Estas instrucciones están escritas para ayudarte a configurar tu Raspberry Pi cuando se ejecuta en modo *headless*, es decir, sin un teclado, monitor o cable de red conectados. Sigue las instrucciones que aparecen a continuación para configurar tu Raspberry Pi para que intente conectarse automáticamente a la red especificada, lo que permitirá que la máquina host pueda acceder a ella mediante SSH.
1. En el equipo, cree un archivo denominado `wpa_supplicant.conf`.
1. Copia el siguiente texto y pégalo en el `wpa_supplicant.conf` archivo:
```
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"
}
```
Reemplace los valores `ssid` y `psk` por la información de su red wifi.
1. Copie el archivo `wpa_supplicant.conf` en la tarjeta SD. Se debe copiar en la raíz del volumen `boot`.
1. Inserte la tarjeta SD en el Raspberry Pi y encienda el dispositivo. Se conecta a su red wifi y SSH está habilitado.
# Conéctate remotamente a tu Raspberry Pi
Si utiliza un monitor y teclado conectados, vaya a [Configura la cámara Raspberry Pi](producersdk-cpp-rpi-camera.md).
Estas instrucciones están escritas para ayudarte a configurar tu Raspberry Pi cuando se ejecuta en modo *headless*, es decir, sin un teclado, monitor o cable de red conectados. Sigue las instrucciones que aparecen a continuación para localizar tu Raspberry Pi en la red y conectarla mediante SSH desde tu máquina host.
1. Antes de conectarse a su dispositivo Raspberry Pi de forma remota, realice una de las siguientes operaciones para determinar su dirección IP:
+ Si tiene acceso al router wifi de su red, mire los dispositivos wifi conectados. Busque el dispositivo denominado `Raspberry Pi` para encontrar la dirección IP del dispositivo.
+ Si no tiene acceso al router wifi de su red, puede utilizar otro software para buscar dispositivos en su red. [Fing](https://www.fing.com/) es una aplicación popular que está disponible tanto para dispositivos Android como iOS. Puede utilizar la versión gratuita de esta aplicación para buscar las direcciones IP de dispositivos en su red.
1. Cuando sepa la dirección IP del dispositivo Raspberry Pi, puede utilizar cualquier aplicación de terminal para conectarse.
+ En macOS o Linux, utilice `ssh`:
```
ssh pi@
```
+ En Windows, utilice [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), un cliente SSH gratuito para Windows.
En una nueva instalación de Raspbian, el nombre de usuario es **pi** y la contraseña es **raspberry**. Le recomendamos que cambie [la contraseña predeterminada](https://www.raspberrypi.com/documentation/computers/configuration.html#change-user-password-nonint).
# Configura la cámara Raspberry Pi
Siga estos pasos para configurar el [módulo de cámara Raspberry Pi](https://www.raspberrypi.com/documentation/accessories/camera.html) para enviar vídeo desde el dispositivo a una transmisión de vídeo de Kinesis.
**nota**
Si utiliza una cámara web USB, vaya a[Requisitos previos de instalación del software](producersdk-cpp-rpi-software.md).
------
#### [ Camera module 1 ]
Siga estas instrucciones para actualizar el archivo de módulos, habilitar la interfaz de la cámara y verificar el funcionamiento de la cámara. La actualización del archivo de módulos indica a la Raspberry Pi qué módulos del núcleo debe cargar en el momento del arranque. El controlador de la cámara no se carga de forma predeterminada para conservar los recursos del sistema en los dispositivos Raspberry Pi que no utilizan una cámara.
1. Abre un editor para realizar cambios en el archivo del módulo. Abre el terminal y usa el siguiente comando para editar el archivo con el `nano` editor:
```
sudo nano /etc/modules
```
1. Añada la siguiente línea al final del archivo, si aún no se ha añadido:
```
bcm2835-v4l2
```
1. Guarde el archivo y salga del editor. Para guardar y salir con el `nano` editor, utilice Ctrl\$1X.
1. Reinicie el Raspberry Pi:
```
sudo reboot
```
1. Cuando el dispositivo se reinicie, vuelva a conectarse a través de su aplicación de terminal si se está conectando de forma remota.
1. Abrir `raspi-config`:
```
sudo raspi-config
```
1. **Elija **Opciones de interfaz**, Legacy Camera.** **En versiones anteriores del sistema operativo Raspbian, esta opción de menú podría estar en **Opciones de interfaz**, Cámara.**
Habilite la cámara si aún no está habilitada y reiníciela si se le solicita.
1. Compruebe que la cámara funciona escribiendo el siguiente comando:
```
raspistill -v -o test.jpg
```
Si la cámara está configurada correctamente, este comando captura una imagen de la cámara, la guarda en un archivo denominado `test.jpg` y muestra mensajes informativos.
------
#### [ Camera module 2 or 3 ]
Si utiliza un módulo de cámara 2, puede utilizar uno `bcm2835-v4l2` (antiguo) o uno `libcamera` (moderno). Sin embargo, se recomienda `libcamera` usar el paquete para mejorar el soporte y las funciones. Siga los pasos que se indican a continuación para confirmar que `libcamera` está up-to-date en su sistema.
1. [libcamera](https://www.raspberrypi.com/documentation/computers/camera_software.html#libcamera) debería venir preinstalado en tu Raspberry Pi. Comprueba si hay actualizaciones y actualiza a la última versión para ver las correcciones de errores y las actualizaciones de seguridad. Abre el terminal y escribe los siguientes comandos:
```
sudo apt-get update
sudo apt-get upgrade
```
1. Reinicie el sistema para que las actualizaciones surtan efecto.
```
sudo reboot
```
1. Pon a prueba tu cámara. Esta aplicación inicia una secuencia de previsualización de la cámara y la muestra en la pantalla.
```
libcamera-hello
```
Si tiene problemas con el módulo de la cámara, consulte la [documentación de Raspberry Pi](https://raspberrypi.com/documentation/computers/camera_software.html#troubleshooting) para solucionar el problema.
------
# Requisitos previos de instalación del software
El SDK para productores de C\$1\$1 requiere que instales los siguientes requisitos previos de software en Raspberry Pi.
1. Actualice la lista de paquetes e instale las bibliotecas necesarias para compilar el SDK. Abre la terminal y escribe los siguientes 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. Si estás usando la `libcamera` pila, instala también el `libcamerasrc` GStreamer complemento. Este GStreamer complemento no viene instalado de forma predeterminada.
```
sudo apt-get install gstreamer1.0-libcamera
```
1. Copie el siguiente archivo PEM en `/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
```
# Descargue y cree el SDK para productores de Kinesis Video Streams C\$1\$1
Siga los procedimientos que se indican a continuación para descargar y crear el SDK para [productores de Kinesis Video Streams C\$1\$1](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp). Asegúrese de haber instalado los requisitos previos del software; consulte estos [Requisitos previos de instalación del software](producersdk-cpp-rpi-software.md) pasos.
1. Navegue hasta el directorio de descargas. Abre un terminal y cambia al directorio de descargas que prefieras.
Por ejemplo:
```
cd ~/Downloads
```
1. Clona el repositorio del SDK. Usa el `git clone` comando para descargar el SDK del GitHub repositorio. Escriba:
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git --single-branch -b master kvs-producer-sdk-cpp
```
Este comando clona solo una rama (la `master` rama), lo que reduce el tamaño y el tiempo de descarga. También coloca el contenido descargado en una carpeta llamada `kvs-producer-sdk-cpp` dentro del directorio actual.
1. Verifica la descarga. Una vez finalizado el proceso de clonación, enumere el contenido de la `kvs-producer-sdk-cpp` carpeta para comprobar que se ha descargado el SDK.
```
ls kvs-producer-sdk-cpp
```
1. Prepara un directorio de compilación. Escriba:
```
mkdir -p kvs-producer-sdk-cpp/build
cd kvs-producer-sdk-cpp/build
```
1. Configure la compilación. Ejecute el siguiente `cmake` comando para configurar el entorno de compilación con opciones 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)utiliza las siguientes opciones para generar las opciones adecuadas`Makefiles`:
+ Uso de la carpeta del proyecto (`..`) como directorio de origen.
+ Usando el directorio actual (`.`) (`build/`) para el resultado de la compilación.
+ `-DBUILD_GSTREAMER_PLUGIN=ON`permite la creación del GStreamer complemento kvssink.
+ `-DBUILD_DEPENDENCIES=OFF`desactiva la creación de dependencias externas desde la fuente. El proyecto buscará y utilizará las dependencias externas instaladas en un paso anterior.
+ `-DALIGNED_MEMORY_MODEL=ON`desactiva el modelo de memoria no alineado. Algunos dispositivos Raspberry Pi no admiten el acceso no alineado a la memoria.
**nota**
Para obtener una lista completa de CMake argumentos, consulte[Descargue y configure el código de la biblioteca del productor de C\$1\$1](producersdk-cpp-download.md).
1. Compilar el proyecto. Tras configurar la compilación, utilice el `make` comando para compilar utilizando el `Makefile` generado por`cmake`.
```
make -j$(nproc)
```
El `-j` argumento to `make` le permite ejecutar varios trabajos de compilación en paralelo. Para reducir los tiempos de compilación, usa el `nproc` comando para calcular dinámicamente el número de núcleos de CPU de tu Raspberry Pi.
1. Confirma que `libgstkvssink.so` está presente.
Enumere los archivos del directorio actual.
**Mensaje:**
```
ls
```
**Respuesta**:
```
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 que GStreamer se puede cargar`kvssink`.
Establezca la variable de `GST_PLUGIN_PATH` entorno en el directorio que la contiene`libgstkvssink.so`.
```
export GST_PLUGIN_PATH=`pwd`
```
Tenga GStreamer carga`kvssink`:
```
gst-inspect-1.0 kvssink
```
Deberías ver alguna documentación al respecto`kvssink`. Usa las teclas de flecha para navegar y presiona `q` para salir.
1. (**Opcional**) Actualice el script de inicio del shell para incluir la configuración de la variable de `GST_PLUGIN_PATH` entorno. Esto garantiza que `GST_PLUGIN_PATH` esté configurado correctamente durante una nueva sesión de terminal. En los dispositivos Raspberry Pi, el script de inicio de la consola es`~/.bashrc`.
Ejecute el siguiente comando para añadir el comando al final del script de inicio del shell.
```
echo "export GST_PLUGIN_PATH=~/Downloads/kvs-producer-sdk-cpp/build" >> ~/.bashrc
```
Escriba lo siguiente para ejecutar el script de inicio del shell o cierre el shell actual y abra uno nuevo.
```
source ~/.bashrc
```
Confirme que `GST_PLUGIN_PATH` está configurado y ya puede cargarlo`kvssink`.
```
echo $GST_PLUGIN_PATH
```
```
gst-inspect-1.0 kvssink
```
# Transmita vídeo a su transmisión de vídeo de Kinesis
Para ejecutar la aplicación de ejemplo, necesita la siguiente información:
+ El nombre de la secuencia que creó en la sección [Requisitos previos](producersdk-cpp-rpi-prerequisites.md).
+ Las credenciales de cuenta (ID de clave de acceso y clave de acceso secreta) que creó en [Cree un usuario de IAM con permiso para escribir en Kinesis Video Streams](producersdk-cpp-rpi-iam.md).
+ GStreamer es capaz de localizar el `kvssink` complemento. Para obtener más información, consulte [Descargue y cree el SDK para productores de Kinesis Video Streams C\$1\$1](producersdk-cpp-rpi-download.md).
1. Establece las credenciales y la región.
```
export AWS_ACCESS_KEY_ID=YourAccessKey
export AWS_SECRET_ACCESS_KEY=YourSecretKey
export AWS_DEFAULT_REGION=us-west-2
```
Para ver otros métodos de autenticación, consulte[Proporcione las credenciales a `kvssink`](examples-gstreamer-plugin-parameters.md#credentials-to-kvssink).
**nota**
El SDK para productores de C\$1\$1 usa la región EE.UU. Oeste (Oregón) (`us-west-2`) de forma predeterminada. Para usar la opción predeterminada, Región de AWS cree su transmisión de vídeo de Kinesis en la región EE.UU. Oeste (Oregón).
Para usar una región diferente para la transmisión de vídeo de Kinesis, defina la siguiente variable de entorno en su región (por ejemplo,*us-east-1*):
```
export AWS_DEFAULT_REGION=us-east-1
```
1. En función del medio de entrada, elija una de las siguientes opciones:
------
#### [ Sample GStreamer video ]
Esta GStreamer canalización genera una transmisión de vídeo de prueba en directo con un patrón de prueba estándar que se ejecuta a 10 fotogramas por segundo con una resolución de 640 x 480 píxeles. Se añade una superposición que muestra la fecha y hora actuales del sistema. A continuación, el vídeo se codifica en formato H.264 y los fotogramas clave se generan como máximo cada 10 fotogramas, lo que da como resultado una duración del fragmento (también conocida como tamaño de grupo de imágenes (GoP)) de 1 segundo. kvssink toma la transmisión de vídeo codificada en H.264, la empaqueta en el formato contenedor Matroska (MKV) y la carga en la transmisión de vídeo de Kinesis.
Use el siguiente 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 detener la canalización, seleccione la ventana del terminal y pulse CTRL\$1C. GStreamer **
El ejemplo de la GStreamer canalización de vídeo tiene el siguiente aspecto:
![\[Imagen del patrón de prueba estándar con una marca de fecha y hora superpuesta.\]](http://docs.aws.amazon.com/es_es/kinesisvideostreams/latest/dg/images/sample-video.png)
------
#### [ USB web cam ]
Ejecute el siguiente comando para que su cámara USB GStreamer detecte automáticamente:
```
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 detener la GStreamer canalización, selecciona la ventana del terminal y pulsa **CTRL\$1C**.
En lugar de permitir la GStreamer detección automática, puedes usarlo `v4l2src` con un identificador de dispositivo específico. Use el siguiente comando:
```
gst-device-monitor-1.0
```
En el resultado, verás algunos dispositivos y el inicio de GStreamer un proceso sobre cómo usarlos:
```
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 detener la GStreamer canalización, selecciona la ventana del terminal y pulsa **CTRL\$1C**.
------
#### [ Raspberry Pi camera module 1 ]
Si utiliza el módulo de cámara Pi 1 o el módulo de cámara Pi 2 con`bcm2835-v4l2`, utilice lo siguiente:
```
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 detener la GStreamer canalización, selecciona la ventana del terminal y pulsa **CTRL\$1C**.
------
#### [ Raspberry Pi camera module 2 or 3 ]
Si utilizas la `libcamera` pila moderna, utiliza la siguiente GStreamer canalización:
```
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 detener la GStreamer canalización, selecciona la ventana del terminal y pulsa **CTRL\$1C**.
------
#### [ Sample RTSP camera ]
Para este ejemplo, solemos alojar localmente una Gst-Rtsp-Server transmisión de cámara RTSP de demostración. A continuación, creamos una GStreamer canalización para cargar la transmisión de la cámara RTSP a la transmisión de vídeo de Kinesis especificada.
**Para configurarlo Gst-Rtsp-Server en su Raspberry Pi**
1. Instale las bibliotecas de dependencias necesarias para construir el Gst-Rtsp-Server proyecto. Asegúrese de tener también instalados los requisitos previos del software. Escribe lo siguiente en tu terminal:
```
sudo apt-get update
sudo apt-get install libgstrtspserver-1.0
```
1. Descarga la versión 1.22 de GStreamer en tu Raspberry Pi.
```
git clone https://gitlab.freedesktop.org/gstreamer/gstreamer.git --single-branch -b 1.22
```
1. Cambia los directorios al directorio de ejemplos de. gst-rtsp-server
```
cd gstreamer
cd subprojects
cd gst-rtsp-server
cd examples
```
1. Compila el archivo test-launch.c en un ejecutable llamado test-launch usando gcc.
```
gcc -o test-launch test-launch.c `pkg-config --cflags --libs gstreamer-rtsp-server-1.0`
```
1. Ejecuta el ejecutable con los siguientes argumentos. Nota: GStreamer es posible que tarde algún tiempo en cargarse por primera 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"
```
Debería ver los siguientes datos de salida:
```
stream ready at rtsp://127.0.0.1:8554/test
```
1. Compruebe la transmisión de vídeo RTSP. Puede utilizar cualquier visor RTSP. Por ejemplo, el reproductor multimedia VLC. Para usar el reproductor multimedia VLC para ver tu transmisión en directo, abre un nuevo terminal y escribe:
```
sudo apt-get install vlc
```
para instalar el reproductor multimedia VLC. Luego escribe:
```
vlc rtsp://127.0.0.1:8554/test
```
Debería aparecer una ventana de VLC con la transmisión en vivo. De lo contrario, compruebe que el ejecutable de lanzamiento de prueba aún se esté ejecutando y compruebe si hay errores en el resultado.
Otra forma de verificar la transmisión RTSP es mediante la utilidad gst-discoverer-1.0. Escriba:
```
gst-discoverer-1.0 "rtsp://127.0.0.1:8554/test"
```
El resultado esperado es el siguiente:
```
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 el feed RTSP a su Kinesis Video Stream mediante kvssink**
Esta GStreamer canalización se utiliza `rtspsrc` para conectarse al servidor RTSP para obtener la transmisión de vídeo RTP. Pasa los fotogramas al`rtph264depay`, que extrae los fotogramas de vídeo codificados en H.264 de los paquetes RTP. `h264parse`agrupa los fotogramas de vídeo en un formato que pueda entender. `kvssink` `kvssink`toma la transmisión de vídeo codificada en H.264, la empaqueta en el formato contenedor Matroska (MKV) y la carga en la transmisión de vídeo de Kinesis.
Use el siguiente 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 detener la GStreamer canalización, seleccione la ventana del terminal y pulse CTRL\$1C.**
------
## Utilice hardware
Algunos modelos de Raspberry Pi vienen con codificadores H.264 acelerados por hardware. Puede usarlos en lugar de`x264enc`, que es un codificador de software.
1. Asegúrese de que los GStreamer complementos estén instalados:
```
sudo apt-get install gstreamer1.0-tools gstreamer1.0-plugins-bad
```
1. Escriba:
```
gst-inspect-1.0 | grep h264
```
Determine si los siguientes elementos están disponibles:
+ omxh264enc
+ v4l2h264enc
Si están disponibles, puede utilizarlos. Estos son algunos ejemplos de canalizaciones en las que se utilizan esos 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`y`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 tiempo de ejecución
A continuación, se muestran algunos de los problemas de tiempo de ejecución más frecuentes y cómo solucionarlos.
### No existe el elemento «xxxxxxxxx»
Si recibes un error como el siguiente, significa que te falta un GStreamer complemento:
```
WARNING: erroneous pipeline: no element "videoconvert"
```
**Solución**:
En función del elemento que falte, determina la acción adecuada:
+ `kvssink`: Consulte [Descargue y cree el SDK para productores de Kinesis Video Streams C\$1\$1](producersdk-cpp-rpi-download.md).
+ `libcamerasrc`: Consulte [Error «Falló la activación del grupo de búferes»](#rpi-troubleshoot-buffer) para instalar el `libcamerasrc` GStreamer elemento.
+ `omxh264enc`o`v4l2h264enc`:
Siga [Requisitos previos de instalación del software](producersdk-cpp-rpi-software.md) para instalar todas las GStreamer bibliotecas. Si las has instalado todas y estos elementos no aparecen, significa que tu Raspberry Pi no tiene el hardware necesario. En su `x264enc` lugar, usa el codificador de software.
+ Otros: Siga estos pasos [Requisitos previos de instalación del software](producersdk-cpp-rpi-software.md) para instalar todas las GStreamer bibliotecas. Se encuentran diferentes GStreamer elementos en los distintos grupos de GStreamer complementos (buenos, malos, feos), así que asegúrate de instalarlos todos.
### Error «Falló la activación del grupo de búferes»
Si recibes un error como el siguiente, significa que la canalización que se está utilizando se está utilizando`v4l2src`, pero debería usarla `libcamerasrc` en su lugar.
```
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 ejemplo, si utiliza la siguiente canalización con el módulo de cámara 2 sin `libcamerasrc` instalar, GStreamer es posible que se produzca este error al intentar detectar automáticamente qué elementos utilizar.
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
**Solución**:
Asegúrese de que `libcamerasrc` esté instalado y utilícelo como elemento fuente, en lugar de`v4l2src`. Escriba lo siguiente para instalar el `libcamerasrc` GStreamer elemento:
```
sudo apt-get update
sudo apt-get install gstreamer1.0-libcamera
```
Una vez `libcamerasrc` instalado, si está utilizando el `autovideosrc` elemento, GStreamer debería cambiar automáticamente para utilizar la fuente correcta `libcamerasrc` en su lugar`v4l2src`.
### Error de bus
Si recibes un error de bus poco después de empezar `kvssink` (normalmente, cuando `PutMedia` finaliza la llamada HTTP), significa que tu Raspberry Pi no admite el acceso no alineado a la memoria. Los registros tendrán el siguiente aspecto:
```
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
```
El PIC de Kinesis Video Streams utiliza un acceso a la memoria no alineado para optimizar el uso de la memoria, lo que no es compatible con todos los dispositivos.
**Solución**:
Para usar el SDK en el modo de acceso a memoria alineado, debe establecer explícitamente el `ALIGNED_MEMORY_MODEL` CMake indicador en `ON` al compilar`kvssink`, ya que el valor predeterminado es. `OFF` Consulte [Descargue y cree el SDK para productores de Kinesis Video Streams C\$1\$1](producersdk-cpp-rpi-download.md) para obtener instrucciones más detalladas.
### La marca de tiempo se congela y la tubería se detiene
Cuando se utiliza `x264enc` en una GStreamer canalización, es posible que se produzcan situaciones en las que el cronograma de la canalización se ralentice considerablemente o se detenga por completo en unos pocos segundos.
Esto se debe a que la configuración `x264enc` predeterminada puede introducir una latencia de codificación alta, que supera la capacidad del búfer de entrada predeterminado. Como resultado, el búfer de entrada se llena, lo que provoca que los elementos anteriores se bloqueen y que la tubería se detenga.
Para obtener más información, consulte la [Documentación de GStreamer ](https://gstreamer.freedesktop.org/documentation/x264/index.html?gi-language=c).
**Solución**:
Configure `x264enc` con la opción de `zerolatency` ajuste. Esto reduce significativamente la latencia de codificación al optimizarla para escenarios en tiempo real, lo que garantiza que los fotogramas se procesen y emitan con mayor rapidez.
Ejemplo de configuración:
```
... ! x264enc tune=zerolatency byte-stream=true speed-preset=ultrafast bframes=0 key-int-max=60 ! ...
```
**nota**
Si bien esta solución evita eficazmente el estancamiento de la canalización, puede afectar a la eficiencia y la calidad de la codificación. Para los escenarios que requieren baja latencia y alta calidad, considere enfoques alternativos, como utilizar optimizaciones de hardware o encontrar una cámara web que emita directamente H.264, omitiendo este paso de codificación.
Para obtener más información, consulte [Utilice hardware](#producersdk-cpp-rpi-utilize).
### No se pueden ejecutar varias canalizaciones desde el mismo `v4l2` dispositivo al mismo tiempo
A estos dispositivos solo se `/dev/video0` puede acceder mediante un proceso a la vez. Si varios procesos intentan acceder a él al mismo tiempo, el segundo proceso espera a que se complete el primero.
**Solución**:
Cree un dispositivo de bucle invertido que permita que varios procesos utilicen la interfaz de bucle invertido al mismo tiempo. [Para obtener más información, consulte Stack Exchange.](https://raspberrypi.stackexchange.com/questions/19630/take-picam-image-while-motion-is-running/19897#19897)
### Error interno en el flujo de datos
Al crear una GStreamer canalización, los elementos se conectan uniendo la almohadilla de origen de un elemento a la almohadilla de absorción de otro elemento. Este proceso de vinculación permite el flujo de datos desde el elemento fuente al elemento receptor, formando una canalización de datos.
El mensaje de error «Error en el enlace del teclado» en el registro GStreamer indica que se ha producido un problema al intentar establecer una conexión (enlace) entre los paneles de dos elementos de la canalización.
```
Pad link failed
Error received from element udpsrc0: Internal data stream error.
```
**Solución**:
Determina qué elementos no se pueden vincular entre sí. Para reducir el alcance de la tubería, retire los elementos de la tubería. Sustituya el elemento situado más a la derecha por uno `fakesink` y extráigalos uno por uno.
Es posible que tengas que ajustar las [tapas y los elementos filtrantes](https://gstreamer.freedesktop.org/documentation/coreelements/capsfilter.html?gi-language=c) y and/or cambiar los elementos que utiliza tu canalización.
Los casos más comunes son pedir una cámara `framerate` o una cámara `resolution` que no sea compatible. `gst-device-monitor-1.0`Úselo en el terminal para obtener el soporte `framerates``resolutions`, y`formats`. Puede utilizar el GStreamer elemento [videoscale](https://gstreamer.freedesktop.org/documentation/videoconvertscale/videoscale.html?gi-language=c) para ajustar la resolución del vídeo y [videorate](https://gstreamer.freedesktop.org/documentation/videorate/?gi-language=c) para ajustar la velocidad de fotogramas del vídeo.
Para inspeccionar los formatos compatibles con un GStreamer elemento individual, escriba `gst-inspect-1.0 element-name` en el terminal.
# Reproduzca contenido multimedia de su transmisión de vídeo de Kinesis
Abra la consola de [Kinesis Video Streams](https://console.aws.amazon.com//kinesisvideo/home/) y seleccione **el** nombre de la transmisión que ha creado.
En la consola aparece la transmisión de vídeo enviada desde el dispositivo Raspberry Pi.
**nota**
Es posible que el vídeo tarde unos segundos en aparecer en la consola.
Una vez que se esté reproduciendo la transmisión, puedes experimentar con las siguientes funciones de la consola:
+ En la sección **Video preview** (Vista previa de vídeo), utilice los controles de navegación para rebobinar o avanzar la secuencia.
+ En la sección de **información de la transmisión**, revisa el códec, la resolución y la velocidad de bits de la transmisión. En este tutorial, los valores de resolución y velocidad de bits de la Raspberry Pi están configurados a un nivel bajo a propósito para minimizar el uso del ancho de banda.
Para ver las CloudWatch métricas de Amazon que se están creando para tu transmisión, selecciona **Ver métricas de transmisión en CloudWatch**.
+ En **Data retention period** (Período de retención de datos), observe que la secuencia de vídeo se conserva durante un día. Puede editar este valor y establecerlo en **No data retention** (Sin retención de datos) o establecer un valor desde un día hasta varios años.
+ En **Cifrado del lado del servidor**, observa que tus datos se cifran en reposo mediante una clave mantenida por AWS Key Management Service ()AWS KMS.
## Problemas de reproducción
A continuación, se muestran algunos problemas de reproducción frecuentes y cómo solucionarlos.
### No hay contenido multimedia, pero hay ACKs PERSISTENTES en los registros
Si ve PERSISTED ACK en los registros, significa que Kinesis Video Streams ha ingerido y almacenado correctamente el contenido multimedia cargado por. `kvssink` Los ACKs recibidos de Kinesis Video Streams tienen este aspecto. En el JSON, observe el valor de la `"EventType"` clave.
```
{"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"}
```
**Solución**:
Espere uno o dos minutos en la consola de Kinesis Video Streams y, a continuación, utilice la flecha doble hacia la derecha. Si no aparece ningún archivo multimedia, compruebe que la transmisión se está enviando a la región correcta y revise la ortografía del nombre de la transmisión. Puedes encontrar esta información en los registros.
Consulte [Proporcione una región a `kvssink`](examples-gstreamer-plugin-parameters.md#kvssink-region) para obtener más información sobre cómo kvssink determina qué región usar.
### El contenido multimedia tarda mucho en cargarse en el Consola de administración de AWS
**importante**
La experiencia de reproducción de la consola es diferente a la experiencia de reproducción en HLS y DASH. Utilice también la [página web de muestra alojada](https://aws-samples.github.io/amazon-kinesis-video-streams-media-viewer/) en el reproductor multimedia GitHub para probar la reproducción. El código fuente de la página web se puede encontrar [aquí](https://github.com/aws-samples/amazon-kinesis-video-streams-media-viewer).
Es posible que el contenido multimedia se cargue lentamente en la consola debido a un ancho de banda de red deficiente o a un dispositivo limitado, pero también puede estar relacionado con la codificación y fragmentación del vídeo.
**Conceptos básicos de codificación de vídeo:**
+ Los codificadores H.264 y H.265 utilizan fotogramas clave (fotogramas I) y fotogramas predecibles (fotogramas P) para una compresión eficiente.
+ Los fotogramas clave contienen datos de imagen completos, mientras que los fotogramas P solo contienen cambios con respecto a los fotogramas anteriores.
+ El «intervalo de fotogramas clave» determina la frecuencia con la que aparecen los fotogramas clave en la transmisión de vídeo.
**Fragmentación en la transmisión:**
+ En Kinesis Video Streams, los fragmentos nuevos comienzan con cada fotograma clave. Para obtener más información, consulte [Modelo de datos de Kinesis Video Streams](how-data.md).
+ *La longitud del fragmento (en segundos) se puede estimar de la siguiente manera: intervalo entre fotogramas *clave ÷ velocidad de fotogramas**
**Ejemplo:**
Para una transmisión con un intervalo entre fotogramas clave de 30 y una velocidad de fotogramas de 15 fps:
Longitud del fragmento = 30 ÷ 15 = 2 segundos
Debido a que los intervalos entre fotogramas clave y fotogramas son mayores, los fragmentos más largos aumentan la latencia en la transmisión multimedia.
**Solución**:
Para mejorar los tiempos de carga, considere reducir el intervalo entre fotogramas clave. Esto creará fragmentos más cortos, lo que reducirá la latencia, pero también aumentará el tamaño del archivo de vídeo.
Para el `x264enc` GStreamer elemento, puedes establecer de forma explícita el intervalo entre fotogramas y claves mediante la `key-int-max` propiedad:
```
x264enc bframes=0 key-int-max=60
```
Al revisar la salida del registro, observe la frecuencia con la que el cliente de carga recibe ACKs de Kinesis Video Streams. Cuantos más fotogramas clave se generen, más se devolverán ACKs .
### El contenido multimedia está distorsionado o tiene artefactos
Para solucionar este problema, asegúrese de que todos los cables estén bien conectados. Revise la salida de los módulos de cámara `libcamera-hello` (o `raspistill` de las cámaras Pi antiguas).
En GStreamer proceso, `kvssink` sustitúyalo por `autovideosink` o `matroskamux` y`filesink`. Por ejemplo:
```
... x264enc tune=zerolatency speed-preset=ultrafast bframes=0 key-int-max=60 byte-stream=true ! h264parse ! matroskamux ! filesink location=output.mkv
```
Revisa el archivo de salida `filesink` o el reproductor multimedia que se abre `autovideosink` al usarlo para comprobar si los artefactos también están ahí.
Revise también el resultado de la siguiente canalización:
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
Añadir elementos a la canalización, como [Dewarp](https://gstreamer.freedesktop.org/documentation/opencv/dewarp.html?gi-language=c), puede corregir las salidas de las cámaras tipo ojo de pez.
Revisa los códecs de salida compatibles con tu cámara y ajusta los elementos según sea necesario.
Por ejemplo, si su cámara USB solo admite la salida JPEG, necesitará usar los `jpegdec` elementos `jpegparse` y para transformar el contenido multimedia antes de codificarlo en H.264. `x264enc` Busca ayuda en los GStreamer foros para otros usuarios con canales o configuraciones de cámara web similares.
# Solución de problemas de compilación en el SDK para productores de C\$1\$1 para Raspberry Pi
Si tienes un problema con la compilación y quieres probar diferentes CMake argumentos, asegúrate de realizar una compilación limpia. Elimine las `build` carpetas `open-source``dependency`, y antes de volver a intentarlo.
## Problemas de compilación con OpenSSL
Si recibe un resultado similar al siguiente, indica que OpenSSL ha detectado incorrectamente la arquitectura del 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]'
```
En este ejemplo, está intentando crear una versión de 64 bits (`linux-aarch64`) cuando esta Raspberry Pi es en realidad de 32 bits. Algunos dispositivos Raspberry Pi tienen un núcleo de 64 bits, pero un espacio de usuario de 32 bits.
Determine para qué arquitectura está intentando construir OpenSSL. Puedes encontrar la línea de registro durante el `configure` paso para 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
```
Verifica la arquitectura de tu sistema:
+ Revise el nivel de bits del núcleo: ejecute `uname -m`
+ Revise el espacio de usuario bit-ness: run `getconf LONG_BIT`
También puedes revisar la información de la CPU con nuestros comandos`cat /proc/cpuinfo`. `lscpu`
**Solución**:
Para resolver este problema, añada el siguiente CMake argumento al compilar para garantizar que OpenSSL se compila correctamente para la arquitectura ARM de 32 bits:
```
-DBUILD_OPENSSL_PLATFORM=linux-armv4
```
## Solucione problemas de carga `kvssink` en GStreamer
Confirme `GST_PLUGIN_PATH`
Asegúrese de que la variable de `GST_PLUGIN_PATH` entorno de su sesión de shell actual apunte al directorio que la contiene`kvssink`. Las variables de entorno son específicas de cada sesión, por lo que tendrás que configurarlas para cada nueva sesión. Para que este cambio sea permanente, consulta la sección «Actualiza el script de inicio del shell para incluir la configuración de la variable de entorno GST\$1PLUGIN\$1PATH».
**Error: no se puede abrir el archivo de objetos compartidos: no existe ese archivo o directorio**
Si se produce el error`Cannot open shared object file: No such file or directory`, ejecute el siguiente comando:
```
gst-inspect-1.0 /path/to/libgstkvssink.so
```
Si recibe el siguiente resultado, indica que el enlazador dinámico no puede encontrar las bibliotecas necesarias para`kvssink`. Esto suele ocurrir debido a:
+ Mudarse `kvssink` a una ubicación diferente de donde se construyó.
+ Compilación cruzada para una arquitectura de CPU incorrecta.
+ Falta una dependencia necesaria.
**Salida:**
```
WARNING: erroneous pipeline: no element "kvssink"
error while loading shared libraries: libcproducer.so: cannot open shared object file: No such file or directory
```
**Solución**:
En el **caso de las bibliotecas trasladadas**, añada el directorio que contiene las bibliotecas que faltan`LD_LIBRARY_PATH`.
Desde el directorio raíz del repositorio original, puede localizar la biblioteca que falta mediante la `find` utilidad. En la terminal, escriba:
```
find . -name "*libcproducer*"
```
**Salida:**
```
./build/dependency/libkvscproducer/kvscproducer-src/libcproducer.so
```
El separador de rutas de archivos en los dispositivos Linux es`:`. El siguiente comando añade una nueva ruta de carpeta a la variable de `LD_LIBRARY_PATH` entorno existente, conservando los valores anteriores.
En tu terminal, escribe:
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/build/dependency/libkvscproducer/kvscproducer-src
```
**importante**
Las variables de entorno son específicas de la sesión. Para conservar los cambios en todas las sesiones, modifique el script de inicio del shell.
Es posible que también tengas que añadir el `open-source/local/lib` a tu`$LD_LIBRARY_PATH`.
**Error:. /path/to/libcproducer.so.1: encabezado ELF no válido**
Si recibe este error al cargar **bibliotecas compartidas**, es posible que se deba a que los enlaces simbólicos están rotos ()`symlinks`. Los enlaces simbólicos pueden romperse si el sistema operativo de la máquina host no coincide con el de la máquina de destino. Por ejemplo, la compilación cruzada en una Raspberry MacBook Pi.
Otra posible causa es que los binarios creados eran para una arquitectura incorrecta. Por ejemplo, si los binarios se crearon para x86 (Raspberry Pi usa ARM). CPUs
Navegue hasta la ubicación de la biblioteca especificada en el error y escriba: `ls -la` para inspeccionar la biblioteca. `symlinks`
**Respuesta**:
```
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
```
En el ejemplo de salida anterior, no `symlinks` están rotos. Broken `symlinks` no tendrá flechas apuntando a sus objetivos.
**Solución**:
Hay dos opciones para corregir los enlaces simbólicos:
+ **Recomendado: Vuelva** a crearlo `symlink` con el `ln` comando. Escriba:
```
ln -s /path/to/actual/library /path/to/symlink
```
+ Copie el archivo de biblioteca actual y cámbiele el nombre para que coincida con. `symlink`
**nota**
Esta opción aumenta el uso del almacenamiento.
Como práctica recomendada, compile en el mismo sistema operativo con herramientas como Docker para evitar problemas de compilación cruzada.
**Dependencias faltantes:**
Si el nombre de la biblioteca que falta empieza por`libkvs`, consulte la sección anterior sobre «bibliotecas trasladadas» para instalar las bibliotecas de Kinesis Video Streams del dispositivo anfitrión al dispositivo de destino.
De lo contrario, asegúrese de [Requisitos previos de instalación del software](producersdk-cpp-rpi-software.md) que todos los requisitos previos del software de código abierto estén instalados en el dispositivo de destino.