Cómo añadir Video Streaming en Linux con OpenTok Linux SDK

Cómo añadir Video Streaming en Linux con OpenTok Linux SDK

Como parte de nuestra iniciativa OpenTok Labs, nos complace compartir las nuevas muestras de nuestro SDK para Linux. Utilizando el SDK para Linux, podrá crear aplicaciones de escritorio compatibles con soluciones de videovigilancia en sistemas Linux integrados y otras aplicaciones en las que sea necesario el streaming de audio y vídeo. La etiqueta OpenTok Labs indica que el SDK está actualmente en una base de mejores esfuerzos, en lugar de un SDK con soporte oficial, por lo que nos encantaría que contribuyas mediante la presentación de problemas y el envío de pull requests para mejorarlo. El SDK de OpenTok para Linux está diseñado para trabajar con un consumo reducido de recursos del sistema y un bajo consumo de memoria. Puedes utilizar el SDK de Linux a través de una API en C, lo que permitirá a los desarrolladores integrarlo prácticamente en cualquier lugar. Dado que Linux ha sido ampliamente adoptado para una gran variedad de casos de uso, ahora puede ampliar su alcance y añadir comunicaciones en tiempo real a dispositivos basados en Linux utilizando la plataforma OpenTok.

Cómo funciona

Si ya estás familiarizado con las APIs y conceptos del SDK de OpenTok, entonces empezar con el SDK de Linux será fácil porque utiliza los mismos conceptos de OpenTok, como sesiones, editores y suscriptores, entre otros. Con el OpenTok Linux SDK, también seguimos un modelo de programación donde la aplicación inicia acciones, como conectarse a una sesión, comenzar a publicar, y suscribirse a un stream, etc. Después de que la acción es iniciada y ciertos eventos ocurren, entonces la aplicación es notificada vía callbacks. Estos eventos, por ejemplo, incluyen:

• cuando una sesión se conecta correctamente o se produce un error,

• cuando un editor empieza a publicar,

• cuando hay un nuevo participante en la sesión, y cuando un nuevo participante empieza a publicar, lo que desencadena la creación de un nuevo abonado, etc.

Empecemos por cómo implementar los pasos comunes utilizados para añadir vídeo en directo a cualquier aplicación utilizando los SDK de cliente de OpenTok.

Conectarse a una sesión

Cuando se conecta a una sesión, el desarrollador tiene que proporcionar las funciones callback que implementan la respuesta para los eventos en los que la aplicación está interesada. Los punteros a estas funciones se proporcionan a través de una estructura, que actúa como argumento de la función que puede crear una sesión. El puntero a esta nueva sesión se utiliza posteriormente al conectar la sesión. Al igual que con nuestras otras aplicaciones de ejemplo, el desarrollador tiene que proporcionar las credenciales de OpenTok (es decir, API KEY, id de sesión y token).

// ...

void onOpenTokSessionConnectedCallback(otc_session *session, void *user_data) {
}

void onOpenTokSessionStreamReceivedCallback(otc_session *session, 
                                            void *user_data,
                                            const otc_stream *stream) {
}

void onOpenTokSessionStreamDroppedCallback(otc_session *session,
                                           void *user_data,
                                           const otc_stream *stream) {
}

void onOpenTokSessionErrorCallback(otc_session *session,
                                   void *user_data,
                                   const char* error_string,
                                   enum otc_session_error error) {
}

// ...

struct otc_session_cb session_callbacks = {0};
session_callbacks.user_data = this;
session_callbacks.on_connected = onOpenTokSessionConnectedCallback;
session_callbacks.on_stream_received = onOpenTokSessionStreamReceivedCallback;
session_callbacks.on_stream_dropped = onOpenTokSessionStreamDroppedCallback;
session_callbacks.on_error = onOpenTokSessionErrorCallback;
session_ = otc_session_new(apiKey.c_str(), sessionId.c_str(), &session_callbacks);

if (session_ == nullptr) {
  return;
}

otc_session_connect(session_, token.c_str());

Publicar Audio y Video en una Sesión

Para los editores, seguimos el mismo enfoque y proporcionamos funciones callback que implementan la respuesta para eventos en los que la aplicación está interesada. Para el editor, el desarrollador es responsable de crear esas funciones callback. Éstas implementan la respuesta a ciertos eventos, por ejemplo: cuando el editor comienza a publicar (se crea el flujo, entonces se dispara un evento), o hay un nuevo fotograma del flujo de vídeo del editor que puede ser renderizado o se produce un error. Los punteros a estas funciones de callback se proporcionan a través de otra estructura que se pasa como argumento a la función que crea un nuevo editor.

void onOpenTokPublisherStreamCreatedCallback(otc_publisher *publisher, 
                                             void *user_data, 
                                             const otc_stream *stream) {
}

void onOpenTokPublisherRenderFrameCallback(otc_publisher *publisher,
                                           void *user_data,
                                           const otc_video_frame *frame) {
}

void onOpenTokPublisherErrorCallback(otc_publisher *publisher,
                                     void *user_data,
                                     const char* error_string,
                                     enum otc_publisher_error error_code) {
}

struct otc_publisher_cb publisher_cb = {0};
publisher_cb.user_data = this;
publisher_cb.on_stream_created = onOpenTokPublisherStreamCreatedCallback;
publisher_cb.on_render_frame = onOpenTokPublisherRenderFrameCallback;
publisher_cb.on_error = onOpenTokPublisherErrorCallback;
publisher_ = otc_publisher_new(name_.c_str(), nullptr, &publisher_cb);

if (publisher_ == nullptr) {
  return;
}

