Compile UltraGrid (Source)

Martin Pulec edited this page Feb 14, 2019 · 29 revisions

For source distribution, you have to compile UltraGrid by yourself. Prior to compiling UltraGrid, you need to satisfy dependencies for individual modules you want to compile with UltraGrid.

Instructions for the setting of optional modules and UltraGrid itself are listed below.

Table of Contents

Prerequisites

Windows

For compilation under Windows, you will need to use MinGW or MinGW-w64 (the latter one is recommended). Visual Studio with MSVC will not run out-of-box. Strongly recommended is the use of MSYS2 environment (although not necessary). Windows implementation of pthreads is also needed.

Build environment

If you do not have pregenerated “configure” script in you sources (eg. in a release), you will need to have autoconf and automake.

You generally do not need pkg-config for Windows. But if you want to regenerate a configure script (or generate if building from GIT), you will need at least pkg.m4 macro (can be grabbed from pkg-config sources) to autoconf run smoothly. Place it to <path_to_aclocal_binary>/../share/aclocal/.

Building libraries

In following sections, we assume that you install libraries into /mingw or /mingw/i686-w64-mingw32. This is fine because the preprocessor/compiler/linker can find it easily there. On the other hand, you slightly contaminate your MinGW installation. There is one alternative - to install custom packages into /usr/local as it is on Unix-based systems. MSys maps this somewhere to its directory tree and takes care of translation to native path when invoking a non-MSys command (eg. compiler). Then you can use –prefix=/usr/local when building packages. You may also need some (or all) of these environment variables adjusted:

 export PATH=/usr/local/bin`[ -n "$PATH" ] && echo :$PATH`
 export CPATH=/usr/local/include`[ -n "$CPATH" ] && echo :$CPATH`
 export LIBRARY_PATH=/usr/local/lib`[ -n "$LIBRARY_PATH" ] && echo :$LIBRARY_PATH`

CUDA

You will need to add path to your Visual Studio installation to your path, eg. something like the following (VS 2012):

 PATH=$PATH:/c/Program\ Files\ \(x86\)/Microsoft\ Visual\ Studio\ 11.0/Common7/Tools:/c/Program\ Files\ \(x86\)/Microsoft\ Visual\ Studio\ 11.0/Common7/IDE:/c/Program\ Files\ \(x86\)/Microsoft\ Visual\ Studio\ 11.0/VC/bin

Furthermore, you need to have nvcc (CUDA compiler) in your path (usually already so, if not, add it).

macOS

On macOS you need to have Xcode with command line tools (need to be installed separately). Highly recommended is also to install MacPorts.

If you compile from GIT, that doesn't the configure script, you need additional dependencies (can be installed via MacPorts):

 sudo port install autoconf automake pkgconfig libtool

Linux

For Linux build you generally need working build environment, eg. for Debian/Ubuntu:

 sudo apt install build-essential

