Compilation instructions!  Temporary quick compilation instructions!
Will give better instructions later when things are in a more complete state.

Windows:
  - NOTE: OBS on windows currently requires VS2013, as obs-studio uses C99 and
    C++11.  Express might not be supported at this time (though I'll fix it at
    some point).

  - Clone the repo.  After cloning, run the following git commands:
        git submodule init
        git submodule update
    which will download submodules.

  - Download (or build) development packages of FFmpeg, x264, Qt5.

  - Download windows version of cmake from: http://www.cmake.org/

  - Add windows environment variables:
        FFMpegPath    (path to FFmpeg include directory)
        x264Path      (path to x264 include directory)
        QTDIR         (path to Qt build base directory)

    NOTE: Each of these environment variables can specify 32bit and 64bit by
    appending 32 and 64 to the end of the environment variable names.
    So if you want to separate locations for 32bit or 64bit, you can set:
    FFmpegPath32, FFmpegPath64, x264Path32, x264Path64, QTDIR32, QTDIR64, etc.

    NOTE: These variables are optional and these can be entered in to cmake
    while generating, but having these variables makes life much easier in case
    you need to regenerate your cmake data from scratch for whatever reason.

    NOTE: An example Qt directory you would use here if you installed Qt5 to
    D:\Qt would usually look something like this for the 32bit version:
        D:\Qt\5.3\msvc2013
    And something like this for the 64bit version
        D:\Qt\5.3\msvc2013_64

    NOTE: Search paths and search order for FFmpeg and x264 library/binary
    files, relative to their include directories:

        Library files
          ../lib
          ../lib32 (if 32bit)
          ../lib64 (if 64bit)
          ./lib
          ./lib32 (if 32bit)
          ./lib64 (if 64bit)

        Binary files:
          ../bin
          ../bin32 (if 32bit)
          ../bin64 (if 64bit)
          ./bin
          ./bin32 (if 32bit)
          ./bin64 (if 64bit)

  - Run cmake-gui.  In "where is the source code", enter in the repo directory
    (example: D:/obs).  In "where to build the binaries", enter the repo
    directory path with the 'build' subdirectory (example: D:/obs/build).

    NOTE: The subdirectories 'build', 'release', and 'debug' are meant for
    builds, and are excluded from the repo in .gitignore, so they are safe to
    use for building.

  - Press 'Configure', then enable the COPY_DEPENDENCIES option, then press
    'Configure' again, and then press 'Generate' to generate visual studio
    project files in the 'build' subdirectory.

  - Open obs-studio.sln from the 'build' subdirectory, and it should run and
    be good to go.  All required dependencies should be copied on compile and
    it should be a fully fuctional build environment.


Mac OSX
  - Use macports or homebrew and install FFmpeg, x264, Qt5, and cmake.

    NOTE: Qt5 can also be downloaded/installed via the Qt website, though keep
    in mind that you will have to set the QTDIR environment variable to the
    Qt5 build base directory.

  - Make sure to have the OSX 10.9 or newer SDK installed (comes with recent
    versions of Xcode)

  - In a terminal, go to the obs-studio directory create a 'build' sub
    directory and change to it, then to build, type:

      - on OSX 10.9 or newer:
          cmake .. && make
      - on OSX 10.8:
          MACOSX_DEPLOYMENT_TARGET=10.8 cmake -DCMAKE_OSX_SYSROOT=/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.9.sdk/ .. && make

  - It builds in a modular structure by default.  To run it via terminal, go to
    build/rundir/RelWithDebInfo/bin, then type ./obs to run.

    NOTE: If you are running via command prompt, you *must* be in the 'bin'
    directory specified above, otherwise it will not be able to find its files
    relative to the binary.

  - To create an app bundle instead, use the command: make package
    This will create a .dmg file with an app bundle inside.


Linux (Ubuntu 14.04 installation)
  - FFmpeg is required.  If you do not have the FFmpeg installed (if you're not
    sure, then you probably don't have it), you can get it with the following
    commands:

        sudo add-apt-repository ppa:jon-severinsson/ffmpeg
        sudo apt-get update && sudo apt-get install ffmpeg

  - Then you can install OBS with the following commands:

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


Linux (Arch Linux installation, unofficial)
  - Link:  https://aur.archlinux.org/packages/obs-studio-git


Linux (OpenSUSE installation, unofficial)
  - Link:  http://packman.links2linux.org/package/obs-studio


Linux (Gentoo installation, unofficial)
  - Link:  https://github.com/saintdev/obs-studio-overlay


Linux (Manually compiling on Redhat-based distros such as Fedora)
  - Get RPM fusion at http://rpmfusion.org/Configuration/

  - Set up a build environment:

        sudo yum install gcc gcc-c++ gcc-objc cmake git

  - If you don't care much about FFmpeg features, just get it from RPM fusion:

        sudo yum install ffmpeg-devel

  - Get the required packages:

	sudo yum install libX11-devel libGL-devel ffmpeg-devel libv4l-devel \
                pulseaudio-libs-devel x264-devel freetype-devel \
                fontconfig-devel libXcomposite-devel libXinerama-devel \
                qt5-qtbase-devel qt5-qtx11extras-devel

  - Building and installing OBS:

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


Linux (Manually compiling on Debian-based distros)
  - Set up a build environment:

        sudo apt-get install build-essential pkg-config cmake git checkinstall

  - FFmpeg is required, and not commonly available on debian-based distros.
    If you want a custom compilation with FDK AAC encoder and such, see:

        https://trac.ffmpeg.org/wiki/CompilationGuide

  - Otherwise, I will only give easy and brief instructions for a very minimal
    FFmpeg installation:

        sudo apt-get install zlib1g-dev yasm
        git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
        cd ffmpeg
        ./configure --enable-shared --prefix=/usr
        make -j4
        sudo checkinstall --pkgname=FFmpeg --fstrans=no --backup=no \
                --pkgversion="$(date +%Y%m%d)-git" --deldoc=yes

  - Get the required packages:

        sudo apt-get install libx11-dev libgl-dev libpulse-dev libxcomposite-dev \
                libxinerama-dev libv4l-dev libudev-dev libfreetype6-dev \
                libfontconfig-dev qtbase5-dev libqt5x11extras5-dev libx264-dev \
                libxcb-xinerama0-dev libxcb-shm0-dev

  - Building and installing OBS:

        git clone https://github.com/jp9000/obs-studio.git
        cd obs-studio
        mkdir build && cd build
        cmake -DUNIX_STRUCTURE=1 -DCMAKE_INSTALL_PREFIX=/usr ..
        make -j4
        sudo checkinstall --pkgname=obs-studio --fstrans=no --backup=no \
               --pkgversion="$(date +%Y%m%d)-git" --deldoc=yes


Linux portable mode
  - You can also build in portable mode on Linux, which installs all the
    files to an isolated directory:

        mkdir build && cd build
        cmake -DUNIX_STRUCTURE=0 \
                -DCMAKE_INSTALL_PREFIX="${HOME}/obs-studio-portable" ..
        make -j4 && make install

    After that you should have a portable install in ~/obs-studio-portable
    Change to bin/64bit or bin/32bit and then simply run:  ./obs
