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