Publicação de streams — Linux

Depois de conectado a uma sessão, você pode publicar um stream que outros clientes conectados à sessão possam visualizar.

Este tópico inclui as seguintes seções:

Inicializando uma estrutura `otc_publisher` e definindo callbacks do publisher

Comece criando uma estrutura do tipo 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;

Use o user_data membro do otc_publisher_callbacks estrutura para definir dados aos quais você possa querer fazer referência nas funções de retorno de chamada. Neste exemplo, definimos isso como um ponteiro para uma matriz de caracteres. Mas poderia ser um ponteiro para uma instância de algum outro tipo que contenha informações relevantes.

Os demais membros do otc_publisher_callbacks A estrutura é composta por funções de retorno de chamada que são invocadas quando ocorrem eventos relacionados ao fluxo publicado:

  • on_stream_created — É chamado quando o editor inicia a transmissão para a sessão.
  • on_render_frame — É chamado sempre que o publisher estiver pronto para renderizar um novo quadro de vídeo na transmissão.
  • on_stream_destroyed — É chamado quando o fluxo do publisher é destruído.
  • on_error — É chamado quando ocorre um erro na publicação do fluxo.

Todas as chamadas de retorno não serão executadas na thread do aplicativo ou na thread principal, mas em uma thread interna. O aplicativo deve retornar a chamada de retorno o mais rápido possível para evitar o bloqueio da thread interna.

Veja otc_publisher_callbacks Consulte a documentação de referência do SDK do OpenTok para Linux para obter detalhes sobre cada uma das funções de retorno de chamada.

Ligue para o otc_publisher_new() para criar um otc_publisher estrutura, que representa o editor do 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;
}

O otc_publisher_new() O método recebe três argumentos:

  • name — Um nome (opcional) que identifica o emissor da transmissão.
  • capturer — Use este parâmetro se desejar especificar um capturador de vídeo personalizado. Se estiver definido como NULL, o editor utiliza a câmera padrão do sistema como fonte de vídeo. Consulte Utilizando um capturador de vídeo personalizado (para saber como implementar um capturador de vídeo personalizado.)
  • callbacks — O otc_publisher_callbacks estrutura de callback do editor, descrita acima.

Você pode criar um driver de áudio personalizado para ser utilizado por todos os editores e assinantes.

Você pode usar um capturador de vídeo personalizado para publicar uma transmissão com uma fonte de vídeo personalizada — consulte Utilizando um capturador de vídeo personalizado.

Publicação de um stream

Quando o aplicativo se conecta à sessão do OpenTok, o on_connected() função de retorno de chamada do otc_session_callbacks a estrutura é chamada (ver Participar de uma sessão). Em resposta a isso, você pode chamar o otc_session_publish() função para publicar um stream na sessão do OpenTok:


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

O otc_session_publish() A função recebe dois argumentos:

  • O ponteiro para o otc_session estrutura.
  • O otc_publisher estrutura.

Isso retorna OTC_SUCCESS quando consegue iniciar a publicação de um fluxo na sessão. Ou então retorna um erro, e o otc_error a função de retorno de chamada é chamada.

Definindo a taxa de bits máxima para uma transmissão

É possível definir a taxa de bits máxima para uma transmissão publicada. Definir a taxa de bits máxima pode ajudar a reduzir o consumo de largura de banda quando um usuário se conecta por meio de uma conexão com limite de tráfego. Consulte esta documentação.

Impedir que uma editora transmita conteúdo

Para interromper a transmissão de um editor, chame a função otc_session_unpublish() função, passando o otc_session e otc_publisher estruturas:

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

Como obter estatísticas sobre o stream de um editor

Utilize as funções de retorno de chamada on_audio_stats() e on_video_stats() do otc_publisher_callbacks para monitorar as estatísticas do fluxo de um editor. Para obter estatísticas de baixo nível sobre as conexões entre pares de um editor, use o otc_publisher_get_rtc_stats_report() função.

Consulte Guia do desenvolvedor sobre observabilidade do cliente para obter informações detalhadas.