Una vez que se llama a la función callback conectada a la sesión, la aplicación puede empezar a publicar. Se puede implementar dentro de la propia función callback. Nota: esta es una función callback para la sesión. Se proporcionó un puntero a ella cuando se creó la sesión anteriormente.

void onOpenTokSessionConnectedCallback(otc_session *session, void *user_data) {
  // ...
  if ((session_ != nullptr) && (publisher_ != nullptr)) {
    otc_session_publish(session_, publisher_);
  }
  // ...
}

La aplicación no debe permitir que el editor publique hasta que la sesión esté conectada.

Suscribirse a un flujo de audio y Video

Cada vez que hay un nuevo participante conectado a la sesión, y el participante está publicando, la sesión es notificada a través de la llamada de retorno del flujo recibido de la sesión. Podemos implementar cómo se crea un suscriptor dentro de la función callback de la sesión. Tenga en cuenta que esta función de devolución de llamada pertenece a la sesión creada anteriormente, y se proporcionó un puntero a la misma al crear la sesión. De forma similar a los objetos session y publisher, el desarrollador tiene que implementar funciones callback. Siempre se debe proporcionar una de error para activar las notificaciones de error. Esto se refiere a la llamada de retorno de error. Si se produce un error, se llama a la función callback. Cuando se crea el suscriptor, la sesión puede conectarse al nuevo suscriptor y empezar a recibir el flujo de audio y vídeo del nuevo participante.

// ...

void onOpenTokSubscriberRenderFrameCallback(otc_subscriber *subscriber,
					    void *user_data,
					    const otc_video_frame *frame) {
}

void onOpenTokSubscriberErrorCallback(otc_subscriber *subscriber,
                                      void *user_data,
                                      const char* error_string,
                                      enum otc_subscriber_error error_code) {
}

// ...

void onOpenTokSessionStreamReceivedCallback(otc_session *session,
					    void *user_data,
					    const otc_stream *stream) {
  // ...
  struct otc_subscriber_cb subscriber_cb = {0};
  subscriber_cb.user_data = conference;
  subscriber_cb.on_render_frame = onOpenTokSubscriberRenderFrameCallback;
  subscriber_cb.on_error = onOpenTokSubscriberErrorCallback;
  otc_subscriber* subscriber = otc_subscriber_new((otc_stream*)stream, &subscriber_cb);
  if (subscriber == nullptr) {
    return;
  }
  otc_session_subscribe(session, subscriber);
  // ...
}

// ...

Renderizar Video Stream

Si desea renderizar el flujo de vídeo para editores y suscriptores utilizando OpenTok Linux SDK, existen varios buenos recursos, como por ejemplo Simple DirectMedia Layer Library conocidas librerías de terceros que pueden ayudar. Las dos funciones callback de abajo son llamadas cuando hay un nuevo cuadro a ser renderizado para editores y suscriptores.

void onOpenTokSubscriberRenderFrameCallback(otc_subscriber *subscriber,
					    void *user_data,
					    const otc_video_frame *frame) {
}

void onOpenTokPublisherRenderFrameCallback(otc_publisher *publisher,
                                           void *user_data,
                                           const otc_video_frame *frame) {
}

Podemos tener un gestor de render, o algo similar, que renderice el fotograma por nosotros. En el ejemplo de abajo, estamos usando la librería Simple DirectMedia Layer.

void Renderer::onFrame(otc_video_frame* frame) {
  if (!window_) {
    return;
  }
  SDL_Surface* surface_ =  SDL_GetWindowSurface(window_);

  auto pixels = otc_video_frame_get_plane(frame, 0);
  SDL_Surface* sdl_frame = SDL_CreateRGBSurfaceFrom(
      const_cast<unsigned char*>(pixels),
      otc_video_frame_get_width(frame),
      otc_video_frame_get_height(frame),
      32,
      otc_video_frame_get_width(frame) * 4,
      0,0,0,0);

  SDL_BlitScaled(sdl_frame, NULL, surface_, nullptr);
  SDL_FreeSurface(sdl_frame);

  SDL_UpdateWindowSurface(window_);
}

Ejemplos del SDK de OpenTok para Linux

Hace un par de semanas hicimos público un repositorio Github para OpenTok Linux SDK con algunos ejemplos para ayudar a proporcionar una mejor comprensión de las características y las mejores prácticas. A día de hoy, tenemos tres muestras diferentes; sin embargo, estamos trabajando para añadir muchas más. En uno de los ejemplos, se puede implementar una aplicación básica de video chat que se puede ejecutar en un entorno de escritorio Linux normal (por ejemplo, Ubuntu 18.04.2 LTS, Bionic Beaver). Como mencionamos al principio, OpenTok Linux SDK se puede utilizar para implementar una solución de videovigilancia, utilizando un pequeño ordenador de placa única, como la Raspberry Pi, para transmitir vídeo como un punto final de sólo publicación. Esta funcionalidad es parte de la muestra que proporcionamos.

Ciclo de vida del SDK para Linux de OpenTok

A partir de hoy, el SDK de OpenTok para Linux está en beta cerrada (beta privada). Nuestro nuevo SDK es capaz de aportar valor, y por eso lo presentamos ahora. Sin embargo, aún no está listo para el primetime. Todavía estamos en proceso de crear todo lo necesario, como la documentación para desarrolladores y los recursos para nuestro centro de desarrolladores. Mientras tanto, ¡nos encantaría recibir tus comentarios! Te invitamos a que pruebes nuestro nuevo SDK y nos cuentes qué te parece. OpenTok Linux SDK se pueden encontrar en nuestro repositorio en GitHub. Empieza con cualquiera de las tres compilaciones incluidas en GitHub, incluyendo x86_64, armv7 y arm64. Permanece atento a más noticias sobre OpenTok Linux SDK.