Diffusion de flux — Linux

Une fois que vous avez connecté à une sessionvous pouvez publier un flux que les autres clients connectés à la session peuvent visualiser.

Cette rubrique comprend les sections suivantes :

Initialisation d'une structure otc_publisher et mise en place des callbacks de l'éditeur

Commencez par créer une structure de type otc_publisher_callbacks:

char *publisher_user_data = strdup("Publisher user data");

static void on_publisher_stream_created(otc_publisher *publisher,
                                        void *user_data,
                                        const otc_stream *stream) {
  // The stream has been created.
}

static void on_publisher_render_frame(otc_publisher *publisher,
                                      void *user_data,
                                      const otc_video_frame *frame) {
  // You can render the frame to the UI.
}

static void on_publisher_stream_destroyed(otc_publisher *publisher,
                                          void *user_data,
                                          const otc_stream *stream) {
  // The stream has been destroyed.
}

static void on_publisher_error(otc_publisher *publisher,
                               void *user_data,
                               const char* error_string,
                               enum otc_publisher_error_code error_code) {
  // Handle the error.
}


struct otc_publisher_callbacks publisher_callbacks = {0};
publisher_callbacks.user_data = publisher_user_data;
publisher_callbacks.on_stream_created = on_publisher_stream_created;
publisher_callbacks.on_render_frame = on_publisher_render_frame;
publisher_callbacks.on_stream_destroyed = on_publisher_stream_destroyed;
publisher_callbacks.on_error = on_publisher_error;

Utiliser le user_data membre de la otc_publisher_callbacks pour définir les données que vous souhaitez référencer dans les fonctions de rappel. Dans cet exemple, il s'agit d'un pointeur sur un tableau de caractères. Mais il pourrait s'agir d'un pointeur sur une instance d'un autre type contenant des informations significatives.

Les autres membres de la otc_publisher_callbacks sont des fonctions de rappel qui sont invoquées lorsque des événements liés au flux publié se produisent :

  • on_stream_created - Appelé lorsque l'éditeur commence à diffuser des informations dans la session.
  • on_render_frame - Appelé chaque fois que l'éditeur est prêt à rendre une nouvelle image vidéo dans le flux.
  • on_stream_destroyed - Appelé lorsque le flux de l'éditeur est détruit.
  • on_error - Appelé lorsqu'une erreur se produit lors de la publication du flux.

Tous les rappels ne seront pas effectués sur l'application ou le thread principal, mais sur un thread interne. L'application doit renvoyer le rappel le plus rapidement possible afin d'éviter de bloquer le thread interne.

Voir otc_publisher_callbacks dans la référence OpenTok Linux SDK pour plus de détails sur chacune des fonctions de rappel.

Appeler le otc_publisher_new() pour créer un otc_publisher qui représente l'éditeur OpenTok :

publisher = otc_publisher_new("Bob's video",
                                                   NULL, /* Use the system camera. */
                                                   &publisher_callbacks);
if (publisher == NULL) {
  printf("Could not create OpenTok publisher successfully");
  otc_session_delete(session);
  otc_destroy();
  return EXIT_FAILURE;
}

Les otc_publisher_new() prend trois arguments :

  • name - Un nom (facultatif) identifiant l'éditeur du flux.
  • capturer - Utilisez ce paramètre si vous souhaitez fournir un capteur vidéo personnalisé. S'il est défini sur NULL, l'éditeur utilise la caméra par défaut du système comme source vidéo. Voir Utilisation d'un capteur vidéo personnalisé (pour découvrir comment implémenter un module de capture vidéo personnalisé.)
  • callbacks - Le otc_publisher_callbacks structure de rappel de l'éditeur, décrite ci-dessus.

Vous pouvez créer un pilote audio personnalisé à utiliser par tous les éditeurs et abonnés.

Vous pouvez utiliser un capteur vidéo personnalisé pour publier un flux avec une source vidéo personnalisée - voir Utilisation d'un capteur vidéo personnalisé.

Publication d'un flux

Lorsque l'application se connecte à la session OpenTok, le on_connected() de la fonction de rappel du otc_session_callbacks est appelée (voir Rejoindre une session). En réponse à cela, vous pouvez appeler la fonction otc_session_publish() pour publier un flux dans la session OpenTok :


if (otc_session_publish(session, publisher) != OTC_SUCCESS) {
  printf("Could not publish successfully.");
}

Les otc_session_publish() prend deux arguments :

  • Le pointeur sur le otc_session structure.
  • Les otc_publisher structure.

Il renvoie OTC_SUCCESS lorsqu'il réussit à publier un flux dans la session. Dans le cas contraire, il renvoie une erreur, et la fonction otc_error est appelé.

Définition du débit maximal d'un flux

Vous pouvez définir le débit binaire maximal d'un flux publié. La définition d'un débit binaire maximal peut contribuer à réduire la consommation de bande passante lorsqu'un utilisateur se connecte via une connexion à volume limité. Voir cette documentation.

Empêcher un éditeur de diffuser en streaming

Pour interrompre le flux d'un éditeur, appelez la fonction otc_session_unpublish() en passant la fonction otc_session et otc_publisher des structures :

otc_status status = otc_session_unpublish(session, publisher);
  if (status == OTC_SUCCESS) {
  printf("Unpublished successfully.");
} else {
  printf("Could not unpublish.");
}

Obtenir des statistiques sur le flux d'un éditeur

Utilisez les fonctions de rappel on_audio_stats() et on_video_stats() de la méthode otc_publisher_callbacks pour surveiller les statistiques relatives au flux d'un éditeur. Pour obtenir des statistiques détaillées sur les connexions entre pairs pour un éditeur, utilisez la commande otc_publisher_get_rtc_stats_report() fonction.

Se référer à le guide du développeur de l'observabilité du client pour obtenir des informations détaillées.