Comment ajouter des vidéos en streaming sur Linux avec OpenTok Linux SDK

Comment ajouter des vidéos en streaming sur Linux avec OpenTok Linux SDK

Dans le cadre de notre initiative OpenTok Labs, nous sommes heureux de partager les nouveaux échantillons de notre SDK Linux. En utilisant le SDK Linux, vous serez en mesure de créer des applications de bureau qui prennent en charge des solutions de vidéosurveillance sur des systèmes Linux embarqués et d'autres applications où le streaming audio et vidéo est nécessaire. Le label OpenTok Labs indique que le SDK est actuellement sur une base de meilleur effort, plutôt qu'un SDK officiellement supporté, donc nous aimerions que vous contribuiez en déposant des problèmes et en envoyant des requêtes pour l'améliorer. Le SDK Linux OpenTok est conçu pour fonctionner avec une consommation réduite de ressources système et une faible empreinte mémoire. Vous pouvez utiliser le SDK Linux via une API C, ce qui permettra aux développeurs de l'intégrer presque partout. Étant donné que Linux a été largement adopté pour une variété de cas d'utilisation, vous pouvez maintenant étendre votre portée et ajouter des communications en temps réel aux appareils basés sur Linux en utilisant la plateforme OpenTok.

Comment cela fonctionne-t-il ?

Si vous êtes déjà familiarisé avec les API et les concepts du SDK OpenTok, il vous sera facile de commencer à utiliser le SDK Linux, car il utilise les mêmes concepts OpenTok, tels que les sessions, les éditeurs et les abonnés, entre autres. Avec le SDK Linux OpenTok, nous suivons également un modèle de programmation dans lequel l'application initie des actions, telles que se connecter à une session, commencer à publier et s'abonner à un flux, etc. Une fois que l'action est initiée et que certains événements se produisent, alors l'application est notifiée via des rappels. Ces événements sont, par exemple, les suivants

• lorsqu'une session est connectée avec succès ou en cas d'erreur,

• lorsqu'un éditeur commence à publier,

• lorsqu'il y a un nouveau participant à la session, et lorsqu'un nouveau participant commence à publier, ce qui déclenche la création d'un nouvel abonné, etc.

Commençons par la mise en œuvre des étapes courantes utilisées pour ajouter des vidéos en direct à n'importe quelle application à l'aide des SDK clients OpenTok.

Se connecter à une session

Lors de la connexion à une session, le développeur doit fournir les fonctions de rappel qui mettent en œuvre la réponse pour les événements qui intéressent l'application. Les pointeurs vers ces fonctions sont fournis par l'intermédiaire d'une structure, qui sert d'argument à la fonction qui peut créer une session. Le pointeur vers cette nouvelle session est ensuite utilisé lors de la connexion de la session. Comme pour nos autres exemples d'applications, le développeur doit fournir les informations d'identification OpenTok (c'est-à-dire la clé API, l'identifiant de session et le jeton).

// ...

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());

Publier des fichiers audio et Video dans une session

Pour les éditeurs, nous suivons la même approche et fournissons des fonctions de rappel qui mettent en œuvre la réponse pour les événements qui intéressent l'application. Pour l'éditeur, le développeur est responsable de la création de ces fonctions de rappel. Celles-ci mettent en œuvre la réponse à certains événements, par exemple : lorsque l'éditeur commence à publier (le flux est créé, puis un événement est déclenché), lorsqu'une nouvelle image du flux vidéo de l'éditeur peut être rendue ou lorsqu'une erreur se produit. Les pointeurs vers ces fonctions de rappel sont fournis par une autre structure qui est transmise en tant qu'argument à la fonction qui crée un nouvel éditeur.

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;
}

Une fois que la fonction de rappel connectée à la session est appelée, l'application peut commencer à publier. Elle peut être mise en œuvre dans la fonction de rappel elle-même. Remarque : il s'agit d'une fonction de rappel pour la session. Un pointeur vers cette fonction a été fourni lors de la création de la session ci-dessus.

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

L'application ne doit pas permettre à l'éditeur de publier tant que la session n'est pas connectée.

S'abonner à un flux audio et vidéo

Chaque fois qu'un nouveau participant est connecté à la session et qu'il publie, la session en est informée par l'intermédiaire de la fonction de rappel "session stream received" (flux de session reçu). Nous pouvons implémenter la création d'un abonné dans la fonction de rappel de la session. Veuillez noter que cette fonction de rappel appartient à la session créée ci-dessus et qu'un pointeur vers cette fonction a été fourni lors de la création de la session. Comme pour les objets session et publisher, le développeur doit mettre en œuvre des fonctions de rappel. Une fonction d'erreur doit toujours être fournie pour déclencher les notifications d'erreur. Il s'agit de la fonction de rappel d'erreur. Si une erreur se produit, la fonction de rappel est appelée. Lorsque l'abonné est créé, la session peut se connecter au nouvel abonné et commencer à recevoir le flux audio et vidéo du nouveau participant.

// ...

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);
  // ...
}

// ...

Rendu du flux Video

Si vous souhaitez effectuer le rendu du flux vidéo pour les éditeurs et les abonnés à l'aide du SDK Linux d'OpenTok, il existe plusieurs bonnes ressources, telles que Simple DirectMedia Layer Library, des bibliothèques tierces bien connues qui peuvent vous aider. Les deux fonctions de rappel ci-dessous sont appelées lorsqu'une nouvelle image doit être rendue pour les éditeurs et les abonnés.

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) {
}

Nous pouvons avoir un gestionnaire de rendu, ou quelque chose de similaire, qui rend le cadre pour nous. Dans l'exemple ci-dessous, nous utilisons la bibliothèque 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_);
}

Exemples de SDK Linux OpenTok

Il y a quelques semaines, nous avons rendu public un dépôt Github pour OpenTok Linux SDK avec quelques exemples pour aider à mieux comprendre les fonctionnalités et les meilleures pratiques. À ce jour, nous avons trois exemples différents ; cependant, nous travaillons à en ajouter beaucoup plus. Dans l'un des exemples, vous pouvez mettre en œuvre une application de chat vidéo de base qui peut être exécutée sur un environnement de bureau Linux ordinaire (par exemple Ubuntu 18.04.2 LTS, Bionic Beaver). Comme nous l'avons mentionné précédemment, OpenTok Linux SDK peut être utilisé pour mettre en œuvre une solution de vidéosurveillance, en utilisant un minuscule ordinateur monocarte, tel que le Raspberry Pi, pour diffuser de la vidéo en tant que point d'extrémité publisher-only. Cette fonctionnalité de point d'accès réservé aux éditeurs fait partie de l'exemple que nous fournissons.

Cycle de vie de la version du SDK Linux OpenTok

À partir d'aujourd'hui, le SDK Linux OpenTok est en bêta fermée (bêta privée). Notre nouveau SDK est capable d'apporter de la valeur, c'est pourquoi nous le présentons maintenant. Cependant, il n'est pas encore prêt pour le primetime. Nous sommes encore en train de créer tous les éléments nécessaires, tels que la documentation destinée aux développeurs et les ressources de notre centre de développement. En attendant, nous aimerions connaître votre avis ! Nous vous invitons à essayer notre nouveau SDK et à nous faire part de vos commentaires. OpenTok Linux SDK sont disponibles sur notre dépôt sur GitHub. Commencez avec l'une des trois versions incluses sur GitHub, y compris x86_64, armv7 et arm64. Restez à l'écoute pour plus d'informations sur le SDK Linux OpenTok.