Transmissões de vídeo interativas ao vivo

A transmissão da Video API da Vonage permite que você compartilhe sessões de vídeo ao vivo com muitos espectadores.

Esta página inclui as seguintes seções:

Em uma transmissão de vídeo interativa ao vivo, um grande número de clientes pode se comunicar em tempo real ao publicar e se inscrever nos fluxos uns dos outros durante a sessão. Uma sessão de transmissão de vídeo interativa ao vivo pode acomodar até 15.000 participantes no total, com base no número de emissores ativos na sessão.

A tabela abaixo detalha o número de participantes da transmissão interativa ao vivo que podem se inscrever para receber todos os fluxos publicados da sessão. Os participantes da transmissão interativa são os assinantes de baixa latência, com acesso apenas para visualização, de todos os fluxos publicados e os espectadores da transmissão interativa ao vivo. Os editores da sessão podem ser considerados os anfitriões da transmissão e, nessa função, também podem se inscrever para receber os outros fluxos publicados. À medida que o número de editores por sessão aumenta, o número de espectadores simultâneos de todos os fluxos publicados também é reduzido.

Por exemplo, com base na tabela abaixo, quando há 1 ou 2 transmissões publicadas na sessão, até 15.000 participantes podem assistir a ambas as transmissões publicadas com latência em tempo real como participantes da transmissão ao vivo. Da mesma forma, quando há 3 transmissões publicadas na sessão, até 13.000 participantes podem assistir a todas as 3 transmissões publicadas com latência em tempo real como participantes da transmissão ao vivo.

**Número de editoras *** Número de participantes interativos simultâneos ao vivo por sessão (os participantes seguem todos os emissores)
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

* As transmissões publicadas incluem tanto transmissões de câmera quanto transmissões com compartilhamento de tela.

Se o número de participantes na sessão for maior do que o valor indicado na tabela, você deve usar o recurso de transmissão ao vivo (consulte Transmissões ao vivo de programas).

Da mesma forma, as sessões do OpenTok suportam até 15.000 clientes conectados simultaneamente a uma sessão.

Os desenvolvedores de aplicativos devem gerenciar os limites da plataforma no próprio aplicativo. Consulte a próxima seção.

O recurso de transmissão de vídeo interativa ao vivo está disponível apenas para sessões roteadas (sessões que utilizam o OpenTok Media Router). Para obter mais informações, consulte O OpenTok Media Router e os Modos de Mídia.

As transmissões de vídeo interativas ao vivo suportam vídeo em HD (assim como vídeo em resolução inferior) desde que os recursos do cliente (largura de banda e CPU) suportem a resolução.

Como desenvolver seu aplicativo para oferecer suporte a transmissões de vídeo interativas ao vivo

Existem algumas melhorias na API que você deve utilizar para dar suporte a um grande número de clientes conectados a sessões do OpenTok. Consulte as seções a seguir:

Supressão de eventos de conexão

Se um grande número de clientes se conectar a uma sessão, é importante desativar os eventos de conexão nos clientes. Esses eventos incluem aqueles disparados quando outros clientes se conectam e se desconectam da sessão. A maioria dos clientes não precisa processar esses eventos, e desativá-los evita que os clientes sofram perdas de desempenho (por exemplo, na publicação ou assinatura de fluxos de áudio e vídeo) causadas por esses eventos em grande volume.

Importante: Para otimizar seu aplicativo para essa escala ampla, certifique-se de usar as APIs de supressão de eventos de conexão descritas aqui.

Na versão 2.10.0 e posteriores, cada um dos SDKs de cliente do OpenTok (para Web, iOS e Android) inclui um aprimoramento da API para desativar eventos de conexão no cliente. Esses aprimoramentos são descritos nas seções a seguir:

Embora seja possível usar outras versões compatíveis do cliente OpenTok (2.9.0+) em sessões de grande porte, os eventos de conexão não serão suprimidos em clientes que utilizem versões anteriores à 2.10.0+. Clientes que utilizem versões mais antigas do OpenTok.js podem apresentar uma redução no desempenho, devido ao alto volume de eventos de conexão.

