Istruzioni per l'installazione

Se vuoi sviluppare per OBS, visita il nostro Discord e conosci gli sviluppatori o hai risposte alle domande!

Inoltre, se c'è qualcosa in questa guida che vuoi cambiare / migliorare, ti consigliamo di parlarne prima con gli sviluppatori in Discord o IRC.

Si noti che tutte le istruzioni / pacchetti di installazione per le distribuzioni Linux / FreeBSD elencate come Non ufficiali significa che sono forniti dalla comunità, e qualsiasi supporto per quei pacchetti dovrebbe essere diretto ai manutentori di distribuzione / pacchetto appropriati.


Sommario:


Windows

Istruzioni per l'installazione di Windows:

Le versioni predefinite di Windows possono essere trovate qui: https://github.com/obsproject/obs-studio/releases/

Il programma di installazione completo .exe e .zip contengono OBS Studio a 32 bit, 64 bit, Browser Source e il plug-in Intel® RealSense ™. Durante l'installazione verrà richiesto di installare il plug-in Browser Source e RealSense se si utilizza il programma di installazione .exe, altrimenti i componenti sono inclusi nel .zip.

Il piccolo programma di installazione .exe contiene il plug-in OBS Studio a 32 bit, 64 bit, Intel® RealSense ™ di base, ma non contiene il plug-in Browser Source.

NOTA: se si utilizza il metodo .zip per l'installazione completa o ridotta e l'installazione in una posizione del programma non standard (ovvero all'esterno dei file di programma), sarà necessario aggiungere il gruppo di sicurezza TUTTI I PACCHETTI DELL'APPLICAZIONE per avere il controllo completo sull'OBS principale Directory e sottodirectory di Studio. Alcune funzionalità potrebbero non funzionare correttamente senza questi diritti di sicurezza (principalmente, la possibilità di utilizzare l'acquisizione di giochi nelle app UWP).


