Plugins Guide

Linux
(Flatpak)

Plugins

Fast alle benutzerdefinierten Funktionen werden durch Plugin -Module hinzugefügt, bei denen es sich normalerweise um dynamische Bibliotheken oder Skripte handelt. Die Möglichkeit, Audio/Video zu erfassen und/oder auszugeben, eine Aufzeichnung zu erstellen, in einem RTMP -Stream auszugeben, in x264 codieren, sind alle Beispiele für Dinge, die über Plugin -Module erreicht werden.

Plugins können Quellen, Ausgänge, Encoder und Dienste implementieren.

Schreiben Sie Ihr erstes Plugin? .

Plugin -Modul -Header

Dies sind einige bemerkenswerte Header, die üblicherweise von Plugins verwendet werden:

• Libobs/Obs-Modul.H – der primäre Header zum Erstellen von Plugin -Modulen.
  • libobs/obs.H – der Hauptlibobs -Header. Diese Datei enthält automatisch die folgenden Dateien:
    • Libobs/Obs-Source.H – Wird zur Implementierung von Quellen in Plugin -Modulen verwendet
    • libobs/ob-output.H – Wird zum Implementieren von Ausgängen in Plugin -Modulen verwendet
    • libobs/ob-ccoder.H – Wird zur Implementierung von Encodern in Plugin -Modulen verwendet
    • .H – Wird zur Implementierung von Diensten in Plugin -Modulen verwendet
    • libobs/ob-data.H – Wird zur Verwaltung von Einstellungen für Libobs -Objekte verwendet
    • .H – Wird zur Generierung von Eigenschaften für Libobs -Objekte verwendet
    • Libobs/Grafik/Grafik.

    Gemeinsame Verzeichnisstruktur und Cmakelisten.

    Die gemeinsame Art und Weise, wie Quelldateien organisiert sind. Wenn Sie beispielsweise ein Plugin namens “My-Plugin” erstellen würden, hätten Sie so etwas wie My-Plugin.c wo Plugin-Initialisierung durchgeführt wird, My-Source.C für die Definition einer benutzerdefinierten Quelle, mein Ausgangsput.C für die Definition einer benutzerdefinierten Ausgabe usw. (Dies ist natürlich keine Regel)

    Dies ist ein Beispiel für eine gemeinsame Verzeichnisstruktur für ein natives Plugin -Modul:

    Mein-///en-UNS.Ini Mein-Plugin/Cmakelisten.txt Mein-Plugin/Mein-Plugin.C Mein-Plugin/Mein-Quelle.C Mein-Plugin/Mein-Ausgabe.C Mein-Plugin/Mein-Encoder.C Mein-Plugin/Mein-Service.C 

    Dies wäre ein Beispiel für ein gemeinsames Cmakelisten.TXT -Datei, die diesen Dateien zugeordnet sind:

    # my-plugin/cmakelisten.TXT Project (My-Plugin) Set (my-plugin_sources my-plugin.c My-Source.c mein Ausgang..c My-Service.c) add_library (My-Plugin-Modul $) target_link_libraries (my-plugin libobs) install_obs_plugin_with_data (my-plugin-Daten)

    Native Plugin -Initialisierung 

    Um ein natives Plugin-Modul zu erstellen, müssen Sie die Libobs/Obs-Modul einbeziehen.H -Header, verwenden Sie OBS_DECLARE_MODULE () -Makro und erstellen Sie dann eine Definition der Funktion OBS_MODULE_LOAD () . . Weitere Informationen finden Sie in der Modul -API -Referenz.

    Das Folgende ist ein Beispiel für My-Plugin.c, die ein Objekt jedes Typs registrieren würde:

    /* my-plugin. #enthalten  OBS_DECLARE_MODULE() / * Implementiert das gemeinsame Ini-basierte Gebietsschema (optional) */ OBS_MODULE_USE_DEFAULT_LOCALE("My-Plugin", "en-us" extern Struktur OBS_SOURCE_INFO my_source; /* In My-Source definiert.C */ extern Struktur obs_output_info my_output; .C */ extern Struktur obs_encoder_info my_encoder; .C */ extern Struktur  my_service; /* In My-Service definiert.C */ bool OBS_MODULE_LOAD(Leere)  OBS_register_Source&my_source); obs_register_output(&my_output); obs_register_encoder(&my_encoder); OBS_register_Service(&my_service); zurückkehren WAHR; > 

    Quellen

    Quellen werden verwendet, um Video und/oder Audio im Stream zu rendern. Dinge wie das Erfassen von Displays/Spielen/Audio, das Spielen eines Videos, das Anzeigen eines Bildes oder das Abspielen von Audio. Quellen können auch verwendet werden, um Audio- und Videofilter sowie Übergänge zu implementieren. Die Libobs/Obs-Source.H -Datei ist der dedizierte Header für die Implementierung von Quellen. Weitere Informationen finden Sie in der Quell -API -Referenz (OBS_SOURCE_T).

    Um ein Quellobjekt zu implementieren, müssen Sie beispielsweise eine OBS_SOURCE_INFO -Struktur definieren und mit Informationen und Rückrufen im Zusammenhang mit Ihrer Quelle ausfüllen:

    /* My-Source.C */ [. ] Struktur OBS_SOURCE_INFO my_source  .Ausweis = "my_source", .Typ = Obs_source_type_input, .output_flags = OBS_SOURCE_VIDEO, .get_name = my_source_name, .erstellen = , . = my_source_destroy, . = MY_SOURCE_UPDATE, .Video_Render = my_source_render, .get_width  MY_SOURCE_WIDTH, .get_height = my_source_height >; 

    Dann in My-Plugin.c, Sie würden achter_register_Source () in obs_module_load () aufrufen, um die Quelle mit Libobs zu registrieren.

    /* my-plugin. [. ] extern  OBS_SOURCE_INFO my_source; /* In My-Source definiert.C */  OBS_MODULE_LOAD(Leere)  OBS_register_Source(&my_source); [.  zurückkehren WAHR;  

    Einige einfache Beispiele für Quellen:

    • Synchrone Videoquelle: Die Bildquelle
    • Asynchrone Videoquelle: Die Quelle für zufällige Texturprüfung
    • Audioquelle: Die Sinus -Wellen -Testquelle
    • Videofilter: Der Test -Videofilter
    • Audiofilter: Der Gewinn -Audiofilter

    Ausgänge

    Die Ausgänge ermöglichen die Möglichkeit, den aktuell rendernden Audio/Video auszugeben. Streaming und Aufzeichnung sind zwei häufige Beispiele für Ausgänge, jedoch nicht die einzigen Arten von Ausgängen. Ausgänge können die Rohdaten empfangen oder codierte Daten empfangen. Die libobs/ob-outputput.H -Datei ist der dedizierte Header für die Implementierung von Ausgängen. Weitere Informationen finden Sie in der Ausgangs -API -Referenz (OBS_Output_t).

    Um beispielsweise ein Ausgabeobjekt zu implementieren, müssen Sie eine OBS_Output_Info -Struktur definieren und mit Informationen und Rückrufen im Zusammenhang mit Ihrer Ausgabe ausfüllen:

    /* mein Ausgang.C */ [. ] Struktur  my_output  .Ausweis = "my_output", .Flaggen = Obs_output_av | , . = , .erstellen = my_output_create, .zerstören = my_output_destroy, .Start = my_output_start, .stoppen = my_output_stop, .coded_packet = my_output_data, .get_total_bytes = my_output_total_bytes, .coded_video_codecs = "H264", .coded_audio_codecs =  >; 

    Dann in My-Plugin..

    /* my-plugin.C */ [. ] extern Struktur obs_output_info my_output; /* In meinem Output definiert.C */ bool OBS_MODULE_LOAD(Leere)  obs_register_output(my_output); [.   WAHR; > 

    Einige Beispiele für Ausgänge:

    • Codierte Video-/Audioausgänge:
      • Der FLV -Ausgang
      • Der FFMPEG -MUXER -Ausgang
      • Der RTMP -Stream -Ausgang
      • Die FFMPEG -Ausgabe

      Encoder 

      Encoder sind obsspezifische Implementierungen von Video-/Audio-Encodern, die mit Ausgängen verwendet werden, die Encoder verwenden. X264, NVENC, QuickSync sind Beispiele für Encoder -Implementierungen. Die libobs/obs-coder.H -Datei ist der dedizierte Header für die Implementierung von Encodern. Weitere Informationen finden Sie in der API -Referenz für Encoder -API (OBS_Enencoder_t).

      Um beispielsweise ein Encoder -Objekt zu implementieren, müssen Sie eine OBS_Encoder_Info -Struktur definieren und mit Informationen und Rückrufen im Zusammenhang mit Ihrem Encoder ausfüllen:

      .C */ [. ] Struktur obs_encoder_info my_encoder_encoder =  .Ausweis = "my_encoder", .Typ = Obs_encoder_video, .Codec = "H264", .get_name  my_encoder_name, .erstellen = my_encoder_create, .zerstören = my_encoder_destroy, .kodieren = my_encoder_encode, .aktualisieren = my_encoder_update, .get_extra_data = my_encoder_extra_data, . = , .get_video_info = my_encoder_video_info >; 

      Dann in My-Plugin.C, Sie würden obs_register_encoder () in obs_module_load () aufrufen, um den Encoder bei Libobs zu registrieren.

      /* my-plugin.C */ [. ] extern Struktur obs_encoder_info my_encoder; .C */ bool OBS_MODULE_LOAD(Leere)  obs_register_encoder(&my_encoder); [. ] zurückkehren WAHR; > 

      WICHTIGER HINWEIS: Encoder -Einstellungen haben derzeit einige erwartete gemeinsame Einstellungswerte, die eine spezifische Namenskonvention haben sollten:

      • “Bitrate” – Dieser Wert sollte sowohl für Video- als auch für Audio -Encoder verwendet werden: Bitrate in Kilobits.
      • “Rate_control” – Dies ist eine Einstellung, die für Video -Encoder verwendet wird. Es wird allgemein erwartet, dass es mindestens eine CBR -Ratenkontrolle hat. Weitere gängige Ratenkontrollen sind „VBR“, „CQP“.
      • “KEYINT_SEC” – Legt für Video -Encoder den Keyframe -Intervallwert in Sekunden oder der engsten Annäherung fest. (Anmerkung des Autors: Dies hätte in Frames “KeyInt” sein sollen.)
      • Video -Encoder:
        • Der QuickSync -Encoder
        • Der FFMPEG AAC/Opus -Encoder

        Dienstleistungen

        Dienste sind benutzerdefinierte Implementierungen von Streaming -Diensten, die mit Ausgaben verwendet werden, die Streams haben. Beispielsweise können Sie eine benutzerdefinierte Implementierung für das Streaming zu Twitch und eine andere für YouTube haben, damit sich die Möglichkeit anmelden und ihre APIs verwenden kann, um Dinge wie die RTMP -Server zu erhalten oder den Kanal zu steuern. Die Libobs/Obs-Service.H -Datei ist der dedizierte Header für die Implementierung von Diensten. Weitere Informationen finden Sie in der Service -API -Referenz (OBS_Service_T).

        (Anmerkung des Autors: Die Service -API ist ab diesem Zeitpunkt unvollständig)

        Um ein Dienstobjekt zu implementieren, müssen Sie beispielsweise eine OBS_Service_Info -Struktur definieren und mit Informationen und Rückrufen im Zusammenhang mit Ihrem Dienst ausfüllen:

        /* My-Service.C */ [. ] Struktur  my_service_service =  .Ausweis  "my_service", .get_name = my_service_name, .erstellen = my_service_create, .zerstören = my_service_destroy, .kodieren = my_service_encode, .aktualisieren = my_service_update, .get_url = my_service_url, .get_key  my_service_key >; 

        Dann in My-Plugin.c, Sie würden achter_register_Service () in obs_module_load () aufrufen, um den Dienst mit Libobs zu registrieren.

        /* my-plugin.C */ [. ] extern Struktur obs_service_info my_service; .C */  OBS_MODULE_LOAD(Leere)  OBS_register_Service(&); [. ] zurückkehren WAHR; > 

        Die einzigen beiden vorhandenen Diensteobjekte sind die „gemeinsamen RTMP-Dienste“ und „benutzerdefinierte RTMP-Dienst“ -Objekte in Plugins/RTMP-Services

        Einstellungen

        .h) werden verwendet, um Einstellungsdaten zu erhalten oder festzulegen, die normalerweise Libobs -Objekten zugeordnet sind, und können dann über JSON -Text gespeichert und geladen werden. Weitere Informationen finden Sie in der API -Referenz der Dateneinstellungen (OBS_DATA_T).

        obs_data_t ist das Äquivalent eines JSON-Objekts, in dem es sich um eine String-Tabelle von Sub-Objects handelt, und der obs_data_array_t wird ähnlich verwendet, um eine Reihe von einer Reihe von zu speichern obs_data_t Objekte, ähnlich wie JSON -Arrays (wenn auch nicht ganz identisch).

        obs_data_t oder obs_data_array_t Objekt, Sie rufen die Funktionen achs_data_create () oder obs_data_array_create () auf. obs_data_t Und obs_data_array_t Die Objekte werden referenziert. Wenn Sie also mit dem Objekt fertig sind, rufen Sie OBS_DATA_RELEASE () oder OBS_DATA_Array_Release () auf, um diese Referenzen zu veröffentlichen. Jederzeit an obs_data_t oder Das Objekt wird von einer Funktion zurückgegeben, ihre Referenzen werden inkrementiert, sodass Sie diese Referenzen jedes Mal freigeben müssen.

        Werte für eine festlegen obs_data_t Objekt verwenden Sie eine der folgenden Funktionen:

        / * Funktionen festlegen *// EXPORT  obs_data_set_stringobs_data_t *, Const verkohlen *, Const verkohlen *val EXPORT Leere obs_data_set_int(obs_data_t *Daten, Const verkohlen *Name, lang lang val); EXPORT Leere obs_data_set_double(obs_data_t *Daten, Const verkohlen Name, doppelt val); EXPORT Leere OBS_DATA_SET_BOOL(obs_data_t *Daten, Const  *Name,  val); EXPORT Leere obs_data_set_obj(obs_data_t *Daten, Const verkohlen *Name, obs_data_t obj); EXPORT Leere obs_data_set_array(obs_data_t *Daten, Const verkohlen Name, obs_data_array_t *Array); 

        Ebenso, um einen Wert von einem zu erhalten obs_data_t Objekt verwenden Sie eine der folgenden Funktionen:

        / * Funktionen erhalten */ EXPORT  verkohlen *obs_data_get_string( Daten, Const verkohlen *Name); EXPORT lang  obs_data_get_int(obs_data_t *, Const verkohlen *Name); EXPORT doppelt obs_data_get_doubleobs_data_t *Daten, Const verkohlen *Name); EXPORT bool obs_data_get_bool(obs_data_t *Daten, Const verkohlen *); EXPORT obs_data_t *obs_data_get_obj(obs_data_t Daten,  verkohlen *Name); EXPORT obs_data_array_t *obs_data_get_array(obs_data_t *Daten, Const verkohlen *Name); 

        obs_data_t Objekt kann auch Standardwerte festlegen. Dies ermöglicht die Möglichkeit, zu steuern, was zurückgegeben wird, wenn kein Wert einer bestimmten Zeichenfolge in einem zugewiesen ist obs_data_t Objekt, wenn diese Daten aus einer JSON -String- oder JSON -Datei geladen werden. Jedes Libobs -Objekt hat auch a get_defaults .

        Diese Funktionen steuern die Standardwerte wie folgt:

        /* Standardwertfunktionen. */ EXPORT Leere obs_data_set_default_stringobs_data_t *Daten, Const verkohlen *Name, Const verkohlen *val EXPORT Leere obs_data_set_default_int(obs_data_t *Daten, Const verkohlen *Name, lang  val); EXPORT Leere obs_data_set_default_double(obs_data_t *Daten, Const verkohlen Name, doppelt val); EXPORT Leere OBS_DATA_SET_DEFAULT_BOOL(obs_data_t *Daten, Const verkohlen *Name, bool val); EXPORT Leere OBS_DATA_SET_DEFAULT_OBJ( *Daten, Const verkohlen *Name, obs_data_t *); 

        Eigenschaften

        Eigenschaften (siehe Libobs/Obs-Properties.H) werden verwendet, um die Benutzeroberfläche automatisch zu generieren, um Einstellungen für ein Libobs -Objekt zu ändern (falls gewünscht). Jedes Libobs -Objekt hat a get_properties . Die Eigenschaften-API definiert bestimmte Eigenschaften, die mit den Einstellungen des Objekts verknüpft sind, und das Front-End verwendet diese Eigenschaften, um Widgets zu generieren, damit der Benutzer die Einstellungen ändern kann. Wenn Sie beispielsweise eine Boolesche Einstellung hätten, würden Sie OBS_PRORTIES_ADD_BOOL () verwenden, damit der Benutzer diese Einstellung ändern kann. Weitere Informationen finden Sie in der Eigenschaften -API -Referenz (OBS_PROPERTIES_T).

        Ein Beispiel dafür:

          *my_source_properties(Leere *)  obs_properties_t *PPTs = (); OBS_PRORTIES_ADD_BOOL(PPTs, "my_bool", OBS_MODULE_TEXT("MyBool")); UNNEUSED_PARAMETERDaten); zurückkehren PPTs; > [. ]  OBS_SOURCE_INFO my_source  .get_properties = my_source_properties, [. ] >; 

        Der Daten Der Parameter ist die Daten des Objekts, wenn das Objekt vorhanden ist. In der Regel ist dies nicht genutzt und sollte wahrscheinlich nicht verwendet werden, wenn möglich. Es kann null sein, wenn die Eigenschaften ohne damit verbundenes Objekt abgerufen werden.

        Eigenschaften können auch geändert werden, je nachdem, welche Einstellungen angezeigt werden. Sie können beispielsweise bestimmte Eigenschaften als deaktiviert oder unsichtbar markieren, je nachdem, welche Einstellung die Funktion der OBS_PROPERTY_SET_MODIFIFD_CALLBACK () verwendet wird.

        Wenn Sie beispielsweise die Boolesche Eigenschaft A haben möchten, um die Texteigenschaft B zu verbergen B:

        statisch bool Einstellung_A_MODIFIFIFIFIG(obs_properties_t *PPTs, obs_property_t P, obs_data_t *Einstellungen)  bool ermöglicht = obs_data_get_bool(Einstellungen, "Seting_a"); P = obs_properties_get(PPTs, "Einstellung_B"); obs_property_set_enabled(P, ermöglicht); /* Return true to Aktualisierung von Eigenschaften -Widgets, falsch ansonsten */ zurückkehren WAHR;  . ] statisch obs_properties_t *my_source_properties *Daten)  obs_properties_t *PPTs = obs_properties_create(); obs_property_t *P P = OBS_PRORTIES_ADD_BOOL(PPTs, "Seting_a", OBS_MODULE_TEXT"Settinga")); obs_property_set_modified_callback(P, Einstellung_A_MODIFIFIFIFIG); obs_properties_add_text(PPTs, "Einstellung_B", OBS_MODULE_TEXT("SetingB"), Obs_text_default); zurückkehren PPTs; > 

        Lokalisierung

        In der Regel verwendet die meisten Plugins, die mit OBS Studio gebündelt sind. Bei Verwendung dieser Methode wird das Makro der OBS_MODULE_USE_DEFAULT_LOCALE () verwendet, wodurch die Gebietsschemasdaten automatisch geladen/zerstört werden, ohne dass ein Teil des Plugins zusätzlichen Aufwand ist. Dann die Funktion OBS_MODULE_TEXT () (die automatisch von libobs/obs-Module als Extern deklariert wird.h) wird verwendet, wenn eine Suchanlage benötigt wird.

        Es gibt zwei Exporte, das das Modul zum Laden/Zerstören des Gebietsschemas verwendet. Der Export von OBS_MODULE_SET_LOCALE () wird von Libobs aufgerufen, um die aktuelle Sprache festzulegen, und dann wird der Export von OBS_MODULE_FREE_LOCALE () von Libobs zur Zerstörung des Moduls aufgerufen. Wenn Sie eine benutzerdefinierte Implementierung des Gebietsschale für Ihr Plugin implementieren möchten, möchten Sie diese Exporte zusammen mit dem OBS_MODULE_TEXT () extern, anstatt sich auf das OBS_MODULE_USE_DEFAULT_LOCALE () -Makro zu verlassen.

        © Copyright 2017-2023, Lain Bailey.

        Plugins Guide

        OBS Studio unterstützt eine Vielzahl von Plugins, die neue Arten von Quellen, Filtern und Funktionen bieten. Einige Plugins ermöglichen es OBS Studio auch, mit bestimmten Arten von Hardware zu kommunizieren, wie das Elgato -Stream -Deck.

        Einige Plugins werden auch Linux -Benutzern über Flathub zur Verfügung gestellt.

        Kompatibilität

        Die meisten Plugins sind so entwickelt, dass sie auf allen Plattformen, auf denen OBS -Studio verfügbar ist. Es gibt jedoch bestimmte Fälle, in denen ein Plugin möglicherweise nicht mit Ihrer Kopie von OBS Studio kompatibel ist:

        • Das Plugin ist nur auf einer Plattform erhältlich (i.e.
        • Das Plugin ist für dieselbe Architektur nicht verfügbar (i.e. x86_64, nicht arm64)
        • Das Plugin wurde nicht für die Version von OBS Studio aktualisiert, die Sie verwenden

        .0, siehe OBS Studio 28 Plugin -Kompatibilitätsliste.

        Plugins installieren oder entfernen

        Viele der beliebtesten Plugins von OBS Studios sind mit Installateuren geliefert. Im Allgemeinen installieren sie Plugins an den unten aufgeführten Standorten.

        Wenn Sie ein Plugin manuell installieren müssen, müssen die entsprechenden Dateien wahrscheinlich in einen diese Ordner eingehen. Bitte überprüfen Sie zuerst die Dokumentation des Plugins.

        Fenster (Alle Nutzer)

        C: \ Programme \ Obs-Studio \ Obs-Plugins \ 64bit

        
        (Legacy 32-Bit-Plugins; OBS Studio 27.2.4 und nur früher)

        C: \ Programme \ Obs-Studio \ Obs-Plugins \ 32bit

        Fenster (Einzelnutzer)

        %AppData%\ Obs-Studio \ Obs-Plugins

        Mac OS

        ~/Bibliothek/Anwendungsunterstützung/Obs-Studio/Plugins

        Linux

        ~/.config/ob-studio/plugins

        Linux
        (Flatpak)

        Installieren Sie Plugins mit Flatpak

        Wenn Sie OBS Studio an einem benutzerdefinierten Speicherort installieren oder den tragbaren Modus verwenden, müssen Sie den Zielordner des Installationsprogramms in den benutzerdefinierten Standort ändern Ordner.

        Inhaltsverzeichnis