Suprimindo eventos de conexão com o OpenTok.js (web)

Ao inicializar o objeto Session, crie um objeto com o connectionEventsSuppressed propriedade definida como true, e passar esse objeto como o options parâmetro ao chamar o OT.initSession() método. Em seguida, conecte-se à sessão:

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

Isso impede que o objeto Session execute connectionCreated e connectionDestroyed eventos quando outros clientes se conectam ou se desconectam da sessão. (Além disso, o servidor OpenTok não envia esses eventos ao cliente web.)

Suprimindo eventos de conexão com o SDK do OpenTok para iOS

Ao inicializar um objeto OTSessionSettings, defina seu connectionEventsSuppressed propriedade para YES. Em seguida, passe esse objeto como o settings parâmetro ao chamar o [OTSession initWithApiKey:sessionId:delegate:settings:] método para inicializar o objeto OTSession:

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

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

Em seguida, conecte-se à sessão:

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

Isso evita que o [SessionDelegate session:connectionCreated:] e [SessionDelegate session:connectionCreated:] impedem que as mensagens sejam enviadas quando outros clientes se conectam ou se desconectam da sessão. (Além disso, o servidor OpenTok não envia esses eventos para o cliente iOS.)

Suprimindo eventos de conexão com o SDK do OpenTok para Android

Para se conectar à sessão, instancie um objeto Session.Builder, passando sua chave de API e o ID da sessão do OpenTok. Em seguida, chame o connectionEventsSuppressed() método do objeto Builder, passando true. Ligue para o build() método para criar o objeto Session. Em seguida, chame o connect() método do objeto Session para se conectar à sessão:

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

session.connect(myToken);

Não ligue para o Session.setConnectionListener(ConnectionListener listener) método (para definir um ConnectionListener para o objeto Session); chamar esse método não terá efeito algum. Suprimir eventos de conexão impede que os métodos do ConnectionListener sejam chamados quando outros clientes se conectarem ou se desconectarem da sessão. (Além disso, o servidor OpenTok não envia esses eventos para o cliente Android.)

Suprimindo eventos de conexão com o SDK do OpenTok para Windows

Para se conectar à sessão, instancie um objeto Session usando o Session.Builder classe. Insira sua chave de API e o ID da sessão do OpenTok no o Session.Builder() construtor e definir o connectionEventsSuppressed parâmetro para true. Em seguida, chame o Connect() método do objeto Session para se conectar à sessão:

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

Não defina o Session.StreamReceived ou Session.StreamDropped manipuladores de eventos, A supressão de eventos de conexão impede que esses eventos sejam gerados quando outros clientes se conectam ou se desconectam da sessão. (Além disso, o servidor OpenTok não envia esses eventos ao cliente do Windows.)

Suprimindo eventos de conexão com o SDK do OpenTok para Linux

Para se conectar à sessão, instancie um otc_session_settings struct, inserindo sua chave de API e o ID da sessão do OpenTok. Em seguida, chame o otc_session_settings_set_connection_events_suppressed() função, passando o otc_session_settings instância como primeiro parâmetro, e OTC_TRUE como o segundo, suppress, parâmetro. Em seguida, chame o otc_session_new_with_settings() função para criar a estrutura otc_session. Em seguida, função para se conectar à sessão:

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

Não defina o otc_session_callbacks.on_connection_created ou otc_session_callbacks.on_connection_dropped funções de retorno de chamada. A supressão dos eventos de conexão impede que essas funções de retorno de chamada sejam chamadas quando outros clientes se conectam ou se desconectam da sessão. (Além disso, o servidor OpenTok não envia esses eventos ao cliente Linux.)

Detecção de excedimento dos limites de conexão e de fluxo

Os SDKs de cliente do OpenTok incluem erros que indicam quando um cliente está tentando se conectar a uma sessão ou se inscrever em um stream, caso o limite de conexões (15.000) ou de streams (15.000) para a sessão tenha sido excedido. Esses erros são descritos nas seções a seguir:

