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. # Ejemplos de Amazon Kinesis Video Streams Los siguientes ejemplos de código muestran cómo trabajar con la API de Kinesis Video Streams: ## Ejemplos: Envío de datos a Kinesis Video Streams + [Ejemplo: complemento del GStreamer SDK para productores de Kinesis Video Streams: kvssink](examples-gstreamer-plugin.md): muestra cómo crear el SDK para productores de Kinesis Video Streams para usarlo como destino GStreamer . + [Ejecute el GStreamer elemento en un contenedor de Docker](examples-gstreamer-plugin.md#examples-gstreamer-plugin-docker): muestra cómo utilizar una imagen de Docker prediseñada para enviar vídeo del Protocolo de transmisión en tiempo real (RTSP) desde una cámara IP a Kinesis Video Streams. + [Ejemplo: transmisión desde una fuente RTSP](examples-rtsp.md): muestra cómo crear su propia imagen de Docker y cómo enviar vídeo RTSP desde una cámara IP a Kinesis Video Streams. + [Ejemplo: envío de datos a Kinesis Video Streams mediante PutMedia la API](examples-putmedia.md): muestra cómo utilizarla [Utilice la biblioteca de productores de Java](producer-sdk-javaapi.md) para enviar datos a Kinesis Video Streams que ya están en formato contenedor (MKV) mediante [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)la API. ## Ejemplos: Recuperación de datos de Kinesis Video Streams + [KinesisVideoExample](parser-library-write.md#parser-library-write-example): Muestra cómo analizar y registrar fragmentos de vídeo mediante la biblioteca de analizadores de Kinesis Video Streams. + [Ejemplo: análisis y renderización de fragmentos de Kinesis Video Streams](examples-renderer.md): Muestra cómo analizar y renderizar fragmentos de transmisión de vídeo de Kinesis mediante [JCodec](http://jcodec.org/)y. [JFrame](https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html) ## Ejemplos: reproducción de datos de vídeo + [Ejemplo: utilice HLS en HTML y JavaScript](hls-playback.md#how-hls-ex1): muestra cómo recuperar una sesión de streaming HLS para una transmisión de vídeo de Kinesis y reproducirla en una página web. ## Requisitos previos + En el código de ejemplo, las credenciales se proporcionan especificando un perfil que se establece en el archivo de perfil de AWS credenciales o se proporcionan las credenciales en las propiedades del sistema Java de su entorno de desarrollo integrado (IDE). Si aún no lo ha hecho, configure primero sus credenciales. Para obtener más información, consulte [Configurar AWS credenciales y regiones para el desarrollo](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-credentials.html). + Le recomendamos que utilice un IDE Java para ver y ejecutar el código, como, por ejemplo, uno de los siguientes: + [Eclipse Java Neon](https://www.eclipse.org/downloads/packages/release/neon/3/eclipse-jee-neon-3) + [JetBrains IntelliJ IDEA](https://www.jetbrains.com/idea/) # Ejemplo: complemento del GStreamer SDK para productores de Kinesis Video Streams: kvssink En este tema se describe cómo crear el SDK para productores de Amazon Kinesis Video Streams para usarlo como GStreamer complemento. **Topics** + [Descargue, cree y configure el GStreamer elemento](#examples-gstreamer-plugin-download) + [Ejecuta el elemento GStreamer](#examples-gstreamer-plugin-run) + [Ejemplos de comandos de lanzamiento GStreamer](#examples-gstreamer-plugin-launch) + [Ejecute el GStreamer elemento en un contenedor de Docker](#examples-gstreamer-plugin-docker) + [GStreamer referencia de parámetros de elementos](examples-gstreamer-plugin-parameters.md) [GStreamer](https://gstreamer.freedesktop.org/)es un marco multimedia popular que utilizan varias cámaras y fuentes de vídeo para crear canales multimedia personalizados mediante la combinación de complementos modulares. El complemento Kinesis Video GStreamer Streams agiliza la integración de su canal multimedia GStreamer existente con Kinesis Video Streams. Tras la integración GStreamer, puede transmitir vídeo desde una cámara web o una cámara del Protocolo de Transmisión en Tiempo Real (RTSP) a Kinesis Video Streams para reproducirlo, almacenarlo y analizarlo en tiempo real o posteriormente. El GStreamer complemento gestiona automáticamente la transferencia de su transmisión de vídeo a Kinesis Video Streams al encapsular la funcionalidad proporcionada por el SDK para productores de Kinesis Video Streams GStreamer en un elemento receptor,. `kvssink` El GStreamer marco proporciona un entorno gestionado estándar para crear el flujo de contenido multimedia desde un dispositivo, como una cámara u otra fuente de vídeo, para su posterior procesamiento, renderización o almacenamiento. La GStreamer canalización suele consistir en el enlace entre una fuente (cámara de vídeo) y el elemento receptor (ya sea un reproductor para renderizar el vídeo o un almacenamiento para recuperarlo sin conexión a Internet). En este ejemplo, se utiliza el elemento SDK Producer como *receptor* o destino multimedia, para su fuente de vídeo (cámara web o cámara IP). El elemento del complemento que encapsula el SDK envía entonces la transmisión de vídeo a Kinesis Video Streams. En este tema se describe cómo crear una canalización GStreamer multimedia capaz de transmitir vídeo desde una fuente de vídeo, como una cámara web o una transmisión RTSP, normalmente conectada a Kinesis Video Streams a través de etapas de codificación intermedias (mediante codificación H.264). Cuando la transmisión de vídeo esté disponible como transmisión de vídeo de Kinesis, podrá utilizarla [Vea la salida de las cámaras mediante la biblioteca de analizadores](parser-library.md) para seguir procesando, reproduciendo, almacenando o analizando la transmisión de vídeo. ![\[Vista funcional del canal GStreamer multimedia para la transmisión de vídeo desde una cámara al servicio.\]](http://docs.aws.amazon.com/es_es/kinesisvideostreams/latest/dg/images/gstreamer-pipeline.png) ## Descargue, cree y configure el GStreamer elemento El ejemplo del GStreamer complemento se incluye en el SDK para productores de Kinesis Video Streams C\$1\$1. Para obtener información acerca de los requisitos de SDK y de la descarga, consulte [Descargue y configure el código de la biblioteca del productor de C\$1\$1](producersdk-cpp-download.md). Puedes crear el receptor del SDK del GStreamer productor como una biblioteca dinámica en macOS, Ubuntu, Raspberry Pi o Windows. El GStreamer complemento se encuentra en tu `build` directorio. Para cargar este complemento, debe estar en su`GST_PLUGIN_PATH`. Use el siguiente comando: ``` export GST_PLUGIN_PATH=`pwd`/build ``` **nota** En macOS, solo puede transmitir vídeo desde una cámara de red cuando se ejecuta GStreamer en un contenedor Docker. No es compatible el streaming de vídeo desde una cámara USB en macOS en un contenedor de Docker. ## Ejecuta el elemento GStreamer Para ejecutar GStreamer con el elemento SDK del productor de Kinesis Video Streams como receptor, utilice `gst-launch-1.0` el comando. Utilice los elementos originales que sean adecuados para el GStreamer complemento que vaya a utilizar. Por ejemplo, [v4l2src](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page) para dispositivos v4l2 en sistemas Linux o [rtspsrc](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html#rtspsrc-page) para dispositivos RTSP. Especifique `kvssink` como receptor (destino final de la canalización) para enviar vídeo al SDK Producer. Además de [proporcionar credenciales](https://docs.aws.amazon.com//kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html#credentials-to-kvssink) y [proporcionar una región](https://docs.aws.amazon.com//kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html#kvssink-region), el `kvssink` elemento tiene el siguiente parámetro obligatorio: + `stream-name`— El nombre del Kinesis Video Streams de destino. Para obtener información acerca de los parámetros opcionales `kvssink`, consulte [GStreamer referencia de parámetros de elementos](examples-gstreamer-plugin-parameters.md). Para obtener la información más reciente sobre los GStreamer complementos y los parámetros, consulte [GStreamer Complementos](https://gstreamer.freedesktop.org/documentation/plugins_doc.html?gi-language=c). También puedes usar el `gst-inspect-1.0` comando seguido del nombre de un GStreamer elemento o complemento para imprimir su información y comprobar que está disponible en tu dispositivo: ``` gst-inspect-1.0 kvssink ``` Si la compilación `kvssink` ha fallado o GST\$1PLUGIN\$1PATH no está configurado correctamente, el resultado tendrá un aspecto similar al siguiente: ``` No such element or plugin 'kvssink' ``` ## Ejemplos de comandos de lanzamiento GStreamer Los siguientes ejemplos muestran cómo usar el `kvssink` GStreamer complemento para transmitir vídeo desde diferentes tipos de dispositivos. ### Ejemplo 1: Transmitir vídeo desde una cámara RTSP en Ubuntu El siguiente comando crea una GStreamer canalización en Ubuntu que transmite desde una cámara RTSP de red mediante el complemento [ GStreamer rtspsrc](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html?gi-language=c): ``` gst-launch-1.0 -v rtspsrc location="rtsp://YourCameraRtspUrl" short-header=TRUE ! rtph264depay ! h264parse ! kvssink stream-name="YourStreamName" storage-size=128 ``` ### Ejemplo 2: Codifique y transmita vídeo desde una cámara USB en Ubuntu El siguiente comando crea una GStreamer canalización en Ubuntu que codifica la transmisión desde una cámara USB en formato H.264 y la transmite a Kinesis Video Streams. [En este ejemplo se utiliza el complemento v4l2src.](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page) GStreamer ``` gst-launch-1.0 v4l2src do-timestamp=TRUE device=/dev/video0 ! videoconvert ! video/x-raw,format=I420,width=640,height=480,framerate=30/1 ! x264enc bframes=0 key-int-max=45 bitrate=500 ! video/x-h264,stream-format=avc,alignment=au,profile=baseline ! kvssink stream-name="YourStreamName" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion" ``` ### Ejemplo 3: Transmite vídeo precodificado desde una cámara USB en Ubuntu El siguiente comando crea una GStreamer canalización en Ubuntu que transmite vídeo que la cámara ya ha codificado en formato H.264 a Kinesis Video Streams. En este ejemplo se utiliza el complemento [ GStreamer v4l2src](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page). ``` gst-launch-1.0 v4l2src do-timestamp=TRUE device=/dev/video0 ! h264parse ! video/x-h264,stream-format=avc,alignment=au ! kvssink stream-name="plugin" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion" ``` ### Ejemplo 4: Transmitir vídeo desde una cámara de red en macOS El siguiente comando crea una GStreamer canalización en macOS que transmite vídeo a Kinesis Video Streams desde una cámara de red. En este ejemplo se utiliza el complemento [rtspsrc](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html#rtspsrc-page) GStreamer . ``` gst-launch-1.0 rtspsrc location="rtsp://YourCameraRtspUrl" short-header=TRUE ! rtph264depay ! h264parse ! video/x-h264, format=avc,alignment=au ! kvssink stream-name="YourStreamName" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion" ``` ### Ejemplo 5: Transmita vídeo desde una cámara de red en Windows El siguiente comando crea una GStreamer canalización en Windows que transmite vídeo a Kinesis Video Streams desde una cámara de red. En este ejemplo se utiliza el complemento [rtspsrc](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html#rtspsrc-page) GStreamer . ``` gst-launch-1.0 rtspsrc location="rtsp://YourCameraRtspUrl" short-header=TRUE ! rtph264depay ! video/x-h264, format=avc,alignment=au ! kvssink stream-name="YourStreamName" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion" ``` ### Ejemplo 6: Transmite vídeo desde una cámara de Raspberry Pi El siguiente comando crea una GStreamer canalización en Raspberry Pi que transmite vídeo a Kinesis Video Streams. En este ejemplo se utiliza el complemento [ GStreamer v4l2src](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page). ``` gst-launch-1.0 v4l2src do-timestamp=TRUE device=/dev/video0 ! videoconvert ! video/x-raw,format=I420,width=640,height=480,framerate=30/1 ! omxh264enc control-rate=1 target-bitrate=5120000 periodicity-idr=45 inline-header=FALSE ! h264parse ! video/x-h264,stream-format=avc,alignment=au,width=640,height=480,framerate=30/1,profile=baseline ! kvssink stream-name="YourStreamName" access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion" ``` ### Ejemplo 7: Transmite audio y vídeo en Raspberry Pi y Ubuntu Descubra cómo [ejecutar el comando gst-launch-1.0 para comenzar el streaming de audio y vídeo en Raspberry-PI y Ubuntu](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/linux.md#running-the-gst-launch-10-command-to-start-streaming-both-audio-and-video-in-raspberry-pi-and-ubuntu). ### Ejemplo 8: Transmite audio y vídeo desde las fuentes del dispositivo en macOS Descubra cómo [ejecutar el comando gst-launch-1.0 para comenzar el streaming de audio y vídeo en MacOS](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/macos.md#running-the-gst-launch-10-command-to-start-streaming-both-audio-and-raw-video-in-mac-os). ### Ejemplo 9: Cargue un archivo MKV que contenga audio y vídeo Descubra cómo [ejecutar el comando gst-launch-1.0 para cargar un archivo MKV que contenga audio y vídeo](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/windows.md#running-the-gst-launch-10-command-to-upload-mkv-file-that-contains-both-audio-and-video). Necesitará un archivo de prueba MKV con contenido multimedia codificado en H.264 y AAC. ## Ejecute el GStreamer elemento en un contenedor de Docker Docker es una plataforma para desarrollar, implementar y ejecutar aplicaciones utilizando contenedores. El uso de Docker para crear la GStreamer canalización estandariza el entorno operativo de Kinesis Video Streams, lo que agiliza la creación y el uso de la aplicación. Para instalar y configurar Docker, consulte lo siguiente: + [Instrucciones de descarga de Docker](https://docs.docker.com/engine/install/) + [Introducción a Docker](https://docs.docker.com/guides/getting-started/) Tras instalar Docker, puede descargar el SDK ( GStreamer y el complemento) para C\$1\$1 Producer de Kinesis Video Streams desde Amazon Elastic Container Registry mediante uno de los comandos que se proporcionan a continuación`docker pull`. Para ejecutar GStreamer el elemento del SDK del productor de Kinesis Video Streams como sumidero en un contenedor de Docker, haga lo siguiente: **Topics** + [Autentique su cliente de Docker](#examples-gstreamer-plugin-docker-authenticate) + [Descargue la imagen de Docker para Ubuntu, macOS, Windows o Raspberry Pi](#examples-gstreamer-plugin-docker-download) + [Ejecute la imagen de Docker](#examples-gstreamer-plugin-docker-run) ### Autentique su cliente de Docker Autentique su cliente de Docker en el registro de Amazon ECR del que va a extraer la imagen. Debe obtener los tokens de autenticación para cada registro utilizado. Los tokens son válidos durante 12 horas. Para obtener más información, consulte [Autenticación de registros](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) en la *Guía del usuario de Amazon Elastic Container Registry*. **Example : autenticación con Amazon ECR** Para autenticarse con Amazon ECR, copie y pegue el siguiente comando como se muestra. ``` sudo aws ecr get-login-password --region us-west-2 | docker login -u AWS --password-stdin https://546150905175.dkr.ecr.us-west-2.amazonaws.com ``` Si la acción se realiza correctamente, se muestra el texto `Login Succeeded` (Inicio de sesión correcto). ### Descargue la imagen de Docker para Ubuntu, macOS, Windows o Raspberry Pi Descargue la imagen de Docker en su entorno de Docker con uno de los siguientes comandos, en función de su sistema operativo: #### Descargue la imagen de Docker para Ubuntu ``` sudo docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux:latest ``` #### Descargue la imagen de Docker para macOS ``` docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux:latest ``` #### Descargue la imagen de Docker para Windows ``` docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-windows:latest ``` #### Descargue la imagen de Docker para Raspberry Pi ``` sudo docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-raspberry-pi:latest ``` Para comprobar que la imagen se ha agregado correctamente, utilice el comando siguiente: ``` docker images ``` ### Ejecute la imagen de Docker Utilice uno de los comandos siguientes para ejecutar la imagen de Docker, en función de su sistema operativo: #### Ejecute la imagen de Docker en Ubuntu ``` sudo docker run -it --network="host" --device=/dev/video0 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux /bin/bash ``` #### Ejecuta la imagen de Docker en macOS ``` sudo docker run -it --network="host" 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux /bin/bash ``` #### Ejecute la imagen de Docker en Windows ``` docker run -it 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-windows AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY RTSP_URL STREAM_NAME ``` #### Ejecute la imagen de Docker en Raspberry Pi ``` sudo docker run -it --device=/dev/video0 --device=/dev/vchiq -v /opt/vc:/opt/vc 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-raspberry-pi /bin/bash ``` Docker lanza el contenedor y le presenta una línea de comandos para usar los comandos dentro del contenedor. En el contenedor, establezca las variables de entorno utilizando el siguiente comando: ``` export LD_LIBRARY_PATH=/opt/awssdk/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$LD_LIBRARY_PATH export PATH=/opt/awssdk/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/bin:$PATH export GST_PLUGIN_PATH=/opt/awssdk/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$GST_PLUGIN_PATH ``` Comience a transmitir y `kvssink` utilice el `gst-launch-1.0` para ejecutar una canalización adecuada para su dispositivo y fuente de vídeo. Para ver, por ejemplo, canalizaciones, consulte[Ejemplos de comandos de lanzamiento GStreamer](#examples-gstreamer-plugin-launch). # GStreamer referencia de parámetros de elementos *Para enviar un vídeo al SDK de C\$1\$1 para productores de Amazon Kinesis Video Streams, debe `kvssink` especificarlo como destino final o destino final de la canalización.* Esta referencia proporciona información sobre parámetros `kvssink` obligatorios y opcionales. Para obtener más información, consulte [Ejemplo: complemento del GStreamer SDK para productores de Kinesis Video Streams: kvssink](examples-gstreamer-plugin.md). **Temas** + [Proporcione las credenciales a `kvssink`](#credentials-to-kvssink) + [Proporcione una región a `kvssink`](#kvssink-region) + [`kvssink`parámetros opcionales](#kvssink-optional-parameters) ## Proporcione las credenciales a `kvssink` Para permitir que el `kvssink` GStreamer elemento realice solicitudes AWS, proporcione AWS las credenciales que utilizará cuando llame al servicio Amazon Kinesis Video Streams. La cadena de proveedores de credenciales busca las credenciales en el siguiente orden: ### 1. AWS IoT credenciales Para configurar AWS IoT las credenciales, consulte[Control del acceso a los recursos de Kinesis Video Streams mediante AWS IoT](how-iot.md). El valor del `iot-credentials` parámetro debe empezar por `iot-certificate,` e ir seguido de una lista separada por comas de los siguientes pares *key* =*value*. **** | Key | Obligatorio | Descripción | | --- | --- | --- | | ca-path | Sí | Ruta del archivo al certificado de CA utilizado para establecer la confianza con el servicio de backend a través de TLS. **Example** **Ejemplo**: ` /file/path/to/certificate.pem` | | cert-path | Sí | Ruta del archivo al certificado X.509. **Example** **Ejemplo**: `/file/path/to/certificateID-certificate.pem.crt` | | endpoint | Sí | El punto de conexión del proveedor de AWS IoT Core credenciales de su cuenta. AWS Consulte la [guía AWS IoT para desarrolladores](https://docs.aws.amazon.com//iot/latest/developerguide/authorizing-direct-aws.html). **Example** **Ejemplo**: `credential-account-specific-prefix.credentials.iot.aws-region.amazonaws.com` | | key-path | Sí | Ruta del archivo a la clave privada utilizada en el public/private key pair. **Example** **Ejemplo**: `/file/path/to/certificateID-private.pem.key` | | role-aliases | Sí | El nombre del alias del rol que apunta al rol de AWS IAM que se va a usar al conectarse AWS IoT Core. **Example** **Ejemplo**: `KvsCameraIoTRoleAlias` | | iot-thing-name | No | La `iot-thing-name` es opcional. Si no `iot-thing-name` se proporciona, se utiliza el valor del `stream-name` parámetro. **Example** **Ejemplo**: `kvs_example_camera` | **Example** **Ejemplo:** ``` gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" iot-certificate="iot-certificate,endpoint=credential-account-specific-prefix.credentials.iot.aws-region.amazonaws.com,cert-path=certificateID-certificate.pem.crt,key-path=certificateID-private.pem.key,ca-path=certificate.pem,role-aliases=YourRoleAlias,iot-thing-name=YourThingName" ``` ### 2. Variables de entorno Para poder `kvssink` utilizar las credenciales del entorno, defina las siguientes variables de entorno: **** | Nombre de la variable de entorno | Obligatorio | Descripción | | --- | --- | --- | | AWS\$1ACCESS\$1KEY\$1ID | Sí | La clave de AWS acceso que se utiliza para acceder a Amazon Kinesis Video Streams. | | AWS\$1SECRET\$1ACCESS\$1KEY | Sí | La clave AWS secreta asociada a la clave de acceso. | | AWS\$1SESSION\$1TOKEN | No | Especifica el valor del token de sesión necesario si utiliza credenciales de seguridad temporales directamente de AWS STS las operaciones. | La configuración de la variable de entorno cambia el valor usado hasta el final de su sesión del intérprete de comandos o hasta que otorgue a la variable un valor diferente. Para que las variables sean persistentes en futuras sesiones, configúrelas en el script de inicio de su shell. ### 3. `access-key`, `secret-key` parámetros Para especificar las credenciales directamente como `kvssink` parámetro, defina los siguientes parámetros: **** | `kvssink`Nombre del parámetro | Obligatorio | Descripción | | --- | --- | --- | | access-key | Sí | La clave de AWS acceso que se utiliza para acceder a Amazon Kinesis Video Streams. | | secret-key | Sí | La clave AWS secreta asociada a la clave de acceso. | | session-token | No | Especifica el valor del token de sesión necesario si utiliza credenciales de seguridad temporales directamente de AWS STS las operaciones. | **Example** **Uso de credenciales estáticas:** ``` gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" access-key="AKIDEXAMPLE" secret-key="SKEXAMPLE" ``` **Example** **Uso de credenciales temporales:** ``` gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" access-key="AKIDEXAMPLE" secret-key="SKEXAMPLE" session-token="STEXAMPLE" ``` ### 4. Archivo de credenciales **importante** Si ha seleccionado uno de los métodos anteriores, no podrá usar el `credential-path` `kvssink` parámetro. **** | `kvssink`Nombre del parámetro | Obligatorio | Descripción | | --- | --- | --- | | credential-path | Sí | Ruta al archivo de texto que contiene las credenciales en un formato específico. | El archivo de texto debe contener credenciales en uno de los siguientes formatos: + CREDENCIALES *YourAccessKey* *YourSecretKey* + CREDENCIALES *YourAccessKey* *Expiration* *YourSecretKey* *SessionToken* **Example** **Ejemplo:** el `credentials.txt` archivo se encuentra en `/home/ubuntu` y contiene lo siguiente: `CREDENTIALS AKIDEXAMPLE 2023-08-10T22:43:00Z SKEXAMPLE STEXAMPLE` Para usarlo en`kvssink`, escriba: ``` gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" credential-path="/home/ubuntu/credentials.txt" ``` El tiempo de caducidad debería ser de al menos 5 \$1 30 \$1 3 = **38** segundos en el futuro. El período de gracia se define como la `IOT_CREDENTIAL_FETCH_GRACE_PERIOD` variable en [https://github.com/awslabs/amazon-kinesis-video-streams-producer-c/blob/master/src/source/Common/IotCredentialProvider.h](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c/blob/master/src/source/Common/IotCredentialProvider.h). Si las credenciales están muy cerca de caducar al empezar`kvssink`, recibirá el código de error`0x52000049 - STATUS_INVALID_TOKEN_EXPIRATION`. `kvssink`no modifica el archivo de credenciales. Si utiliza credenciales temporales, una fuente externa debe actualizar el archivo de credenciales antes de la fecha de caducidad menos el período de gracia. ## Proporcione una región a `kvssink` El orden de búsqueda de las regiones es el siguiente: 1. `AWS_DEFAULT_REGION`la variable de entorno se revisa primero. Si está establecida, esa región se usa para configurar el cliente. 1. `aws-region`El parámetro se revisa a continuación. Si está establecido, esa región se usa para configurar el cliente. 1. Si no se ha utilizado ninguno de los métodos anteriores, el `kvssink` valor predeterminado es. `us-west-2` ## `kvssink`parámetros opcionales El elemento `kvssink` tiene los siguientes parámetros opcionales. Para obtener más información sobre estos parámetros, consulte [Estructuras de transmisión de vídeo de Kinesis](producer-reference-structures-stream.md). **** | Parámetro | Description (Descripción) | Unidad/tipo | Predeterminado | | --- | --- | --- | --- | | stream-name | El nombre de la transmisión de vídeo de Amazon Kinesis de destino. Si no se especifica ningún nombre de transmisión, se utilizará el nombre de transmisión predeterminado: «DEFAULT\$1STREAM». Si aún no existe una transmisión con ese nombre predeterminado, se creará. | | | | absolute-fragment-times | Si se utilizan tiempos de fragmentos absolutos. | Booleano | true | | access-key | La clave de AWS acceso que se utiliza para acceder a Kinesis Video Streams. Debe tener AWS configuradas las credenciales o proporcionar este parámetro. Para proporcionar esta información, escriba lo siguiente: 
export AWS_ACCESS_KEY_ID=
| | | | avg-bandwidth-bps | El ancho de banda medio previsto para la secuencia. | Bits por segundo | 4194304 | | aws-region | El que Región de AWS se va a usar. También puede proporcionar la variable de `AWS_DEFAULT_REGION` entorno a la región. Las variables de entorno tienen prioridad si se establecen los parámetros de la variable de entorno y kvssink. La región se establecerá de forma predeterminada `us-west-2` si no se especifica lo contrario. | Cadena | "us-west-2" | | buffer-duration | La duración del búfer de la secuencia. | Segundos | 120 | | codec-id | El ID del códec de la secuencia. | Cadena | "V\$1MPEG4/ISO/AVC" | | connection-staleness | El tiempo transcurrido, al que se denomina devolución de señal por inactividad de la transmisión. | Segundos | 60 | | content-type | El tipo de contenido de la secuencia. | Cadena | "video/h264" | | fragment-acks | Si se debe usar el fragmento. ACKs | Booleano | true | | fragment-duration | La duración del fragmento que desea. | Milisegundos | 2000 | | framerate | La velocidad de fotogramas prevista. | Fotogramas por segundo | 25 | | frame-timecodes | Si se utilizan códigos de tiempo de fotograma o se generan marcas de tiempo utilizando la devolución de llamada de tiempo actual. | Booleano | true | | key-frame-fragmentation | Si se producen fragmentos en un fotograma clave. | Booleano | true | | log-config | La ruta de configuración de registro. | Cadena | "../kvs\$1log\$1configuration" | | max-latency | La latencia máxima de la secuencia. | Segundos | 60 | | recalculate-metrics | Si se vuelven a calcular las métricas. | Booleano | true | | replay-duration | La duración para restaurar el lector actual para reproducir durante un error si está habilitada la reactivación. | Segundos | 40 | | restart-on-error | Si se reinicia cuando se produce un error. | Booleano | true | | retention-period | El periodo de tiempo que se mantiene la secuencia. | Horas | 2 | | rotation-period | El período de rotación de claves. Para obtener más información, consulte [AWS KMS Teclas giratorias](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html). | Segundos | 3600 | | secret-key | La clave AWS secreta que se usa para acceder a Kinesis Video Streams. Debe tener AWS configuradas las credenciales o proporcionar este parámetro. 
export AWS_SECRET_ACCESS_KEY=
| | | | session-token | Especifica el valor del token de sesión necesario si utiliza credenciales de seguridad temporales directamente de AWS STS las operaciones. | | | | storage-size | El tamaño de almacenamiento del dispositivo en mebibyte (MiB). Para obtener información acerca de la configuración del almacenamiento de dispositivo, consulte [StorageInfo](producer-reference-structures-producer.md#producer-reference-structures-producer-storageinfo). | Mebibyte (MiB) | 128 | | streaming-type | El tipo de streaming. Los valores válidos son: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html) | Enum GstKvsSinkStreamingType | 0: tiempo real | | timecode-scale | La escala de código de tiempo de MKV. | Milisegundos | 1 | | track-name | El nombre de la pista MKV. | Cadena | "kinesis\$1video" | | iot-certificate | AWS IoT credenciales que se utilizarán en el `kvssink` elemento. `iot-certificate`acepta las siguientes claves y valores: El `iot-thing-name` es **opcional**. Si no `iot-thing-name` se proporciona, se utiliza el valor del `stream-name` parámetro. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html) | Cadena | Ninguno | # Ejemplo: envío de datos a Kinesis Video Streams mediante PutMedia la API En este ejemplo se muestra cómo utilizar la [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)API. Muestra cómo enviar datos que ya están en formato contenedor (MKV). Si los datos deben agruparse en un formato contenedor antes de enviarlos (por ejemplo, si va a agrupar los datos de vídeo de la cámara en fotogramas), consulte[Cargar a Kinesis Video Streams](producer-sdk.md). **nota** La `PutMedia` operación solo está disponible en C\$1\$1 y Java SDKs. Esto se debe a la gestión dúplex completa de las conexiones, el flujo de datos y las confirmaciones. No se admite en otros idiomas. **Topics** + [Descarga y configura el código](#examples-putmedia-download) + [Escribe y examina el código](#examples-putmedia-write) + [Ejecute y verifique el código](#examples-putmedia-run) ## Descarga y configura el código Siga los pasos para descargar el código de ejemplo de Java, importar el proyecto a su IDE de Java, configurar las ubicaciones de las bibliotecas y configurar el código para usar sus AWS credenciales. 1. Crea un directorio y clona el código fuente del ejemplo desde el GitHub repositorio. El ejemplo de `PutMedia` forma parte de la [Java](producer-sdk-javaapi.md). ``` git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-java ``` 1. Abra el IDE de Java que esté utilizando (por ejemplo, [Eclipse](https://www.eclipse.org/) o [IntelliJ](https://www.jetbrains.com/idea/) IDEA) e importe el proyecto Apache Maven que ha descargado: + **En Eclipse:** seleccione **File** (Archivo), **Import...** (Importar...), **Maven** (Maven), **Existing Maven Projects** (Proyectos Maven existentes) y vaya a la raíz del paquete descargado. Seleccione el archivo `pom.xml`. + **En IntelliJ Idea: **seleccione **Import**. Vaya al archivo `pom.xml` en la raíz del paquete descargado. Para obtener más información, consulte la documentación del IDE relacionada. 1. Actualice el proyecto, de modo que el IDE pueda encontrar las bibliotecas que ha importado. + Para IntelliJ IDEA, realice lo siguiente: 1. Abra el menú contextual (clic secundario) en el directorio **lib** del proyecto y seleccione **Add as library**. 1. **Elija **Archivo** y, a continuación, elija Estructura del proyecto.** 1. En **Project Settings**, seleccione **Modules**. 1. En la pestaña **Sources (Orígenes)**, configure **Language Level (Nivel de lenguaje)** en **7** o más. + Para Eclipse, haga lo siguiente: 1. Abra el menú contextual (clic secundario) del proyecto y seleccione **Properties**, **Java Build Path**, **Source**. A continuación, proceda del modo siguiente: 1. En la pestaña **Source**, haga doble clic en **Native library location**. 1. En el asistente **Native Library Folder Configuration**, seleccione **Workspace**. 1. En la opción **Native Library Folder**, seleccione el directorio **lib** del proyecto. 1. Abra el menú contextual (clic secundario) del proyecto y seleccione **Properties**. A continuación, proceda del modo siguiente: 1. En la pestaña **Libraries**, elija **Add Jars**. 1. En el asistente **JAR selection (Selección de JAR)**, seleccione todos los archivos .jar del directorio `lib` del proyecto. ## Escribe y examina el código El ejemplo de API `PutMedia` () muestra el siguiente patrón de codificación:`PutMediaDemo` **Topics** + [Crea el PutMediaClient](#producersdk-javaapi-writecode-putmediaapi-putmediaclient) + [Transmisión de medios y pausa del subproceso](#producersdk-javaapi-writecode-putmediaapi-run) Los ejemplos de código de esta sección pertenecen a la clase `PutMediaDemo`. ### Crea el PutMediaClient La creación del `PutMediaClient` objeto requiere los siguientes parámetros: + La URI del punto de conexión `PutMedia`. + Un `InputStream` que señale al archivo MKV que se ha de transmitir. + El nombre de la transmisión. En este ejemplo se utiliza la misma transmisión creada en la [Utilice la biblioteca de productores de Java](producer-sdk-javaapi.md) (`my-stream`). Para utilizar otra transmisión, cambie el siguiente parámetro: ``` private static final String STREAM_NAME="my-stream"; ``` **nota** El ejemplo de la `PutMedia` API no crea una transmisión. Debe crear una transmisión mediante la aplicación de prueba de la [Utilice la biblioteca de productores de Java](producer-sdk-javaapi.md) consola Kinesis Video Streams o AWS CLI la. + Marca temporal actual. + Tipo de código temporal. En el ejemplo se utiliza `RELATIVE`, lo que indica que la marca temporal es relativa al inicio del contenedor. + Un objeto `AWSKinesisVideoV4Signer` que comprueba que los paquetes recibidos han sido enviados por el remitente autorizado. + El ancho de banda de subida máximo en Kbps, + Un objeto `AckConsumer` para recibir los reconocimientos de los paquetes recibidos. El siguiente código crea el objeto `PutMediaClient`: ``` /* actually URI to send PutMedia request */ final URI uri = URI.create(KINESIS_VIDEO_DATA_ENDPOINT + PUT_MEDIA_API); /* input stream for sample MKV file */ final InputStream inputStream = new FileInputStream(MKV_FILE_PATH); /* use a latch for main thread to wait for response to complete */ final CountDownLatch latch = new CountDownLatch(1); /* a consumer for PutMedia ACK events */ final AckConsumer ackConsumer = new AckConsumer(latch); /* client configuration used for AWS SigV4 signer */ final ClientConfiguration configuration = getClientConfiguration(uri); /* PutMedia client */ final PutMediaClient client = PutMediaClient.builder() .putMediaDestinationUri(uri) .mkvStream(inputStream) .streamName(STREAM_NAME) .timestamp(System.currentTimeMillis()) .fragmentTimeCodeType("RELATIVE") .signWith(getKinesisVideoSigner(configuration)) .upstreamKbps(MAX_BANDWIDTH_KBPS) .receiveAcks(ackConsumer) .build(); ``` ### Transmisión de medios y pausa del subproceso Tras crear el cliente, la muestra inicia el streaming asincrónico con `putMediaInBackground`. Posteriormente, el subproceso principal se pausa con `latch.await` hasta que devuelve `AckConsumer` y en ese punto se cierra el cliente. ``` /* start streaming video in a background thread */ client.putMediaInBackground(); /* wait for request/response to complete */ latch.await(); /* close the client */ client.close(); ``` ## Ejecute y verifique el código Para ejecutar el ejemplo de API `PutMedia`, siga estos pasos: 1. Cree una transmisión con el nombre `my-stream` correspondiente en la consola de Kinesis Video Streams o mediante AWS CLI. 1. Cambie el directorio de trabajo actual al directorio del SDK Producer de Java: ``` cd //amazon-kinesis-video-streams-producer-sdk-java/ ``` 1. Compile el SDK de Java y la aplicación de demostración: ``` mvn package ``` 1. Cree un nombre de archivo temporal en el directorio `/tmp`: ``` jar_files=$(mktemp) ``` 1. Cree una cadena classpath de dependencias desde el repositorio local a un archivo: ``` mvn -Dmdep.outputFile=$jar_files dependency:build-classpath ``` 1. Establezca el valor de la variable de entorno `LD_LIBRARY_PATH` del modo siguiente: ``` export LD_LIBRARY_PATH=//amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$LD_LIBRARY_PATH $ classpath_values=$(cat $jar_files) ``` 1. Ejecute la demostración desde la línea de comandos de la siguiente manera, proporcionando sus AWS credenciales: ``` java -classpath target/kinesisvideo-java-demo-1.0-SNAPSHOT.jar:$classpath_values -Daws.accessKeyId=${ACCESS_KEY} -Daws.secretKey=${SECRET_KEY} -Djava.library.path=/opt/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build com.amazonaws.kinesisvideo.demoapp.DemoAppMain ``` 1. Abra la consola de [Kinesis Video Streams](https://console.aws.amazon.com//kinesisvideo/home/) y elija su transmisión en **la página Administrar** transmisiones. El vídeo se reproduce en el panel **Video Preview**. # Ejemplo: transmisión desde una fuente RTSP [C\$1\$1](producer-sdk-cpp.md)Contiene una definición para un contenedor [Docker](https://www.docker.com/) que se conecta a una cámara de red del Protocolo de transmisión en tiempo real (RTSP). El uso de Docker estandariza el entorno operativo de Kinesis Video Streams, lo que agiliza la creación y el uso de la aplicación. El siguiente procedimiento demuestra cómo configurar y utilizar la aplicación de demostración RTSP. **Topics** + [Tutoriales de vídeo](#rtsp-video) + [Requisitos previos](#examples-rtsp-prerequisites) + [Compilación de la imagen de Docker](#examples-rtsp-build) + [Ejecute la aplicación de ejemplo de RTSP](#examples-rtsp-procedure) ## Tutoriales de vídeo Este vídeo muestra cómo configurar una Raspberry Pi para enviar feeds RTSP a la AWS nube y a Amazon Kinesis Video Streams. Se trata de una demostración end-to-end. [![AWS Videos](http://img.youtube.com/vi/YoOYTCD_v3Q?si=ajdNXZpRhNnpAOKk/0.jpg)](http://www.youtube.com/watch?v=YoOYTCD_v3Q?si=ajdNXZpRhNnpAOKk) En este vídeo se muestra cómo capturar imágenes de un feed para utilizar la visión artificial y Amazon Rekognition para procesar las imágenes y enviar alertas. ## Requisitos previos Para ejecutar la aplicación de ejemplo RTSP de Kinesis Video Streams, debe disponer de lo siguiente: + **Docker:** para obtener información sobre cómo instalar y utilizar Docker, consulte los siguientes enlaces: + [Instrucciones de descarga de Docker](https://docs.docker.com/desktop/) + [Introducción a Docker](https://docs.docker.com/guides/getting-started/) + **Origen cámara de red RTSP:** para obtener más información acerca de las cámaras recomendadas, consulte [Requisitos del sistema](system-requirements.md). ## Compilación de la imagen de Docker En primer lugar, cree la imagen de Docker en la que se ejecutará la aplicación de demostración. 1. Clone el repositorio de demostraciones de Amazon Kinesis Video Streams. ``` git clone https://github.com/aws-samples/amazon-kinesis-video-streams-demos.git ``` 1. Cambie al directorio que contiene el Dockerfile. En este caso, es el directorio [docker-rtsp](https://github.com/aws-samples/amazon-kinesis-video-streams-demos/blob/master/producer-cpp/docker-rtsp/). ``` cd amazon-kinesis-video-streams-demos/producer-cpp/docker-rtsp/ ``` 1. Usa el siguiente comando para crear la imagen de Docker. Este comando crea la imagen y la etiqueta como rtspdockertest. ``` docker build -t rtspdockertest . ``` 1. Ejecute `docker images` y busque el ID de imagen con el que está etiquetado. `rtspdockertest` Por ejemplo, en el resultado de ejemplo que aparece a continuación, el `IMAGE ID` es`54f0d65f69b2`. ``` REPOSITORY TAG IMAGE ID CREATED PLATFORM SIZE BLOB SIZE rtspdockertest latest 54f0d65f69b2 10 minutes ago linux/arm64 653.1 MiB 292.4 MiB ``` Lo necesitará en un paso posterior. ## Ejecute la aplicación de ejemplo de RTSP Puede ejecutar la aplicación de ejemplo de RTSP desde dentro o fuera del contenedor de Docker. Siga las instrucciones correspondientes que aparecen a continuación. **Topics** + [Dentro del contenedor Docker](#examples-rtsp-within) + [Fuera del contenedor de Docker](#examples-rtsp-outside) ### Dentro del contenedor Docker **Ejecute la aplicación de ejemplo de RTSP** 1. Inicie el contenedor Docker de Amazon Kinesis Video Streams mediante el siguiente comando: ``` docker run -it YourImageId /bin/bash ``` 1. Para iniciar la aplicación de muestra, proporcione sus AWS credenciales, el nombre de la transmisión de vídeo de Amazon Kinesis y la URL de la cámara de red RTSP. **importante** Si utiliza credenciales temporales, también tendrá que proporcionar las suyas. `AWS_SESSION_TOKEN` Consulta el segundo ejemplo que aparece a continuación. ``` export AWS_ACCESS_KEY_ID=YourAccessKeyId export AWS_SECRET_ACCESS_KEY=YourSecretKeyId export AWS_DEFAULT_REGION=YourAWSRegion ./kvs_gstreamer_sample YourStreamName YourRtspUrl ``` **Credenciales temporales:** ``` export AWS_ACCESS_KEY_ID=YourAccessKeyId export AWS_SECRET_ACCESS_KEY=YourSecretKeyId export AWS_SESSION_TOKEN=YourSessionToken export AWS_DEFAULT_REGION=YourAWSRegion ./kvs_gstreamer_sample YourStreamName YourRtspUrl ``` 1. Inicie sesión en la consola de [Kinesis Video Streams Consola de administración de AWS](https://console.aws.amazon.com//kinesisvideo/home/) y ábrala. Vea la transmisión. 1. Para salir del contenedor de Docker, cierra la ventana de la terminal o escribe`exit`. ### Fuera del contenedor de Docker Desde **fuera** del contenedor de Docker, usa el siguiente comando: ``` docker run -it YourImageId /bin/bash -c "export AWS_ACCESS_KEY_ID=YourAccessKeyId; export AWS_SECRET_ACCESS_KEY=YourSecretKeyId; export AWS_SESSION_TOKEN=YourSessionToken; export AWS_DEFAULT_REGION=Your AWS Region; ./kvs_gstreamer_sample YourStreamName YourRtspUrl" ``` # Ejemplo: análisis y renderización de fragmentos de Kinesis Video Streams [Transmita usando la biblioteca de analizadores](parser-library.md)Contiene una aplicación de demostración denominada `KinesisVideoRendererExample` que muestra cómo analizar y renderizar fragmentos de transmisiones de vídeo de Amazon Kinesis. El ejemplo se utiliza [JCodec](http://jcodec.org/)para decodificar los fotogramas codificados en H.264 que se ingieren con la aplicación. [Ejemplo: complemento del GStreamer SDK para productores de Kinesis Video Streams: kvssink](examples-gstreamer-plugin.md) Después de decodificar el marco utilizando JCodec, la imagen visible se renderiza utilizando. [JFrame](https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html) Este ejemplo le muestra cómo hacer lo siguiente: + Recupere fotogramas de una transmisión de vídeo de Kinesis mediante la `GetMedia` API y procese la transmisión para su visualización. + Vea el contenido de vídeo de las transmisiones en una aplicación personalizada en lugar de utilizar la consola de Kinesis Video Streams. También puede usar las clases de este ejemplo para ver contenido de transmisión de vídeo de Kinesis que no esté codificado como H.264, como una transmisión de archivos JPEG que no requieren decodificación antes de mostrarse. El siguiente procedimiento demuestra cómo configurar y utilizar la aplicación de demostración Renderer. ## Requisitos previos Para examinar y utilizar la biblioteca de ejemplos de Renderer, debe tener lo siguiente: + Una cuenta de Amazon Web Services (AWS). Si aún no tiene una AWS cuenta, consulte [Introducción a Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/getting-started.html). + Un entorno de desarrollo integrado (IDE) de Java, como [Eclipse Java Neon](https://www.eclipse.org/downloads/packages/release/neon/3/eclipse-jee-neon-3) o [JetBrains IntelliJ Idea](https://www.jetbrains.com/idea/download/). ## Ejemplo de ejecución del renderizador 1. Cree un directorio y, a continuación, clone el código fuente del ejemplo desde el GitHub repositorio. ``` git clone https://github.com/aws/amazon-kinesis-video-streams-parser-library ``` 1. Abra el IDE de Java que utilice (por ejemplo, [Eclipse](https://www.eclipse.org/) o [IntelliJ IDEA](https://www.jetbrains.com/idea/)) e importe el proyecto de Apache Maven que ha descargado: + **En Eclipse:** seleccione **File**, **Import**, **Maven**, **Existing Maven Projects**. Vaya al directorio `kinesis-video-streams-parser-lib`. + **En IntelliJ Idea: **seleccione **Import**. Vaya al archivo `pom.xml` en la raíz del paquete descargado. **nota** Si IntelliJ no encuentra sus dependencias, es posible que tenga que hacer lo siguiente: **Compilación limpia:** elija **File (Archivo)**, **Settings (Configuración)**, **Build, Execution, Deployment (Compilación, ejecución, implementación)**, **Compiler (Compilador)**. Compruebe que esté seleccionada la opción **Borrar el directorio de salida al reconstruir** y, a continuación, elija **Construir**, **compilar proyecto**. **Vuelva a importar el proyecto:** abra el menú contextual (clic con el botón derecho) del proyecto y seleccione **Maven**, **Reimport (Volver a importar)**. Para obtener más información, consulte la documentación del IDE relacionada. 1. Desde su IDE de Java, abra `src/test/java/com.amazonaws.kinesisvideo.parser/examples/KinesisVideoRendererExampleTest`. 1. Elimine la directiva `@Ignore` del archivo. 1. Actualice el `.stream` parámetro con el nombre de la transmisión de vídeo de Kinesis. 1. Ejecute la prueba `KinesisVideoRendererExample`. ## Cómo funciona **Topics** + [Envío de datos MKV](#examples-renderer-howitworks-send) + [Análisis de fragmentos de MKV para convertirlos en fotogramas](#examples-renderer-howitworks-parse) + [Decodificar y mostrar el marco](#examples-renderer-howitworks-display) ### Envío de datos MKV En el ejemplo, se envían muestras de datos MKV desde el `rendering_example_video.mkv` archivo y se utilizan `PutMedia` para enviar datos de vídeo a una transmisión denominada. **render-example-stream** La aplicación crea un `PutMediaWorker`: ``` PutMediaWorker putMediaWorker = PutMediaWorker.create(getRegion(), getCredentialsProvider(), getStreamName(), inputStream, streamOps.amazonKinesisVideo); executorService.submit(putMediaWorker); ``` Para obtener más información acerca de la clase `PutMediaWorker`, consulte [Llama PutMedia](parser-library-write.md#parser-library-write-example-putmedia) en la documentación de [Transmita usando la biblioteca de analizadores](parser-library.md). ### Análisis de fragmentos de MKV para convertirlos en fotogramas A continuación, el ejemplo recupera y analiza los fragmentos MKV de la secuencia utilizando un `GetMediaWorker`: ``` GetMediaWorker getMediaWorker = GetMediaWorker.create(getRegion(), getCredentialsProvider(), getStreamName(), new StartSelector().withStartSelectorType(StartSelectorType.EARLIEST), streamOps.amazonKinesisVideo, getMediaProcessingArgumentsLocal.getFrameVisitor()); executorService.submit(getMediaWorker); ``` Para obtener más información acerca de la clase `GetMediaWorker`, consulte [Llama GetMedia](parser-library-write.md#parser-library-write-example-getmedia) en la documentación de [Transmita usando la biblioteca de analizadores](parser-library.md). ### Decodificar y mostrar el marco A continuación, el ejemplo decodifica y muestra el marco utilizando [JFrame](https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html). El siguiente ejemplo de código procede de la clase `KinesisVideoFrameViewer`, que amplía `JFrame`: ``` public void setImage(BufferedImage bufferedImage) { image = bufferedImage; repaint(); } ``` La imagen se muestra como una instancia de [java.awt.image. BufferedImage](https://docs.oracle.com/javase/7/docs/api/java/awt/image/BufferedImage.html). Para ver ejemplos que ilustran cómo trabajar con `BufferedImage`, consulte [Reading/Loading an Image](https://docs.oracle.com/javase/tutorial/2d/images/loadimage.html).