Hinzufügen von Streaming-Video unter Linux mit OpenTok Linux SDK

Hinzufügen von Streaming-Video unter Linux mit OpenTok Linux SDK

Als Teil unserer OpenTok Labs-Initiative freuen wir uns, Ihnen die neuen Beispiele unseres Linux-SDKs vorstellen zu können. Mit dem Linux-SDK können Sie Desktop-Anwendungen erstellen, die Videoüberwachungslösungen auf eingebetteten Linux-Systemen und andere Anwendungen unterstützen, bei denen Audio- und Video-Streaming erforderlich ist. Das OpenTok Labs-Label weist darauf hin, dass das SDK derzeit auf einer Best-Effort-Basis und nicht als offiziell unterstütztes SDK läuft. Wir würden uns freuen, wenn Sie dazu beitragen, indem Sie Probleme melden und Pull-Requests senden, um es zu verbessern. Das OpenTok Linux SDK ist so konzipiert, dass es mit geringem Verbrauch von Systemressourcen und geringem Speicherbedarf arbeitet. Sie können das Linux-SDK über eine C-API verwenden, die es Entwicklern ermöglicht, es fast überall zu integrieren. Da Linux für eine Vielzahl von Anwendungsfällen weit verbreitet ist, können Sie nun mit der OpenTok-Plattform Ihre Reichweite erweitern und Linux-basierten Geräten Echtzeitkommunikation hinzufügen.

Wie es funktioniert

Wenn Sie bereits mit den OpenTok-SDK-APIs und -Konzepten vertraut sind, wird Ihnen der Einstieg in das Linux-SDK leicht fallen, da es dieselben OpenTok-Konzepte verwendet, wie z. B. Sitzungen, Publisher und Abonnenten. Mit dem OpenTok Linux SDK folgen wir ebenfalls einem Programmiermodell, bei dem die Anwendung Aktionen auslöst, wie z. B. eine Verbindung zu einer Sitzung herstellen, eine Veröffentlichung starten und einen Stream abonnieren usw. Nachdem die Aktion initiiert wurde und bestimmte Ereignisse eintreten, wird die Anwendung über Callbacks benachrichtigt. Zu diesen Ereignissen gehören zum Beispiel:

• wenn eine Sitzung erfolgreich verbunden wurde oder ein Fehler aufgetreten ist,

• wenn ein Verlag mit der Veröffentlichung beginnt,

• wenn es einen neuen Teilnehmer in der Sitzung gibt, und wenn ein neuer Teilnehmer mit der Veröffentlichung beginnt, was die Erstellung eines neuen Abonnenten auslöst, usw.

Beginnen wir mit der Implementierung der üblichen Schritte zum Hinzufügen von Live-Videos zu einer beliebigen Anwendung mit den OpenTok-Client-SDKs.

Verbinden mit einer Sitzung

Bei der Verbindung mit einer Sitzung muss der Entwickler die Callback-Funktionen bereitstellen, die die Antwort auf die Ereignisse implementieren, an denen die Anwendung interessiert ist. Die Zeiger auf diese Funktionen werden über eine Struktur bereitgestellt, die als Argument für die Funktion dient, die eine Sitzung erstellen kann. Der Zeiger auf diese neue Sitzung wird später bei der Verbindung der Sitzung verwendet. Wie bei unseren anderen Beispielanwendungen muss der Entwickler die OpenTok-Anmeldeinformationen bereitstellen (d. h. API KEY, Sitzungs-ID und 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());

Veröffentlichen von Audio und Video in einer Sitzung

Für Publisher verfolgen wir den gleichen Ansatz und stellen Callback-Funktionen bereit, die die Antwort auf Ereignisse implementieren, an denen die Anwendung interessiert ist. Für den Publisher ist der Entwickler für die Erstellung dieser Callback-Funktionen verantwortlich. Sie implementieren die Reaktion auf bestimmte Ereignisse, z. B. wenn der Herausgeber mit der Veröffentlichung beginnt (der Stream wird erstellt, dann wird ein Ereignis ausgelöst), wenn ein neues Bild aus dem Herausgeber-Videostream gerendert werden kann oder wenn ein Fehler auftritt. Die Zeiger auf diese Callback-Funktionen werden über eine andere Struktur bereitgestellt, die als Argument an die Funktion übergeben wird, die einen neuen Publisher erstellt.

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