Se o cliente não conseguir se conectar a uma sessão ou se inscrever em um fluxo porque o limite de conexões ou de fluxos foi atingido, você pode fazer com que o cliente visualize um transmissão ao vivo transmissão da sessão (caso você tenha implementado uma).

Erros de conexão e de limite de transmissão no OpenTok.js (web)

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente ) tiver sido atingido, o manipulador de conclusão para a Session.connect() método é chamado com o error parâmetro definido como um objeto Error com o name propriedade definida como 'OT_CONNECTION_LIMIT_EXCEEDED'.

Se você tentar se inscrever em um fluxo quando o limite de fluxos para uma sessão tiver sido excedido, o manipulador de conclusão para o Session.subscribe() O método é chamado com o error parâmetro definido como um objeto Error com o name propriedade definida como 'OT_STREAM_LIMIT_EXCEEDED'.

Erros de conexão e de limite de transmissão no SDK do OpenTok para Android

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente ) tiver sido atingido, o Session.SessionListener.onError(session, error) método é chamado com o error parâmetro definido como um objeto OpenTokError com o code propriedade definida como SessionConnectionLimitExceeded.

Se você tentar se inscrever em um stream quando o limite de streams para uma sessão já tiver sido atingido, o Session.SubscriberListener.onError(subscriber, error) O método é chamado com o error parâmetro definido como um objeto OpenTokError com o code propriedade definida como SubscriberStreamLimitExceeded.

Erros de conexão e de limite de transmissão no SDK do OpenTok para iOS

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente ) tiver sido atingido, o [SessionDelegate session:didFailWithError:] a mensagem é enviada com o error definido como um objeto OTError com o code propriedade definida como OTSessionConnectionLimitExceeded .

Se você tentar se inscrever em um stream quando o limite de streams para uma sessão já tiver sido atingido, o [OTSubscriberKitDelegate subscriber:didFailWithError:] a mensagem é enviada com o error definido como um objeto OTError com o code propriedade definida como OTSubscriberStreamLimitExceeded.

Erros de conexão e de limite de transmissão no SDK do OpenTok para Windows

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente ) tiver sido atingido, o Session o objeto envia um Error evento enviado com o ErrorCode definir como ErrorCode.SessionConnectionLimitExceeded.

Se você tentar se inscrever em um stream quando o limite de streams para uma sessão já tiver sido atingido, o Subscriber o objeto envia um Error evento com o ErrorCode definido como um objeto OTError com o code propriedade definida como ErrorCode.SubscriberStreamLimitExceeded.

Erros de conexão e de limite de fluxo no SDK do OpenTok para Linux

Se você tentar se conectar a uma sessão quando o limite de conexões para essa sessão (15.000 clientes conectados simultaneamente ) tiver sido atingido, o otc_session_callbacks.on_error() a função é chamada com o error parâmetro definido como OTC_SESSION_CONNECTION_LIMIT_EXCEEDED.

Se você tentar se inscrever em um stream quando o limite de streams para uma sessão já tiver sido atingido, o otc_subscriber_callbacks.on_error() a função é chamada com o error parâmetro definido como OTC_SUBSCRIBER_STREAM_LIMIT_EXCEEDED .

Qualidade de vídeo em transmissões interativas ao vivo

Sessões em grande escala se beneficiam do recurso de vídeo escalável do OpenTok. Com esse recurso, os terminais assinantes podem utilizar diferentes resoluções de vídeo e taxas de quadros com base nas condições de sua rede e CPU. Esse recurso está disponível no SDK do OpenTok para iOS (em determinados dispositivos), no SDK do OpenTok para Android (em determinados dispositivos), no SDK do OpenTok para Windows e no OpenTok.js no Chrome e no Safari.

Preços para transmissões interativas ao vivo

O vídeo interativo ao vivo utiliza o mesmo modelo de cobrança por minuto de assinatura usado em outras sessões do OpenTok. Para mais detalhes, consulte Preços.