Diffusions vidéo interactives en direct

La fonctionnalité de diffusion de la Video API Vonage vous permet de partager des sessions vidéo en direct avec un large public.

Cette page comprend les sections suivantes :

Dans une diffusion vidéo interactive en direct, un grand nombre de clients peuvent communiquer en direct en publiant et en s'abonnant aux flux des autres participants à la session. Une session de diffusion vidéo interactive en direct peut accueillir jusqu'à 15 000 participants au total, en fonction du nombre d'émetteurs actifs dans la session.

Le tableau ci-dessous détaille le nombre de participants à la diffusion interactive en direct pouvant s'abonner à tous les diffuseurs de la session. Les participants à la diffusion interactive sont les abonnés à faible latence, en lecture seule, de tous les flux publiés, ainsi que les spectateurs de la diffusion interactive en direct. Les éditeurs de la session peuvent être considérés comme les animateurs de la diffusion et, en tant que tels, ils peuvent également s'abonner aux autres flux publiés. À mesure que le nombre d'éditeurs par session augmente, le nombre de spectateurs simultanés de tous les flux publiés diminue également.

Par exemple, d’après le tableau ci-dessous, lorsqu’il y a 1 ou 2 flux publiés dans la session, jusqu’à 15 000 participants peuvent visionner ces deux flux publiés avec une latence en temps réel, à l’instar des participants à une diffusion en direct. De même, lorsque la session comporte 3 flux publiés, jusqu'à 13 000 participants peuvent visionner les 3 flux publiés avec une latence en temps réel en tant que participants à la diffusion en direct.

**Nombre d'éditeurs *** Nombre de participants interactifs simultanés en direct par session (les participants s'abonnent à tous les diffuseurs)
1 15,000
2 15,000
3 13,000
4 11,000
5 8,000
6 6,800
7 5,700
8 5,000
9 4,300
10 4,000
12 3,400
15 2,900
16 2,800
20 2,000
25 1,600
50 800
55 700

* Les diffusions publiées comprennent à la fois les diffusions par caméra et celles par partage d'écran.

Si le nombre de participants à la session est supérieur à la valeur indiquée dans le tableau, vous devriez utiliser la fonctionnalité de diffusion en direct (voir Diffusions en direct).

De même, les sessions OpenTok permettent à un maximum de 15 000 clients de se connecter simultanément à une session.

Les développeurs d'applications doivent gérer les limites de la plateforme dans l'application. Voir la section suivante.

La fonctionnalité de diffusion vidéo interactive en direct n'est disponible que pour les sessions acheminées (c'est-à-dire celles qui utilisent le routeur multimédia OpenTok). Pour plus d'informations, consultez Le routeur multimédia OpenTok et les modes multimédia.

Les diffusions vidéo interactives en direct prennent en charge la vidéo HD (ainsi que les vidéos de résolution inférieure) si les ressources du client (bande passante et processeur) permettent cette résolution.

Construire votre application pour prendre en charge les diffusions vidéo interactives en direct.

Il existe quelques améliorations apportées à l'API que vous devriez utiliser pour prendre en charge un grand nombre de clients se connectant à des sessions OpenTok. Reportez-vous aux sections suivantes :

Suppression des événements de connexion

Si un grand nombre de clients doit se connecter à une session, il est important de désactiver les événements de connexion au niveau des clients. Ces événements comprennent notamment ceux déclenchés lorsque d’autres clients se connectent à la session ou s’en déconnectent. La plupart des clients n’ont pas besoin de traiter ces événements, et leur désactivation évite aux clients de subir des baisses de performances (par exemple lors de la publication ou de l’abonnement à des flux audio-vidéo) causées par ces événements à haut volume.

Important : Pour optimiser votre application à cette grande échelle, veillez à utiliser les API de suppression des événements de connexion décrites ici.

À partir de la version 2.10.0, chacun des SDK client OpenTok (pour le Web, iOS et Android) intègre une amélioration de l'API permettant de désactiver les événements de connexion au niveau du client. Ces améliorations sont décrites dans les sections suivantes :

Bien que vous puissiez utiliser d'autres versions prises en charge du client OpenTok (2.9.0+) dans le cadre de sessions à grande échelle, les événements de connexion ne seront pas supprimés dans les clients utilisant des versions antérieures à la 2.10.0+. Les clients utilisant des versions plus anciennes d'OpenTok.js peuvent constater une baisse des performances, en raison du volume élevé d'événements de connexion.

Supprimer les événements de connexion avec OpenTok.js (web)

Lors de l'initialisation de l'objet Session, créez un objet avec le connectionEventsSuppressed est définie comme étant la propriété true, et transmettre cet objet en tant que le options lors de l'appel de la fonction OT.initSession() méthode. Connectez-vous ensuite à la session :

