Guia dos plugins

Linux
(Flatpak)

Quase toda a funcionalidade personalizada é adicionada através de módulos de plug -in, que são tipicamente bibliotecas ou scripts dinâmicos. A capacidade de capturar e/ou sair áudio/vídeo, fazer uma gravação, produzir em um fluxo RTMP, codificar em x264 são exemplos de coisas que são realizadas por módulos de plug -in.

Os plugins podem implementar fontes, saídas, codificadores e serviços.

Escrevendo seu primeiro plugin? .

• .H – O cabeçalho principal usado para criar módulos de plug -in.
  • .H – o cabeçalho principal dos libobs. Este arquivo inclui automaticamente os seguintes arquivos:
    • Libobs/obs-Source.
    • Libobs/obs-Output.
    • Libobs/Obs-Oncoder.H – usado para implementar codificadores em módulos de plug -in
    • .H – usado para implementar serviços em módulos de plug -in
    • Libobs/Obs-Data.
    • Libobs/obs-Properties.H – usado para gerar propriedades para objetos Libobs
    • Libobs/Graphics/Graphics.

    .txt

    . Por exemplo, se você criasse um plugin chamado ‘My-Plugin’, você teria algo como My-Plugin.C onde a inicialização do plug-in é feita, minha fonte.c Para a definição de uma fonte personalizada, My-Output..

    Este é um exemplo de uma estrutura de diretório comum para um módulo de plug -in nativo:

    -plugardados/localidade/-.ini meu-plugar/Cmakelists.TXT meu-/-plugar. -plugar/meu-.c -plugar/meu-saída.c meu-plugar-codificador. meu-/meu-serviço. 

    Este seria um exemplo de cmakelistas comuns.Arquivo TXT associado a esses arquivos:

    # my-plugin/cmakelists..C My-Source.C My-Output.c meu codificador.C My-Service.

    .h cabeçalho, use obs_declare_module () macro e, em seguida, crie uma definição da função obs_module_load () . . Veja a referência da API do módulo para obter mais informações.

    A seguir é um exemplo de my-plugin.c, que registraria um objeto de cada tipo:

    /* my-plugin.c */  / * Define funções comuns (exigidas) */ () / * Implementa o local comum baseado em INI (opcional) */ Obs_module_use_default_locale, "En-us" extern estrutura obs_source_info  .c */ extern estrutura  ; .c */ extern   my_encoder; /* Definido no meu codificador.  estrutura obs_service_info my_service /* Definido em my-service. bool obs_module_load(  (my_source (&my_output (my_encoder); obs_register_service(&my_service); retornar ; > 

    Fontes são usadas para renderizar vídeo e/ou áudio no fluxo. Coisas como capturar displays/jogos/áudio, reproduzir um vídeo, mostrar uma imagem ou reproduzir áudio. Fontes também podem ser usadas para implementar filtros de áudio e vídeo, bem como transições. The Libobs/obs-Source.O arquivo H é o cabeçalho dedicado para a implementação de fontes. Veja a referência da API de origem (obs_source_t) para obter mais informações.

    Por exemplo, para implementar um objeto de origem, você precisa definir uma estrutura obs_source_info e preenchê -lo com informações e retornos de chamada relacionados à sua fonte:

    /* My-Source.c */ [[. ]  obs_source_info my_source  .eu ia = "My_source", .tipo  Obs_source_type_input, . = , .get_name = my_source_name, .criar  , . = my_source_destroy, . = my_source_update, .video_render  my_source_render, .  , . =  >; 

    Então, em minha plugin..

    . [[.   estrutura  my_source; . bool obs_module_load(  obs_register_source(&my_source [[.  retornar  > 

    • Fonte de vídeo síncrono: a fonte da imagem
    • Filtro de áudio: o filtro de áudio de ganho

    Saídas

    As saídas permitem a capacidade de gerar o áudio/vídeo atualmente renderizado. Streaming e gravação são dois exemplos comuns de saídas, mas não os únicos tipos de saídas. As saídas podem receber os dados brutos ou receber dados codificados. .O arquivo H é o cabeçalho dedicado para a implementação de saídas. Consulte a referência da API de saída (obs_output_t) para obter mais informações.

    Por exemplo, para implementar um objeto de saída, você precisa definir uma estrutura obs_output_info e preenchê -lo com informações e retornos de chamada relacionados à sua saída:

    /* my-output.c */ [[. ] estrutura obs_output_info my_output  .  , .bandeiras = Obs_output_av  Obs_output_encoded, .get_name = my_output_name, . = my_output_create, .destruir = my_output_destroy, .começar  my_output_start, .  my_output_stop, .coded_packet = , .get_total_bytes = my_output_total_bytes, .coded_video_codecs = , .coded_audio_codecs   >; 

    Então, em minha plugin..

    . . ] extern estrutura obs_output_info my_output; .  (vazio)  obs_register_output(my_output); . ]  verdadeiro; > 

    Alguns exemplos de saídas:

    • Saídas de vídeo/áudio codificadas:
      • A saída FLV
      • A saída FFMPEG

      Os codificadores são implementações específicas de obs específicas de codificadores de vídeo/áudio, que são usados ​​com saídas que usam codificadores. . Os Libobs/Obs-Coder.O arquivo H é o cabeçalho dedicado para a implementação dos codificadores. .

      Por exemplo, para implementar um objeto de codificador, você precisa definir uma estrutura obs_encoder_info e preenchê -la com informações e retornos de chamada relacionados ao seu codificador:

      /* meu codificador.c */ .  estrutura obs_encoder_info my_encoder_encoder =  .eu ia = "My_Encoder", .  Obs_encoder_video, .Codec = "H264", .get_name = , .criar = , .destruir = my_encoder_destroy, .codificar = , .atualizar = my_encoder_update, . = my_encoder_extra_data, .get_sei_data = my_encoder_sei, .  my_encoder_video_info  

      Então, em minha plugin.C, você ligaria para obs_register_encoder () em obs_module_load () para registrar o codificador com libobs.

      /* my-plugin.c */ [[. ] extern estrutura  ; . bool obs_module_loadvazio  obs_register_encodermy_encoder [[.   verdadeiro; > 

      Atualmente, as configurações do codificador têm alguns valores de configuração comuns esperados que devem ter uma convenção de nomenclatura específica:

      • – Este valor deve ser usado para codificadores de vídeo e áudio: taxa de bits, em Kilobits.
      • – . . Outros controles de taxa comum são “VBR”, “CQP”.
      • “Keyint_sec” – . (Nota do autor: isso deveria ter sido “Keyint”, em quadros.)

      Exemplos de codificadores:

      • • O codificador ffmpeg nvenc
        • O codificador FFMPEG AAC/Opus

        Serviços

        Serviços são implementações personalizadas dos serviços de streaming, que são usados ​​com saídas que fluem. Por exemplo, você pode ter uma implementação personalizada para streaming para se contorcer e outro para o YouTube para permitir a capacidade de fazer login e usar suas APIs para fazer coisas como obter os servidores RTMP ou controlar o canal. .. Veja a referência da API de serviço (obs_service_t) para obter mais informações.

        Por exemplo, para implementar um objeto de serviço, você precisa definir uma estrutura obs_service_info e preenchê -la com informações e retornos de chamada relacionados ao seu serviço:

        . [[. ] estrutura obs_service_info my_service_service =  .eu ia = "My_service", .get_name = my_service_name, .criar = my_service_create, . = my_service_destroy, . = , .atualizar = , .get_url  my_service_url, .get_key = my_service_key >; 

        Então, em minha plugin.C, você ligaria para obs_register_service () em obs_module_load () para registrar o serviço no Libobs.

        .c */ [[. ] extern estrutura  my_service .  obs_module_loadvazio)  (my_service); . ] retornar verdadeiro;  

        Os únicos dois objetos de serviços existentes são os objetos “Serviços RTMP comuns” e “Serviço RTMP personalizado” em Plugins/RTMP-Services

        Configurações

        Configurações (ver Libobs/Obs-Data.h) são usados ​​para obter ou definir dados de configurações normalmente associados aos objetos Libobs e podem ser salvos e carregados via JSON Text. Consulte a referência da API de configurações de dados (obs_data_t) para obter mais informações.

        O obs_data_t é o equivalente a um objeto JSON, onde é uma tabela de subobjetos, e o obs_data_array_t é usado da mesma forma para armazenar uma variedade de obs_data_t objetos, semelhantes às matrizes JSON (embora não sejam muito idênticas).

        Para criar um obs_data_t ou obs_data_array_t Objeto, você chamaria as funções obs_data_create () ou obs_data_array_create (). obs_data_t e obs_data_array_t Os objetos são contados de referência; portanto, quando você terminar o objeto, ligue para obs_data_release () ou obs_data_array_release () para liberar essas referências. A qualquer momento um obs_data_t ou obs_data_array_t O objeto é retornado por uma função, suas referências são incrementadas, então você deve liberar essas referências a cada vez.

        Para definir valores para um obs_data_t Objeto, você usaria uma das seguintes funções:

        / * Definir funções */ EXPORTAR vazio obs_data_set_string(obs_data_t *dados, const Caracteres *nome, const Caracteres *Val); EXPORTAR vazio obs_data_set_int(obs_data_t *dados, const Caracteres *nome, longo longo Val); EXPORTAR vazio obs_data_set_double(obs_data_t *dados, const Caracteres *nome, dobro Val); EXPORTAR vazio obs_data_set_bool(obs_data_t *dados, const Caracteres *nome, bool Val); EXPORTAR vazio obs_data_set_obj(obs_data_t , const Caracteres *nome, obs_data_t *obj); EXPORTAR vazio obs_data_set_array(obs_data_t *, const Caracteres *nome,  *variedade); 

        obs_data_t Objeto, você usaria uma das seguintes funções:

        / * Obtenha funções */ EXPORTAR const Caracteres *obs_data_get_stringobs_data_t *dados, const Caracteres *nome); EXPORTAR longo longo obs_data_get_int(obs_data_t *dados, const Caracteres *nome EXPORTAR dobro obs_data_get_double(obs_data_t *, const Caracteres *nome); EXPORTAR bool obs_data_get_bool(obs_data_t *dados,  Caracteres *nome); EXPORTAR obs_data_t *obs_data_get_obj( *dados, const Caracteres *nome); EXPORTAR obs_data_array_t *obs_data_get_array(obs_data_t *dados, const Caracteres *nome); 

        Ao contrário dos objetos típicos de dados JSON, o obs_data_t . Isso permite a capacidade de controlar o que é retornado se não houver valor atribuído a uma string específica em um obs_data_t objeto quando esses dados são carregados de uma string json ou arquivo json. Cada objeto Libobs também tem um get_defaults retorno de chamada que permite definir as configurações padrão do objeto na criação.

        /* Funções de valor padrão. */ EXPORTAR vazio obs_data_set_default_stringobs_data_t *dados, const  *nome, const Caracteres *Val);  vazio (obs_data_t dados, const Caracteres *nome, longo longo Val); EXPORTAR vazio (obs_data_t dados, const Caracteres *nome, dobro Val); EXPORTAR vazio obs_data_set_default_bool(obs_data_t *dados, const Caracteres *nome, bool Val); EXPORTAR vazio obs_data_set_default_obj(obs_data_t *dados, const Caracteres *nome, obs_data_t *obj); 

        Propriedades

        Propriedades (ver Libobs/Obs-Properties.. Cada objeto Libobs tem um get_properties retorno de chamada que é usado para gerar propriedades. A API de propriedades define propriedades específicas vinculadas às configurações do objeto, e o front-end usa essas propriedades para gerar widgets para permitir que o usuário modifique as configurações. Por exemplo, se você tivesse uma configuração booleana, usaria OBS_PROPERTIES_ADD_BOOL () para permitir que o usuário possa alterar essa configuração. Veja a referência da API de propriedades (obs_properties_t) para obter mais informações.

        Um exemplo disso:

        estático obs_properties_t *my_source_properties(vazio *dados)  obs_properties_t *ppts = obs_properties_create(); (ppts, "my_bool", obs_module_text("MyBool")); UNUSUST_PARAMETER(dados); retornar ppts; > [[. ] estrutura obs_source_info my_source  . = my_source_properties, [[. ] >; 

        O dados O parâmetro é os dados do objeto se o objeto estiver presente. Normalmente, isso não é utilizado e provavelmente não deve ser usado se possível. Pode ser nulo se as propriedades forem recuperadas sem um objeto associado a ele.

        As propriedades também podem ser modificadas dependendo de quais configurações são mostradas. Por exemplo, você pode marcar certas propriedades como desativadas ou invisíveis, dependendo do que uma configuração específica está definida para usar a função obs_property_set_modified_callback ().

        Por exemplo, se você deseja a propriedade booleana para ocultar a propriedade de texto B:

        estático bool Setting_A_Modified(obs_properties_t *ppts, obs_property_t *p, obs_data_t *configurações  bool habilitado = obs_data_get_bool(configurações, "Setting_a"); p  obs_properties_get(ppts, "Setting_B"); obs_property_set_enabled(p, ); /* Retorne true para atualizar widgets de propriedades, false de outra forma */ retornar verdadeiro; > [[. ] estático obs_properties_t *my_source_properties(vazio *dados   *ppts = obs_properties_create(); obs_property_t *p p = obs_properties_add_bool(, "Setting_a", obs_module_text()); obs_property_set_modified_callback(p, Setting_A_Modified); (ppts, "Setting_B", obs_module_text("SettingB"), Obs_text_default); retornar ppts > 

        Normalmente, a maioria dos plugins incluída no OB Studio usará um método simples de localização de arquivos ini, onde cada arquivo é um idioma diferente. Ao usar esse método, a macro obs_module_use_default_locale () é usada que carregará/destruirá automaticamente os dados do local sem esforço extra em parte do plug -in. Então a função obs_module_text () (que é automaticamente declarada como um externo por Libobs/obs-Module.h) é usado quando a pesquisa de texto é necessária.

        Existem duas exportações que o módulo usado para carregar/destruir o localidade: o obs_module_set_locale () Exportar e o obs_module_free_locale () exportar. A exportação obs_module_set_locale () é chamada por Libobs para definir o idioma atual e, em seguida, a exportação obs_module_free_locale () é chamada por Libobs na destruição do módulo. Se você deseja implementar uma implementação personalizada de localidade para o seu plug -in, deseja definir essas exportações junto com o obs_module_text ().

        © Copyright 2017-2023, Lain Bailey.

        Guia dos plugins

        O OB Studio suporta uma variedade de plugins que fornecem novos tipos de fontes, filtros e recursos. Alguns plug -ins também permitem que o OB Studio se comunique com certos tipos de hardware, como o convés de stream Elgato.

        Alguns plugins também são disponibilizados para usuários do Linux via Flathub.

        Compatibilidade

        A maioria dos plugins é desenvolvida para ser utilizável em todas as plataformas onde o OB Studio está disponível. No entanto, há certos casos em que um plug -in pode não ser compatível com sua cópia do Studio OB:

        • O plugin está disponível apenas em uma plataforma (eu.e.
        • O plugin não está disponível para a mesma arquitetura (i.e. x86_64, não ARM64)
        • O plugin não foi atualizado para a versão do estúdio OB que você está usando

        Para ver quais plugins estão disponíveis para quais plataformas no Obs Studio 28.0, veja a lista de compatibilidade do Plugin do OBS Studio 28.

        Instale ou remova os plugins

        Muitos dos plugins mais populares do Obs Studio vêm com os instaladores. Em geral, eles instalam plugins nos locais listados abaixo.

        Se você precisar instalar um plug -in manualmente, os arquivos relevantes provavelmente precisam ir em uma dessas pastas. Por favor, verifique a documentação do plugin primeiro.

        janelas (todos os usuários)

        C: \ Arquivos de programas \ obs-studio \ obs-plugins \ 64bit

        janelas
        (Legacy Plugins de 32 bits; Obs Studio 27.2.

        C: \ Arquivos de programas \ obs-studio \ obs-plugins \ 32bit

        janelas (Único usuário)

        %AppData%\ obs-studio \ obs-plugins

        Mac OS

        ~/Biblioteca/suporte de aplicativo/obs-studio/plugins

        Linux

        ~/.Config/obs-studio/plugins

        Linux
        (Flatpak)

        Instale plugins usando Flatpak

        Se você instalar o Obs Studio em um local personalizado ou usar o modo portátil, precisará alterar a pasta de destino do instalador para o seu local personalizado dados/plugins pasta.

        Índice