Sobald die mit der Sitzung verbundene Callback-Funktion aufgerufen wird, kann die Anwendung mit der Veröffentlichung beginnen. Sie kann innerhalb der Callback-Funktion selbst implementiert werden. Hinweis: Dies ist eine Callback-Funktion für die Sitzung. Ein Zeiger auf diese Funktion wurde bei der Erstellung der Sitzung oben angegeben.

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

Die Anwendung sollte es dem Verleger nicht erlauben, zu veröffentlichen, bevor die Sitzung verbunden ist.

Abonnieren Sie einen Audio- und Video-Stream

Immer wenn ein neuer Teilnehmer mit der Sitzung verbunden ist und der Teilnehmer veröffentlicht, wird die Sitzung über den Callback des Sitzungsstroms benachrichtigt. Wir können in der Callback-Funktion der Sitzung implementieren, wie ein Teilnehmer erstellt wird. Bitte beachten Sie, dass diese Callback-Funktion zu der oben erstellten Sitzung gehört und ein Zeiger auf sie bei der Erstellung der Sitzung bereitgestellt wurde. Ähnlich wie bei den Session- und Publisher-Objekten muss der Entwickler Callback-Funktionen implementieren. Eine Fehlerfunktion sollte immer zur Verfügung gestellt werden, um Fehlerbenachrichtigungen auszulösen. Dies bezieht sich auf den Fehler-Callback. Tritt ein Fehler auf, so wird die Callback-Funktion aufgerufen. Wenn der Teilnehmer erstellt ist, kann die Sitzung eine Verbindung zu dem neuen Teilnehmer herstellen und den Audio- und Videostream von dem neuen Teilnehmer empfangen.

// ...

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

// ...

Videostream rendern

Wenn Sie den Videostream für Publisher und Abonnenten mit OpenTok Linux SDK rendern möchten, gibt es mehrere gute Ressourcen, wie Simple DirectMedia Layer Library bekannte Bibliotheken von Drittanbietern die helfen können. Die beiden folgenden Callback-Funktionen werden aufgerufen, wenn ein neuer Frame für Publisher und Subscriber gerendert werden soll.

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

Wir können einen Rendermanager oder etwas Ähnliches verwenden, der das Bild für uns rendert. Im folgenden Beispiel verwenden wir die Simple DirectMedia Layer-Bibliothek.

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

OpenTok Linux SDK-Beispiele

Vor ein paar Wochen haben wir ein Github-Repository für OpenTok Linux SDK mit einigen Beispielen veröffentlicht, um ein besseres Verständnis der Funktionen und Best Practices zu ermöglichen. Bis heute haben wir drei verschiedene Beispiele, aber wir arbeiten daran, noch viel mehr hinzuzufügen. In einem der Beispiele können Sie eine einfache Video-Chat-Anwendung implementieren, die auf einer normalen Linux-Desktop-Umgebung (z. B. Ubuntu 18.04.2 LTS, Bionic Beaver) ausgeführt werden kann. Wie bereits erwähnt, kann mit dem OpenTok Linux SDK eine Videoüberwachungslösung implementiert werden, bei der ein winziger Einplatinencomputer, wie z. B. der Raspberry Pi, zum Streamen von Videos als reiner Veröffentlichungsendpunkt verwendet wird. Diese Endpunktfunktionalität ist Teil des von uns bereitgestellten Beispiels.

OpenTok Linux SDK Release Lebenszyklus

Ab heute befindet sich das OpenTok Linux SDK in der geschlossenen Betaphase (Private Beta). Unser neues SDK ist in der Lage, einen Mehrwert zu liefern, weshalb wir es jetzt einführen. Es ist jedoch noch nicht bereit für die Primetime. Wir sind noch dabei, alle notwendigen Dinge zu erstellen, wie z. B. eine Entwicklerdokumentation und Ressourcen für unser Entwicklerzentrum. In der Zwischenzeit würden wir uns über Ihr Feedback freuen! Wir laden Sie ein, unser neues SDK auszuprobieren und uns Ihre Meinung mitzuteilen. OpenTok Linux SDK Builds können gefunden werden unter unser Repository auf GitHub. Beginnen Sie mit einem der drei auf GitHub enthaltenen Builds, einschließlich x86_64, armv7 und arm64. Bleiben Sie dran für weitere Neuigkeiten über das OpenTok Linux SDK.