Istruzioni per la compilazione di Windows:

  • Requisiti per la creazione di OBS su Windows

  • Procedura d'installazione

    • Clona il repository e i sottomoduli :
    git clone --recursive https://github.com/obsproject/obs-studio.git
    • Se non sai cosa sono i sottomoduli, o non stai usando Git dalla riga di comando, PER FAVORE assicurati di recuperare anche i sottomoduli .

    • Creare uno o più dei seguenti sottodirectory all'interno del repository clonato per la costruzione: release, debug, e build(con o senza suffisso 32/64 per specificare l'architettura). Sono esclusi dal repository in .gitignore per motivi di compilazione, quindi è sicuro crearne un utilizzo all'interno della directory di base del repository.

    • Esegui cmake-gui e imposta i seguenti campi:
    • In "dov'è il codice sorgente", inserisci nella directory repo (esempio: D: / obs).
    • In "where to build the baries", inserisci il percorso della directory repo con la sottodirectory 'build' (esempio: D: / obs / build).

    • Imposta le seguenti variabili. È possibile impostarli in cmake-gui oppure impostarli come variabili di ambiente Windows per persistere tra le configurazioni.
    • necessario

      • DepsPath

      DepsPathè il percorso della cartella contenente le dipendenze, escluse Qt. Impostalo sulla directory win32 o win64 dal pacchetto delle dipendenze predefinite scaricato in precedenza.
      Ad esempio, se hai estratto le dipendenze .zip in C: \ obs-deps, DepsPathdovrebbe essere uno di questi:

      • C:\obs-deps\win32
      • C:\obs-deps\win64

      Se desideri specificare dipendenze sia a 32 che a 64 bit per evitare di modificare la variabile tra le build, puoi invece impostare DepsPath32e in questo DepsPath64modo:

      • DepsPath32: C:\obs-deps\win32
      • DepsPath64: C:\obs-deps\win64

      • QTDIR

      QTDIRè il percorso della directory di installazione di Qt. L'interfaccia utente di OBS è costruita per impostazione predefinita, il che richiede Qt. Impostare la variabile booleana CMake DISABLE_UI su TRUE se non si desidera la GUI e questo non è più necessario. Opzionalmente può essere suffisso 32 o 64 per specificare l'arco di destinazione.

      NOTA : assicurati di scaricare i componenti Qt precompilati per la tua versione di MSVC (32 o 64 bit).

      Le directory Qt di esempio che useresti se installassi Qt su D: \ Qt avrebbero di solito un aspetto simile a questo:

      • QTDIR32=D:\Qt\5.15.2\msvc2019 (32 bit)
      • QTDIR64=D:\Qt\5.15.2\msvc2019_64 (64 bit)
      • CEF_ROOT_DIR

      CEF_ROOT_DIRè il percorso per un wrapper CEF estratto. Forniamo un wrapper predefinito personalizzato per semplificare il processo di costruzione. Questa build personalizzata include l'accesso all'accelerazione hardware e codec aggiuntivi. Ciò abilita la sorgente del browser e i dock del browser personalizzati.

      Assicurati di abilitare anche il flag CMake BUILD_BROWSERaltrimenti questo non farà nulla

    • Opzionale

      • VIRTUALCAM_GUID- Impostare su qualsiasi valore GUID casuale. Deve essere impostato per creare le funzionalità della fotocamera virtuale.

      (Se questi componenti di seguito condividono la stessa directory di DepsPath, non è necessario specificarli individualmente.)

      • FFmpegPath - Percorso alla sola directory di inclusione di FFmpeg.
      • x264Path - Percorso solo per x264 include directory.
      • curlPath - Percorso alla sola directory cURL include.
    • NOTA INFORMATIVA : percorsi di ricerca e ordine di ricerca per libreria di dipendenze di base / file binari, rispetto alle loro directory di inclusione:

      File di libreria

      • ../lib
      • ../lib32 (se a 32 bit)
      • ../lib64 (se 64 bit)
      • ./lib
      • ./lib32 (se a 32 bit)
      • ./lib64 (se 64 bit)

      File binari:

      • ../bidone
      • ../bin32 (se 32 bit)
      • ../bin64 (se 64 bit)
      • ./bidone
      • ./bin32 (se a 32 bit)
      • ./bin64 (se 64 bit)
    • In cmake-gui, premere 'Configura' e selezionare il generatore che si adatta alla versione VS installata:
      Visual Studio 16 2019 o i loro equivalenti a 64 bit se si desidera creare la versione a 64 bit di OBS

      • NOTA: se è necessario modificare le dipendenze da una build già configurata, sarà necessario deselezionare COPIED_DEPENDENCIES ed eseguire nuovamente Configura.
    • Se non hai impostato le variabili d'ambiente in precedenza, ora puoi configurare DepsPath e, se necessario, il percorso x264, FFmpeg e cUrl in cmake-gui.

    • In cmake-gui, premere "Genera" per generare i file di progetto di Visual Studio nella sottodirectory "build".

    • Apri obs-studio.sln dalla sottodirectory specificata in "dove creare i binari" (ad esempio D: / obs / build) in Visual Studio (o fai clic sul pulsante "Apri progetto" da cmake-gui).

    • Il progetto dovrebbe ora essere pronto per essere compilato ed eseguito. Tutte le dipendenze richieste dovrebbero essere copiate durante la compilazione e dovrebbe essere un ambiente di compilazione completamente funzionale. L'output è compilato nella directory "rundir / [build type]" della tua sottodirectory "build".
  • Integrazione del formato clang in Visual Studio
    • Il formato clang è richiesto per le richieste pull e OBS utilizza una versione più recente di quella fornita con VS2019.
    • Scarica e installa LLVM 8.0.0
    • Esegui VS e vai su Strumenti -> Opzioni ...
    • Editor di testo -> C / C ++ -> Stile codice -> Formattazione -> Generale
      • Abilita "Usa custom clang-format.exe" e inserisci il nome del file. Per esempio:
      • C: \ Programmi \ LLVM \ bin \ clang-format.exe
    • Il comando predefinito per la formattazione di un documento (Edit.FormatDocument) è Ctrl + K, Ctrl + D.

Mac OS

Istruzioni per l'installazione di macOS

Le versioni di macOS predefinite possono essere trovate qui: https://github.com/obsproject/obs-studio/releases

Basta eseguire il programma di installazione e seguire le istruzioni sullo schermo per installare OBS Studio.


Istruzioni per la creazione di macOS

  • Clona il repository e i sottomoduli :

    git clone --recursive https://github.com/obsproject/obs-studio.git
  • Se non sai cosa sono i sottomoduli, o non stai usando Git dalla riga di comando, PER FAVORE assicurati di recuperare anche i sottomoduli .