var props = {connectionEventsSuppressed: true};
var session = OT.initSession(API_KEY, SESSION_ID, props);
session.connect(token, function(error) {
  if (error) {
    console.log('Error connecting: ', error.code, error.message);
  } else {
    console.log('Connected to the session.');
  }
});

Cela empêche l'objet Session d'envoyer connectionCreated et connectionDestroyed les événements survenant lorsqu'autres clients se connectent à la session ou s'en déconnectent. (Par ailleurs, le serveur OpenTok n'envoie pas ces événements au client Web.) ```

Suppression des événements de connexion avec le SDK OpenTok pour iOS

Lors de l'initialisation d'un objet OTSessionSettings, il convient de définir le paramètre connectionEventsSuppressed propriété à YES. Passez ensuite cet objet en tant que settings paramètre lors de l'appel de la [OTSession initWithApiKey:sessionId:delegate:settings:] méthode permettant d' initialiser l'objet OTSession :

OTSessionSettings *settings = [[OTSessionSettings alloc] init];
settings.connectionEventsSuppressed = YES;

OTSession *session = [[OTSession alloc] initWithApiKey:apiKey
                                        sessionId:sessionId
                                        delegate:self
                                        Settings:settings];

Ensuite, connectez-vous à la session :

OTError* error = nil;
[session connectWithToken:kToken error:&error];
if (error) {
  NSLog(@"connect failed with error: (%@)", error);
}

Cela permet d'éviter que le [SessionDelegate session:connectionCreated:] et [SessionDelegate session:connectionCreated:] l'envoi de messages lorsque d'autres clients se connectent à la session ou s'en déconnectent. (Par ailleurs, le serveur OpenTok n'envoie pas ces événements au client iOS.)

Suppression des événements de connexion avec le SDK Android d'OpenTok

Pour vous connecter à la session, créez un objet `Session.Builder` en lui transmettant votre clé API et l'identifiant de session OpenTok. Appelez ensuite la méthode connectionEventsSuppressed() de l'objet Builder, en passant par la méthode true. Appelez le build() méthode permettant de créer l'objet Session. Appelez ensuite la connect() de l'objet Session pour se connecter à la session :

Session session = new Session.Builder(this, API_KEY, mySessionId)
                    .connectionEventsSuppressed(true)
                    .build();

session.connect(myToken);

Ne pas appeler le Session.setConnectionListener(ConnectionListener listener) méthode (permettant de définir un ConnectionListener pour l'objet Session) ; l'appel de cette méthode n'aura aucun effet. La suppression des événements de connexion empêche l' appel des méthodes ConnectionListener lorsque d'autres clients se connectent à la session ou s'en déconnectent. (Par ailleurs, le serveur OpenTok n'envoie pas ces événements au client Android.)

Suppression des événements de connexion avec le SDK OpenTok pour Windows

Pour vous connecter à la session, instanciez un objet Session à l'aide de la méthode Session.Builder classe. Transmettez votre clé API et l'identifiant de session OpenTok à la Session.Builder() et de définir le connectionEventsSuppressed paramètre à true. Appelez ensuite le Connect() méthode de l'objet Session permettant de se connecter à la session :

Session = new Session.Builder(Context.Instance, API_KEY, SESSION_ID, true).Build();
// Set event handlers for the Session object. Then, connect:
Session.Connect(TOKEN);

Ne pas régler le Session.StreamReceived ou Session.StreamDropped gestionnaires d'événements, La suppression des événements de connexion empêche ces événements d'être déclenchés lorsque d'autres clients se connectent à la session ou s'en déconnectent. (De plus, le serveur OpenTok n'envoie pas ces événements au client Windows.)

Suppression des événements de connexion avec le SDK OpenTok pour Linux

Pour se connecter à la session, instanciez un fichier otc_session_settings struct, en y indiquant votre clé API et l'identifiant de session OpenTok. Appelez ensuite la fonction otc_session_settings_set_connection_events_suppressed() fonction, en lui transmettant le otc_session_settings l'instance comme premier paramètre, et OTC_TRUE en tant que deuxième, suppress, paramètre. Appelez ensuite le otc_session_new_with_settings() fonction permettant de créer la structure `otc_session`. Puis, fonction permettant de se connecter à la session :

otc_session_settings *session_settings = otc_session_settings_new();
otc_session_settings_set_connection_events_suppressed(session_settings, OTC_TRUE);

otc_session_callbacks session_callbacks = {0};
// Set the callback functions of the otc_session_callbacks instance.

otc_session *session = otc_session_new_with_settings(API_KEY, SESSION_ID,
                                                     &session_callbacks,
                                                     session_settings);
otc_session_connect(session, TOKEN);

Ne pas régler le otc_session_callbacks.on_connection_created ou otc_session_callbacks.on_connection_dropped fonctions de rappel. La désactivation des événements de connexion empêche l'appel de ces fonctions de rappel lorsque d'autres clients se connectent à la session ou s'en déconnectent. (Par ailleurs, le serveur OpenTok n'envoie pas ces événements au client Linux.)

Détection du dépassement des limites de connexion et de flux

Les SDK client OpenTok comportent des messages d'erreur qui indiquent qu'un client tente de se connecter à une session ou de s'abonner à un flux alors que la limite de connexions (15 000) ou de flux (15 000) pour cette session a été dépassée. Ces messages sont décrits dans les sections suivantes :

Si le client ne parvient pas à se connecter à une session ou à s'abonner à un flux parce que la limite de connexions ou de flux a été atteinte, vous pouvez faire en sorte que le client affiche un diffusion en direct diffusion télévisée de la session (si vous en avez implémenté une).

Erreurs de connexion et de limite de flux OpenTok.js (Web)

Si vous tentez de vous connecter à une session alors que la limite de connexions pour cette session (15 000 clients connectés simultanément ) a été atteinte, le gestionnaire de fin d'exécution de la Session.connect() La méthode est appelée avec le error à un objet Error avec le paramètre name propriété définie sur 'OT_CONNECTION_LIMIT_EXCEEDED'.

Si vous essayez de vous abonner à un flux alors que la limite de flux pour une session a été dépassée, le gestionnaire de fin d'exécution du Session.subscribe() La méthode est appelée avec le error à un objet Error avec le paramètre name propriété définie sur 'OT_STREAM_LIMIT_EXCEEDED'.

Erreurs de connexion et de limite de flux dans le SDK OpenTok pour Android

Si vous essayez de vous connecter à une session alors que la limite de connexions pour cette session (15 000 clients connectés simultanément ) a été atteinte, le Session.SessionListener.onError(session, error) La méthode est appelée avec le error paramètre défini sur un objet OpenTokError avec le code propriété définie sur SessionConnectionLimitExceeded.

Si vous essayez de vous abonner à un flux alors que la limite de flux pour une session a été atteinte, le Session.SubscriberListener.onError(subscriber, error) La méthode est appelée avec le error paramètre défini sur un objet OpenTokError avec le code propriété définie sur SubscriberStreamLimitExceeded.

Erreurs de connexion et de limite de flux dans le SDK OpenTok pour iOS

Si vous essayez de vous connecter à une session alors que la limite de connexions pour cette session (15 000 clients connectés simultanément ) a été atteinte, le [SessionDelegate session:didFailWithError:] Le message est envoyé avec le error à un objet OTError avec l'attribut code propriété définie sur OTSessionConnectionLimitExceeded .

Si vous essayez de vous abonner à un flux alors que la limite de flux pour une session a été atteinte, le [OTSubscriberKitDelegate subscriber:didFailWithError:] le message est envoyé avec le error à un objet OTError avec l'attribut code propriété définie sur OTSubscriberStreamLimitExceeded.

Erreurs de connexion et de limite de flux dans le SDK OpenTok pour Windows

Si vous essayez de vous connecter à une session alors que la limite de connexions pour cette session (15 000 clients connectés simultanément ) a été atteinte, le Session envoie un Error événement envoyé avec le ErrorCode fixé à ErrorCode.SessionConnectionLimitExceeded.

Si vous essayez de vous abonner à un flux alors que la limite de flux pour une session a été atteinte, le Subscriber envoie un Error événement avec le ErrorCode à un objet OTError avec l'attribut code propriété définie sur ErrorCode.SubscriberStreamLimitExceeded.

Erreurs de connexion et de limite de flux dans le SDK OpenTok pour Linux

Si vous essayez de vous connecter à une session alors que la limite de connexions pour cette session (15 000 clients connectés simultanément ) a été atteinte, le otc_session_callbacks.on_error() la fonction est appelée avec le error paramètre réglé sur OTC_SESSION_CONNECTION_LIMIT_EXCEEDED.

Si vous essayez de vous abonner à un flux alors que la limite de flux pour une session a été atteinte, le otc_subscriber_callbacks.on_error() la fonction est appelée avec le error paramètre réglé sur OTC_SUBSCRIBER_STREAM_LIMIT_EXCEEDED .

Qualité vidéo dans les diffusions vidéo interactives en direct

Les sessions à grande échelle tirent parti de la fonctionnalité vidéo évolutive d'OpenTok. Grâce à cette fonctionnalité, les terminaux abonnés peuvent utiliser différentes résolutions vidéo et fréquences d’images en fonction de leur réseau et de la puissance de leur processeur. Cette fonctionnalité est disponible dans le SDK OpenTok pour iOS (sur certains appareils), le SDK OpenTok pour Android (sur certains appareils), le SDK OpenTok pour Windows, ainsi que dans OpenTok.js sur Chrome et Safari.

Prix des émissions interactives en direct

La vidéo interactive en direct est facturée selon le même barème à la minute que les autres sessions OpenTok. Pour plus d'informations, consultez Tarification.