To be able to build from GIT (that doesn't have generated configure script), you also need:

 sudo apt install autoconf automake pkg-config libtool # Ubuntu, Debian

and of course if you are cloning from GIT:

 sudo apt install git

Module requirements

If applicable, requirements are in pkg-config compatible format.

Module Required libraries Ubuntu packages Fedora packages Notes Non-free*
Cineform Cineform SDK Requires cmake no
Conference OpenCV libopencv-dev opencl-devel no
DVS DVS SDK yes
DeckLink DesktopVideo DesktopVideo is not needed for UltraGrid compilation (only for drivers)
BitFlow BitFlow SDK yes
Bluefish444 bluefish444 SDK yes
DELTACAST VideoMasterHD SDK yes
SDL sdl2 | sdl >= 1.2.14 libsdl2-dev | libsdl1.2-dev SDL2-devel | SDL-devel
RTSP glib-2.0 >= 2.24.1 libcurl libglib2.0-dev libcurl4-nss-dev libcurl-devel glib2-devel
RTSP server live555 liblivemedia-dev
resize opencv libopencv-dev opencv-devel
GL glew GLUT gl libglew-dev freeglut3-dev libgl1-mesa-dev mesa-libGL-devel freeglut-devel glew-devel
swmix gl libgl1-mesa-dev
screen none (OSX) x11 (Linux) libx11-dev
RTDXT gl libgl1-mesa-dev
UYVY CUDA nvidia-cuda-toolkit
JPEG libgpujpeg (submodule of UltraGrid, see below)
CUDA DXT CUDA nvidia-cuda-toolkit
JPEG to DXT CUDA libgpujpeg nvidia-cuda-toolkit (libgpujpeg not available in Ubuntu repositories)
Comprimato J2K UltraJ2K expects libs/headers in common path yes
SAGE SAGE libraries
Portaudio portaudio-2.0 portaudio19-dev portaudio-devel
JACK transport jack libjack-jackd2-dev jack-audio-connection-kit-devel
JACK audio driver jack libjack-jackd2-dev jack-audio-connection-kit-devel
ALSA alsa libasound-dev alsa-lib-devel
scale gl libgl1-mesa-dev
V4L2 libv4l2 libv4lconvert libv4l-dev libv4l-devel
libavcodec libavcodec libavutil libavcodec-dev libavutil-dev ffmpeg-devel
OpenSSL crypto (OpenSSL) libssl-dev openssl-devel
quicktime QuickTime Framework (preinstalled in OS X) disabled by default, use AV Foundation if possible (Quicktime can be enabled only in 32-bit builds)
avfoundation AV Foundation Kit Framework (preinstalled in OS X)
NDI NDI SDK expects libs/headers in common path yes
Qt GUI Qt5 qtbase5-dev

* For modules marked as a non-free you shall obtain SDK from vendor by yourself.

Modules

AJA

Linux

In order to use AJA cards with native API, you have to have obtained SDK from AJA called NTV2. More specific, file libajantv2.a need to be compiled. Also, set environment variable AJA_DIRECTORY to path to SDK location:

 cd ~/ntv2sdklinux_14.2.0.6/ajalibraries/ajantv2
 make

You may want to also build a driver:

 cd ~/ntv2sdklinux_14.2.0.6/ajadriver/linux
 make

Kernel object is not installed into the kernel tree by default, so you may want to load the driver prior its use:

 cd ~/ntv2sdklinux_14.2.0.6/bin && ./load_ajantv2

Note: You should use the same C++ ABI for compilation of AJA libraries and UltraGrid itself (clang++ sometimes adds C++ 11 ABI version info into mangled symbol while GCC does not indicate ABI version explicitly).

Then, define AJA_DIRECTORY environment variable pointing to path to the SDK to tell UltraGrid configure, where to find the SDK, eg.:

 export AJA_DIRECTORY=/home/ultragrid/ntv2sdklinux

macOS

Go to <ntv2_dir>/ajalibraries/ajantv2/build. In ajantv2.xcodeproj/project.pbxproj replace (all occurences) of

 CLANG_CXX_LIBRARY = "libstdc++";

to

 CLANG_CXX_LIBRARY = "libc++";

Then

 xcodebuild -project ajantv2.xcodeproj
 sudo cp ../../../bin/ajantv2.dylib /usr/local/lib/libajantv2.dylib
 sudo ln -s /usr/local/lib/libajantv2.dylib /usr/local/lib/ajantv2.dylib

And set AJA_DIRECTORY to your NTV2SDK, eg.:

 export AJA_DIRECTORY=/Users/toor/ntv2sdkmac_13.0.0.79b79

Then you should be able to configure and compile UltraGrid with AJA support:

 ./autogen.sh --enable-aja

BitFlow

Following instructions applies currently to Linux only.

You need to have BitFlow SDK. Assuming you installed the SDK into /bitflow, you need also camera file (bfml XML file) for you camera copied to /bitflow/camf. The camera file contains couple of regimes. You need also to set appropriate camera file in configuration file to your grabber file /bitflow/config/<name>. Information about present framegrabbers can be obtained with:/bitflow/src/CIexample -i.

Driver can be compiled from /bitflow/drv. You may also want to copy the compiled bitflow.ko to module tree (directory /lib/modules/$(uname -r)) and run depmod in order the dependencies to be satisfied automatically. You may also needed to run "modprobe bitflow" manually.

In order to bitflow work properly, you need to set paths to (assuming instalation in /bitflow):

 export BITFLOW_INSTALL_DIRS=/bitflow\;/bitflow/flash\;/bitlow/camf

UltraGrid needs header files to be present in source directory as bitflow, so you just need to copy them. Libraries should be located somewhere UltraGrid can find them (eg. /usr/local/lib):

 cp -r /bitflow/inc <path_with_ug_sources>/bitflow
 cp /bitflow/64b/lib/* /usr/local/lib

If all of above is done, you should be able to build and run UltraGrid with bitflow, bitflow support has to be enabled explicitly:

 ./autogen.sh --enable-bitflow && make
 ./bin/uv -t bitflow

Bluefish 444

You will need Bluefish 444 SDK for in your system.

Linux

Extract the archive and then execute following command in extracted directory:

 cd apis/BlueVelvet
 make install
 cd ../BlueHancUtils
 make install

Then export path to the the SDK directory, eg.:

 export BLUE_LATEST_SDK=$HOME/EpochLinuxDriver_V5_11_0_19

After that, UltraGrid configure script should report support for BlueFish cards.

Conference

For video-conferencing mode you need to have OpenCV installed.

For CUDA-accelerated OpenCV build, follow instructions here:

 cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D INSTALL_C_EXAMPLES=ON -D INSTALL_PYTHON_EXAMPLES=ON -D BUILD_EXAMPLES=ON -D WITH_QT=ON -D WITH_OPENGL=ON -D ENABLE_FAST_MATH=1 -D CUDA_FAST_MATH=1 -D WITH_CUBLAS=1 ..

DELTACAST

Linux and Windows

  • download SDK from DELTACAST download center
  • extract it to directory of your choice, eg. $HOME/VideoMasterHD
  • install libraries:
 make -C $HOME/VideoMasterHD/Library/VideoMasterHD/x64 install
 make -C $HOME/VideoMasterHD/Library/VideoMasterHD_Audio/x64 install
 make -C $HOME/VideoMasterHD/Library/VideoMasterHD_SP/x64 install # if present
  • install drivers:
 # for HDMI devices and newer SDI devices
 make -C $HOME/VideoMasterHD/Drivers/X300/x64
 make -C $HOME/VideoMasterHD/Drivers/X300/x64 install
 # for older SDI devices
 make -C $HOME/VideoMasterHD/Drivers/HD/x64
 make -C $HOME/VideoMasterHD/Drivers/HD/x64 install
 # for DVI
 make -C $HOME/VideoMasterHD/Drivers/DVI/x64
 make -C $HOME/VideoMasterHD/Drivers/DVI/x64 install
  • finally, let UltraGrid know where is the SDK, you can do it this way:
 export DELTACAST_DIRECTORY=$HOME/VideoMasterHD
  • then, you can configure UltraGrid and DELTACAST support should be detected automatically

DKMS

In Linux you may wish to create a DKMS to allow automatical drivers build with new kernels.

OS X

Install VideoMasterHD SDK downloaded from DELTACAST download center. UltraGrid should recognize the framework and add support for DELTACAST automatically

GL Display

Linux

You will need GLUT (preferably freeglut) and GLEW packages including headers installed on your system.

Windows

Download freeglut and GLEW sources and compile and install it as usual. With GLEW, you will need to specify install location for GLEW:

 export GLEW_DEST=/mingw/
 make install

Note: You can also use a MSYS2 package.

JPEG

Obtaining CUDA

For JPEG compression you will need to have CUDA-capable NVidia card (a reasonably recent one, GeForce 4XX or better). You will also need NVIDIA drivers and Cuda Toolkit, both can be obtained from NVidia web pages or with distro packages

Compiling GPUJPEG library

GPUJPEG sources are distributed as a submodule within UltraGrid GIT, run following command to fetch current version:

 git submodule update --init

The same command can be then use to update GPUJPEG to latest version referenced by UltraGrid.

Official repository of GPUJPEG can be found here here. (UltraGrid submodule is tracked from there.)

OS X and Linux

Enter the GPUJPEG directory and compile the library.

 cd gpujpeg
 ./autogen.sh
 make 
 make install

You may wish to also run ldconfig. Then you can configure UltraGrid as usual.

Note: On OS X there is sometimes needed to provide manually PKG_CONFIG/PKG_CONFIG_PATH, so you can add following to your .profile file:

 export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig 
 export PKG_CONFIG=/opt/local/bin/pkg-config #assuming you have pkg-config from MacPorts

Windows

Open a gpujpeg project (inside UltraGrid source tree) in Visual Studio and build the library (target Release). No further steps need to be be done.

Configuring UltraGrid

UltraGrid configuration script expects that CUDA Toolkit installation is located in /usr/local/cuda (default). If so, no other action is required. If it is located in other place, you can pass its directory to UltraGrid configuration script with –with-cuda=<dir> parameter. Eg.:

 ./autogen.sh --with-cuda=/opt/cuda/

You should verify if JPEG is going to be compiled from the script output. Look for line like this:

Configuration summary:
<--- output omitted -->
JPEG ........................ yes
<--- output omitted -->
If you have supported NVidia Toolkit and have passed its output to the script (if needed) and you still don’t see JPEG support enabled, consider reporting a bug.

Libavcodec

Linux

For standard featured FFMPEG, you can use package from your distribution (including headers, eg. libavcodec-dev in Debian/Ubuntu). If you want to enable NVENC or another optional feature, you will need to build FFMPEG from source (see below).

OS X

Recommended way is to obtain libavcodec from MacPorts:

 sudo port install ffmpeg-devel

Or, to have most complete installation, you can better use

 sudo port install ffmpeg-devel +universal +gpl2 +gpl3 +nonfree
  • adjust PKG_CONFIG_PATH and PKG_CONFIG environment variables, eg. by adding following line to ~/.profile (assuming default MacPorts location):
 export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/opt/local/lib/pkgconfig
 export PKG_CONFIG=/opt/local/bin/pkg-config
  • after these steps, UltraGrid configure script should detect libavcodec and compile support for it.

Windows

FFMPEG

Download buids from this page, select LGPL Dev and Shared version for 32-bit Windows. Copy files from Dev in include, lib to appropriate /usr/local directories. From Shared, copy from bin DLL files to path visible to uv.exe binary (that is eg /usr/local/bin or to a directory where is UltraGrid executable)

From Source

You can use latest version of FFMPEG to configure custom codecs or utilize most recent features of libavcodec. In this case:

 git clone git://source.ffmpeg.org/ffmpeg.git

Recommended configuration options include these (all platforms, leads to GPL build):

 ./configure --enable-gpl --enable-libx264 --enable-libopus

HEVC

Additionally, you may want to add support for HEVC:

 ./configure ... --enable-libx265

(you may want to download x265 from https://github.com/videolan/x265.git)

NVENC

Clone this GIT: https://git.videolan.org/git/ffmpeg/nv-codec-headers.git

Then install it:

 make
 make install
  • Then enable support for NVENC in FFMPEG:
 ./configure ... --enable-nonfree --enable-nvenc

Intel Quick Sync Video

Note: Following setup is not tested yet. For installation and requirements, please refer here.

  • Download Intel Media Server Studio (or Intel Media SDK for Windows).
  • from the download archive, install SDK - supposing it gets installed to /opt/intel/mediasdk, remove distribution-sticked VA and DRM libs and install them from SDK.
  • run:
 sudo ln -s /opt/intel/mediasdk/lib/lin_x64/libmfx.a /usr/local/lib
 sudo ln -s /opt/intel/mediasdk/include /usr/local/include/mfx
  • create file /usr/local/lib/pkgconfig/libmfx.pc with following contents

    prefix=/opt/intel/mediasdk exec_prefix=<math display="inline">{prefix} libdir=</math>{exec_prefix}/lib includedir=<math display="inline">{prefix}/include Name: libmfx Description: Intel Media SDK Version: 2015R6 Libs: -L</math>{libdir} -lmfx -lstdc++ -lva-drm -lva  -lva-x11 -lva  Libs.private: Cflags: -I${includedir}

Configure FFMPEG with following flag:

 ./configure --enable-libmfx --extra-libs="-ldl"

Build

Then build and install it as usual:

 make && sudo make install

Cineform

First you need to init and update git submodules

 git submodule init && git submodule update

Linux & MacOS

Before building Ultragrid you need to build the static Cineform library. You may need to install uuid-dev package for this to work.

 cd cineform-sdk/ && cmake . && make CFHDCodecStatic

If the compilation succeeds the file libCFHDCodec.a should appear in the cineform-sdk directory. After this, you can compile Ultragrid with

 ./autogen --enable-cineform && make

Windows

On Windows Cineform needs to be compiled as a dynamic library with MSVC. For this you need to install CMake and Visual Studio (tested on 2017).

The first step is to open CMake select the cineform-sdk as the source and build folders. Then press the Configure button and select Visual Studio 15 2017. After that you need to uncheck the BUILD_STATIC option and press Generate.

You can then press the Open Project button to launch Visual Studio. If you want to build Ultragrid as a 64-bit binary you need to also build Cineform as 64-bit. To do this you need to right-click on CFHDCodecShared in Solution Explorer and select Properties then Configuration Manager -> Active solution platform -> new. Here we select x64 and copy settings from Win32. Then we select Release configuration. Then in Linker -> All options we need to replace /machine:X86 in Additional options with /machine:x64. Finally we can build CFHDCodecShared solution.

This should result in CFHDCodec.lib in cineform-sdk/Release/ and CFHDCodec.dll in cineform-sdk/x64/Release/

After this you can compile Ultragrid with the --enable-cineform option. Keep in mind that you need to have the CFHDCodec.dll in PATH or in the executable directory.

MSYS2 or cmd/PS

From the MSYS2 environment, the project can be build with following commands. Similarly this commands can be used in a normal Windows command-line shell (Command Prompt or PowerShell) only by substituting path separators.

 /c/Program\ Files/CMake/bin/cmake -DBUILD_STATIC=false -G "Visual Studio 15 2017" -A x64 .
 /c/Program\ Files\ \(x86\)/Microsoft\ Visual\ Studio/2017/Community/MSBuild/15.0/Bin/MSBuild.exe CineFormSDK.sln -property:Configuration=Release

PortAudio

General

To use Portaudio, you will need Portaudio library installed inside your system including headers. When recognize with configure script, Portaudio support will be automatically added.

Please note that PortAudio v19 is needed, some Linux distributions still stick with v18 only but they usually provide package for newer version (eg. Ubungu package portaudio19-dev).

Windows

Download PortAudio, configure it and install:

 cd portaudio
 # you may also use wasapi, which is, however, much less tested
 ./configure --prefix=/usr/local --enable-shared --disable-static --with-winapi=wmme 
 make && make install

Default Windows Portaudio backend is MME but WDM also works. WASAPI looks currently (stable build from 2016) defunct for capture (although it compiles). See also here.

DirectSound and ASIO APIs are also available. You can use multiple APIs within one build.

Then you can configure and compile UltraGrid as usual. Finally, copy PortAudio dll into location where resides UG binary:

 cp /usr/local/bin/libportaudio-2.dll bin

ASIO

Use these instructions to build PortAudio with ASIO backend. When compiled, the resulting dll can replace the one with different backend. You can also link UltraGrid directly with the dll, in that case (assuming MSYS build environment):

  1. copy dll to /usr/local/bin and lib to /usr/local/lib
  2. copy contents of include subdirectory to /usr/local/include
  3. modify UltraGrid configure.ac not to use pkg-config (or supply appropriate .pc file by yourself)

WASAPI

You may need to patch file src/hostapi/wasapi/pa_win_wasapi.c if build with MinGW (as for version current stable version pa_stable_v190600_20161030):

 58d57
 < #if defined(_MSC_VER) && (_MSC_VER >= 1400)
 65c64
 < 	#include <functiondiscoverykeys.h>
 ---
 > 	//#include <functiondiscoverykeys.h>
 68d66
 < #endif
 72a71,73
 > #include <setupapi.h>
 > #include <initguid.h>
 > #include <Functiondiscoverykeys_devpkey.h>

Configure UltraGrid

To assure PortAudio compilation, run UltraGrid configure script with argument –enable-portaudio:

 ./configure --enable-portaudio

QuickTime

QuickTime capture/display module is disabled in 64-bit UltraGrid builds (default in UltraGrid 1.3 and further). To enable it use following commands:

 export CFLAGS='-m32'
 export CXXFLAGS='-m32'
 export NVCCFLAGS='-m32'
 export LDFLAGS='-m32'
 ./configure --enable-quicktime

Note: Some features may be unavailable in 32-bit UltraGrid builds, eg. CUDA Toolkit is available only in 64-bit flavor (you can disable explicitly UltraGrid CUDA code with –disable-cuda configure option).

RTSP client/server

RTSP client (Linux)

On Ubuntu, you need to install libcurl4-dev (or equivalent on other distros).

RTSP server

You will need older version of live555, eg. from https://github.com/xanview/live555/, you will need commit 35c375 (Bump to 2015.08.07). If you install it, you can reconfigure ultragrid with:

 --enable-rtsp-server --with-live555=/usr/local

SAGE

Setup SAGE

If you have a working version of SAGE client already present on your computer, you can link it with Ultragrid upon configuration. Otherwise you can download and compile it using the manual below.

Configuring UltraGrid with SAGE suppport

You can configure UltraGrid to use SAGE client library by adding the parameter --with-sage=<path> to the configuration script of ultragrid:

 ./configure --with-sage=/home/sageuser/sage3.0

Compiling SAGE client

To compile a SAGE client, download it from here and save it to the UltraGrid root directory.

Note: Since UltraGrid has the name pre-set statically, make sure the directory you created is named "sage3.0". The other option is to use --with-sage=<dir>

Enter the directory and compile SAGE library:

 cd sage3.0 && make

Running

To be able to use the SAGE display, you need to run from a directory, where is placed SAGE application configuration file. The configuration file must be named “ultragrid.conf”.

Syphon

On OS X, you can compile in support for Syphon by downloading and installing framework (to /Library/Frameworks). UltraGrid should be then configured with following option:

 ./configure --enable-syphon

NDI

Linux

Obtain the SDK and run the script:

 ./InstallNDISDK_v3_Linux.sh

which creates you directory "NDI SDK for Linux" after agreeing license. Then copy headers and libs to system path:

 sudo cp -r NDI\ SDK\ for\ Linux/include/* /usr/local/include
 sudo cp -r NDI\ SDK\ for\ Linux/lib/x86_64-linux-gnu/libndi.so /usr/local/lib

After that, UltraGrid should detect installed NDI.

macOS

NDI installes itself to "/NewTek NDI SDK/". In order to avoid troubles I'd recommend to rename it to a name without spaces, eg by replacing them by underscores. Then you need to add headers/libs to your paths:

 export CPATH=${CPATH:+":$CPATH"}:/NewTek_NDI_SDK/include
 export LIBRARY_PATH=${LIBRARY_PATH:+":$LIBRARY_PATH"}/NewTek_NDI_SDK/lib/x64
 export DYLD_LIBRARY_PATH=${DYLD_LIBRARY_PATH:+":$LIBRARY_PATH"}/NewTek_NDI_SDK/lib/x64

UltraGrid then detects NDI automatically.

Note: If you are making a bundle (make bundle or make gui-bundle) it you may want to set EXTRA_LIB_PATH to same content as DYLD_LIBRARY_PATH for dylibbundler to find and bundle the NDI library located in a non-standard path.

Compiling UltraGrid

Once all above is done, based on your preferences, run the configuration script:

 cd ultragrid
 ./autogen.sh

Here you can check whether all the features you have selected were detected and are going to be included. If so, compile UltraGrid:

 make

If no error has occured, the compilation is complete and ultragrid is ready to run.

Bundling

Distributions in macOS and Windows usually includes adding (non-standard) libraries into a bundle (macOS) or a running directory (Windows). Without that, resulting executable may not be portable because of missing dependencies. In Linux the situation is different - you may either distribute either a package or use AppImage. The second variant resembles the remaining 2 platforms.

Linux

Note: further text describes creation of an AppImage. If you do not intend to create that package, you may ignore this part.

First, compile UltraGrid. Although not necessary, it is recommended to use plugins:

 ./autogen.sh --enable-plugins

Then make a directory (AppDir). Use it as a dest dir of make:

 make DESTDIR=<AppDir> install

Copy libraries to <AppDir>/lib (eg. using ldd on uv executable). Do not bundle glibc libraries (eg. listed here) except libnsl.so.1 (which Fedora 28 doesn't distribute by default). You may also consider removing other libraries mentioned at that page.

Create <AppDir>/AppRun, eg.:

 #!/bin/sh
 DIR=`dirname $0`
 export LD_LIBRARY_PATH=$DIR/lib${LD_LIBRARY_PATH:+":$LD_LIBRARY_PATH"}
 $DIR/bin/uv "$@"

Supply icon and .desktop file (can be taken from UltraGrid data directory):

 cp data/ultragrid.png $APPDIR/ultragrid.png
 cp data/uv-qt.desktop $APPDIR/ultragrid.desktop

At last, call appimagetool from AppImageKit to the <AppDir>.

References: 1 2

macOS

On Mac systems, we recommend to create UltraGrid application bundle. UltraGrid itself doesn’t require this, but some drivers (SDL) do. To create a bundle, type

 make bundle

You can also use

 make bundle-nolib

which doesn’t include libraries in that bundle (in that case the bundle won’t probably run on another Mac).

Note: target bundle command requires dylibbundler to be installed, bundle-nolib doesn't.

This creates bundle uv.app. To run UltraGrid from bundle via command-line, use this command:

<path_to>/uv.app/Contents/MacOS/uv [params]

GUI

If you build UltraGrid with GUI, you can use Makefile target gui-bundle (UltraGrid needs to be configured to compile the GUI, see Compile UltraGrid (Source)#QT), which creates an application bundle gui/QT/uv-qt.app. Because this is a normal GUI app, it can be executed normally by clicking in Finder (if moved to Applications).

Furthermore, there exists also a target osx-gui-dmg that creates from the GUI bundle a DMG file.

Note: See also the section GUI if QT was build as a dynamic library (Framework).

Windows

For Windows there exists a script get_dll_depends.sh inside source tree that generates dependencies of a executable and prints them on commandline. Please note that it is tailored to MSYS2 environment - it is a BASH script expecting objdump to be present and uses MSYS/cygwin paths. Intended use is something like:

 for n in `./get_dll_depends.sh "<dir>/uv"`; do
    cp "$n" <dir>
 done

GUI

Use windeployqt to add QT assets.

GUI

QT

Sources for QT GUI are stored in directory gui/QT. To use it, compile UG with GUI support:

 ./autogen.sh --enable-qt

and then:

 make gui/QT/uv-qt

The GUI itself can be built also alone which is, however, not recommended (preview will be disabled):

 gui/QT$ qmake
 gui/QT$ make

When started, the GUI tries to find UltraGrid (uv) executable in system path or application bundle (macOS). Custom location can be provided with --with-uv parameter.

macOS

See QT deployment

You have 2 options from the perspective of distribution the bundle - static and dynamic linking. Static linking works, dynamic was not yet tested.

Dynamic Linking

You may be able to use QT from MacPorts, those are dynamic libraries which impose problems when deploying (UltraGrid Makefile with dylibbundler doesn't handle that) and must be solved manually.

There exists a program macdeployqt (distributed with QT) which should handle the deployment.

TODO: Not tested, ideally this should be added to Makefile. macdeployqt, however, doesn't currently look like to be included in MacPort QT distribution now.

Static Linking

To use static QT, it is needed to be however compiled from source (see Building static QT):

 wget https://download.qt.io/archive/qt/5.11/5.11.2/single/qt-everywhere-src-5.11.2.tar.xz # or use a newer version
 tar xJf qt-everywhere-src-5.11.2.tar.xz
 cd qt-everywhere-src-5.11.2
 ./configure -static -release -nomake examples -opensource -confirm-license -opengl
 make -j 6
 sudo make install

UltraGrid needs to add option --enable-qt-static in order to use correct link flags (otherwise eg. libqtpcre2 may be omitted):

 ./configure --enable-qt --enable-qt-static

Linux

For portable application it is mostly recommended static Qt build (eg. for AppImage) although linuxdeployqt also exists. The procedure is very similar to macOS so see the instructions above. Recommended configure options for Qt are:

 ./configure -static -release -nomake examples -opensource -confirm-license -opengl -no-fontconfig
Clone this wiki locally
You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.
Press h to open a hovercard with more details.