MacOS Full Build Script

Per ottenere un OBS autocostruito attivo e funzionante, viene fornito uno script di creazione e creazione di pacchetti predefinito. Questo script richiede solo che Homebrew ( https://brew.sh ) sia già installato sul sistema di compilazione:

  • Per creare OBS così com'è con il supporto completo del browser sorgente, è sufficiente eseguire ./CI/full-build-macos.shdalla directory di checkout (lo script si occuperà di scaricare tutte le dipendenze necessarie).
  • Per creare un app bundle dopo aver creato OBS, esegui lo script con il -bflag:./CI/full-build-macos.sh -b
  • Per creare un'immagine disco dopo aver creato OBS, esegui lo script con il -pflag:./CI/full-build-macos.sh -b -p
  • Per autenticare un app-bundle dopo aver creato e raggruppato OBS, eseguire lo script con il -nflag:./CI/full-build-macos.sh -b -n
  • Per creare un app-bundle senza costruire nuovamente OBS , esegui lo script con il -sflag:./CI/full-build-macos.sh -s -b

L'ultima opzione è utile se cmakesono stati utilizzati flag personalizzati , ma si desidera un app bundle appropriato.

Build personalizzate di macOS

Le configurazioni di build personalizzate richiedono l'installazione di una serie di dipendenze nel sistema di build. Alcune dipendenze devono essere installate tramite Homebrew ( https://brew.sh ):

  • FFmpeg
  • x264
  • cmake
  • freetype
  • mbedtls
  • sorso
  • Qt5

Se hai bisogno del supporto SRT, usa FFmpeg fornito da obs-depso installa FFmpeg da un tocco personalizzato invece dell'homebrew predefinito FFmpeg:

brew tap homebrew-ffmpeg/ffmpeg
brew install homebrew-ffmpeg/ffmpeg/ffmpeg --with-srt

Dipendenze predefinite

Queste dipendenze sono anche disponibili tramite obs-deps( https://github.com/obsproject/obs-deps ) come binari precompilati, che sono garantiti per essere compatibili con il codice OBS corrente (poiché OBS è costruito su versioni specifiche di alcuni pacchetti mentre Homebrew fornisce le build stabili più recenti).

  • Quando si utilizza obs-deps , estrarre entrambi gli archivi dalla versione macOS /tmp/obsdepsper garantire la compatibilità con il raggruppamento delle app in un secondo momento (a causa del modo in cui le dylibs vengono identificate e collegate).
  • Crea una directory di compilazione all'interno della obs-studiodirectory, cambiala, quindi configura il progetto tramite cmake:

    cmake -DCMAKE_OSX_DEPLOYMENT_TARGET=10.13 -DQTDIR="/tmp/obsdeps" -DSWIGDIR="/tmp/obsdeps" -DDepsPath="/tmp/obsdeps" -DDISABLE_PYTHON=ON ..
  • Costruisci OBS eseguendo make.

Configurazione e costruzione

  • Se non è già gestito dall'installazione di Homebrew, installa un SDK della piattaforma macOS corrente (è supportato solo macOS High Sierra 10.13.4 o successivo): xcode-select --install
  • Crea una directory di compilazione all'interno della obs-studiodirectory, cambiala, quindi configura il progetto tramite cmake:

    cmake -DCMAKE_OSX_DEPLOYMENT_TARGET=10.13 -DDISABLE_PYTHON=ON ..
  • NOTA : cmakepotrebbero richiedere parametri aggiuntivi per trovare le Qt5librerie presenti su questo sistema, questo può essere fornito tramite -DQTDIR="/usr/local/opt/qt"o impostando una variabile d'ambiente, ad esempio:export QTDIR=/usr/local/opt/qt
  • Costruisci OBS eseguendo make
  • Esegui OBS dalla /rundir/RelWithDebInfo/bindirectory nella directory di build, eseguendo ./obsda un terminale
  • NOTA : Se si esegue tramite prompt dei comandi, è necessario essere nella directory 'bin' sopra specificato, altrimenti non sarà in grado di trovare i suoi file relativo al binario.

Progetto macOS Xcode

Per creare un progetto Xcode per OBS, cmakedeve essere eseguito con flag aggiuntivi. Segui le istruzioni di compilazione sopra per creare una configurazione di configurazione funzionante, quindi aggiungi -G Xcodeal cmakecomando, ad esempio:

   cmake -DCMAKE_OSX_DEPLOYMENT_TARGET=10.13 -DDISABLE_PYTHON=ON -G Xcode ..

Questo creerà un obs-studio.xcodeprojfile di progetto nella directory di compilazione così come i file di progetto Xcode per tutte le dipendenze di compilazione. Per creare una build macOS completa, è ALL_BUILDpossibile utilizzare la destinazione della build , ma prima deve essere configurata:

  • Seleziona uno ALL_BUILDdegli schemi di compilazione disponibili in Xcode, quindi premi CMD+Bper creare il progetto almeno una volta
  • Quindi selezionare Edit Scheme...dallo stesso menu.
  • Nella Infoscheda, fai clic sul menu a discesa per Executable, quindi fai clic su other.
  • Passa alla /rundir/debug/bincartella bin che il precedente processo di compilazione Xcode avrebbe dovuto creare e seleziona il file obsbinario che si trova lì.
  • Quindi, passa alla Optionsscheda e seleziona la casella Use custom working directorye seleziona la stessa /rundir/debug/bindirectory nella directory di compilazione di Xcode.

NOTA: quando si esegue OBS direttamente da Xcode, tenere presente che le fonti del browser non saranno disponibili (poiché CEF richiede di essere eseguito come parte di un bundle dell'applicazione in macOS) e l'accesso alla webcam provocherà un arresto anomalo (poiché macOS richiede un testo di richiesta di autorizzazione impostato in un bundle dell'applicazione Info.plistche, ovviamente, non è disponibile).

Per eseguire il debug di OBS su macOS con tutti i plug-in e i moduli caricati, segui questi passaggi:

  • Crea (ma non eseguire) OBS con Xcode.
  • Esegui BUILD_DIR="YOUR_XCODE_BUILD_DIR" BUILD_CONFIG="Debug" ../CI/full-build-macos.sh -d -s -bper raggruppare OBS compilato da Xcode, sostituisci YOUR_XCODE_BUILD_DIRcon la directory in cui hai eseguito cmakeper creare il progetto Xcode.
  • Quindi, crea un nuovo progetto Xcode, seleziona macOScome piattaforma e Frameworkcome tipo.
  • Dai al tuo progetto un nome arbitrario e inseriscilo nella cartella che preferisci.
  • Con il nuovo progetto aperto, fai clic sul tuo schema di compilazione corrente in Xcode e seleziona Edit Scheme....
  • Per il Runpassaggio, vai alla Infoscheda e seleziona Other...nel menu a discesa per Executable.
  • Accedi alla directory di compilazione Xcode di OBS e seleziona il OBS.appbundle dell'applicazione creato dallo script.

Ora puoi eseguire OBS con Xcode direttamente collegato come debugger. È possibile eseguire il debug dello stack visivo, nonché tracciare arresti anomali e impostare punti di interruzione.

NOTA: i punti di interruzione impostati nel progetto Xcode effettivo non vengono trasferiti a questo progetto "di supporto" e viceversa.

Linux

Eventuali istruzioni di installazione contrassegnate come non ufficiali non vengono mantenute dall'autore di OBS Studio e potrebbero non essere aggiornate o stabili.

NOTA: OpenGL 3.3 o successivo è necessario per utilizzare OBS Studio su Linux. Puoi verificare quale versione di OpenGL è supportata dal tuo sistema digitando glxinfo | grep "OpenGL"su Terminale.

Istruzioni per l'installazione di Linux

Installazione di Ubuntu / Mint

Tieni presente che OBS Studio non funziona completamente su Chrome OS e funzionalità come Screen e Window Capture non funzionano.

  • Si consiglia xserver-xorg versione 1.18.4 o successiva per evitare potenziali problemi di prestazioni con alcune funzionalità di OBS, come il proiettore a schermo intero.
  • FFmpeg è obbligatorio. Se non hai installato FFmpeg (se non sei sicuro, probabilmente non lo hai), puoi ottenerlo con i seguenti comandi:

    sudo apt install ffmpeg
  • Se desideri il supporto per la fotocamera virtuale, devi installare v4l2loopback-dkms. Puoi installarlo con il seguente comando:
sudo apt install v4l2loopback-dkms
  • Assicurati di aver abilitato il repository multiverse nel centro software di Ubuntu (NOTA: nelle versioni più recenti di Ubuntu, l'aggiunta di un repository automaticamente agli aggiornamenti di apt.) Quindi puoi installare OBS con i seguenti comandi:

    sudo add-apt-repository ppa:obsproject/obs-studio
    sudo apt update
    sudo apt install obs-studio

Installazione di Arch Linux (non ufficiale)

  • La versione "Release" è disponibile nel repository della community:
    sudo pacman -S obs-studio
  • La versione "Git" è disponibile su AUR

Installazione di Manjaro (non ufficiale)

  • Grafica: cerca "obs-studio" su Pamac Manager o Octopi
  • Riga di comando: installalo tramite pacman con il seguente comando:
    sudo pacman -S obs-studio

Installazione di Fedora (non ufficiale)

  • OBS Studio è incluso in RPM Fusion. Se non lo hai configurato (se non sei sicuro, probabilmente non lo hai), puoi farlo con il seguente comando:

    sudo dnf install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm https://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm
  • Quindi puoi installare OBS con il seguente comando (questo estrae tutte le dipendenze, incluso FFmpeg abilitato per NVENC):

    sudo dnf install obs-studio
  • Per la codifica con accelerazione hardware NVIDIA, assicurati di aver installato CUDA:

    sudo dnf install xorg-x11-drv-nvidia-cuda
  • Se hai una carta più vecchia, usa invece questo comando:
    sudo dnf install xorg-x11-drv-nvidia-340xx-cuda

Installazione di OpenMandriva (non ufficiale)

  • OBS Studio è incluso nel repository non libero di OpenMandriva Lx3 e nel repository limitato per la prossima versione di Lx4 - disponibile ora come Cooker.

Per OpenMandriva Lx3

  • Grafica: cerca e installa "obs-studio" su "OpenMandriva Installa e rimuovi software" (Rpmdrake)
  • Riga di comando: installalo come root (su o sudo) tramite terminale / konsole con il seguente comando:

    urpmi obs-studio

Per OpenMandriva Lx4

  • Grafica: cerca e installa "obs-studio" su "OpenMandriva Software Management" (dnfdragora)
  • Riga di comando: installalo come root (su o sudo) tramite terminale / konsole con il seguente comando:

    dnf install obs-studio

Installazione di openSUSE (non ufficiale)

  • Il repository Packman contiene il pacchetto obs-studio poiché richiede
    la versione più completa di FFmpeg che si trova in Packman per motivi legali. Se
    non si dispone già del repository Packman, aggiungerlo come mostrato di seguito.

    • Per openSUSE Tumbleweed:
    sudo zypper ar --refresh --priority 90 http://packman.inode.at/suse/openSUSE_Tumbleweed packman
    • Per openSUSE Leap 15.0:
    sudo zypper ar --refresh --priority 90 http://packman.inode.at/suse/openSUSE_Leap_15.0 packman
    • Per openSUSE Leap 42.3:
    sudo zypper ar --refresh http://packman.inode.at/suse/openSUSE_Leap_42.3 packman
  • Si consiglia di impostare una priorità più bassa per Packman in modo che abbia la
    precedenza sui repository di base (saltare su Tumbleweed come incluso nel comando iniziale).

    sudo zypper mr --priority 90 packman
  • La versione Packman di FFmpeg dovrebbe essere utilizzata per il supporto completo dei codec. Per
    assicurarsi che tutti i pacchetti FFmpeg esistenti siano passati alle versioni Packman,
    eseguire quanto segue prima di installare obs-studio.

    sudo zypper dup --repo packman
  • Installa il pacchetto obs-studio.

    sudo zypper in obs-studio

Collegamenti:


Installazione di Gentoo (non ufficiale)

Riga di comando: può essere installato utilizzando portage con il seguente comando:

sudo emerge media-video/obs-studio

Vedere https://packages.gentoo.org/packages/media-video/obs-studio per le versioni disponibili e ulteriori informazioni.


Installazione di NixOS (non ufficiale)

Riga di comando: può essere installato con il seguente comando:

nix-env -i obs-studio

Vedi https://nixos.org/wiki/OBS per ulteriori istruzioni


Installazione UOS / Deepin (non ufficiale)

È richiesto UOS / Deepin 20 o più recente.

  • Innanzitutto, assicurati di avere tutto aggiornato.

    sudo apt-get update
  • FFmpeg è obbligatorio. Se non hai installato FFmpeg (se non sei sicuro, probabilmente non lo hai), puoi ottenerlo con il seguente comando (o compilarlo da solo):

    sudo apt-get install ffmpeg
  • Infine, installa OBS Studio.

    sudo apt-get install obs-studio
  • o con Spark Store :

    sudo apt install com.obsproject.studio

Installazione Debian / LMDE (non ufficiale)

È richiesta Debian 9.0 o più recente.
Tieni presente che OBS Studio non funziona completamente su Chrome OS e funzionalità come Screen e Window Capture non funzionano.

  • Innanzitutto, assicurati di avere tutto aggiornato.

    sudo apt update
  • FFmpeg è obbligatorio. Se non hai installato FFmpeg (se non sei sicuro, probabilmente non lo hai), puoi ottenerlo con il seguente comando (o compilarlo da solo):

    sudo apt install ffmpeg
  • Infine, installa OBS Studio.

    sudo apt install obs-studio

Installazione nulla (non ufficiale)

  • Per prima cosa assicurati che i tuoi repository siano aggiornati. OBS è disponibile nei multilibrepository se è necessaria la build a 32 bit.

    sudo xbps-install -S
  • Quindi installa OBS Studio. Eventuali dipendenze mancanti verranno installate automaticamente.

    • Se si rifiuta di installarsi, prova prima a eseguire sudo xbps-install -Super aggiornare tutto.
    sudo xbps-install obs

Installazione rapida (non ufficiale)

  • Se non lo hai già fatto, installa snapd (ignora la panoramica del supporto che non è aggiornata).

  • Installa OBS Studio.

    sudo snap install obs-studio

Istruzioni per la compilazione di Linux

Nota: a partire dal 1 maggio 2019, Facebook live ora impone l'uso di RTMPS . Questa funzionalità richiede il pacchetto TLS mbed della tua distribuzione , che lo script obs-studio / cmake / Modules / FindMbedTLS.cmake cerca in fase di compilazione.

Nota: non utilizzare il file .tar sorgente di GitHub poiché non include tutti i file sorgente richiesti. Usa sempre il tag Git appropriato con i sottomoduli associati.

Istruzioni di costruzione basate su Red Hat

  • Ottieni RPM Fusion su http://rpmfusion.org/Configuration/ ( Nux Desktop è un'alternativa che può includere pacchetti migliori per RHEL / CentOS 7)

  • Ottieni i pacchetti richiesti:

    sudo yum install \
          make \
          gcc \
          gcc-c++ \
          gcc-objc \
          cmake \
          git \
          libX11-devel \
          mesa-libGL-devel \
          libv4l-devel \
          pulseaudio-libs-devel \
          speexdsp-devel \
          x264-devel \
          freetype-devel \
          fontconfig-devel \
          libXcomposite-devel \
          libwayland-dev \
          libXinerama-devel \
          qt5-qtbase-devel \
          qt5-qtx11extras-devel \
          qt5-qtsvg-devel \
          libcurl-devel \
          systemd-devel \
          ffmpeg \
          ffmpeg-devel \
          luajit-devel \
          python3-devel \
          mbedtls \
          mbedtls-devel \
          swig
  • Creazione e installazione di OBS:

    • Se si crea con l'origine del browser:

      wget https://cdn-fastly.obsproject.com/downloads/cef_binary_4280_linux64.tar.bz2
      tar -xjf ./cef_binary_4280_linux64.tar.bz2
      git clone --recursive https://github.com/obsproject/obs-studio.git
      cd obs-studio
      mkdir build && cd build
      cmake -DUNIX_STRUCTURE=1 -DBUILD_BROWSER=ON -DCEF_ROOT_DIR="../../cef_binary_4280_linux64" ..
      make -j4
      sudo make install
    • Se si costruisce senza l'origine del browser:

      git clone --recursive https://github.com/obsproject/obs-studio.git
      cd obs-studio
      mkdir build && cd build
      cmake -DUNIX_STRUCTURE=1 ..
      make -j4
      sudo make install
  • Per impostazione predefinita, OBS installa le librerie in / usr / local / lib. Per assicurarti che il caricatore possa trovarli lì, crea un file /etc/ld.so.conf.d/local.conf con la singola riga

    
     

    e poi corri

    sudo ldconfig

    Istruzioni per la costruzione di Fedora

    sudo dnf install \
          make \
          gcc \
          gcc-c++ \
          gcc-objc \
          cmake \
          git \
          libX11-devel \
          mesa-libGL-devel \
          libv4l-devel \
          pulseaudio-libs-devel \
          speexdsp-devel \
          x264-devel \
          freetype-devel \
          fontconfig-devel \
          libXcomposite-devel \
          wayland-devel \
          libXinerama-devel \
          qt5-qtbase-devel \
          qt5-qtbase-private-devel \
          qt5-qtx11extras-devel \
          qt5-qtsvg-devel \
          qt5-qtwayland-devel \
          libcurl-devel \
          systemd-devel \
          ffmpeg \
          ffmpeg-devel \
          luajit-devel \
          python3-devel \
          mbedtls \
          mbedtls-devel \
          swig
  • Creazione e installazione di OBS:

    • Se si crea con l'origine del browser:

      wget https://cdn-fastly.obsproject.com/downloads/cef_binary_4280_linux64.tar.bz2
      tar -xjf ./cef_binary_4280_linux64.tar.bz2
      git clone --recursive https://github.com/obsproject/obs-studio.git
      cd obs-studio
      mkdir build && cd build
      cmake -DUNIX_STRUCTURE=1 -DBUILD_BROWSER=ON -DCEF_ROOT_DIR="../../cef_binary_4280_linux64" ..
      make -j$(nprocs)
      sudo make install
      sudo echo "/usr/local/lib" >> /etc/ld.so.conf.d/local.conf
      sudo ldconfig
    • Se si costruisce senza l'origine del browser:

      git clone --recursive https://github.com/obsproject/obs-studio.git
      cd obs-studio
      mkdir build && cd build
      cmake -DUNIX_STRUCTURE=1 ..
      make -j$(nprocs)
      sudo make install
      sudo echo "/usr/local/lib" >> /etc/ld.so.conf.d/local.conf
      sudo ldconfig

Istruzioni di compilazione basate su Debian

  • Ottieni i pacchetti richiesti:

    sudo apt-get install \
              build-essential \
              checkinstall \
              cmake \
              git \
              libmbedtls-dev \
              libasound2-dev \
              libavcodec-dev \
              libavdevice-dev \
              libavfilter-dev \
              libavformat-dev \
              libavutil-dev \
              libcurl4-openssl-dev \
              libfdk-aac-dev \
              libfontconfig-dev \
              libfreetype6-dev \
              libgl1-mesa-dev \
              libjack-jackd2-dev \
              libjansson-dev \
              libluajit-5.1-dev \
              libpulse-dev \
              libqt5x11extras5-dev \
              libspeexdsp-dev \
              libswresample-dev \
              libswscale-dev \
              libudev-dev \
              libv4l-dev \
              libvlc-dev \
              libwayland-dev \
              libx11-dev \
              libx264-dev \
              libxcb-shm0-dev \
              libxcb-xinerama0-dev \
              libxcomposite-dev \
              libxinerama-dev \
              pkg-config \
              python3-dev \
              qtbase5-dev \
              qtbase5-private-dev \
              libqt5svg5-dev \
              swig \
              libxcb-randr0-dev \
              libxcb-xfixes0-dev \
              libx11-xcb-dev \
              libxcb1-dev \
              libxss-dev
  • Creazione e installazione di OBS:

    • Se si crea con l'origine del browser:

      apt install libnss3-dev
      wget https://cdn-fastly.obsproject.com/downloads/cef_binary_4280_linux64.tar.bz2
      tar -xjf ./cef_binary_4280_linux64.tar.bz2
      git clone --recursive https://github.com/obsproject/obs-studio.git
      cd obs-studio
      mkdir build && cd build
      cmake -DUNIX_STRUCTURE=1 -DCMAKE_INSTALL_PREFIX=/usr -DBUILD_BROWSER=ON -DCEF_ROOT_DIR="../../cef_binary_4280_linux64" ..
      make -j4
      sudo checkinstall --default --pkgname=obs-studio --fstrans=no --backup=no --pkgversion="$(date +%Y%m%d)-git" --deldoc=yes
    • Se si costruisce senza l'origine del browser:
    git clone --recursive https://github.com/obsproject/obs-studio.git
    cd obs-studio
    mkdir build && cd build
    cmake -DUNIX_STRUCTURE=1 -DCMAKE_INSTALL_PREFIX=/usr ..
    make -j4
    sudo checkinstall --default --pkgname=obs-studio --fstrans=no --backup=no --pkgversion="$(date +%Y%m%d)-git" --deldoc=yes

Istruzioni per la costruzione di openSUSE

  • Vedere le istruzioni di installazione di openSUSE (sopra) per i dettagli sull'aggiunta del repository Packman.

  • Installa le dipendenze di compilazione:

    sudo zypper in cmake \
                fontconfig-devel \
                freetype2-devel \
                gcc \
                gcc-c++ \
                libcurl-devel \
                ffmpeg2-devel \
                libjansson-devel \
                libpulse-devel \
                libspeexdsp-devel \
                libqt5-qtbase-devel \
                libqt5-qtx11extras-devel \
                libudev-devel \
                libv4l-devel \
                libXcomposite-devel \
                libXinerama-devel \
                libXrandr-devel \
                luajit-devel \
                mbedtls \
                swig \
                python3-devel \
                libxss-dev
  • Creazione e installazione di OBS:

    • Se si crea con l'origine del browser:

      wget https://cdn-fastly.obsproject.com/downloads/cef_binary_4280_linux64.tar.bz2
      tar -xjf ./cef_binary_4280_linux64.tar.bz2
      git clone --recursive https://github.com/obsproject/obs-studio.git
      cd obs-studio
      mkdir build && cd build
      cmake -DUNIX_STRUCTURE=1 -DCMAKE_INSTALL_PREFIX=/usr -DBUILD_BROWSER=ON -DCEF_ROOT_DIR="../../cef_binary_4280_linux64" ..
      make -j4
      sudo make install
    • Se si costruisce senza l'origine del browser:

      git clone --recursive https://github.com/obsproject/obs-studio.git
      cd obs-studio
      mkdir build && cd build
      cmake -DUNIX_STRUCTURE=1 -DCMAKE_INSTALL_PREFIX=/usr ..
      make -j4
      sudo make install

Modalità portatile Linux (tutte le distribuzioni)

  • Nota che devi installare le dipendenze di build per la tua distribuzione prima di seguire questi passaggi. Vedi sopra.

  • È possibile creare in modalità portatile su Linux, che installa tutti i file in una directory isolata.

    • Se si crea con l'origine del browser:

      wget https://cdn-fastly.obsproject.com/downloads/cef_binary_4280_linux64.tar.bz2
      tar -xjf ./cef_binary_4280_linux64.tar.bz2
      git clone --recursive https://github.com/obsproject/obs-studio.git
      cd obs-studio
      mkdir build && cd build
      cmake -DUNIX_STRUCTURE=0 -DCMAKE_INSTALL_PREFIX="${HOME}/obs-studio-portable" -DBUILD_BROWSER=ON -DCEF_ROOT_DIR="../../cef_binary_4280_linux64" ..
      make -j4 && make install
    • Se si costruisce senza l'origine del browser:

      git clone --recursive https://github.com/obsproject/obs-studio.git
      cd obs-studio
      mkdir build && cd build
      cmake -DUNIX_STRUCTURE=0 -DCMAKE_INSTALL_PREFIX="${HOME}/obs-studio-portable" ..
      make -j4 && make install
  • Dopodiché, dovresti avere un'installazione portatile in ~/obs-studio-portable. Passa a bin/64bito bin/32bite quindi esegui semplicemente:./obs

FreeBSD

Installazione di FreeBSD (non ufficiale)

  • Installa OBS Studio:

    pkg install obs-studio

Istruzioni per la costruzione di FreeBSD

  • Il modo più semplice per creare OBS Studio dai sorgenti è usare i port di FreeBSD e modificare il multimedia/obs-studioport in base alle tue esigenze.

  • Per prima cosa devi configurare l'infrastruttura delle porte sul tuo sistema. Vedi il relativo capitolo nel Manuale di FreeBSD .

  • Una volta che hai il tuo albero dei port, /usr/portspuoi modificare il multimedia/obs-studioport come preferisci . Quindi, puoi creare e installare il port con:

    cd /usr/ports/multimedia/obs-studio
    make install clean