Diffusion de flux — macOS

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 Consultez la documentation de référence du SDK OpenTok pour macOS 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

Pour enregistrer des méthodes de rappel destinées à générer des rapports périodiques sur les statistiques audio et vidéo d'un éditeur, définissez le on_audio_stats() et on_video_stats() fonctions de rappel lors de l'initialisation du otc_publisher_callbacks structure destinée à être utilisée par l'éditeur. Voir Initialisation d'une structure otc_publisher et mise en place des callbacks de l'éditeur.

Ces fonctions de rappel sont appelées périodiquement afin de transmettre les statistiques audio et vidéo à l'éditeur. Chaque fonction reçoit les paramètres suivants : un pointeur vers le publisher struct, un pointeur vers la user_data que vous définissez pour l'éditeur, un tableau de statistiques et le nombre de statistiques que contient ce tableau. Le paramètre « stats » est défini par le otc_publisher_audio_stats et otc_publisher_video_stats structures. Pour un éditeur dans une session routée (c'est-à-dire une session qui utilise le Routeur multimédia OpenTok), le tableau contient un seul objet, qui définit les statistiques relatives au flux multimédia audio ou vidéo unique envoyé au routeur multimédia OpenTok. Dans une session relayée, le tableau contient un objet pour chaque abonné au flux publié. La structure transmise en tant que paramètre « stats » comprend les propriétés suivantes :

  • Le nombre total de paquets audio ou vidéo envoyés
  • Le nombre total de paquets audio ou vidéo perdus
  • Nombre total d'octets audio ou vidéo envoyés
  • L'horodatage correspondant au moment où les statistiques ont été recueillies
  • Le niveau audio (pour les statistiques audio)

De plus, pour un éditeur dans une session relayée, chaque objet du tableau contient les deux propriétés suivantes :

  • ConnectionId — L'identifiant de connexion du client abonné au flux
  • SubscriberId — L'identifiant de l'abonné correspondant au client qui s'abonne au flux

Ces deux propriétés ne sont pas définies pour un éditeur dans une session acheminée.

Pour obtenir des statistiques plus détaillées sur les flux, utilisez la fonction otc_publisher_get_rtc_stats_report() fonction. Elle fournit des rapports de statistiques RTC pour le flux média. Il s'agit d'une opération asynchrone. Créer un otc_publisher_rtc_stats_report_cb struct et de le passer dans le otc_publisher_set_rtc_stats_report_cb avant d'appeler la fonction otc_publisher_get_rtc_stats_report(). Lorsque les statistiques sont disponibles, le otc_publisher_rtc_stats_report_cb.on_rtc_stats_report() est appelée. Cette fonction comprend un stats qui est un pointeur sur un tableau de otc_publisher_rtc_stats structures. Cette structure comprend un json_array_of_reports propriété. Il s'agit d'un tableau JSON de rapports de statistiques RTC, qui sont similaires au format de l'objet RtcStatsReport mis en œuvre dans les navigateurs web (voir ces documents de Mozilla). Voir également cette documentation du W3C.