scottk/UltraGrid
1
0
Fork 0
mirror of https://github.com/outbackdingo/UltraGrid.git synced 2026-03-22 04:40:30 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
arm-build
UltraGrid/configure.ac
Martin Pulec 2ee508522b configure: screen: if Linux&req=yes, require x11+PW 
If --enable-screen is used in Linux without specifying explicitly
x11 or pipewire, require both. The user may need to have the PipeWire
implementation and end up with X11 or vice versa.

Also fix the check for implementation - checked X11 only if
--enable-screen=x11 (without PW) and vice versa for Pipewire.  But not
eg. --enable-screen=x11,pipewire.
2026-01-20 10:02:30 +01:00

3743 lines
139 KiB
Plaintext
Raw Permalink Blame History

dnl Process this file with autoconf to produce a configure script.
AC_INIT([UltraGrid],[1.10],[ultragrid-dev@cesnet.cz])
configure_flags="$*"
AC_CANONICAL_TARGET
AM_INIT_AUTOMAKE([1.10])
AC_PREREQ([2.61])
AC_CONFIG_SRCDIR([src/main.cpp])
AC_CONFIG_MACRO_DIR([m4])
PARENT=`echo $PWD | sed -e 's%/[[^/]]*$%%'`
AC_DEFINE_UNQUOTED([CONFIG_FLAGS], ["$configure_flags"], [Flags passed to configure])
AC_CANONICAL_HOST
AC_PROG_CC
AC_PROG_CPP
AC_PROG_CXX
AC_PROG_CXXCPP
AC_PROG_EGREP
AC_PROG_INSTALL
AC_C_CONST
AC_TYPE_SIZE_T
AC_C_BIGENDIAN
AC_C_CHAR_UNSIGNED
AC_SYS_LARGEFILE
PKG_PROG_PKG_CONFIG([], [PKG_CONFIG=])
if test -z "$PKG_CONFIG"; then
PKG_CONFIG=$(command -v pkgconf)
PKG_PROG_PKG_CONFIG
fi
# -------------------------------------------------------------------------------------------------
POST_COMPILE_MSG=""
CXXFLAGS="${CXXFLAGS:+$CXXFLAGS }-std=gnu++17"
CUDA_FLAGS="$CUDA_FLAGS${CUDA_FLAGS:+${CUDAFLAGS:+ }}$CUDAFLAGS"
INC="${INC-}"
LDFLAGS="${LDFLAGS-}"
LIB_MODULES= # modules libraries
UG_LIB_MODULES=
LIB_OBJS= # module object files
UG_LIB_OBJS=
LIBS="${LIBS-}"
MODULES=
OBJS=
TARGETS=
AC_SUBST(INC)
AC_SUBST(LIBS)
AC_SUBST(ULTRAGRID_LIBS)
AC_SUBST(ULTRAGRID_OBJS)
AC_SUBST(POST_COMPILE_MSG)
AC_SUBST(COMMON_FLAGS)
AC_CHECK_SIZEOF([int *])
AC_C_BIGENDIAN(
AC_DEFINE([WORDS_BIGENDIAN], 1, [This is big endian system]),
AC_DEFINE([WORDS_SMALLENDIAN], 1, [This is little endian system])
)
AC_CHECK_SIZEOF([size_t])
if test $ac_cv_sizeof_size_t -eq 8
then
WORD_LEN=64
else
WORD_LEN=32
fi
AC_DEFUN([HM_VERSION_WARNING], [
AC_MSG_WARN([If you still want to try with unsupported version of dependency,
you may want to try --disable-depends-version-check option.
If you find out that some unsupported version is working,
please let us know at ultragrid-dev@cesnet.cz.
])
])
WARNINGS=
# variant of AC_MSG_WARN that in addition stores the message for repost at the end
m4_defun([UG_MSG_WARN], [
AC_MSG_WARN([$1])
WARNINGS="${WARNINGS}$1\n"
])
m4_defun([MY_CHECK_FRAMEWORK],
[AC_CACHE_CHECK([if -framework ]$1[ works],[my_cv_framework_]$1,
[save_LIBS="$LIBS"
LIBS="$LIBS -framework ]$1["
AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
[my_cv_framework_]$1[=yes],
[my_cv_framework_]$1[=no])
])
LIBS="$save_LIBS"
if test "$my_cv_framework_]$1["="yes"; then
AC_DEFINE(AS_TR_CPP([HAVE_FRAMEWORK_]$1),1,
[Define if you have the ] $1 [ framework])
AS_TR_CPP([FRAMEWORK_]$1)="-framework ]$1["
AC_SUBST([FRAMEWORK_]AS_TR_CPP($1))
fi])
AC_MSG_CHECKING([GIT presence])
if which git
then
AC_MSG_CHECKING([checking GIT branch ])
git_branch=$(srcdir=$(dirname "$0"); cd "$srcdir"; git name-rev --name-only HEAD)
if test "$git_branch"; then
AC_DEFINE_UNQUOTED([GIT_BRANCH], "$git_branch", [Current GIT branch])
AC_MSG_RESULT($git_branch);
else
AC_MSG_RESULT(no);
fi
AC_MSG_CHECKING([checking GIT revision ])
git_rev=$(srcdir=$(dirname "$0"); cd "$srcdir"; git rev-parse --short HEAD)
if test "$git_rev"; then
AC_DEFINE_UNQUOTED([GIT_REV], "$git_rev", [Current GIT revision])
AC_MSG_RESULT($git_rev);
else
AC_MSG_RESULT(no);
fi
fi
# TODO: remove plaform macros definitions
AC_MSG_CHECKING([OS family])
if test "$host_vendor" = "apple"; then
system=MacOSX
AC_DEFINE([HAVE_MACOSX], [1], [This is Mac X OS])
APPEXT=.app
elif expr "x$host_os" : "x.*mingw32.*" > /dev/null ||
expr "x$host_os" : "x.*msys.*" > /dev/null || test "$host_os" = cygwin; then
system=Windows
APPEXT=.exe
AC_DEFINE([WIN32], [1], [This is an Windows OS])
elif expr "x$host_os" : xlinux >/dev/null; then
system=Linux
AC_DEFINE([HAVE_LINUX], [1], [This is Linux])
else
system=other
fi
AC_MSG_RESULT($system);
AC_SUBST(system)
if test $build != $host; then
cross_compile=yes # don't confuse with autoconf's $cross_compiling - ours is more correct
# because $cross_compiling=no if we are cross-compiling but are able to
# execute the compiled binary (eg. using wine-binfmt)
else
cross_compile=no
fi
if test $system = Linux; then
AC_CHECK_HEADERS([linux/version.h])
LDFLAGS="$LDFLAGS -Wl,--dynamic-list-data"
COMMON_FLAGS="${COMMON_FLAGS:+$COMMON_FLAGS }-D_GNU_SOURCE"
fi
if test $system = MacOSX; then
MACOS_LEGACY=no
macos_major=$(sw_vers -productVersion | cut -d. -f1)
macos_minor=$(sw_vers -productVersion | cut -d. -f2)
if test ${macos_major?} -eq 10 && test ${macos_minor?} -lt 15; then
MACOS_LEGACY=yes
fi
CFLAGS="$CFLAGS $COMMON_OSX_FLAGS"
CPPFLAGS="$CPPFLAGS $COMMON_OSX_FLAGS"
CXXFLAGS="$CXXFLAGS $COMMON_OSX_FLAGS"
if test $WORD_LEN = 32; then
CUDA_FLAGS="$CUDA_FLAGS -Xcompiler -Wno-error=unused-command-line-argument-hard-error-in-future"
fi
LDFLAGS="$LDFLAGS $COMMON_OSX_FLAGS -headerpad_max_install_names"
OBJS="$OBJS src/utils/macos.o"
AC_SUBST(MACOS_LEGACY)
fi
if test $system = Windows; then
LIBS="$LIBS -lsetupapi -lws2_32 -liphlpapi -lole32 -loleaut32"
LIBS="$LIBS -ldbghelp"
AC_CHECK_FUNCS(SetThreadDescription)
if $CXX -dM -E - </dev/null | grep clang >/dev/null; then
AC_CHECK_PROG([LLD], [lld], [yes])
if test "$LLD" = yes; then
COMMON_FLAGS="${COMMON_FLAGS:+$COMMON_FLAGS }-gcodeview"
UV_LDFLAGS="-fuse-ld=lld -g -Wl,--pdb=bin/uv.pdb"
fi
fi
if ! expr "x$COMMON_FLAGS" : '.*gcodeview' >/dev/null; then
UG_MSG_WARN([Windows stacktrace will not be available.])
fi
fi
LINKER=$CXX
AC_SUBST(LINKER)
AC_SUBST(LDFLAGS)
AC_SUBST(UV_LDFLAGS)
AC_SUBST(CXXFLAGS)
AC_ARG_ENABLE(depends-version-check,
AS_HELP_STRING([--disable-depends-version-check], [Disable libraries version check]),
[version_check=$enableval],
[version_check=yes]
)
build_default=auto
AC_ARG_ENABLE(all,
AS_HELP_STRING([--enable-all], [Enable or disable all features (default is auto)]),
[build_default=$enableval],
[build_default=auto]
)
if test $system = Windows; then
CUDA_FLAGS="$CUDA_FLAGS -Xcompiler -FS -Xcompiler -GS- -Xcompiler -MD"
else
CFLAGS="$CFLAGS -fPIC"
CXXFLAGS="$CXXFLAGS -fPIC"
CUDA_FLAGS="$CUDA_FLAGS -Xcompiler -fPIC"
fi
AC_SUBST(CUDA_FLAGS)
AC_ARG_VAR([ARCH], [Architecture to build for])
if test "${target_cpu?}" = x86_64 || test "${target_cpu?}" = i686
then
ARCH=${ARCH--msse4.1}
fi
if test $target_cpu = armv7l || { test $target_cpu = aarch64 && \
test $ac_cv_sizeof_int_p -eq 4; }
then
LIBS="${LIBS:+$LIBS }-latomic" # needed for atomic_uint64_t
fi
CFLAGS="$CFLAGS${ARCH:+ $ARCH}"
CXXFLAGS="$CXXFLAGS${ARCH:+ $ARCH}"
LDFLAGS="$LDFLAGS${ARCH:+ $ARCH}"
if expr "x$CFLAGS" : 'x.*-O' >/dev/null; then
OFAST=""
else
OFAST="-Ofast"
fi
AC_SUBST(OFAST)
AC_CHECK_HEADERS([termios.h])
# Adds the module to UltraGrid build system.
# @param $1 name of the module, should be in format <class>_<name> unless
# sure that the modular build won't take place
# @param $2 object files
# @param $3 libraries
add_module() {
TARGET=lib/ultragrid/ultragrid_"$1".so
if `echo "$1" | grep -q 'vcompress\|vdecompress\|display_video_mix'`; then
LIB_OBJS="$LIB_OBJS $2"
LIB_MODULES="$LIB_MODULES $3"
else
UG_LIB_OBJS="$UG_LIB_OBJS $2"
UG_LIB_MODULES="$UG_LIB_MODULES $3"
fi
if test -n "$1"; then
MODULES="$MODULES $TARGET"
TARGETS="$TARGETS
$TARGET: $2
\$(MKDIR_P) lib/ultragrid
\$(LINKER) \$(LDFLAGS) -shared -Wl,-soname,ultragrid_$1.so $2 -o lib/ultragrid/ultragrid_$1.so $3
"
fi
}
# ---------------------------------------------------------------------
# Dylib bundler
# ---------------------------------------------------------------------
if test $system = MacOSX; then
AC_PATH_PROGS(DYLIBBUNDLER, dylibbundler, [true])
if test "$DYLIBBUNDLER" = true; then
UG_MSG_WARN([Cannot find dylibbundler. We cannot put libraries into a bundle so it probably will not be portable.])
else
AC_MSG_CHECKING([dylibbundler version])
dyl_ver=$($DYLIBBUNDLER -V >/dev/null 2>&1 && dylibbundler -V | cut -d\ -f2 || echo unknown)
AC_MSG_RESULT($dyl_ver);
if test "x$dyl_ver" = xunknown || test "${dyl_ver%%.*}" -eq 1
then
UG_MSG_WARN([Original dylib bundler detected, recommending v2 instead (https://github.com/SCG82/macdylibbundler)])
else
DYLIBBUNDLER="$DYLIBBUNDLER -f" # bundle also frameworks
fi
fi
fi
AC_SUBST(DYLIBBUNDLER)
# ---------------------------------------------------------------------
# AsciiDoc
# ---------------------------------------------------------------------
AC_PATH_PROGS(A2X, [asciidoctor a2x], [:])
AC_SUBST(A2X)
AC_SUBST(MANPAGES)
man=no
AC_ARG_ENABLE(man, AS_HELP_STRING([--enable-man], [build (default is auto)]
[requires: AsciiDoc/Asciidoctor]),
[req_man=$enableval],
[req_man=$build_default])
if test "$req_man" != no; then
if test "$A2X" != :; then
man=yes
MANPAGES=uv.1
fi
fi
if test "$req_man" = yes && test "$A2X" = :; then
AC_MSG_ERROR([Manual pages generate required, but]
[AsciiDoc/Asciidoctor was not found!])
fi
AC_SUBST(DLL_LIBS)
AC_CHECK_FUNCS(usleep)
# ---------------------------------------------------------------------
# Common shell utility functions
# ---------------------------------------------------------------------
# Be careful about [] m4 processing - either use quadrigraphs or enclose macro with additional []
# remove redundant spaces from argument (multiplied, leading, trailing)
[compact_spaces_pipe() { sed -e 's/ */ /g' -e 's/^ //' -e 's/ $//' ;}]
[compact_spaces() { echo "$1" | compact_spaces_pipe ;}]
# remove "-mwindows" from lib flags obtained with pkg-config
# because it causes output to be scratched by cmd/pwsh (but
# not MSYS2 terminal)
remove_mwindows() {
echo "$1" | sed 's/-mwindows//' | compact_spaces_pipe
}
## ensures that user explicitly requested feature is present, otherwise fail
## @param $1 feature requeseted
## @param $2 feature feature found
## @param $3 error message
AC_DEFUN([ENSURE_FEATURE_PRESENT], [
if { test "$1" != no && test "$1" != auto ;} && test "$2" = no; then
AC_MSG_ERROR([$3]);
fi
])
# -------------------------------------------------------------------------------------------------
# GCC-specific warning flags
if test "$GCC" = yes
then
CFLAGS="$CFLAGS -pipe -W -Wcast-qual -Wcast-align -Wbad-function-cast -Wmissing-prototypes -Wmissing-declarations"
CXXFLAGS="$CXXFLAGS -pipe -W -Wcast-qual -Wcast-align -Wmissing-declarations"
fi
# ------------------------------------------------------------------------------------------------
# Dynamic libraries stuff
#
build_libraries=no
AC_ARG_ENABLE(plugins, AS_HELP_STRING([--enable-plugins], [build modules as libraries (default is off)]),
[build_libraries=$enableval])
if test "$build_libraries" = yes
then
if test "$system" = "Linux"
then
LIBS="$LIBS -ldl"
LDFLAGS="$LDFLAGS -rdynamic"
else
UG_MSG_WARN([Building libraries is not supported with other system than Linux])
build_libraries=no
fi
AC_DEFINE([BUILD_LIBRARIES], [1], [Build drivers as a standalone libraries])
fi
# -------------------------------------------------------------------------------------------------
# Check for libraries
AC_SEARCH_LIBS(socket, socket)
AC_SEARCH_LIBS(inet_addr, nsl)
AC_CHECK_LIB(rt, timer_create)
AC_CHECK_FUNC(sin, MATHLIBS="", MATHLIBS="-lm")
AC_SUBST(MATHLIBS)
# -------------------------------------------------------------------------------------------------
# See if this system supports sched_setscheduler()
use_rt=no
AC_ARG_ENABLE(rt,
AS_HELP_STRING([--enable-rt], [enable RT priority]),
[use_rt=$enableval])
if test "$use_rt" = "yes"; then
AC_CHECK_FUNCS(sched_setscheduler)
AC_DEFINE([USE_RT], [1], [We use RT priority])
fi
# -------------------------------------------------------------------------------------------------
# Try to find the pthread library...
case "$host" in
*-*-*bsd*)
CFLAGS="$CFLAGS -pthread"
;;
*)
AC_CHECK_LIB(pthread, pthread_create, LIBS="$LIBS -lpthread", AC_MSG_ERROR([Require POSIX thread]))
;;
esac
# -------------------------------------------------------------------------------------------------
debug_output=no
profile=no
ipv6=yes
AC_ARG_ENABLE(profile,
[ --enable-profile enable profiling],
[if test $enableval = yes
then
if test "$GCC" = yes
then
CFLAGS="$CFLAGS -pg"
profile=yes
else
AC_MSG_ERROR([Do not know how to enable profiling for $CC])
fi
fi])
AC_ARG_ENABLE(debug,
[ --enable-debug enable debug messages and code],
[if test $enableval = yes
then
AC_DEFINE([DEBUG], [1], [We build with debug messages])
debug_output=yes
fi])
AC_ARG_ENABLE(ipv6,
AS_HELP_STRING([--disable-ipv6], [disable ipv6]),
[if test $enableval = no
then
ipv6=no
fi])
if test "$ipv6" != no
then
AC_DEFINE([HAVE_IPv6], [1], [Enable IPv6 support])
fi
# ----------------------------------------------------------------------
# environment variables
# ----------------------------------------------------------------------
AC_ARG_VAR([AJA_DIRECTORY], [Directory to AJA NTV2 SDK.])
AC_ARG_VAR([BLUE_LATEST_SDK], [Placement of Bluefish444 SDK.])
AC_ARG_VAR([CINEFORM_DIRECTORY], [Directory to Cineform SDK.])
AC_ARG_VAR([CUDA_FLAGS], [Flags to be passed to CUDA compiler, eg. -arch=native; alterntatively CUDAFLAGS])
AC_ARG_VAR([CUDA_PATH], [Directory of your Nvidia toolkit instalation.]dnl
[Alternative: CUDACXX (path to nvcc executable)])
AC_ARG_VAR([DELTACAST_DIRECTORY], [Placement of VideoMasterHD directory (Deltacast).])
AC_ARG_VAR([DVS_DIRECTORY], [Path to DVS installation.])
AC_ARG_VAR([GENICAM_GENTL64_PATH], [XIMEA SDK library path])
AC_ARG_VAR([NTV2_ROOT], [Directory to AJA NTV2 SDK (ends with ntv2projects).])
AC_ARG_VAR([SAGE_DIRECTORY], [Directory of your SAGE installation.])
# ------------------------------------------------
# libbacktrace
# -----------------------------------------------
libbacktrace=no
AC_ARG_ENABLE(libbacktrace,
AS_HELP_STRING([--disable-libbacktrace], [disable libbacktrace]),
[libbacktrace_req=$enableval],
[libbacktrace_req=$build_default])
if test "${libbacktrace_req?}" != no; then
AC_CHECK_HEADER(backtrace.h)
AC_CHECK_LIB(backtrace, backtrace_pcinfo)
if test "${ac_cv_header_backtrace_h?}" = yes && \
test "${ac_cv_lib_backtrace_backtrace_pcinfo?}" = yes;
then
LIBS="$LIBS -lbacktrace"
AC_DEFINE([HAVE_LIBBACKTRACE], [1], [we have libbacktrace])
libbacktrace=yes
fi
fi
ENSURE_FEATURE_PRESENT([$libbacktrace_req], [$libbacktrace],
[libbacktrace not found])
# -------------------------------------------------------------------------------------------------
# CUDA stuff
#
# CUDA compiler choice - defaults to nvcc
#
# CUDA lookup order:
# 1) --with-cuda
# 2) CUDA_DIRECTORY env variable
# 3) CUDA_PATH env variable
# 4) default system path (PATH, LD_LIBRARY_PATH, C_INCLUDE_PATH/CPATH)
# 5) default CUDA path
CUDA_COMPUTE_ARGS=""
CUDA_COMPILER=""
CUDA_INC=
CUDA_LIB=
NVCC=
CUDA_LIB_PATH=
FOUND_CUDA=no
if test -n "$CUDA_DIRECTORY"; then
CUDA_PATH=$CUDA_DIRECTORY
fi
AC_ARG_ENABLE(cuda,
AS_HELP_STRING([--disable-cuda], [disable all CUDA code]),
[cuda_req=$enableval],
[cuda_req=$build_default])
AC_ARG_WITH(cuda,
[ --with-cuda=DIR specify location of CUDA Toolkit],
[CUDA_PATH=$withval
])
if test -n "$CUDA_PATH"; then
CUDA_PATH_SEP="$CUDA_PATH/bin$PATH_SEPARATOR"
fi
if test $cuda_req != no; then
# nvcc is intentional here
AC_PATH_PROG(NVCC, nvcc, [], [$CUDA_PATH_SEP$PATH]dnl
[$PATH_SEPARATOR/opt/cuda/bin$PATH_SEPARATOR/usr/local/cuda/bin])
if test -z "$NVCC" && test -x "$CUDACXX"; then
NVCC=$CUDACXX
fi
fi
if test -n "${NVCC?}" && test "${cross_compile?}" = no && test "${cuda_req?}" != no
then
CUDA_PATH=`dirname "$NVCC"`
CUDA_PATH=`dirname "$CUDA_PATH"`
if test $system = Windows; then
AC_CHECK_PROG([CL], [cl], [cl],
[])
if test -n "$CL"; then
cl_lib_path=$(realpath "$(dirname "$(command -v "$CL")")"/../../../lib/x64)
if test $? -ne 0; then
# MSVS 14.0 has it otherwhere
cl_lib_path=$(realpath "$(dirname "$(command -v "$CL")")"/../lib)
fi
DEFAULT_LIB_P=$($LINKER --verbose 2>&1 | awk \
'BEGIN { ORS="" } /InstalledDir: / { print $2 }')/../lib
CUDA_LIB="${CUDA_LIB:+$CUDA_LIB }-L$DEFAULT_LIB_P"
CUDA_LIB="$CUDA_LIB -L\"$cl_lib_path\""
FOUND_CUDA=yes
fi
else
FOUND_CUDA=yes
fi
AC_MSG_CHECKING([CUDA Toolkit version - major])
nvcc_major=`"$NVCC" --version |grep release|sed 's/^.*release \(@<:@0-9@:>@@<:@0-9@:>@*\).*$/\1/'`
AC_MSG_RESULT($nvcc_major)
AC_MSG_CHECKING([CUDA Toolkit version - minor])
nvcc_minor=`"$NVCC" --version |grep release|sed 's/^.*release @<:@0-9@:>@@<:@0-9@:>@*\.\(@<:@0-9@:>@@<:@0-9@:>@*\).*$/\1/'`
AC_MSG_RESULT($nvcc_minor)
if test "${ac_cv_sizeof_int_p?}" -eq 8 && test "${system?}" = Linux
then
CUDA_LIB_PATH="$CUDA_PATH/lib64"
else
CUDA_LIB_PATH="$CUDA_PATH/lib"
fi
if test $system = Windows; then
CUDA_PATH="\"$CUDA_PATH\""
CUDA_LIB_PATH="\"$CUDA_LIB_PATH\""
if test $WORD_LEN = 64; then
CUDA_LIB_PATH="$CUDA_LIB_PATH/x64"
else
CUDA_LIB_PATH="$CUDA_LIB_PATH/Win32"
fi
fi
CUDA_LIB="${CUDA_LIB:+$CUDA_LIB }-L$CUDA_LIB_PATH -lcudart"
CUDA_INC="-I$CUDA_PATH/include"
CUDA_COMPILER="$NVCC"
INC="$INC $CUDA_INC"
if test $system = MacOSX; then
LDFLAGS="$LDFLAGS${LDFLAGS:+ }-rpath $CUDA_LIB_PATH"
DYLIBBUNDLER_FLAGS="${DYLIBBUNDER_FLAGS:+$DYLIBBUNDLER_FLAGS }-s $CUDA_LIB_PATH"
fi
fi
AC_SUBST(DYLIBBUNDLER_FLAGS)
# Pick compiler for cuda device code
AC_ARG_WITH(cuda-compiler,
AS_HELP_STRING([--with-cuda-compiler=compiler], [select compiler to compile cuda code with; suported: clang, nvcc; default: nvcc]),
[CUDA_COMPILER="$withval"],
[])
HOST_CC_REPORT=" ("
case "$CUDA_COMPILER" in
*nvcc*)
;;
*clang*)
CUDA_COMPUTE_ARGS="--cuda-gpu-arch=sm_30 --cuda-gpu-arch=sm_35"
;;
"")
;;
*)
UG_MSG_WARN([Unsupported cuda compiler $CUDA_COMPILER])
;;
esac
HOST_CC_REPORT="$HOST_CC_REPORT"$(basename "$CUDA_COMPILER")
# CUDA host compiler
AC_ARG_WITH(cuda-host-compiler,
AS_HELP_STRING([--with-cuda-host-compiler=BINARY],[specify compiler used for building cuda host code]))
if test "x${with_cuda_host_compiler}" != "x" ; then
AC_PATH_PROG([cuda_host_cc], [${with_cuda_host_compiler}],[no])
# note AC_CHECK_PROG always fails on path with spaces in MSW
if test "x${cuda_host_cc?}" != "xno" || test "${system?}" = Windows; then
CUDA_FLAGS="$CUDA_FLAGS -ccbin \"${cuda_host_cc}\""
else
AC_MSG_FAILURE([Binary ${with_cuda_host_compiler} given as cuda host compiler, yet not found!])
fi
else
with_cuda_host_compiler="default"
fi
if test "x$FOUND_CUDA" = "xyes" ; then
HOST_CC_REPORT="$HOST_CC_REPORT, ${with_cuda_host_compiler})"
else
HOST_CC_REPORT=""
fi
if test "$FOUND_CUDA" = yes; then
AC_DEFINE([HAVE_CUDA], [1], [CUDA is present on the system])
OBJS="$OBJS src/cuda_wrapper.o"
if test $system != Windows; then
POST_COMPILE_MSG="$POST_COMPILE_MSG\n***\nYou have compiled in sort of CUDA code.\nIn order to use use it compression and \
decompression, you will need to have CUDA libraries visible to your OS.\n\
If not done so, you can accomplish this by adding line:\n\
export LD_LIBRARY_PATH=$CUDA_LIB_PATH:\\\$\$LD_LIBRARY_PATH\n\
to your .bashrc file (in home directory). To take effect immediatelly, you will need to enter:\n\
exec bash\n***\n"
else
AC_MSG_CHECKING([cl.exe supports -d2FH4-])
tst=$(mktemp tst-cl-frame-pointer-XXXX.c)
if "$CL" -d2FH4- -c $tst >/dev/null 2>&1; then
CUDA_FLAGS="$CUDA_FLAGS -Xcompiler -d2FH4-"
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(no)
fi
rm $tst
fi
fi
ENSURE_FEATURE_PRESENT([$cuda_req], [$FOUND_CUDA], [CUDA not found])
AC_SUBST(CUDA_INC)
AC_SUBST(CUDA_LIB)
AC_SUBST(CUDA_COMPILER)
AC_SUBST(CUDA_COMPUTE_ARGS)
# -------------------------------------------------------------------------------------------------
# GL common
# -------------------------------------------------------------------------------------------------
AC_ARG_ENABLE(gl,
[ --disable-gl disable all OpenGL stuff (default is auto)]
[ Requires: glew gl (Linux + Win), none (macOS)],
[gl_req=$enableval],
[gl_req=$build_default]
)
OPENGL=no
OPENGL_COMMON=no
SAVED_LIBS=$LIBS
SAVED_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS -DGLEW_NO_GLU"
AC_CHECK_HEADER(GL/gl.h)
AC_CHECK_HEADER(GL/glew.h)
AC_CHECK_HEADER(GL/glx.h)
AC_CHECK_LIB(GL, glBindTexture)
AC_CHECK_LIB(GL, glXCreateNewContext)
AC_CHECK_LIB(GLEW, glewInit)
AC_CHECK_LIB(glew32, glewInit)
AC_CHECK_LIB(X11, XCreateWindow)
LIBS=$SAVED_LIBS
CFLAGS=$SAVED_CFLAGS
HAVE_GL=no
HAVE_GLEW=no
GL_COMMON_OBJ="src/gl_context.o"
if test "${ac_cv_header_GL_gl_h?}" = yes && \
test "${ac_cv_lib_GL_glBindTexture?}" = yes
then
HAVE_GL=yes
fi
if test "${ac_cv_header_GL_glew_h?}" = yes && \
{ test "${ac_cv_lib_GLEW_glewInit?}" = yes || test "${ac_cv_lib_glew32_glewInit?}" = yes; }
then
HAVE_GLEW=yes
fi
# Linux
if { test "$system" = Linux || test "$system" = other; } && \
test "$HAVE_GL" = yes && \
test "$HAVE_GLEW" = yes
then
OPENGL_LIB="-lGLEW -lGL"
OPENGL=yes
if test "$ac_cv_header_GL_glx_h" = yes && \
test "$ac_cv_lib_GL_glXCreateNewContext" = yes && \
test "$ac_cv_lib_X11_XCreateWindow" = yes
then
OPENGL_LIB="$OPENGL_LIB -lX11"
OPENGL_COMMON=yes
GL_COMMON_OBJ="$GL_COMMON_OBJ src/glx_common.o src/x11_common.o"
fi
fi
# Mac
if test "$system" = MacOSX
then
OPENGL=yes
OPENGL_COMMON=yes
OPENGL_LIB="-framework Cocoa -framework OpenGL"
COMMON_FLAGS="$COMMON_FLAGS -DGL_SILENCE_DEPRECATION"
GL_COMMON_OBJ="$GL_COMMON_OBJ src/mac_gl_common.o"
fi
# Win32
if test "${system?}" = Windows && test "${HAVE_GLEW?}" = yes
then
OPENGL=yes
OPENGL_COMMON=yes
GL_COMMON_OBJ="$GL_COMMON_OBJ src/win32_gl_common.o"
OPENGL_LIB="-lopengl32 -lglew32 -lgdi32"
fi
if test $gl_req = no; then
OPENGL=no
GL_COMMON_OBJ=
OPENGL_LIB=
fi
ENSURE_FEATURE_PRESENT([$gl_req], [$OPENGL], [OpenGL stuff requested but dependencies were not found.])
# -------------------------------------------------------------------------------------------------
# Do we have FireWire/DV support?
case "$host_os" in
*freebsd*)
AC_CHECK_HEADER(dev/firewire/firewire.h,[
AC_DEFINE([HAVE_FIREWIRE_DV_FREEBSD], [1], [We have Firewire DV])
])
;;
esac
# -------------------------------------------------------------------------------------------------
# Try to find the SDK for the DVS cards
dvs=no
dvs_req=$build_default
AC_ARG_ENABLE(dvs,
[ --disable-dvs disable DVS (default is auto)]
[ Requires: DVS_SDK],
[dvs_req=$enableval])
case "$system" in
MacOSX)
DVS_SDK_SUBDIR="universal"
;;
Linux)
DVS_SDK_SUBDIR="linux-x86_64"
;;
Windows)
DVS_SDK_SUBDIR="win32"
;;
esac
if test -n "$DVS_DIRECTORY"
then
DVS_HDR_PATH=$DVS_DIRECTORY/development/header
DVS_LIB=$DVS_DIRECTORY/${DVS_SDK_SUBDIR}/lib
else
DVS_HDR_PATH=sdk4.0.1.17/development/header
DVS_LIB=sdk4.0.1.17/${DVS_SDK_SUBDIR}/lib
fi
AC_ARG_WITH(dvs,
[ --with-dvs=DIR specify location of DVS SDK],
[DVS_HDR_PATH=$withval/development/header
DVS_LIB=$withval/${DVS_SDK_SUBDIR}/lib],
)
if test "$dvs_req" != no; then
SAVED_CFLAGS=$CFLAGS
SAVED_CPPFLAGS=$CPPFLAGS
CFLAGS="$CFLAGS -I${DVS_HDR_PATH}"
CPPFLAGS="$CPPFLAGS -I${DVS_HDR_PATH}"
AC_CHECK_HEADER(dvs_clib.h, FOUND_DVS_H=yes, FOUND_DVS_H=no)
CFLAGS=$SAVED_CFLAGS
CPPFLAGS=$SAVED_CPPFLAGS
SAVED_LIBS=$LIBS
if test $system = MacOSX
then
LIBS="$LIBS -framework IOKit"
fi
AC_CHECK_LIB(dvsoem, sv_open, FOUND_DVS_L=yes, FOUND_DVS_L=no, -L${DVS_LIB})
LIBS=$SAVED_LIBS
if test $FOUND_DVS_H = yes && test $FOUND_DVS_L = yes
then
DVS_INC=-I${DVS_HDR_PATH}
DVS_LIB="-L${DVS_LIB} -ldvsoem"
if test $system = Linux; then
DVS_LIB="$DVS_LIB -ldl"
fi
DVS_CAP_OBJ="src/video_capture/dvs.o"
DVS_DISP_OBJ="src/video_display/dvs.o"
DVS_LIB="$DVS_LIB"
if test $system = MacOSX
then
DVS_LIB="$DVS_LIB -framework IOKit"
fi
add_module vidcap_dvs "$DVS_CAP_OBJ" "$DVS_LIB"
add_module display_dvs "$DVS_DISP_OBJ" "$DVS_LIB"
INC="$INC $DVS_INC"
dvs=yes
fi
fi
ENSURE_FEATURE_PRESENT([$dvs_req], [$dvs], [DVS not found.])
# -------------------------------------------------------------------------------------------------
# Blackmagic stuff
decklink=no
AC_ARG_ENABLE(decklink,
[ --disable-decklink disable DeckLink (default is auto)]
[ Requires: DesktopVideo],
[decklink_req=$enableval],
[decklink_req=$build_default]
)
DECKLINK_INC=$srcdir/ext-deps/DeckLink
if test $decklink_req != no; then
case "$system" in
MacOSX)
DECKLINK_INC=$DECKLINK_INC/Mac
OLD_LIBS=$LIBS
LIBS="$LIBS -framework CoreFoundation"
AC_LANG_PUSH(C++)
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include "$DECKLINK_INC/DeckLinkAPI.h"
]],
[[IDeckLinkIterator *deckLinkIter = CreateDeckLinkIteratorInstance();]])],FOUND_DECKLINK=yes,FOUND_DECKLINK=no)
LIBS=$OLD_LIBS
if test $FOUND_DECKLINK = yes; then
DECKLINK_LIB="-framework CoreFoundation"
fi
AC_LANG_POP(C++)
;;
Windows)
DECKLINK_INC=$DECKLINK_INC/Windows
SAVED_LIBS=$LIBS
LIBS="$LIBS -lole32"
AC_LANG_PUSH(C++)
AC_MSG_CHECKING([DeckLink usability])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include "$DECKLINK_INC/DeckLinkAPI.h"
#include "$DECKLINK_INC/DeckLinkAPIVersion.h"
#include <objbase.h>
]],
[[IDeckLinkIterator *deckLinkIter; CoCreateInstance(CLSID_CDeckLinkIterator, NULL, CLSCTX_ALL, IID_IDeckLinkIterator, (void **) deckLinkIter);]])],FOUND_DECKLINK=yes,FOUND_DECKLINK=no)
LIBS=$SAVED_LIBS
if test $FOUND_DECKLINK = yes; then
DECKLINK_LIB="-lole32"
fi
AC_MSG_RESULT([$FOUND_DECKLINK])
AC_LANG_POP(C++)
;;
Linux)
DECKLINK_INC=$DECKLINK_INC/Linux
AC_CHECK_FILE(${DECKLINK_INC}/DeckLinkAPI.h, FOUND_DECKLINK_H=yes, FOUND_DECKLINK_H=no)
AC_CHECK_FILE(${DECKLINK_INC}/DeckLinkAPIDispatch.cpp, FOUND_DECKLINK_SRC=yes, FOUND_DECKLINK_SRC=no)
AC_CHECK_LIB(DeckLinkAPI, main, FOUND_DECKLINK_L=yes, FOUND_DECKLINK_L=no)
#if test $FOUND_DECKLINK_H = yes -a $FOUND_DECKLINK_SRC = yes -a $FOUND_DECKLINK_L = yes; then
if test "${FOUND_DECKLINK_H?}" = yes && test "${FOUND_DECKLINK_SRC?}" = yes; then
FOUND_DECKLINK=yes
DECKLINK_LIB="-ldl"
else
FOUND_DECKLINK=no
fi
;;
esac
if test "$FOUND_DECKLINK" = yes; then
DECKLINK_PATH=${DECKLINK_INC}
AC_SUBST(DECKLINK_PATH)
DECKLINK_INC=-I${DECKLINK_INC}
DECKLINK_CAP_OBJ="src/blackmagic_common.o src/video_capture/decklink.o"
DECKLINK_DISP_OBJ="src/blackmagic_common.o src/video_display/decklink.o"
DECKLINK_SOUND_PLAY_OBJ="src/blackmagic_common.o src/audio/playback/decklink.o"
if test $system = "Windows"; then
DECK_COMMON_OBJS="$OBJS src/video_capture/DeckLinkAPI_i.o"
else
DECK_COMMON_OBJS="$OBJS src/video_capture/DeckLinkAPIDispatch.o"
fi
add_module vidcap_decklink "$DECK_COMMON_OBJS $DECKLINK_CAP_OBJ" "$DECKLINK_LIB"
add_module display_decklink "$DECK_COMMON_OBJS $DECKLINK_DISP_OBJ" "$DECKLINK_LIB"
add_module aplay_decklink "$DECK_COMMON_OBJS $DECKLINK_SOUND_PLAY_OBJ" "$DECKLINK_LIB"
decklink=yes
INC="$INC $DECKLINK_INC"
fi
fi
ENSURE_FEATURE_PRESENT([$decklink_req], [$decklink], [DeckLink not found.])
# -------------------------------------------------------------------------------------------------
# Bluefish444 stuff
# -------------------------------------------------------------------------------------------------
BLUEFISH444_INC=
BLUEFISH444_LIB=
bluefish444=no
blue_audio=no
AC_ARG_ENABLE(bluefish444,
[ --disable-bluefish444 disable Bluefish444 suppport (default is auto)]
[ Requires: bluefish444_SDK],
[bluefish444_req=$enableval],
[bluefish444_req=$build_default]
)
BLUEFISH444_PATH=$BLUE_LATEST_SDK
AC_ARG_WITH(bluefish444,
[ --with-bluefish444=DIR specify location of Bluefish444],
[BLUEFISH444_PATH=$withval
])
SAVED_LIBS=$LIBS
SAVED_CXXFLAGS=$CXXFLAGS
SAVED_CPPFLAGS_SAVE=$CPPFLAGS
if test -n "$BLUEFISH444_PATH"; then
if test $system = Linux; then
BLUEFISH444_INC="-I$BLUEFISH444_PATH/build/inc"
BLUEFISH444_LIB="-L$BLUEFISH444_PATH/build/lib"
elif test $system = Windows; then
BLUEFISH444_INC="-I$BLUEFISH444_PATH/inc"
BLUEFISH444_LIB="-L$BLUEFISH444_PATH/lib/win"
fi
fi
if test $WORD_LEN -eq 64; then
BLUEFISH444_LIB_NAME=BlueVelvetC64
else
BLUEFISH444_LIB_NAME=BlueVelvetC
fi
if test "$bluefish444_req" != no; then
BLUE_L=no
BLUE_H=no
AC_LANG_PUSH(C++)
CPPFLAGS="$CPPFLAGS $BLUEFISH444_INC"
CXXFLAGS="$CXXFLAGS $BLUEFISH444_INC"
LIBS="$LIBS $BLUEFISH444_LIB"
AC_CHECK_HEADERS([BlueVelvetC.h], [BLUE_H=yes], [BLUE_H=no])
AC_CHECK_LIB($BLUEFISH444_LIB_NAME, bfcFactory, [BLUE_L=yes], [BLUE_L=no])
if test "${BLUE_H?}" = yes && "${BLUE_L?}" = yes
then
BLUEFISH444_LIB="$BLUEFISH444_LIB -l$BLUEFISH444_LIB_NAME"
add_module vidcap_bluefish444 src/video_capture/bluefish444.o "$BLUEFISH444_LIB"
add_module display_bluefish444 src/video_display/bluefish444.o "$BLUEFISH444_LIB"
INC="$INC $BLUEFISH444_INC"
bluefish444=yes
fi
AC_LANG_POP(C++)
LIBS=$SAVED_LIBS
CXXFLAGS=$SAVED_CXXFLAGS
CPPFLAGS=$SAVED_CPPFLAGS_SAVE
fi
ENSURE_FEATURE_PRESENT([$bluefish444_req], [$bluefish444], [Bluefish444 not found])
# -------------------------------------------------------------------------------------------------
# AJA stuff
# -------------------------------------------------------------------------------------------------
AJA_PATH=
aja=no
AC_ARG_ENABLE(aja,
[ --disable-aja disable AJA suppport (default is auto)]
[ Requires: NTV2_SDK],
[aja_req=$enableval],
[aja_req=$build_default])
if test -n "$NTV2_ROOT"; then
AJA_PATH=$NTV2_ROOT/..
fi
if test -n "$AJA_DIRECTORY"; then
AJA_PATH=$AJA_DIRECTORY
fi
if test -z "$AJA_PATH"; then
if test -d /usr/local/include/libajantv2; then
AJA_PATH=/usr/local/include/libajantv2
# libajantv2 AUR
elif test -d /usr/include/libajantv2; then
AJA_PATH=/usr/include/libajantv2
fi
fi
AC_ARG_WITH(aja,
[ --with-aja=DIR specify location of NTV2],
[AJA_PATH=$withval
])
if test "$aja_req" != no; then
if test $system != Windows; then
AJA_LIB=ajantv2
platform=lin
if test "$system" = MacOSX; then
platform=mac
fi
AC_CHECK_LIB($AJA_LIB, main, [aja=yes], [aja=no])
if test "$aja" = yes; then
# we need to have the headers path, anyways (see 30 lines below)
if ! test -d "$AJA_PATH"; then
UG_MSG_WARN([libajantv2 found, but \$AJA_DIRECTORY still needs to point to headers root])
aja=no
fi
AJA_LIB=-l$AJA_LIB
fi
else # Windows
AC_CHECK_LIB(aja, display_aja_probe, [aja=yes], [aja=no])
fi
if test "${aja?}" = yes && test "${system?}" = Windows; then
add_module aja src/aja_win32_stub.o -laja
elif test $aja = yes; then # Linux and macOS
AJA_INC="$AJA_INC -I$AJA_PATH -I$AJA_PATH/ajantv2/\
includes -I$AJA_PATH/ajantv2/src/$platform"
if test $system = Linux; then
AJA_CXXFLAGS="-DAJALinux -DAJA_LINUX"
AJA_LIB="$AJA_LIB -lrt"
else # mac
AJA_CXXFLAGS="-DAJAMac -DAJA_MAC"
AJA_LIB="$AJA_LIB -framework IOKit"
fi
add_module aja "src/aja_common.o src/video_capture/aja.o src/video_display/aja.o" "$AJA_LIB"
INC="$INC $AJA_INC"
CXXFLAGS="$CXXFLAGS $AJA_CXXFLAGS"
fi
fi
ENSURE_FEATURE_PRESENT([$aja_req], [$aja], [AJA not found])
# -------------------------------------------------------------------------------------------------
# holepunch stuff
libjuice=no
AC_ARG_ENABLE(holepunch,
AS_HELP_STRING([--disable-holepunch], [disable holepunch suppport (default is auto)]
[Requires: libjuice]),
[libjuice_req=$enableval],
[libjuice_req=$build_default])
if test "$libjuice_req" != no; then
AC_CHECK_LIB(juice, juice_create, FOUND_LIBJUICE=yes, FOUND_LIBJUICE=no)
LIBJUICE_LIB="-ljuice"
if test "$FOUND_LIBJUICE" = yes
then
libjuice=yes
add_module holepunch src/utils/udp_holepunch.o "$LIBJUICE_LIB"
COMMON_FLAGS="$COMMON_FLAGS -DHAVE_LIBJUICE"
fi
fi
ENSURE_FEATURE_PRESENT([$libjuice_req], [$libjuice], [LIBJUICE not found])
# -------------------------------------------------------------------------------------------------
# DELTACAST stuff
deltacast=no
deltacast_found=no
AC_ARG_ENABLE(deltacast,
[ --disable-deltacast disable DELTACAST suppport (default is auto)]
[ Requires: VideoMasterHD_SDK],
[deltacast_req=$enableval],
[deltacast_req=$build_default]
)
AC_ARG_WITH(deltacast,
[ --with-deltacast=DIR specify location of DELTACAST],
[DELTACAST_PATH=$withval
])
if test "$deltacast_req" != no; then
if test "$system" = Linux || test "$system" = Windows; then
AC_LANG_PUSH(C++)
if test ${system?} = Windows; then
DELTACAST_PATH=\
${DELTACAST_DIRECTORY:-/c/PROGRA~1/DELTACAST/VideoMaster/resources}
DELTA_INC=-I$DELTACAST_PATH/include
DELTACAST_LIB=-L$DELTACAST_PATH/lib
EXTRA_HEADERS="#include <windows.h>"
else
DELTACAST_PATH=${DELTACAST_DIRECTORY:-/usr}
DELTA_INC=-I$DELTACAST_PATH/include/videomaster
DELTA_INC="$DELTA_INC -I$DELTACAST_PATH/Include" # old SDK compat
DELTACAST_LIB=-L$DELTACAST_PATH/lib
# no lib path compat for old SDKs - install them with 'make install'
EXTRA_HEADERS=
fi
CXXFLAGS_SAVE=$CXXFLAGS
CXXFLAGS="$CXXFLAGS ${DELTA_INC?}"
CPPFLAGS_SAVE=$CPPFLAGS
CPPFLAGS="$CPPFLAGS ${DELTA_INC?}"
AC_CHECK_HEADERS([VideoMasterHD_Core.h VideoMasterHD_Sdi.h VideoMasterHD_Sdi_Audio.h],
[], [],
[[$EXTRA_HEADERS
#ifdef HAVE_VIDEOMASTERHD_CORE_H
# include <VideoMasterHD_Core.h>
#endif
#ifdef HAVE_VIDEOMASTERHD_SDI_H
# include <VideoMasterHD_Sdi.h>
#endif
]])
SAVED_LIBS=$LIBS
DELTACAST_LIB="$DELTACAST_LIB -lvideomasterhd_audio -lvideomasterhd"
LIBS="$LIBS $DELTACAST_LIB"
AC_MSG_CHECKING([DELTACAST library presence])
AC_LINK_IFELSE([AC_LANG_PROGRAM([[$EXTRA_HEADERS
# include <VideoMasterHD_Core.h>
# include <VideoMasterHD_Sdi.h>
# include <VideoMasterHD_Sdi_Audio.h>
]],
[[
VHD_OpenBoardHandle(0, (void **) 0, (void *) 0, 0);
VHD_SlotExtractAudio(0, 0);
VHD_LockSlotHandle(0, 0);
]])],FOUND_VHD_L=yes,FOUND_VHD_L=no)
#AC_CHECK_LIB(videomasterhd_audio, VHD_GetNbSamples, [], [], [-lvideomasterhd])
LIBS=$SAVED_LIBS
if test -n "$DELTACAST_PATH"; then
CXXFLAGS=$CXXFLAGS_SAVE
CPPFLAGS=$CPPFLAGS_SAVE
fi
AC_MSG_RESULT([$FOUND_VHD_L])
AC_LANG_POP(C++)
if test "${ac_cv_header_VideoMasterHD_Core_h?}" = yes &&
test "${ac_cv_header_VideoMasterHD_Sdi_h?}" = yes &&
test "${ac_cv_header_VideoMasterHD_Sdi_Audio_h?}" = yes &&
test "${FOUND_VHD_L?}" = yes; then
deltacast_found=yes
fi
else # OS X
MY_CHECK_FRAMEWORK([VideoMasterHD])
MY_CHECK_FRAMEWORK([VideoMasterHD_Audio])
AC_CHECK_HEADERS([VideoMasterHD/VideoMasterHD_Core.h])
if test "${ac_cv_header_VideoMasterHD_VideoMasterHD_Core_h?}" = yes &&
test "${my_cv_framework_VideoMasterHD?}" = yes &&
test "${my_cv_framework_VideoMasterHD?}" = yes; then
deltacast_found=yes
DELTACAST_LIB="$FRAMEWORK_VIDEOMASTERHD $FRAMEWORK_VIDEOMASTERHD_AUDIO"
fi
fi
if test "$deltacast_found" = yes; then
INC="$INC${DELTA_INC:+ $DELTA_INC}"
add_module vidcap_deltacast "src/deltacast_common.o \
src/video_capture/deltacast.o src/video_capture/deltacast_dvi.o" "$DELTACAST_LIB"
add_module display_deltacast "src/deltacast_common.o \
src/video_display/deltacast.o" "$DELTACAST_LIB"
deltacast=yes
fi
fi
ENSURE_FEATURE_PRESENT([$deltacast_req], [$deltacast], [Deltacast not found])
#----------------------------------------------------------------------
# XIMEA
# ---------------------------------------------------------------------
AC_ARG_ENABLE(ximea,
[ --disable-ximea disable XIMEA suppport (default is auto)]
[ Requires: XIMEA SDK],
[ximea_req=$enableval],
[ximea_req=$build_default]
)
AC_ARG_ENABLE(ximea-runtime-linking,
[ --disable-ximea-runtime-linking disable XIMEA suppport (default is enable), disabling may result in non-portable build],
[ximea_link_runtime=$enableval],
[ximea_link_runtime=yes]
)
ximea=no
if test $system = MacOSX; then
MY_CHECK_FRAMEWORK([m3api])
if test $my_cv_framework_m3api = yes; then
if test $ximea_link_runtime = no; then
XIMEA_LIBS=$FRAMEWORK_M3API
fi
ximea=yes
fi
if test -z "$GENICAM_GENTL64_PATH"; then
GENICAM_GENTL64_PATH="/Library/Frameworks/m3api.framework"
fi
XI_LIB_NAME="m3api"
else
if test $system = Linux; then
XIAPI_PATH=${GENICAM_GENTL64_PATH:-/opt/XIMEA/lib}
XI_LIB_EXT=".so"
XI_LIB_NAME="m3api"
XI_LIB_PREF="lib"
XIMEA_CFLAGS="-I$XIAPI_PATH/../include"
else
if test -d "$GENICAM_GENTL64_PATH/../../API/xiAPI"; then
# the env var contains actually something like "C:\XIMEA\GenTL Producer\64bit"
XIAPI_PATH=$(realpath "$GENICAM_GENTL64_PATH/../../API/xiAPI")
else
XIAPI_PATH="C:/XIMEA/API/xiAPI"
fi
XI_LIB_EXT=".dll"
XI_LIB_NAME="xiapi64"
XIMEA_CFLAGS="-I$XIAPI_PATH"
fi
SAVED_CFLAGS=$CFLAGS
SAVED_CPPFLAGS=$CPPFLAGS
CFLAGS="$CFLAGS $XIMEA_CFLAGS"
CPPFLAGS="$CPPFLAGS $XIMEA_CFLAGS"
AC_CHECK_HEADERS([xiApi.h])
CFLAGS=$SAVED_CFLAGS
if test $ximea_link_runtime = no; then
XIMEA_LIBS="-L$XIAPI_PATH"
SAVED_LIBS=$LIBS
LIBS="$LIBS $XIMEA_LIBS"
CPPFLAGS=$SAVED_CPPFLAGS
AC_CHECK_LIB($XI_LIB_NAME, xiGetImage, HAVE_XI_L=yes, HAVE_XI_L=no)
XIMEA_LIBS="-l$XI_LIB_NAME -L$XIAPI_PATH"
LIBS=$SAVED_LIBS
else
HAVE_XI_L=yes
fi
if test "${ximea_req?}" != no && test "${HAVE_XI_L?}" = yes &&
test "${ac_cv_header_xiApi_h?}" = yes; then
ximea=yes
fi
fi
if test "${ximea?}" = yes && test "${ximea_link_runtime?}" = yes; then
AC_DEFINE([XIMEA_RUNTIME_LINKING], [1], [Dynamically open XIMEA lib on runtime])
AC_DEFINE_UNQUOTED([XIMEA_LIBRARY_NAME], ["$XI_LIB_PREF$XI_LIB_NAME$XI_LIB_EXT"], [Name of the dynamic libarary])
AC_DEFINE_UNQUOTED([XIMEA_LIBRARY_PATH], ["$GENICAM_GENTL64_PATH"], [Path to the XI dynamic libarary])
fi
if test $ximea = yes; then
CFLAGS="$CFLAGS $XIMEA_CFLAGS"
add_module vidcap_ximea src/video_capture/ximea.o "$XIMEA_LIBS"
fi
ENSURE_FEATURE_PRESENT([$ximea_req], [$ximea], [XIMEA SDK not found])
# -------------------------------------------------------------------------------------------------
# AV Foundation capture
# -------------------------------------------------------------------------------------------------
avfoundation=no
AC_ARG_ENABLE(avfoundation,
AS_HELP_STRING([--disable-avfoundation], [enable AVFoundation support (default is enable on macOS)]),
[avfoundation_req=$enableval],
[avfoundation_req=auto]
)
if test "${system?}" = MacOSX && test "${avfoundation_req?}" != no
then
AVFOUNDATION_LIB="-framework AppKit -framework AVFoundation -framework CoreMedia -framework CoreVideo"
AVFOUNDATION_OBJ="src/video_capture/avfoundation.o"
add_module "" "$AVFOUNDATION_OBJ" "$AVFOUNDATION_LIB"
avfoundation=yes
fi
ENSURE_FEATURE_PRESENT([${avfoundation_req?}], [${avfoundation?}],
[AV Foundation not found])
# ------------------------------------------------------------------------------
# SDL1/2/3 Stuff
# ------------------------------------------------------------------------------
sdl=no
sdl_version=
sdl_version_str=
sdl_ver_suffix=
AC_ARG_ENABLE(sdl,
AS_HELP_STRING([--enable-sdl@<:@=1|2|3@:>@], [enable SDL (optionally with version(s); default is auto), ]
[requires: sdl >= 1.2.14 | sdl2 | sdl3 >= 3.2.0]),
[sdl_req=$enableval],
[sdl_req=$build_default]
)
if test "$sdl_req" != no; then
sdl_req_ver=$sdl_req
sdl2_pc_path=$("$PKG_CONFIG" --path sdl2 2>/dev/null)
if "$PKG_CONFIG" --print-provides sdl2 | grep -q sdl2_compat ||
{ test -f "$sdl2_pc_path" &&
grep -q sdl2_compat -- "$sdl2_pc_path"; } ||
"$PKG_CONFIG" --debug sdl2 2>&1 | grep -q sdl2_compat
then
sdl2_is_compat=yes
fi
if test "$sdl_req" = yes || test "$sdl_req" = auto; then
sdl_req_ver=321
fi
while test -n "$sdl_req_ver"; do
ver=$(echo "$sdl_req_ver" | cut -c1)
case "$ver" in
1) PKG_CHECK_MODULES([SDL], [sdl], [sdl_version=1], [ ]) ;;
2) PKG_CHECK_MODULES([SDL], [sdl2], [sdl_version=2], [ ]) ;;
3) PKG_CHECK_MODULES([SDL], [sdl3 >= 3.2.0], [sdl_version=3], [ ]) ;;
esac
if test -n "$sdl_version"; then
break
fi
sdl_req_ver=$(printf "$sdl_req_ver" | cut -c2-)
done
if test "$sdl_version" = 2 && test "$sdl2_is_compat" ; then
UG_MSG_WARN([Using SDL3 sdl2_compat, which is not recommended (use 3 directly)])
fi
if test -n "$sdl_version"; then
if test "$sdl_version" = 1; then
SDL_LIBS="$SDL_LIBS -lX11" # X11 for x11_common.o
else
sdl_ver_suffix=$sdl_version
fi
if test "$sdl_version" -eq 3; then
AC_DEFINE([HAVE_SDL3], [1], [Build with SDL3 support])
fi
SDL_OBJ="src/video_display/sdl${sdl_ver_suffix}.o"
INC="$INC $($PKG_CONFIG --cflags-only-I sdl${sdl_ver_suffix})"
SDL_LIBS=$(remove_mwindows "$SDL_LIBS")
add_module display_sdl "$SDL_OBJ" "$SDL_LIBS"
sdl_version_str=" (ver. $sdl_version)"
sdl=yes
fi
fi
sdl_version=${sdl_version:-0}
ENSURE_FEATURE_PRESENT([$sdl_req], [$sdl], [SDL requested but not found])
# ------------------------------------------------------------------------------
# Vulkan
# ------------------------------------------------------------------------------
vulkan=no
AC_ARG_ENABLE(vulkan,
[ --disable-vulkan disable sdl2_vulkan display (default is auto)]
[ Requires: sdl2|sdl3 vulkan],
[vulkan_req=$enableval],
[vulkan_req=$build_default]
)
if test "$vulkan_req" != no; then
if test "$vulkan_req" != nomoltenvk; then
SAVED_LIBS=$LIBS
VULKAN_LIBS=-lMoltenVK # mac MoltenVK
LIBS="$LIBS $VULKAN_LIBS"
AC_CHECK_FUNCS(vkCreateImage, [found_vulkan=yes], [found_vulkan=no])
LIBS=$SAVED_LIBS
fi
if test "$found_vulkan" != yes; then
VULKAN_LIBS=
PKG_CHECK_MODULES([VULKAN], [vulkan >= 1.1.101], [found_vulkan=yes], [found_vulkan=no])
fi
AC_CHECK_HEADERS([vulkan/vulkan.h], [], [found_vulkan=no])
if test $sdl = yes && test $sdl_version -ge 2 && test $found_vulkan = yes; then
VULKAN_OBJ="src/video_display/vulkan/vulkan_sdl$sdl_version.o \
src/video_display/vulkan/vulkan_display.o \
src/video_display/vulkan/vulkan_context.o \
src/video_display/vulkan/vulkan_transfer_image.o \
src/video_display/vulkan/vulkan_pipelines.o"
VULKAN_LIBS="$VULKAN_LIBS $SDL_LIBS"
add_module display_vulkan "$VULKAN_OBJ" "$VULKAN_LIBS"
VULKAN=vulkanEnabled
AC_SUBST(VULKAN)
vulkan=yes
vulkan_sdl_ver=" (SDL$sdl_version)"
fi
fi
ENSURE_FEATURE_PRESENT([$vulkan_req], [$vulkan], [Vulkan dependencies were not found (Vulkan ver 1.1.101 or SDL2/3)!])
# ------------------------------------------------------------------------------
# GLM (OpenGL math library)
# ------------------------------------------------------------------------------
GLM_INC=
GLM_DIR=$srcdir/glm
glm=no
PKG_CHECK_MODULES([GLM], [glm], [FOUND_GLM=yes], [FOUND_GLM=no])
if test $FOUND_GLM = yes; then
GLM_INC=$GLM_CFLAGS
glm=yes
elif test $cross_compile = no; then
AC_CHECK_FILE([$GLM_DIR/glm/glm.hpp], [found_glm_hpp=yes], [found_glm_hpp=no])
if test $found_glm_hpp = yes; then
glm=yes
GLM_INC=-I$GLM_DIR
else
AC_LANG_PUSH(C++)
AC_CHECK_HEADER([glm/glm.hpp], [glm=yes], [glm=no])
AC_LANG_POP(C++)
fi
fi
# ------------------------------------------------------------------------------
# Panorama gl display
# ------------------------------------------------------------------------------
panogl_disp=no
AC_ARG_ENABLE(panogl_disp,
[ --disable-panogl_disp disable gl panorama display (default is auto)]
[ Requires: sdl2 gl],
[panogl_disp_req=$enableval],
[panogl_disp_req=$build_default]
)
if test $panogl_disp_req = yes; then
if test "${sdl?}" = no || test "${sdl_version?}" != 2; then
AC_MSG_ERROR([SDL2 not found]);
fi
if test $glm = no; then
AC_MSG_ERROR([GLM not found]);
fi
fi
if test $panogl_disp_req != no && test $sdl = yes && test $sdl_version = 2 && test $glm = yes
then
PANOGL_OBJ="src/video_display/pano_gl.o src/video_display/opengl_utils.o src/video_display/opengl_conversions.o src/video_display/opengl_panorama.o src/video_display/sdl_window.o"
PANOGL_LIBS=$SDL_LIBS
add_module display_panogl "$PANOGL_OBJ" "$PANOGL_LIBS"
INC="$INC $GLM_INC"
panogl_disp=yes
fi
# ------------------------------------------------------------------------------
# OpenXR VR gl display
# ------------------------------------------------------------------------------
xrgl_disp=no
AC_ARG_ENABLE(xrgl_disp,
[ --disable-xrgl_disp disable OpenXR VR display (default is auto)]
[ Requires: sdl2 gl openxr],
[xrgl_disp_req=$enableval],
[xrgl_disp_req=$build_default]
)
FOUND_XRGL_DEPS=no
if test $xrgl_disp_req != no && test "$sdl_version" = 2 && test "$glm" != no; then
PKG_CHECK_MODULES([XRGLDISP], [openxr], [FOUND_XRGL_DEPS=yes], [FOUND_XRGL_DEPS=no])
if test "$FOUND_XRGL_DEPS" = yes; then
XRGLDISP_OBJ="src/video_display/openxr_gl.o src/video_display/opengl_utils.o src/video_display/opengl_conversions.o src/video_display/opengl_panorama.o src/video_display/sdl_window.o"
XRGLDISP_LIBS="$XRGLDISP_LIBS $SDL_LIBS"
add_module display_xrgl "$XRGLDISP_OBJ" "$XRGLDISP_LIBS"
INC="$INC $GLM_INC"
xrgl_disp=yes
fi
fi
ENSURE_FEATURE_PRESENT([$xrgl_disp_req], [$xrgl_disp], [XRGL deps not found])
#
# ------------------------------------------------------------------------------
# caca
# ------------------------------------------------------------------------------
caca=no
AC_ARG_ENABLE(caca,
AS_HELP_STRING([--disable-caca], [disable caca display (default is auto)]),
[caca_req=$enableval],
[caca_req=$build_default]
)
if test $caca_req != no; then
PKG_CHECK_MODULES([CACA], [caca], [caca_found=yes], [caca_found=no])
if test "$caca_found" = no && test "$caca_req" = yes; then
AC_MSG_ERROR([caca requested but libcaca was not found!])
fi
if test "$caca_found" = yes; then
add_module display_caca src/video_display/caca.o "$CACA_LIBS"
caca=yes
fi
fi
ENSURE_FEATURE_PRESENT([$caca_req], [$caca], [libcaca not found])
# -------------------------------------------------------------------------------------------------
# OpenCV version detection
# -------------------------------------------------------------------------------------------------
[remove_all_libs_but_opencv_core() { echo "$1" | sed -e 's/-lopencv_[a-z0-9_]*//g' -e 's/$/ -lopencv_core/' | compact_spaces_pipe ; } ]
AC_ARG_ENABLE(opencv,
AS_HELP_STRING([--disable-opencv], [disable all OpenCV code]),
[opencv_req=$enableval],
[opencv_req=$build_default])
found_opencv=no
opencv=no
if test "$opencv_req" != no; then
PKG_CHECK_MODULES([OPENCV_4], [opencv4], [
found_opencv=yes
OPENCV_LIBS=$OPENCV_4_LIBS
OPENCV_CFLAGS=$OPENCV_4_CFLAGS
], [found_opencv=no])
if test "$found_opencv" = no; then
PKG_CHECK_MODULES([OPENCV_3], [opencv > 3.0], [
found_opencv=yes
OPENCV_LIBS=$OPENCV_3_LIBS
OPENCV_CFLAGS=$OPENCV_3_CFLAGS
], [found_opencv=no])
fi
if test "$found_opencv" = no; then
PKG_CHECK_MODULES([OPENCV_2], [opencv > 2.3], [
found_opencv=yes
OPENCV_LIBS=$OPENCV_2_LIBS
OPENCV_CFLAGS=$OPENCV_2_CFLAGS
], [found_opencv=no])
fi
if test "$found_opencv" = yes; then
OPENCV_LIBS=$(remove_all_libs_but_opencv_core $OPENCV_LIBS)
opencv=yes
fi
if test "$found_opencv" = no; then
AC_CHECK_LIB(opencv_core, cvCreateMat)
AC_LANG_PUSH(C++)
AC_CHECK_HEADERS([opencv2/core/mat.hpp])
# if hdrs not in default path, try also /usr/include/opencv4 (we don't have CFLAGS from .pc; eg. U20.04)
if test "$ac_cv_header_opencv2_core_mat_hpp" = no; then
OPENCV_CFLAGS=-I/usr/include/opencv4
SAVED_CPPFLAGS=$CPPFLAGS
SAVED_CXXFLAGS=$CXXFLAGS
CPPFLAGS="$CPPFLAGS $OPENCV_CFLAGS"
CXXFLAGS="$CXXFLAGS $OPENCV_CFLAGS"
unset ac_cv_header_opencv2_core_mat_hpp # prevent AC from using cached result
AC_CHECK_HEADERS([opencv2/core/mat.hpp])
CPPFLAGS=$SAVED_CPPFLAGS
CXXFLAGS=$SAVED_CXXFLAGS
fi
AC_LANG_POP(C++)
if test "$ac_cv_lib_opencv_core_cvCreateMat" = yes && test "$ac_cv_header_opencv2_core_mat_hpp" = yes; then
OPENCV_LIBS=-lopencv_core
opencv=yes
fi
fi
fi
if test "$opencv" = yes; then
AC_LANG_PUSH(C++)
AC_CHECK_HEADERS([opencv2/opencv.hpp])
AC_LANG_POP(C++)
# opencv_imgproc is commonly needed so make the check here
SAVED_LIBS=$LIBS
LIBS="$LIBS $OPENCV_LIBS"
AC_CHECK_LIB(opencv_imgproc, cvAcc)
FOUND_OPENCV_IMGPROC=$ac_cv_lib_opencv_imgproc_cvAcc
LIBS=$SAVED_LIBS
fi
ENSURE_FEATURE_PRESENT([$opencv_req], [$opencv], [OpenCV dependencies not found!])
# -------------------------------------------------------------------------------------------------
# RTSP capture stuff
# -------------------------------------------------------------------------------------------------
rtsp=no
define(rtsp_deps, [libcurl])
AC_ARG_ENABLE(rtsp,
[ --disable-rtsp disable RTSP support (default is auto)]
[ Requires: rtsp_deps],
[rtsp_req=$enableval],
[rtsp_req=$build_default]
)
if test "$rtsp_req" != no; then
PKG_CHECK_MODULES([RTSP], [rtsp_deps], FOUND_RTSP_DEPS=yes, FOUND_RTSP_DEPS=no)
if test $FOUND_RTSP_DEPS = yes; then
SAVED_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS ${RTSP_CFLAGS}"
SAVED_CXXFLAGS=$CXXFLAGS
CXXFLAGS="$CXXFLAGS ${RTSP_CFLAGS}"
RTSP_OBJ="src/utils/h264_stream.o src/utils/hevc_stream.o \
src/video_capture/rtsp.o \
src/rtp/rtpdec_h264.o src/rtp/rtpdec_jpeg.o src/utils/jpeg_writer.o"
add_module vidcap_rtsp "$RTSP_OBJ" "$RTSP_LIBS"
rtsp=yes
fi
fi
ENSURE_FEATURE_PRESENT([$rtsp_req], [$rtsp], [rtsp not found, check curl dependencies...])
# -------------------------------------------------------------------------------------------------
# -------------------------------------------------------------------------------------------------
# RTSP server stuff
# TODO: create pkg-config search path for liblivemedia-dev (create live555.pc file)
# -------------------------------------------------------------------------------------------------
rtsp_server=no
livemedia=no
livemedia_prefix=/usr
AC_ARG_ENABLE(rtsp_server,
[ --enable-rtsp-server enables RTSP server support (default is auto)]
[ Requires: live555],
[rtsp_server_req=$enableval],
[rtsp_server_req=$build_default]
)
AC_ARG_WITH(live555,
[ --with-live555=DIR specify location of live555],
[livemedia_prefix=$withval],
[livemedia_prefix=/usr/local],
)
if test $rtsp_server_req != no; then
AC_LANG_PUSH(C++)
RTSP_SERVER_FLAGS="-I$livemedia_prefix/include/groupsock -I$livemedia_prefix/include/liveMedia -I$livemedia_prefix/include/BasicUsageEnvironment -I$livemedia_prefix/include/UsageEnvironment"
SAVED_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $RTSP_SERVER_FLAGS"
AC_CHECK_HEADER(liveMedia.hh, FOUND_LIVE_H=yes, FOUND_LIVE_H=no)
CPPFLAGS=$SAVED_CPPFLAGS
AC_LANG_POP(C++)
if test $FOUND_LIVE_H = yes
then
AC_DEFINE([HAVE_RTSP_SERVER], [1], [RTSP server build with live555 support])
CFLAGS="$CFLAGS $RTSP_SERVER_FLAGS"
CXXFLAGS="$CXXFLAGS $RTSP_SERVER_FLAGS"
RTSP_SERVER_LIBS="-lliveMedia -lBasicUsageEnvironment -lUsageEnvironment -lgroupsock"
RTSP_SERVER_OBJ="src/rtsp/c_basicRTSPOnlyServer.o src/rtsp/BasicRTSPOnlyServer.o src/rtsp/BasicRTSPOnlySubsession.o src/video_rxtx/h264_rtp.o"
add_module video_rxtx_h264 "$RTSP_SERVER_OBJ" "$RTSP_SERVER_LIBS"
rtsp_server=yes
livemedia=yes
fi
fi
ENSURE_FEATURE_PRESENT([$rtsp_server_req], [$rtsp_server], [rtsp server not found, check live555 -livemedia lib- dependencies...])
# ----------------------------------------------------------------------
# SDP over HTTP
# ----------------------------------------------------------------------
AC_ARG_ENABLE(sdp-http,
[ --enable-sdp-http enables SDP/HTTP transport (default is auto)],
[sdp_http_req=$enableval],
[sdp_http_req=$build_default]
)
sdp_http=no
if test $sdp_http_req != no; then
AC_CHECK_HEADERS([EmbeddableWebServer.h])
if test $ac_cv_header_EmbeddableWebServer_h = yes
then
AC_DEFINE([SDP_HTTP], 1, [Add support for SDP over HTTP])
sdp_http=yes
fi
fi
ENSURE_FEATURE_PRESENT([$sdp_http_req], [$sdp_http], [SDP/HTTP dependency EmbeddableWebServer.h not found!])
# -------------------------------------------------------------------------------------------------
# Resize stuff
# -------------------------------------------------------------------------------------------------
resize=no
AC_ARG_ENABLE(resize,
[ --disable-resize disable resize capture filter (default is auto)]
[ Requires: opencv],
[resize_req=$enableval],
[resize_req=$build_default]
)
if test $resize_req != no && test "$opencv" = yes && test "$FOUND_OPENCV_IMGPROC" = yes
then
CFLAGS="$CFLAGS ${OPENCV_CFLAGS}"
CXXFLAGS="$CXXFLAGS ${OPENCV_CFLAGS}"
RESIZE_OBJ="src/capture_filter/resize.o src/capture_filter/resize_utils.o"
add_module vcapfilter_resize "$RESIZE_OBJ" "$OPENCV_LIBS -lopencv_imgproc"
resize=yes
fi
ENSURE_FEATURE_PRESENT([$resize_req], [$resize], [Resize dependency not found, may install OpenCV...?])
# -------------------------------------------------------------------------------------------------
# Blank stuff
# -------------------------------------------------------------------------------------------------
blank=no
define(blank_dep, libswscale)
AC_ARG_ENABLE(blank,
[ --disable-blank disable blank capture filter (default is auto)]
[ Requires: blank_dep],
[blank_req=$enableval],
[blank_req=$build_default]
)
if test $blank_req != no; then
PKG_CHECK_MODULES([BLANK], [blank_dep], FOUND_BLANK_DEP=yes, FOUND_BLANK_DEP=no)
if test $FOUND_BLANK_DEP = no; then
AC_CHECK_HEADERS([libswscale/swscale.h], AC_CHECK_LIB(swscale, sws_scale, FOUND_BLANK_DEP=yes))
if test $FOUND_BLANK_DEP = yes; then
BLANK_LIBS='-lswscale'
fi
fi
if test "${blank_req?}" != no && test "${FOUND_BLANK_DEP?}" = yes
then
CFLAGS="$CFLAGS ${BLANK_CFLAGS}"
CXXFLAGS="$CXXFLAGS ${BLANK_CFLAGS}"
BLANK_OBJ="src/capture_filter/blank.o src/libavcodec/utils.o" # get_ug_to_av_pixfmt()
add_module vcapfilter_blank "$BLANK_OBJ" "$BLANK_LIBS"
blank=yes
fi
fi
ENSURE_FEATURE_PRESENT([$blank_req], [$blank], [Blank dep not found (libswscale)])
# -------------------------------------------------------------------------------------------------
# Testcard stuff
# -------------------------------------------------------------------------------------------------
AC_ARG_ENABLE(testcard2,
AS_HELP_STRING([--enable-testcard2@<:@=@<:@no@:>@ttf@:>@], [enable testcard2 (default is auto)]
[This includes testcard2 (optionally with TTF).]
[Requires: SDL_ttf (optional)]),
[testcard2_req=$enableval],
[testcard2_req=$build_default]
)
FOUND_SDL_TTF=no
testcard2=no
testcard2_sdl_ttf_req=auto
case "${testcard2_req?}" in
auto|no|yes)
;;
ttf)
testcard2_req=yes
testcard2_sdl_ttf_req=yes
;;
nottf)
testcard2_req=yes
testcard2_sdl_ttf_req=no
;;
*)
AC_MSG_ERROR([Wrong option for testcard2 $testcard2_req!]);
;;
esac
if test $testcard2_req != no
then
TESTCARD2_OBJ="src/video_capture/testcard2.o"
if test "${testcard2_sdl_ttf_req?}" != no; then
if test "${sdl_version?}" -lt 3; then
PKG_CHECK_MODULES([SDL_TTF], [SDL${sdl_ver_suffix}_ttf],
[FOUND_SDL_TTF=yes], [FOUND_SDL_TTF=no])
else
PKG_CHECK_MODULES([SDL_TTF], [sdl${sdl_ver_suffix}-ttf],
[FOUND_SDL_TTF=yes], [FOUND_SDL_TTF=no])
fi
if test "${FOUND_SDL_TTF?}" = yes
then
SDL_TTF_LIBS=$(remove_mwindows "${SDL_TTF_LIBS?}")
TESTCARD2_LIB="${TESTCARD2_LIB-} ${SDL_TTF_LIBS?}"
AC_DEFINE([HAVE_LIBSDL_TTF], [1], [Build testcard2 with TTF support])
fi
fi
add_module vidcap_testcard2 "${TESTCARD2_OBJ?}" "${TESTCARD2_LIB-}"
testcard2=yes
fi
# ensuring testcard2 itself unneeded - no dependencies
ENSURE_FEATURE_PRESENT([${testcard2_sdl_ttf_req?}], [${FOUND_SDL_TTF?}],
[SDL_ttf for testcard2 not found])
# -------------------------------------------------------------------------------------------------
# libavcodec hw-accelerated decoding support
# -------------------------------------------------------------------------------------------------
lavc_hwacc_vdpau=no
lavc_hwacc_vaapi=no
define(lavc_hwacc_common_dep, libavcodec libavutil >= 55.22.1)
define(lavc_hwacc_vdpau_dep, lavc_hwacc_common_dep vdpau)
define(lavc_hwacc_vaapi_dep, lavc_hwacc_common_dep libva)
AC_ARG_ENABLE(lavc-hw-accel-vdpau,
[ --disable-lavc-hw-accel-vdpau disable lavc-hw-accel-vdpau (default is auto)]
[ Requires: lavc_hwacc_vdpau_dep],
[lavc_hwacc_vdpau_req=$enableval],
[lavc_hwacc_vdpau_req=$build_default]
)
AC_ARG_ENABLE(lavc-hw-accel-vaapi,
[ --disable-lavc-hw-accel-vaapi disable lavc-hw-accel-vaapi (default is auto)]
[ Requires: lavc_hwacc_vaapi_dep],
[lavc_hwacc_vaapi_req=$enableval],
[lavc_hwacc_vaapi_req=$build_default]
)
LAVC_HWACC_FLAGS=-DHWACC_COMMON_IMPL
LAVC_HWACC_LIBS=
HW_ACC_OBJ="src/hwaccel_libav_common.o"
if test $lavc_hwacc_vdpau_req != no; then
PKG_CHECK_MODULES([LAVC_HWACC_VDPAU], [lavc_hwacc_vdpau_dep], [FOUND_HWACC_VDPAU_DEP=yes], [FOUND_HWACC_VDPAU_DEP=no])
if test $FOUND_HWACC_VDPAU_DEP = yes; then
LAVC_HWACC_FLAGS="${LAVC_HWACC_FLAGS} ${LAVC_HWACC_VDPAU_CFLAGS}"
LAVC_HWACC_LIBS="${LAVC_HWACC_LIBS} ${LAVC_HWACC_VDPAU_LIBS}"
HW_ACC_OBJ="${HW_ACC_OBJ} src/hwaccel_vdpau.o"
lavc_hwacc_vdpau=yes
fi
fi
if test $lavc_hwacc_vaapi_req != no; then
PKG_CHECK_MODULES([LAVC_HWACC_VAAPI], [lavc_hwacc_vaapi_dep], [FOUND_HWACC_VAAPI_DEP=yes], [FOUND_HWACC_VAAPI_DEP=no])
if test $FOUND_HWACC_VAAPI_DEP = yes; then
LAVC_HWACC_FLAGS="${LAVC_HWACC_FLAGS} -DHWACC_VAAPI ${LAVC_HWACC_VAAPI_CFLAGS}"
LAVC_HWACC_LIBS="${LAVC_HWACC_LIBS} ${LAVC_HWACC_VAAPI_LIBS}"
HW_ACC_OBJ="${HW_ACC_OBJ} src/hwaccel_vaapi.o"
lavc_hwacc_vaapi=yes
fi
fi
COMMON_FLAGS="$COMMON_FLAGS $LAVC_HWACC_FLAGS"
ENSURE_FEATURE_PRESENT([$lavc_hwacc_vdpau_req], [$lavc_hwacc_vdpau], [Could not find hwacc vdpau dependencies])
ENSURE_FEATURE_PRESENT([$lavc_hwacc_vaapi_req], [$lavc_hwacc_vaapi], [Could not find hwacc vaapi dependencies!])
# -------------------------------------------------------------------------------------------------
# Libswscale
# -------------------------------------------------------------------------------------------------
libswscale=no
AC_ARG_ENABLE(libswscale,
[ --disable-libswscale disable libswscale support (default is auto)]
[ Requires: libswscale libavutil],
[libswscale_req=$enableval],
[libswscale_req=$build_default]
)
if test "$libswscale_req" != no; then
if test $system = Windows; then
AC_CHECK_HEADERS([libswscale/swscale.h])
AC_CHECK_LIB(swscale, sws_getContext)
if test "${ac_cv_header_libswscale_swscale_h?}" = yes && \
test "${ac_cv_lib_swscale_sws_getContext?}" = yes
then
found_libswscale=yes
LIBSWSCALE_LIBS="-lswscale"
else
found_libswscale=no
fi
else # Linux, OS X
PKG_CHECK_MODULES([LIBSWSCALE], [libswscale], [found_libswscale=yes], [found_libswscale=no])
fi
if test $found_libswscale = yes; then
AC_DEFINE([HAVE_SWSCALE], [1], [Build with Swscale support])
COMMON_FLAGS="$COMMON_FLAGS $LIBSWSCALE_CFLAGS"
libswscale=yes
#LIBSWSCALE_LIBS="$LIBSWSCALE_LIBS $LIBAVUTIL_LIBS" # added libavutil explicitly
fi
fi
ENSURE_FEATURE_PRESENT([$libswscale_req], [$libswscale], [Libswscale not found])
# -------------------------------------------------------------------------------------------------
# Libav
# -------------------------------------------------------------------------------------------------
lavc_cuda=no
libavcodec=no
libavcodec_audio=no
AC_ARG_ENABLE(libavcodec,
[ --disable-libavcodec disable libavcodec support (default is auto)]
[ Requires: libavcodec libavutil],
[libavcodec_req=$enableval],
[libavcodec_req=$build_default]
)
AC_ARG_ENABLE(lavc-cuda-conv,
AS_HELP_STRING([--enable-lavc-cuda-conv], [enable lavc CUDA conversions (default is disable)]
[Requires: libavcodec CUDA]),
[lavc_cuda_conv_req=$enableval],
[lavc_cuda_conv_req=no]
)
if test "$libavcodec_req" != no; then
PKG_CHECK_MODULES([LIBAVCODEC], [libavcodec >= 53.35.0 ], [found_libavcodec=yes], [found_libavcodec=no])
PKG_CHECK_MODULES([LIBAVUTIL], [libavutil >= 51.22.1 ], [found_libavutil=yes], [found_libavutil=no])
if test "$found_libavcodec" = no || test "$found_libavutil" = no; then
AC_CHECK_HEADERS([libavcodec/avcodec.h libavutil/imgutils.h libavutil/opt.h])
AC_CHECK_LIB(avcodec, avcodec_open2)
AC_CHECK_LIB(avutil, av_free)
if test "${ac_cv_header_libavcodec_avcodec_h?}" = yes && \
test "${ac_cv_header_libavutil_imgutils_h?}" = yes && \
test "${ac_cv_header_libavutil_opt_h?}" = yes && \
test "${ac_cv_lib_avcodec_avcodec_open2?}" = yes && \
test "${ac_cv_lib_avutil_av_free?}" = yes; then
found_libavcodec=yes
found_libavutil=yes
libavcodec_ge_55=yes # TODO
LIBAVCODEC_LIBS="-lavcodec"
LIBAVUTIL_LIBS="-lavutil"
fi
fi
fi
if test $libavcodec_req != no && test $found_libavcodec = yes &&
test $found_libavutil = yes
then
LIBAVCODEC_COMMON="src/libavcodec/lavc_common.o src/libavcodec/utils.o"
LIBAVCODEC_VIDEO="src/libavcodec/lavc_video.o src/libavcodec/from_lavc_vid_conv.o src/libavcodec/to_lavc_vid_conv.o"
if test "$lavc_cuda_conv_req" != no && test "$FOUND_CUDA" = yes &&
test "$system" != MacOSX && test "$nvcc_major" -ge 9
then
lavc_cuda=yes
fi
if test "$lavc_cuda" = yes && test "$system" = Windows &&
test -z "$INCLUDE"; then
lavc_cuda=no
fi
if test "$lavc_cuda" = yes; then
AC_DEFINE([HAVE_LAVC_CUDA_CONV], [1], [Build with lavc CUDA conversions])
to_lavc_cuda_obj=src/libavcodec/to_lavc_vid_conv_cuda.o
LIBAVCODEC_VIDEO="$LIBAVCODEC_VIDEO $to_lavc_cuda_obj src/libavcodec/from_lavc_vid_conv_cuda.o"
fi
AC_DEFINE([HAVE_LAVC], [1], [Build with LAVC support])
if test $lavc_hwacc_vdpau = yes; then
AC_DEFINE([HWACC_VDPAU], [1], [Build with libavcodec VDPAU HW acceleration support])
fi
LIBAVCODEC_AUDIO_CODEC_OBJ="$LIBAVCODEC_COMMON src/audio/codec/libavcodec.o"
LIBAVCODEC_COMPRESS_OBJ="$LIBAVCODEC_COMMON $LIBAVCODEC_VIDEO $HW_ACC_OBJ src/video_compress/libavcodec.o"
LIBAVCODEC_DECOMPRESS_OBJ="$LIBAVCODEC_COMMON $LIBAVCODEC_VIDEO $HW_ACC_OBJ src/video_decompress/libavcodec.o"
if test $system = MacOSX; then
LIBAVCODEC_DECOMPRESS_OBJ="$LIBAVCODEC_DECOMPRESS_OBJ src/hwaccel_videotoolbox.o"
fi
COMMON_FLAGS="$COMMON_FLAGS $LIBAVCODEC_CFLAGS $LIBAVUTIL_CFLAGS"
if test "$system" != Windows; then
CUDA_FLAGS="$CUDA_FLAGS $LIBAVCODEC_CFLAGS $LIBAVUTIL_CFLAGS"
fi
libavcodec=yes
LIBAVCODEC_LIBS="$LIBAVCODEC_LIBS $LIBAVUTIL_LIBS" # added libavutil explicitly
add_module vcompress_libavcodec "$LIBAVCODEC_COMPRESS_OBJ" "$LIBAVCODEC_LIBS $LIBSWSCALE_LIBS"
add_module vdecompress_libavcodec "$LIBAVCODEC_DECOMPRESS_OBJ" "$LIBAVCODEC_LIBS $LAVC_HWACC_LIBS"
add_module acompress_libavcodec "$LIBAVCODEC_AUDIO_CODEC_OBJ" "$LIBAVCODEC_LIBS"
else
HW_ACC_OBJ=
fi
ENSURE_FEATURE_PRESENT([$libavcodec_req], [$libavcodec], [Libavcodec not found])
ENSURE_FEATURE_PRESENT([$lavc_cuda_conv_req], [$lavc_cuda],
[either libavcodec or CUDA>=9 missing for lavc_cuda])
# -------------------------------------------------------------------------------------------------
# File vidcap/display
# -------------------------------------------------------------------------------------------------
file=no
AC_ARG_ENABLE(file,
AS_HELP_STRING([--disable-file], [disable file IO support (default is auto)]
[Requires: libavcodec libavformat libavutil libswscale]),
[file_req=$enableval],
[file_req=$build_default]
)
if test "${file_req?}" = no; then
unset missing_item
elif test "${libavcodec?}" != yes; then
missing_item=libavcodec
elif test "${libswscale?}" != yes; then
missing_item=libswscale
else
missing_item=libavformat
PKG_CHECK_MODULES([LIBAVFORMAT], [libavformat], [found_libavformat=yes], [found_libavformat=no])
if test "$found_libavformat" != yes; then
SAVED_LIBS=$LIBS
AC_CHECK_HEADERS([libavformat/avformat.h])
AC_CHECK_LIB(avformat, avformat_open_input)
LIBS=$SAVED_LIBS
if test "${ac_cv_header_libavformat_avformat_h?}" = yes && \
test "${ac_cv_lib_avformat_avformat_open_input?}" = yes; then
found_libavformat=yes
LIBAVFORMAT_LIBS="-lavformat"
else
found_libavformat=no
fi
fi
if test $found_libavformat = yes; then
COMMON_FLAGS="$COMMON_FLAGS $LIBAVFORMAT_CFLAGS"
file=yes
add_module vidcap_file "src/libavcodec/lavc_common.o "\
src/video_capture/file.o "$LIBAVCODEC_LIBS $LIBAVFORMAT_LIBS $LIBSWSCALE_LIBS"
add_module display_file "src/libavcodec/lavc_common.o "\
"src/video_display/file.o src/libavcodec/to_lavc_vid_conv.o $to_lavc_cuda_obj" \
"$LIBAVCODEC_LIBS $LIBAVFORMAT_LIBS"
fi
fi
ENSURE_FEATURE_PRESENT([${file_req?}], [${file?}], [Vidcap file input ]dnl
[dependencies not found: ${missing_item?}])
# -------------------------------------------------------------------------------------------------
# DRM display
# -------------------------------------------------------------------------------------------------
drm_disp=no
AC_ARG_ENABLE(drm_disp,
AS_HELP_STRING([--disable-drm_disp], [disable DRM display support (default is auto)]
[Requires: libdrm]),
[drm_req=$enableval],
[drm_req=$build_default]
)
if test $drm_req != no; then
PKG_CHECK_MODULES([DRM], [libdrm], FOUND_DRM_DEP=yes, FOUND_DRM_DEP=no)
if test "${drm_req?}" != no && test "${FOUND_DRM_DEP?}" = yes
then
CFLAGS="$CFLAGS ${DRM_CFLAGS}"
CXXFLAGS="$CXXFLAGS ${DRM_CFLAGS}"
DRM_OBJ="src/video_display/drm.o"
add_module display_drm "$DRM_OBJ" "$DRM_LIBS"
drm_disp=yes
fi
fi
ENSURE_FEATURE_PRESENT([$drm_req], [$drm], [drm dep not found (libdrm)])
# -------------------------------------------------------------------------------------------------
# OpenGL display
# -------------------------------------------------------------------------------------------------
GL_LIB=$OPENGL_LIB
gl_display=no
AC_ARG_ENABLE(gl-display,
[ --disable-gl-display disable OpenGL display (default is auto)]
[ Requires: OpenGL GLFW3],
[gl_display_req=$enableval],
[gl_display_req=$build_default]
)
if test "$OPENGL" = yes && test "$gl_display_req" != no
then
PKG_CHECK_MODULES([GLFW], [glfw3], [ FOUND_GLFW=yes ], [ FOUND_GLFW=no ])
if test "$FOUND_GLFW" = yes; then
GL_LIB="$GLFW_LIBS $OPENGL_LIB"
gl_display=yes
if test $lavc_hwacc_vdpau = yes -a $libavcodec = yes; then
HW_ACC_OBJ="${HW_ACC_OBJ} src/video_display/gl_vdpau.o"
fi
COMMON_FLAGS="$COMMON_FLAGS $GLFW_CFLAGS"
add_module display_gl "$GL_COMMON_OBJ $HW_ACC_OBJ src/video_display/gl.o" "$GL_LIB $LAVC_HWACC_LIBS"
fi
fi
ENSURE_FEATURE_PRESENT([$gl_display_req], [$gl_display], [OpenGL not found])
# -------------------------------------------------------------------------------------------------
# SW Mix Stuff
# -------------------------------------------------------------------------------------------------
swmix=no
AC_ARG_ENABLE(swmix,
[ --disable-swmix disable SW mix (default is auto)]
[ Requires: gl],
[swmix_req=$enableval],
[swmix_req=$build_default]
)
if test "$swmix_req" != no && test "$OPENGL_COMMON" = yes
then
swmix=yes
SWMIX_LIB="$OPENGL_LIB"
SWMIX_OBJ="$SWMIX_OBJ $GL_COMMON_OBJ src/video_capture/swmix.o"
add_module vidcap_swmix "$SWMIX_OBJ" "$SWMIX_LIB"
fi
if test $swmix_req = yes && test $swmix = no; then
AC_MSG_ERROR([SW mix was not found (OpenGL libraries missing)]);
fi
# -----------------------------------------------------------------------------
# DirectShow
# -----------------------------------------------------------------------------
dshow=no
AC_ARG_ENABLE(dshow,
AS_HELP_STRING([--disable-dshow], [disable DirectShow support(default is auto)]),
[dshow_req=$enableval],
[dshow_req=$build_default]
)
if test $system = Windows -a $dshow_req != no; then
add_module "" "src/video_capture/DirectShowGrabber.o" \
"-lstrmiids -luuid -lole32 -loleaut32" #-lstrmbase -ldxguid -ldmoguids
dshow=yes
fi
if test $dshow_req = yes && test $dshow = no; then
AC_MSG_ERROR([DirectShow not found]);
fi
# -----------------------------------------------------------------------------
# Pipewire common
# -----------------------------------------------------------------------------
pipewire_common=no
AC_ARG_ENABLE(pipewire,
[ --disable-pipewire disable all pipewire stuff (default is auto)]
[ Requires: pipewire],
[pipewire_common_req=$enableval],
[pipewire_common_req=$build_default]
)
PKG_CHECK_MODULES([PIPEWIRE], [libpipewire-0.3 >= 0.3.30], [found_pw_common_deps=yes], [found_pw_common_deps=no])
if test "${pipewire_common_req?}" != no && test "${found_pw_common_deps?}" = yes
then
pipewire_common=yes
PIPEWIRE_COMMON_LIBS="$($PKG_CONFIG --libs libpipewire-0.3)"
# include pipewire headers as system headers to supress warnings in the headers (instead of -Ipath use -isystem path)
PIPEWIRE_COMMON_INC="$($PKG_CONFIG --cflags-only-I libpipewire-0.3 | sed 's/\(^\| \)-I\//\1-isystem \//g')"
PIPEWIRE_COMMON_OBJ="src/pipewire_common.o"
INC="$INC $PIPEWIRE_COMMON_INC"
CXXFLAGS="$CXXFLAGS $PIPEWIRE_COMMON_INC"
fi
# -----------------------------------------------------------------------------
# Pipewire audio
# -----------------------------------------------------------------------------
pipewire_audio=no
AC_ARG_ENABLE(pipewire-audio,
[ --disable-pipewire-audio disable pipewire audio (default is auto)]
[ Requires: pipewire],
[pipewire_audio_req=$enableval],
[pipewire_audio_req=$build_default]
)
if test "${pipewire_audio_req?}" != no && test "${pipewire_common?}" = yes
then
pipewire_audio=yes
PIPEWIRE_ACAP_OBJS="$PIPEWIRE_COMMON_OBJ src/audio/capture/pipewire.o"
PIPEWIRE_APLAY_OBJS="$PIPEWIRE_COMMON_OBJ src/audio/playback/pipewire.o"
add_module acap_pipewire "$PIPEWIRE_ACAP_OBJS" "$PIPEWIRE_LIBS"
add_module aplay_pipewire "$PIPEWIRE_APLAY_OBJS" "$PIPEWIRE_LIBS"
fi
if test $pipewire_audio_req = yes && test $pipewire_audio = no; then
AC_MSG_ERROR([pipewire audio was not found (libraries missing)]);
fi
# -----------------------------------------------------------------------------
# Pipewire video
# -----------------------------------------------------------------------------
pipewire_video=no
AC_ARG_ENABLE(pipewire-video,
[ --disable-pipewire-video disable pipewire video (default is auto)]
[ Requires: pipewire],
[pipewire_video_req=$enableval],
[pipewire_video_req=$build_default]
)
if test "${pipewire_video_req?}" != no && test "${pipewire_common?}" = yes
then
pipewire_video=yes
PIPEWIRE_DISP_OBJS="$PIPEWIRE_COMMON_OBJ src/video_display/pipewire.o"
PIPEWIRE_CAP_OBJS="$PIPEWIRE_COMMON_OBJ src/video_capture/pipewire.o"
PIPEWIRE_CAP_LIBS="$PIPEWIRE_LIBS"
add_module display_pipewire "$PIPEWIRE_DISP_OBJS" "$PIPEWIRE_LIBS"
#vcap_pipewire module added after screen
fi
if test $pipewire_video_req = yes && test $pipewire_video = no; then
AC_MSG_ERROR([pipewire video was not found (libraries missing)]);
fi
# -------------------------------------------------------------------------------------------------
# Screen capture stuff
# -------------------------------------------------------------------------------------------------
SCREEN_CAP_INC=
SCREEN_CAP_OBJ=
SCREEN_CAP_LIB=
screen_cap=no
screen_cap_x11=no
sc_details=
AC_ARG_ENABLE(screen,
[ --disable-screen disable screen capture (default is auto)]
AS_HELP_STRING([--enable-screen@<:@=x11,pipewire,cg@:>@],
[choose implementation (Linux: can be both x11 and pipewire; macOS: cg]
[ - use Core Graphics implementation instead of AV Foundation).]
[Requires: macOS<15 (cg), AVF (macOS otherwise); X11 or PipeWire (Linux); DShow (Win)]),
[screen_cap_req=$enableval],
[screen_cap_req=$build_default]
)
if test "${system?}" = Linux && test "${screen_cap_req?}" = yes; then
screen_cap_req=pipewire,x11
fi
if test "${system?}" = Windows && test "${screen_cap_req?}" != no; then
SCREEN_CAP_OBJ="src/video_capture/screen_win.o"
DLL_LIBS="${DLL_LIBS:+$DLL_LIBS }${srcdir}/data/screen-capture-recorder-x64.dll"
screen_cap=$dshow
fi
if test "${system?}" = MacOSX && test "${screen_cap_req?}" != no; then
if test "${avfoundation?}" = no || test "${screen_cap_req?}" = cg; then
if test "${macos_major?}" -ge 15; then
AC_MSG_WARN([Core Graphics screen capture]dnl
[unsupported since macOS 15!])
else
SCREEN_CAP_OBJ="src/video_capture/screen_osx.o"
SCREEN_CAP_LIB="-framework CoreFoundation"
screen_modules="Core Graphics"
screen_cap=yes
fi
else
if test "${avfoundation?}" = yes; then
SCREEN_CAP_OBJ="src/video_capture/screen_avf.o"
screen_modules="AV Foundation"
screen_cap=yes
fi
fi
fi
# X11
screen_cap_x11=no
if test "$system" = Linux && test $screen_cap_req != no && test $screen_cap_req != pipewire; then
SAVED_LIBS=$LIBS
AC_CHECK_HEADER(X11/Xlib.h)
AC_CHECK_HEADER(X11/Xutil.h)
AC_CHECK_LIB(X11, XGetImage)
#PKG_CHECK_MODULES([XFIXES], [xfixes], [AC_DEFINE([HAVE_XFIXES], [1], [Build with XFixes support])], [HAVE_XFIXES=no])
AC_CHECK_LIB(Xfixes, XFixesGetCursorImage)
AC_CHECK_HEADER(X11/extensions/Xfixes.h)
LIBS=$SAVED_LIBS
if test "${screen_cap_req?}" != no &&
test "${ac_cv_lib_X11_XGetImage?}" = yes &&
test "${ac_cv_header_X11_Xlib_h?}" = yes &&
test "${ac_cv_header_X11_Xutil_h?}" = yes; then
screen_cap=yes
screen_cap_x11=yes
SCREEN_CAP_LIB="$SCREEN_CAP_LIB -lX11"
if test "${ac_cv_lib_Xfixes_XFixesGetCursorImage?}" = yes &&
test "${ac_cv_header_X11_extensions_Xfixes_h?}" = yes; then
AC_DEFINE([HAVE_XFIXES], [1], [Build with XFixes support])
SCREEN_CAP_LIB="$SCREEN_CAP_LIB -lXfixes"
fi
add_module vidcap_screen_x11 "src/video_capture/screen_x11.o src/x11_common.o" "$SCREEN_CAP_LIB"
screen_modules="${screen_modules:+$screen_modules,}X11"
fi
fi
# PipeWire
found_screen_screen_pw_deps=no
screen_cap_pw=no
if test ${system?} = Linux && test ${screen_cap_req?} != no &&
test ${screen_cap_req} != x11; then
PKG_CHECK_MODULES([SCREEN_PW_DEPS], [glib-2.0 gobject-2.0 gio-unix-2.0 ], [found_screen_screen_pw_deps=yes], [found_screen_screen_pw_deps=no])
fi
if test $found_screen_screen_pw_deps = yes && test $pipewire_video = yes; then
screen_cap=yes
screen_cap_pw=yes
SCREEN_CAP_PIPEWIRE_LIBS="$($PKG_CONFIG --libs glib-2.0) $($PKG_CONFIG --libs gobject-2.0) $($PKG_CONFIG --libs gio-2.0) $($PKG_CONFIG --libs gio-unix-2.0)"
SCREEN_CAP_PIPEWIRE_INC="$($PKG_CONFIG --cflags-only-I glib-2.0) $($PKG_CONFIG --cflags-only-I gobject-2.0) $($PKG_CONFIG --cflags-only-I gio-2.0) $($PKG_CONFIG --cflags-only-I gio-unix-2.0)"
INC="$INC $SCREEN_CAP_PIPEWIRE_INC"
CXXFLAGS="$CXXFLAGS $SCREEN_CAP_PIPEWIRE_INC"
AC_DEFINE([HAVE_DBUS_SCREENCAST], [1], [Build with pipewire screencast dbus support])
PIPEWIRE_CAP_LIBS="$PIPEWIRE_CAP_LIBS $SCREEN_CAP_PIPEWIRE_LIBS"
PIPEWIRE_CAP_OBJS="$PIPEWIRE_CAP_OBJS src/utils/dbus_portal.o"
screen_modules="${screen_modules:+$screen_modules,}pipewire"
fi
if test $screen_cap_req != no && test $screen_cap = yes
then
if test $system = Linux; then
SCREEN_CAP_OBJ="src/video_capture/screen_linux.o"
fi
add_module vidcap_screen "$SCREEN_CAP_OBJ" "$SCREEN_CAP_LIB"
else
screen_cap=no
fi
ENSURE_FEATURE_PRESENT([$screen_cap_req], [$screen_cap], [Screen capture not found])
if { expr "x${screen_cap_req?}" : "x.*x11" >/dev/null &&
test "${screen_cap_x11?}" = no; } ||
{ expr "x${screen_cap_req?}" : "x.*pipewire" >/dev/null &&
test "${screen_cap_pw?}" = no; }; then
AC_MSG_ERROR([Desired screen capture implementation not found!]
[Wanted: ${screen_cap_req?}])
fi
if test -n "$screen_modules"; then
screen_modules=" ($screen_modules)"
fi
if test $pipewire_video = yes
then
add_module vidcap_pipewire "$PIPEWIRE_CAP_OBJS" "$PIPEWIRE_CAP_LIBS"
fi
# -------------------------------------------------------------------------------------------------
# GLSL DXT
# -------------------------------------------------------------------------------------------------
rtdxt=no
AC_ARG_ENABLE(rtdxt,
[ --disable-rtdxt disable Real-Time OpenGL DXT compression (default is auto)]
[ Requires: gl],
[rtdxt_req=$enableval],
[rtdxt_req=$build_default])
AC_DEFINE([USE_PBO_DXT_ENCODER], [1], [We want to use OpenGL pixel buffer objects])
# We probably want this only if there is need to maximalize bandwidth
# With NVidia cards, it increases latency up about 1.5x frame time
#AC_DEFINE([USE_PBO_DXT_ENCODER], [1], [We want to use OpenGL pixel buffer objects])
# Linux
if test "$rtdxt_req" != no && test "$OPENGL_COMMON" = yes
then
rtdxt=yes
RTDXT_LIB="$OPENGL_LIB"
RTDXT_COMMON_OBJ="$RTDXT_COMMON_OBJ $GL_COMMON_OBJ dxt_compress/dxt_util.o"
RTDXT_COMMON_HEADERS="$RTDXT_COMMON_HEADERS dxt_compress/dxt_glsl.h"
RTDXT_COMPRESS_OBJ="$RTDXT_COMMON_OBJ dxt_compress/dxt_encoder.o src/video_compress/dxt_glsl.o"
RTDXT_DECOMPRESS_OBJ="$RTDXT_COMMON_OBJ dxt_compress/dxt_decoder.o src/video_decompress/dxt_glsl.o"
COMMON_FLAGS="$COMMON_FLAGS -Idxt_compress"
add_module vcompress_rtdxt "$RTDXT_COMPRESS_OBJ" "$RTDXT_LIB"
add_module vdecompress_rtdxt "$RTDXT_DECOMPRESS_OBJ" "$RTDXT_LIB"
LIB_GENERATED_HEADERS="$RTDXT_COMMON_HEADERS"
fi
if test $rtdxt_req = yes && test $rtdxt = no; then
AC_MSG_ERROR([RTDXT not found]);
fi
# -------------------------------------------------------------------------------------------------
# UYVY
uyvy=no
AC_ARG_ENABLE(uyvy,
[ --disable-uyvy disable dummy RGB to UYVY compression (default is auto)]
[ Requires: CUDA],
[uyvy_req=$enableval],
[uyvy_req=$build_default])
SAVED_LIBS=$LIBS
if test "$uyvy_req" != no && test "$OPENGL_COMMON" = yes
then
uyvy=yes
fi
# common
if test $uyvy = yes
then
UYVY_COMPRESS_OBJ="$GL_COMMON_OBJ src/video_compress/uyvy.o"
add_module vcompress_uyvy "$UYVY_COMPRESS_OBJ" "$OPENGL_LIB"
fi
if test $uyvy_req = yes && test $uyvy = no; then
AC_MSG_ERROR([UYVY not found]);
fi
# -------------------------------------------------------------------------------------------------
# GPUJPEG
gpujpeg=no
AC_ARG_ENABLE(gpujpeg,
[ --disable-gpujpeg disable GPUJPEG compression (auto)]
[ Requires: libgpujpeg ],
[gpujpeg_req=$enableval],
[gpujpeg_req=$build_default])
if test "$gpujpeg_req" != no; then
SAVED_PKG_CONFIG_PATH=$PKG_CONFIG_PATH
export PKG_CONFIG_PATH="ext-deps/gpujpeg/install/share/pkgconfig:$PKG_CONFIG_PATH"
PKG_CHECK_MODULES([LIBGPUJPEG_ANY], [libgpujpeg], [ found_gpujpeg_any=yes ], [ found_gpujpeg_any=no ])
PKG_CHECK_MODULES([LIBGPUJPEG], [libgpujpeg >= 0.14.0], [ found_gpujpeg=yes ], [ found_gpujpeg=no ])
PKG_CONFIG_PATH=$SAVED_PKG_CONFIG_PATH
if test "${found_gpujpeg_any?}" = yes && test "${found_gpujpeg?}" = no
then
UG_MSG_WARN([Old GPUJPEG version found, please upgrade])
fi
else
found_gpujpeg=no
found_gpujpeg_any=no
fi
# try to find without pkg-config (but only if old version was not detected - to avoid side-loading
# that version without pkg-config version check)
if test "$gpujpeg_req" != no && test "$found_gpujpeg_any" != yes && test "$found_gpujpeg" != yes
then
GPUJPEG_LIB="$GPUJPEG_LIB -lgpujpeg"
SAVED_LIBS=$LIBS
LIBS="$LIBS $GPUJPEG_LIB"
AC_CHECK_LIB([gpujpeg], [gpujpeg_encoder_create])
AC_CHECK_HEADER([libgpujpeg/gpujpeg_decoder.h])
LIBS=$SAVED_LIBS
if test "${ac_cv_lib_gpujpeg_gpujpeg_encoder_create?}" = yes &&
test "${ac_cv_header_libgpujpeg_gpujpeg_decoder_h?}" = yes
then
found_gpujpeg=yes
else
found_gpujpeg=no
fi
fi
if test "$gpujpeg_req" != no && test "$found_gpujpeg" = yes; then
gpujpeg=yes
GPUJPEG_INC="$GPUJPEG_INC $LIBGPUJPEG_CFLAGS"
GPUJPEG_LIB="$GPUJPEG_LIB $LIBGPUJPEG_LIBS"
GPUJPEG_COMPRESS_OBJ="src/video_compress/gpujpeg.o"
GPUJPEG_DECOMPRESS_OBJ="src/video_decompress/gpujpeg.o "
AC_DEFINE([HAVE_GPUJPEG], [1], [Build with GPUJPEG support])
add_module vcompress_gpujpeg "$GPUJPEG_COMPRESS_OBJ" "$GPUJPEG_LIB"
add_module vdecompress_gpujpeg "$GPUJPEG_DECOMPRESS_OBJ" "$GPUJPEG_LIB"
INC="$INC $GPUJPEG_INC"
fi
ENSURE_FEATURE_PRESENT([$gpujpeg_req], [$gpujpeg], [GPUJPEG not found])
# -------------------------------------------------------------------------------------------------
# CUDA DXT
# -------------------------------------------------------------------------------------------------
cuda_dxt=no
AC_ARG_ENABLE(cuda-dxt,
[ --disable-cuda-dxt disable CUDA DXT compression (auto)]
[ Requires: CUDA],
[cuda_dxt_req=$enableval],
[cuda_dxt_req=$build_default])
LIBS=$SAVED_LIBS
CUDA_DXT_COMMON_OBJ="cuda_dxt/cuda_dxt.o"
if test "${cuda_dxt_req?}" != no && test "${FOUND_CUDA?}" = yes
then
cuda_dxt=yes
CUDA_DXT_LIB="$CUDA_DXT_COMMON_LIB $CUDA_LIB"
CUDA_DXT_OBJ="src/video_compress/cuda_dxt.o $CUDA_DXT_COMMON_OBJ $CUDA_COMMON_OBJ"
add_module vcompress_cuda_dxt "$CUDA_DXT_OBJ" "$CUDA_DXT_LIB"
fi
ENSURE_FEATURE_PRESENT([$cuda_dxt_req], [$cuda_dxt], [CUDA DXT not found])
# -------------------------------------------------------------------------------------------------
# GPUJPEG transcode to DXT
# -------------------------------------------------------------------------------------------------
gpujpeg_to_dxt=no
AC_ARG_ENABLE(gpujpeg_to_dxt,
[ --disable-gpujpeg_to_dxt disable GPUJPEG DXT transcoder (default is disable)]
[ Requires: CUDA libgpujpeg],
[gpujpeg_to_dxt_req=$enableval],
[gpujpeg_to_dxt_req=no])
if test "${gpujpeg_to_dxt_req?}" != no && test "${FOUND_CUDA?}" = yes &&
test "${found_gpujpeg?}" = yes
then
gpujpeg_to_dxt=yes
GPUJPEG_TO_DXT_INC=" $CUDA_INC"
GPUJPEG_TO_DXT_LIB="$CUDA_DXT_COMMON_LIB $CUDA_LIB $GPUJPEG_LIB"
GPUJPEG_TO_DXT_OBJ="src/video_decompress/gpujpeg_to_dxt.o $CUDA_COMMON_OBJ $CUDA_DXT_COMMON_OBJ"
add_module vdecompress_gpujpeg_to_dxt "$GPUJPEG_TO_DXT_OBJ" "$GPUJPEG_TO_DXT_LIB"
fi
ENSURE_FEATURE_PRESENT([$gpujpeg_to_dxt], [$gpujpeg_to_dxt_req], [GPUJPEG DXT transcoder not found])
# -------------------------------------------------------------------------------------------------
# gpustitch stuff
# -------------------------------------------------------------------------------------------------
gpustitch=no
AC_ARG_ENABLE(gpustitch,
[ --disable-gpustitch disable gpustitch (default is auto)]
[ Requires: CUDA gpustitch],
[gpustitch_req=$enableval],
[gpustitch_req=$build_default]
)
if test "$gpustitch_req" != no && test "$FOUND_CUDA" = yes; then
PKG_CHECK_MODULES([LIBGPUSTITCH], [libgpustitch >= 0.0.1 ], [found_gpustitch=yes], [found_gpustitch=no])
AC_LANG_PUSH([C++])
SAVED_LIBS=$LIBS
SAVED_CPPFLAGS=$CPPFLAGS
LIBS="$LIBS -lgpustitch"
CPPFLAGS="$CPPFLAGS $LIBGPUSTITCH_CFLAGS"
AC_CHECK_HEADER([libgpustitch/stitcher.hpp])
LIBS=$SAVED_LIBS
CPPFLAGS=$SAVED_CPPFLAGS
AC_LANG_POP([C++])
if test "$ac_cv_header_libgpustitch_stitcher_hpp" != yes
then
found_gpustitch=no
fi
if test "$found_gpustitch" = yes; then
gpustitch=yes
GPUSTITCH_LIB="-lgpustitch $LIBGPUSTITCH_LIBS"
GPUSTITCH_OBJ="src/video_capture/gpustitch.o src/utils/cuda_pix_conv.o $CUDA_COMMON_OBJ"
add_module vidcap_gpustitch "$GPUSTITCH_OBJ" "$GPUSTITCH_LIB"
INC="$INC $LIBGPUSTITCH_CFLAGS"
fi
fi
ENSURE_FEATURE_PRESENT([$gpustitch_req], [$gpustitch ], [GPUSTITCH not found])
# -------------------------------------------------------------------------------------------------
# SAGE stuff
sage=no
AC_ARG_ENABLE(sage,
[ --disable-sage disable SAGE (default is disable)]
[ Requires: SAGE],
[sage_req=$enableval],
[sage_req=no])
AC_ARG_ENABLE(sage-native-dxt5ycocg,
AS_HELP_STRING([--enable-sage-native-dxt5ycocg], [Assume that SAGE supports native DXT5 YCoCg (default is disable)]),
[native_ycocg=$enableval],
[native_ycocg=no])
AC_ARG_WITH(sage,
[ --with-sage=DIR specify location of SAGE],
[SAGE_DIRECTORY=$withval])
if test $native_ycocg = yes
then
AC_DEFINE([SAGE_NATIVE_DXT5YCOCG], [1], [Assume that SAGE supports native DXT5 YCoCg])
fi
# if directory not set manually, use default installation location
if test -z "$SAGE_DIRECTORY"; then
SAGE_DIRECTORY=/usr/local/sage
fi
if test $sage_req != no; then
SAGE_INC=$SAGE_DIRECTORY/include
SAGE_LIB=$SAGE_DIRECTORY/lib64
AC_CHECK_LIB(sail, main, FOUND_SAGE_L=yes, FOUND_SAGE_L=no, -lquanta -I${SAGE_INC} -L${SAGE_LIB})
# if library not found in lib64/ try lib/
if test $FOUND_SAGE_L = no
then
SAGE_LIB=$SAGE_DIRECTORY/lib
AC_CHECK_LIB(sail, main, FOUND_SAGE_L=yes, FOUND_SAGE_L=no, -lquanta -I${SAGE_INC} -L${SAGE_LIB})
fi
AC_CHECK_HEADERS(${SAGE_INC}/sail.h, FOUND_SAGE_H=yes, FOUND_SAGE_H=no)
if test $FOUND_SAGE_L = yes && test $FOUND_SAGE_H = yes
then
SAGE_INC=-I${SAGE_INC}
SAGE_LIB=-"L${SAGE_LIB} -lsail -lquanta"
SAGE_OBJ="src/video_display/sage.o"
CXXFLAGS="$CXXFLAGS -DQUANTA_USE_PTHREADS -DQUANTA_THREAD_SAFE -DGLSL_YUV"
add_module display_sage "$SAGE_OBJ" "$SAGE_LIB"
INC="$INC $SAGE_INC"
sage=yes
fi
fi
ENSURE_FEATURE_PRESENT([$sage_req], [$sage ], [SAGE not found])
# -------------------------------------------------------------------------------------------------
# AUDIO stuff
portaudio=no
AC_ARG_ENABLE(portaudio,
[ --disable-portaudio disable Portaudio (default is auto)]
[ Requires: portaudio-2.0],
[portaudio_req=$enableval],
[portaudio_req=$build_default])
SAVED_LIBS=$LIBS
if test $portaudio_req != no; then
AC_CHECK_HEADER(portaudio.h)
AC_CHECK_LIB(portaudio, Pa_GetDeviceCount) # present in v19
LIBS=$SAVED_LIBS
if test $ac_cv_lib_portaudio_Pa_GetDeviceCount = yes && test $ac_cv_header_portaudio_h = yes
then
PORTAUDIO_LIB='-lportaudio'
AC_CHECK_LIB(portaudio, Pa_GetVersionInfo,
AC_DEFINE([HAVE_PA_GETVERSIONINFO], [1], [Portaudio
has Pa_GetVersionInfo]))
PORTAUDIO_CAP_OBJ="src/audio/portaudio_common.o src/audio/capture/portaudio.o"
PORTAUDIO_PLAY_OBJ="src/audio/portaudio_common.o src/audio/playback/portaudio.o"
add_module acap_portaudio "$PORTAUDIO_CAP_OBJ" "$PORTAUDIO_LIB"
add_module aplay_portaudio "$PORTAUDIO_PLAY_OBJ" "$PORTAUDIO_LIB"
portaudio=yes
fi
fi
ENSURE_FEATURE_PRESENT([$portaudio_req], [$portaudio], [PortAudio not found])
# ---------------------------------------------------------------------------
# SpeexDSP
# ---------------------------------------------------------------------------
speexdsp=no
AC_ARG_ENABLE(speexdsp,
AS_HELP_STRING([--disable-speexdsp], [disable SpeexDSP (default is auto)]),
[speexdsp_req=$enableval],
[speexdsp_req=$build_default])
if test "$speexdsp_req" != no; then
PKG_CHECK_MODULES([LIBSPEEXDSP], [speexdsp], [found_speexdsp=yes], [found_speexdsp=no])
if test "$found_speexdsp" = yes; then
OBJS="$OBJS src/audio/echo.o"
LIBS="$LIBS $LIBSPEEXDSP_LIBS"
COMMON_FLAGS="$COMMON_FLAGS${SPEEXDSP_COMMON_FLAGS:+${COMMON_FLAGS:+ }}$SPEEXDSP_COMMON_FLAGS"
AC_DEFINE([HAVE_SPEEXDSP], [1], [Build with SpeexDSP support])
speexdsp=yes
fi
fi
ENSURE_FEATURE_PRESENT([$speexdsp_req], [$speexdsp], [SpeexDSP not found])
# ---------------------------------------------------------------------------
# SOXR
# ---------------------------------------------------------------------------
soxr=no
AC_ARG_ENABLE(soxr,
AS_HELP_STRING([--disable-soxr], [disable Soxr (default is auto)]),
[soxr_req=$enableval],
[soxr_req=$build_default])
if test "$soxr_req" != no; then
PKG_CHECK_MODULES([LIBSOXR], [soxr], [found_soxr=yes], [found_soxr=no])
if test "$found_soxr" = yes; then
LIBS="$LIBS $LIBSOXR_LIBS"
COMMON_FLAGS="$COMMON_FLAGS${LIBSOXR_CFLAGS:+${COMMON_FLAGS:+ }}$LIBSOXR_CFLAGS"
AC_DEFINE([HAVE_SOXR], [1], [Build with Soxr support])
soxr=yes
fi
fi
ENSURE_FEATURE_PRESENT([$soxr_req], [$soxr], [Soxr not found])
if test "$found_speexdsp" = no && test "$speexdsp_req" != no && test "$soxr" = no && test "$soxr_req" != no; then
UG_MSG_WARN([Neither Soxr nor SpeexDSP was not found. Strongly recommending installing that, otherwise audio part of UG will be crippled.])
fi
# ---------------------------------------------------------------------------
# Zfec
# ---------------------------------------------------------------------------
zfec=no
AC_ARG_ENABLE(zfec,
AS_HELP_STRING([--disable-zfec], [disable zfec (default is auto)]),
[zfec_req=$enableval],
[zfec_req=$build_default])
AC_ARG_WITH(zfec,
AS_HELP_STRING([--with-zfec=DIR], [path to zfec sources]),
[ZFEC_PREFIX=$withval],
[ZFEC_PREFIX=$srcdir/ext-deps/zfec/zfec]
)
found_zfec=no
if test $cross_compile = no && test "$zfec_req" != no; then
AC_CHECK_FILES([$ZFEC_PREFIX/fec.c $ZFEC_PREFIX/fec.h], [found_zfec=yes])
if test $found_zfec = no; then
ZFEC_PREFIX=/usr/lib/python3/dist-packages/zfec
if test ! -d "$ZFEC_PREFIX"; then
ZFEC_PREFIX=$(echo /usr/lib/python* | sed 's/.* \(@<:@^ @:>@*\)/\1/')/site-packages/zfec
fi
if test ! -d "$ZFEC_PREFIX"; then
ZFEC_PREFIX=/usr/local/src/zfec
fi
if test ! -d "$ZFEC_PREFIX"; then
ZFEC_PREFIX=/usr/src/zfec
fi
AC_CHECK_FILES([$ZFEC_PREFIX/fec.c $ZFEC_PREFIX/fec.h], [found_zfec=yes])
fi
if test "$found_zfec" = yes; then
S_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS -I$ZFEC_PREFIX"
AC_MSG_CHECKING([fec_init declaration in fec.h])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include "fec.h"
]],
[[
#pragma GCC diagnostic error "-Wimplicit-function-declaration"
fec_init();]])], fec_init=yes, fec_init=no)
CFLAGS=$S_CFLAGS
if test "$fec_init" = yes; then
AC_DEFINE([HAVE_FEC_INIT], [1], [fec_init must be called before fec_new])
fi
AC_MSG_RESULT($fec_init)
fi
fi
if test "$found_zfec" = yes; then
OBJS="$OBJS src/zfec.o"
COMMON_FLAGS="$COMMON_FLAGS -I$ZFEC_PREFIX"
AC_DEFINE([HAVE_ZFEC], [1], [Build with zfec support])
AC_SUBST(ZFEC_PREFIX)
zfec=yes
fi
ENSURE_FEATURE_PRESENT([$zfec_req], [$found_zfec], [Zfec not found])
# -------------------------------------------------------------------------------------------------
#
# Jack stuff
#
# transport
jack_trans=no
jack=no
AC_ARG_ENABLE(jack-transport,
[ --enable-jack-transport[=force] enable JACK transport (default is auto)]
[ Requires: jack],
[jack_trans_req=$enableval],
[jack_trans_req=$build_default])
# sound system
AC_ARG_ENABLE(jack,
[ --disable-jack disable JACK (default is auto)]
[ Requires: jack],
[jack_req=$enableval],
[jack_req=$build_default])
FOUND_JACK_H=no
if test $jack_trans_req != no || test $jack_req != no; then
AC_CHECK_HEADER(jack/jack.h, FOUND_JACK_H=yes, FOUND_JACK_H=no)
fi
if test "${system?}" != Windows; then
JACK_LIBS=-ldl
fi
if test "${jack_trans_req?}" != no && test "${FOUND_JACK_H?}" = yes
then
OBJS="$OBJS src/audio/jack.o"
LIBS="$LIBS${JACK_LIBS:+ $JACK_LIBS}"
AC_DEFINE([HAVE_JACK_TRANS], [1], [Build with JACK transport support])
jack_trans=yes
fi
if test "${jack_req?}" != no && test "${FOUND_JACK_H?}" = yes
then
JACK_CAP_OBJ="src/audio/capture/jack.o"
JACK_PLAY_OBJ="src/audio/playback/jack.o"
jack=yes
add_module acap_jack "$JACK_CAP_OBJ" "${JACK_LIBS-}"
add_module aplay_jack "$JACK_PLAY_OBJ" "${JACK_LIBS-}"
fi
ENSURE_FEATURE_PRESENT([$jack_req], [$jack], [JACK not found])
# -------------------------------------------------------------------------------------------------
#
# ALSA
#
alsa=no
AC_ARG_ENABLE(alsa,
[ --disable-alsa disable ALSA (default is auto on Linux)]
[ Requires: alsa],
[alsa_req=$enableval],
[alsa_req=$build_default])
if test "$alsa_req" = yes || { test "$alsa_req" != no && test "$system" = Linux ; }; then
AC_CHECK_HEADER(alsa/asoundlib.h)
SAVED_LIBS=$LIBS
AC_CHECK_LIB(asound, snd_pcm_open)
LIBS=$SAVED_LIBS
if test "$ac_cv_header_alsa_asoundlib_h" = yes && test "$ac_cv_lib_asound_snd_pcm_open" = yes; then
alsa=yes
ALSA_CAP_OBJ="src/audio/capture/alsa.o"
ALSA_PLAY_OBJ="src/audio/playback/alsa.o"
ALSA_LIB="-lasound"
add_module acap_alsa "$ALSA_CAP_OBJ" "$ALSA_LIB"
add_module aplay_alsa "$ALSA_PLAY_OBJ" "$ALSA_LIB"
fi
fi
ENSURE_FEATURE_PRESENT([$alsa_req], [$alsa], [ALSA not found])
# -------------------------------------------------------------------------------------------------
# CoreAudio Stuff
coreaudio=no
AC_ARG_ENABLE(coreaudio,
AS_HELP_STRING([--disable-coreaudio], [disable CoreAudio support(default is auto on macOS)]),
[coreaudio_req=$enableval],
[coreaudio_req=$build_default]
)
if test $system = MacOSX && test $coreaudio_req != no; then
AC_CHECK_HEADERS([AudioUnit/AudioUnit.h], [FOUND_AUDIOUNIT_H=yes], [echo "AudioUnit headers not found."])
if test $FOUND_AUDIOUNIT_H = yes
then
COREAUDIO_LIB="-framework CoreAudio -framework AudioUnit -framework AVFoundation"
COREAUDIO_OBJ="src/audio/capture/coreaudio.o src/audio/playback/coreaudio.o"
coreaudio=yes
add_module "" "$COREAUDIO_OBJ" "$COREAUDIO_LIB"
fi
fi
ENSURE_FEATURE_PRESENT([$coreaudio_req], [$coreaudio], [Core Audio not found])
# -------------------------------------------------------------------------------------------------
# Scale Stuff
# -------------------------------------------------------------------------------------------------
scale=no
AC_ARG_ENABLE(scale,
[ --disable-scale disable scale postprocessor (default is auto)]
[ Requires: gl],
[scale_req=$enableval],
[scale_req=$build_default]
)
if test "${scale_req?}" != no && test "${OPENGL_COMMON?}" = yes
then
scale=yes
SCALE_LIB="$SCALE_LIB $OPENGL_LIB"
SCALE_OBJ="$SCALE_OBJ $GL_COMMON_OBJ src/vo_postprocess/scale.o"
add_module vo_pp_scale "$SCALE_OBJ" "$SCALE_LIB"
fi
ENSURE_FEATURE_PRESENT([$scale_req], [$scale], [Scale not found])
# -------------------------------------------------------------------------------------------------
# Text Stuff
# -------------------------------------------------------------------------------------------------
text=no
define(text_dep, MagickWand)
AC_ARG_ENABLE(text,
[ --disable-text disable text postprocessor (default is auto)]
[ Requires: text_dep ],
[text_req=$enableval],
[text_req=$build_default]
)
if test $text_req != no; then
PKG_CHECK_MODULES([TEXT], [text_dep], FOUND_TEXT_DEPS=yes, FOUND_TEXT_DEPS=no)
if test "$FOUND_TEXT_DEPS" = yes; then
text=yes
COMMON_FLAGS="$COMMON_FLAGS $TEXT_CFLAGS"
TEXT_LIB="$TEXT_LIBS"
TEXT_OBJ="$TEXT_OBJ src/vo_postprocess/text.o"
CFLAGS="$CFLAGS $MAGICKWAND_CFLAGS"
add_module vo_pp_text "$TEXT_OBJ" "$TEXT_LIB"
PKG_CHECK_MODULES([WAND7], [MagickWand > 7], [FOUND_WAND7=yes], [FOUND_WAND7=NO])
if test "$FOUND_WAND7" = yes; then
AC_DEFINE([WAND7], [1], [MagickWand is v7 or later])
fi
fi
fi
ENSURE_FEATURE_PRESENT([$text_req], [$text], [text not found])
# -------------------------------------------------------------------------------------------------
# QT GUI
qt_gui=no
static_qt=no
GUI_EXE=
GUI_TARGET=
QMAKE=
#qmake # default for most distributions
AC_ARG_ENABLE(qt,
[ --enable-qt build Qt GUI (default is disabled)]
[ Requires: qt5_gui_dep | Qt6 ],
[qt_req=$enableval],
[qt_req=no]
)
AC_ARG_ENABLE(static-qt,
AS_HELP_STRING([--enable-static-qt], [use statically built Qt (default is disabled)]),
[static_qt=$enableval],
[static_qt=no]
)
if test "$qt_req" != no; then
AC_PATH_PROGS(QMAKE, [qmake qmake6 qmake-qt5], [:],
[/usr/lib/qt5/bin:$PATH])
#AC_MSG_NOTICE("Qmake: $QMAKE")
if test $QMAKE != :; then
GUI_TARGET=gui/QT/uv-qt$APPEXT
GUI_EXE=$GUI_TARGET
if test $system = MacOSX; then
GUI_EXE=$GUI_TARGET/Contents/MacOS/uv-qt
fi
qt_gui=yes
fi
fi
AC_SUBST(GUI_EXE)
AC_SUBST(GUI_TARGET)
AC_SUBST(QMAKE)
ENSURE_FEATURE_PRESENT([$qt_req], [$qt_gui], [Qt libraries are required.])
# -------------------------------------------------------------------------------------------------
# V4L2
# -------------------------------------------------------------------------------------------------
v4l2=no
found_v4l2=no
AC_ARG_ENABLE(v4l2,
AS_HELP_STRING([--disable-v4l2], [disable V4L2 support (default is auto); requires: Linux, v4lconvert (optional)]),
[v4l2_req=$enableval],
[v4l2_req=$build_default]
)
if test "$system" = Linux && test "$v4l2_req" != no
then
AC_CHECK_HEADERS([linux/videodev2.h])
fi
if test "$ac_cv_header_linux_videodev2_h" = yes; then
PKG_CHECK_MODULES([V4LCONVERT], [libv4lconvert], [found_v4lconvert=yes], [found_v4lconvert=no])
if test $found_v4lconvert = yes; then
AC_DEFINE([HAVE_LIBV4LCONVERT], [1], [Build with libv4lconvert support])
elif test "$v4l2_req" = yes; then
UG_MSG_WARN([Compiling V4L2 capture without v4lconvert support (not found).])
fi
V4L2_CAP_OBJ="src/video_capture/v4l2.o"
V4L2_DISP_OBJ="src/video_display/v4l2.o"
add_module vidcap_v4l2 "$V4L2_CAP_OBJ" "$V4LCONVERT_LIBS"
add_module display_v4l2 "$V4L2_DISP_OBJ"
CFLAGS="$CFLAGS $V4LCONVERT_CFLAGS"
v4l2=yes
fi
ENSURE_FEATURE_PRESENT([$v4l2_req], [$v4l2], [V4L2 not found])
# -----------------------------------------------------------------------------
# WASAPI
# -----------------------------------------------------------------------------
wasapi=no
AC_ARG_ENABLE(wasapi,
AS_HELP_STRING([--disable-wasapi], [disable WASAPI support (default is auto)]),
[wasapi_req=$enableval],
[wasapi_req=$build_default]
)
if test "${system?}" = Windows && test "${wasapi_req?}" != no; then
add_module aplay_wasapi "src/audio/capture/wasapi.o src/audio/playback/wasapi.o"
wasapi=yes
fi
ENSURE_FEATURE_PRESENT([$wasapi_req], [$wasapi], [WASAPI not found])
# -------------------------------------------------------------------------------------------------
# iHDTV
# -------------------------------------------------------------------------------------------------
AC_ARG_ENABLE(ihdtv,
AS_HELP_STRING([--enable-ihdtv], [enable iHDTV support (default is disabled)]),
[ihdtv_req=$enableval],
[ihdtv_req=no]
)
ihdtv=no
if test $ihdtv_req = yes
then
AC_DEFINE([HAVE_IHDTV], [1], [Build with iHDTV support])
ihdtv=yes
fi
# -------------------------------------------------------------------------------------------------
# use shared decoder
# -------------------------------------------------------------------------------------------------
# the shared behaviour is faulty, but it saves resources when restarting sender (different SSRC).
shared_decoder=no
if test $shared_decoder = yes
then
AC_DEFINE([SHARED_DECODER], [1], [use shared decoder for all participants])
fi
# -------------------------------------------------------------------------------------------------
# OpenSSL-libcrypto
# -------------------------------------------------------------------------------------------------
crypto=no
crypto_impl=
AC_ARG_ENABLE(openssl,
AS_HELP_STRING([--enable-openssl@<:@=auto|openssl|wolfssl@:>@], [enable encryption support (default is auto)]
[Requires: crypto | wolfssl]),
[crypto_req=$enableval],
[crypto_req=$build_default]
)
check_required_ciphers() {
SAVED_LIBS=$LIBS
LIBS="$LIBS $CRYPTO_LIBS"
AC_CHECK_FUNCS(EVP_aes_128_cbc, [], AC_CHECK_FUNCS(wolfSSL_EVP_aes_128_cbc, [], crypto_impl=))
AC_CHECK_FUNCS(EVP_aes_128_gcm, [], AC_CHECK_FUNCS(wolfSSL_EVP_aes_128_gcm, [], crypto_impl=))
LIBS=$SAVED_LIBS
}
if test "$crypto_req" != no && test "$crypto_req" != wolfssl; then
PKG_CHECK_MODULES([CRYPTO], [libcrypto], [crypto_impl=OpenSSL], [crypto_impl=])
if test -n "$crypto_impl"; then
SAVED_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS $CRYPTO_CFLAGS"
AC_CHECK_HEADER(openssl/aes.h, FOUND_CRYPTO_H=yes, FOUND_CRYPTO_H=no)
if test $FOUND_CRYPTO_H = no; then
UG_MSG_WARN([libcrypto.pc found but openssl/aes.h is not present. This is usually caused by presence of /usr/lib/pkgconfig/libcrypto.pc on macOS. You can install OpenSSL from Homebrew and set PKG_CONFIG_PATH accordingly (see 'brew ln openssl') OR use WolfSSL instead of OpenSSL.])
crypto_impl=
fi
CFLAGS=$SAVED_CFLAGS
check_required_ciphers
fi
fi
if test -z "$crypto_impl" && test "$crypto_req" != no && test "$crypto_req" != openssl; then
PKG_CHECK_MODULES([CRYPTO], [wolfssl], [crypto_impl=wolfSSL], [crypto_impl=])
if test -n "$crypto_impl"; then
check_required_ciphers
AC_DEFINE([HAVE_WOLFSSL], [1], [Using WolfSSL instead of OpenSSL])
fi
fi
if test -n "$crypto_impl"; then
crypto=yes
crypto_impl=" ($crypto_impl)"
OPENSSL_OBJ="src/crypto/openssl_encrypt.o src/crypto/openssl_decrypt.o"
CFLAGS="$CFLAGS $CRYPTO_CFLAGS"
CXXFLAGS="$CXXFLAGS $CRYPTO_CFLAGS"
CPPFLAGS="$CPPFLAGS $CRYPTO_CFLAGS"
add_module openssl "$OPENSSL_OBJ" "$CRYPTO_LIBS"
SAVED_LIBS=$LIBS
LIBS="$LIBS $CRYPTO_LIBS"
# optional ciphers
AC_CHECK_FUNCS(EVP_aes_128_cfb128)
AC_CHECK_FUNCS(EVP_aes_128_ctr)
AC_CHECK_FUNCS(EVP_aes_128_ecb)
AC_CHECK_FUNCS(wolfSSL_EVP_aes_128_cfb128, AC_DEFINE([HAVE_EVP_AES_128_CFB128], [1], [have CFB128]))
AC_CHECK_FUNCS(wolfSSL_EVP_aes_128_ctr, AC_DEFINE([HAVE_EVP_AES_128_CTR], [1], [have CTR]))
AC_CHECK_FUNCS(wolfSSL_EVP_aes_128_ecb, AC_DEFINE([HAVE_EVP_AES_ECB], [1], [have ECB]))
LIBS=$SAVED_LIBS
fi
ENSURE_FEATURE_PRESENT([$crypto_req], [$crypto], [OpenSSL not found])
# -------------------------------------------------------------------------------------------------
# GPU accelerated LDGM
# -------------------------------------------------------------------------------------------------
ldgm_gpu=no
AC_ARG_ENABLE(ldgm-gpu,
[ --disable-ldgm-gpu disable GPU accelerated LDGM (default is auto)]
[ Requires: CUDA],
[ldgm_gpu_req=$enableval],
[ldgm_gpu_req=$build_default]
)
if test "${ldgm_gpu_req?}" != no && test "${FOUND_CUDA?}" = yes
then
LDGM_GPU_OBJS="ldgm/src/ldgm-session-gpu.o src/rtp/ldgm_gpu.o $CUDA_COMMON_OBJ"
LDGM_GPU_LIBS="$CUDA_LIB"
LDGM_GPU_OBJS="$LDGM_GPU_OBJS ldgm/src/gpu.o"
add_module ldgm_gpu "$LDGM_GPU_OBJS" "$LDGM_GPU_LIBS"
if test "${WORD_LEN?}" -eq 32 && test "${system?}" = Linux; then
CUDA_FLAGS="$CUDA_FLAGS -Xcompiler -msse2"
fi
ldgm_gpu=yes
else
ldgm_gpu=no
fi
ENSURE_FEATURE_PRESENT([$ldgm_gpu_req], [$ldgm_gpu], [LDGM accelerated GPU cannot be enabled (CUDA not found?)])
# -------------------------------------------------------------------------------------------------
# Syphon
# -------------------------------------------------------------------------------------------------
syphon=no
AC_ARG_ENABLE(syphon,
[ --enable-syphon enables Syphon support (default is auto on macOS)]
[ Requires: Syphon],
[syphon_req=$enableval],
[syphon_req=$build_default]
)
if test "$syphon_req" != no && test "$system" = MacOSX; then
MY_CHECK_FRAMEWORK([Syphon])
if test $my_cv_framework_Syphon = yes
then
AC_DEFINE([HAVE_SYPHON], [1], [Build with Syphon support])
add_module syphon "src/syphon_server.o src/video_capture/syphon.o" "-framework Syphon"
syphon=yes
fi
fi
ENSURE_FEATURE_PRESENT([$syphon_req], [$syphon], [Syphon framework cannot be found!])
# ------------------------------------------------------------------------------
# Spout
# ------------------------------------------------------------------------------
spout=no
AC_ARG_ENABLE(spout,
[ --enable-spout enables Spout support (default is auto)]
[ Requires: Spout GLEW],
[spout_req=$enableval],
[spout_req=$build_default]
)
FOUND_SPOUT=no
missing_item="OpenGL"
if test $system = Windows && test "$spout_req" != no && test "$OPENGL_COMMON" = yes
then
AC_LANG_PUSH([C++])
SAVED_LIBS="$LIBS"
LIBS="$LIBS -lSpoutLibrary"
AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <SpoutLibrary.h>]],
[[auto *spout = GetSpout();]])],
FOUND_SPOUT=yes, FOUND_SPOUT=no)
LIBS=$SAVED_LIBS
missing_item="SpoutLibrary.h"
AC_LANG_POP([C++])
fi
if test $FOUND_SPOUT = yes
then
AC_DEFINE([HAVE_SPOUT], [1], [Build with Spout support])
add_module spout "src/spout_sender.o src/video_capture/spout.o" -lSpoutLibrary
spout=yes
fi
ENSURE_FEATURE_PRESENT([$spout_req], [$spout], [Could not found Spout dependencies: ${missing_item?}])
# -------------------------------------------------------------------------------------------------
# MCU-like video mixer
# -------------------------------------------------------------------------------------------------
video_mix=no
AC_ARG_ENABLE(video-mixer,
[ --disable-video-mixer disable MCU-like video mixer (default is auto)]
[ Requires: opencv],
[video_mix_req=$enableval],
[video_mix_req=$build_default]
)
if test $video_mix_req != no && test "$opencv" = yes && test "$FOUND_OPENCV_IMGPROC" = yes; then
CFLAGS="$CFLAGS $OPENCV_CFLAGS"
CXXFLAGS="$CXXFLAGS $OPENCV_CFLAGS"
add_module display_video_mix src/video_display/conference.o "$OPENCV_LIBS -lopencv_imgproc"
video_mix=yes
fi
ENSURE_FEATURE_PRESENT([$video_mix_req], [$video_mix], [Could not found OpenCV needed for video mixer!])
# ------------------------------------------------------------------------------------------------
# BitFlow
# -------------------------------------------------------------------------------------------------
AC_ARG_ENABLE(bitflow,
AS_HELP_STRING([--enable-bitflow], [Compile BitFlow grabber support]),
[bitflow_req=$enableval],
[bitflow_req=no]
)
bitflow=no
if test $bitflow_req = yes
then
LIBS="$LIBS -lBFSOciLib -lBFciLib -lBFML"
OBJS="$OBJS src/video_capture/bitflow.o"
bitflow=yes
fi
# ------------------------------------------------------------------------------
# Comprimato J2K
# ------------------------------------------------------------------------------
cmpto_j2k=no
AC_ARG_ENABLE(cmpto-j2k,
[ --enable-cmpto-j2k enables Comprimato J2K support (default is auto)]
[ Requires: cmpto_j2k],
[cmpto_j2k_req=$enableval],
[cmpto_j2k_req=$build_default]
)
if test $cmpto_j2k_req != no; then
AC_CHECK_HEADER(cmpto_j2k_enc.h, FOUND_CMPTO_J2K_ENC_H=yes, FOUND_CMPTO_J2K_ENC_H=no)
AC_CHECK_HEADER(cmpto_j2k_dec.h, FOUND_CMPTO_J2K_DEC_H=yes, FOUND_CMPTO_J2K_DEC_H=no)
AC_CHECK_LIB(cmpto_j2k_enc, cmpto_j2k_enc_ctx_cfg_create, FOUND_CMPTO_J2K_ENC_L=yes, FOUND_CMPTO_J2K_ENC_L=no)
AC_CHECK_LIB(cmpto_j2k_dec, cmpto_j2k_dec_ctx_cfg_create, FOUND_CMPTO_J2K_DEC_L=yes, FOUND_CMPTO_J2K_DEC_L=no)
fi
if test "$cmpto_j2k_req" != no &&
test "$FOUND_CMPTO_J2K_ENC_H" = yes &&
test "$FOUND_CMPTO_J2K_DEC_H" = yes &&
test "$FOUND_CMPTO_J2K_ENC_L" = yes &&
test "$FOUND_CMPTO_J2K_DEC_L" = yes
then
cmpto_libs=
kernels=
if test "$FOUND_CUDA" = yes; then
cmpto_libs="$CUDA_LIB"
kernels="src/cuda_wrapper/kernels.o"
else
UG_MSG_WARN([CUDA is recommended for optimal cmpto_j2k performance but not found])
fi
# OpenCL
PKG_CHECK_MODULES([OpenCL], [OpenCL], [found_cl=yes], [found_cl=no])
PKG_CHECK_MODULES([OpenCL_Headers], [OpenCL-Headers], [found_cl_h=yes],
[found_cl_h=no])
if test "${found_cl?}" = yes && test "${found_cl_h?}" = yes; then
AC_DEFINE([HAVE_OPENCL], [1], [OpenCL is supported])
cmpto_libs="$cmpto_libs $OpenCL_LIBS"
CFLAGS="$CFLAGS${OpenCL_CFLAGS:+ $OPENCL_CFLAGS}"
CFLAGS="$CFLAGS${OpenCL_Headers_CFLAGS:+ $OPENCL_Headers_CFLAGS}"
fi
add_module vcompress_cmpto_j2k "src/video_compress/cmpto_j2k.o \
src/utils/opencl.o $kernels" "-lcmpto_j2k_enc $cmpto_libs"
add_module vdecompress_cmpto_j2k "src/video_decompress/cmpto_j2k.o \
$kernels" "-lcmpto_j2k_dec $cmpto_libs"
cmpto_j2k=yes
fi
ENSURE_FEATURE_PRESENT([$cmpto_j2k_req], [$cmpto_j2k], [Comprimato J2K not found!])
# ------------------------------------------------------------------------------
# NDI
# ------------------------------------------------------------------------------
ndi=no
AC_ARG_ENABLE(ndi,
AS_HELP_STRING([--enable-ndi@<:@=ver@:>@], [enables NDI support (default is auto).]
[Set ver to 5 if using NDI 5.]),
[ndi_req=$enableval],
[ndi_req=$build_default]
)
NDI_VER=
if expr "x$ndi_req" : 'x@<:@0-9@:>@' >/dev/null; then
NDI_VER=$ndi_req
ndi_req=yes
fi
if test $ndi_req != no; then
S_CPATH=$CPATH
if test -n "$NDI_SDK_DIR"; then
CPATH="$CPATH;$NDI_SDK_DIR/Include"
export CPATH
fi
AC_CHECK_HEADER(Processing.NDI.Lib.h, FOUND_NDI_H=yes, FOUND_NDI_H=no)
CPATH=$S_CPATH
if test "$FOUND_NDI_H" = yes
then
if test -n "$NDI_SDK_DIR" && test $system = Windows; then
COMMON_FLAGS="$COMMON_FLAGS -I\"$NDI_SDK_DIR/Include\""
fi
if test -n "$NDI_VER"; then
AC_DEFINE_UNQUOTED([USE_NDI_VERSION], [$NDI_VER], [NDI version to use])
fi
add_module vidcap_ndi src/video_capture/ndi.o
add_module display_ndi src/video_display/ndi.o
ndi=yes
fi
fi
ENSURE_FEATURE_PRESENT([$ndi_req], [$ndi], [NDI not found!])
# ------------------------------------------------------------------------------
# Cineform
# ------------------------------------------------------------------------------
CINEFORM_PATH=$srcdir/ext-deps/cineform-sdk
cineform=no
AC_ARG_ENABLE(cineform,
AS_HELP_STRING([--disable-cineform], [disable cineform suppport (default is auto)]
[Requires: CINEFORM_SDK]),
[cineform_req=$enableval],
[cineform_req=$build_default]
)
if test -n "$CINEFORM_DIRECTORY"; then
CINEFORM_PATH=$CINEFORM_DIRECTORY
fi
AC_ARG_WITH(cineform,
[ --with-cineform=DIR specify location of Cineform SDK],
[CINEFORM_PATH=$withval
])
if test "$cineform_req" != no; then
PKG_CHECK_MODULES([CINEFORM], [libcineformsdk], [FOUND_CINEFORM=yes], [FOUND_CINEFORM=no])
if test "$FOUND_CINEFORM" = no; then # libcineform fork
PKG_CHECK_MODULES([CINEFORM], [libcineform], [FOUND_CINEFORM=yes], [FOUND_CINEFORM=no])
fi
fi
if test "$cineform_req" != no && test "$FOUND_CINEFORM" = no
then
AC_LANG_PUSH([C++])
AC_CHECK_LIB(CFHDCodec, CFHD_OpenDecoder, [FOUND_CINEFORM=yes; CINEFORM_LIBS=-lCFHDCodec], FOUND_CINEFORM=no)
AC_LANG_POP([C++])
fi
if test "$cineform_req" != no && test "$FOUND_CINEFORM" = no
then
if test $system = Windows
then
CINEFORM_LIBS="${CINEFORM_PATH}/Release/CFHDCodec.lib"
else
CINEFORM_LIBS="${CINEFORM_PATH}/libCFHDCodec.a"
fi
if test -n "${CINEFORM_PATH?}" && test "${cross_compile?}" = no
then
AC_CHECK_FILES(${CINEFORM_LIBS}, FOUND_CINEFORM=yes, FOUND_CINEFORM=no)
fi
fi
if test "$FOUND_CINEFORM" = yes; then
CINEFORM_CFLAGS="$CINEFORM_CFLAGS -I${CINEFORM_PATH}/Common/"
if test "$system" = Linux
then
CINEFORM_LIBS="${CINEFORM_LIBS} -luuid"
fi
fi
if test "${cineform_req?}" != no && test "${FOUND_CINEFORM?}" = yes
then
cineform=yes
CINEFORM_COMPRESS_OBJ="src/video_compress/cineform.o"
CINEFORM_DECOMPRESS_OBJ="src/video_decompress/cineform.o"
INC="$INC $CINEFORM_CFLAGS"
add_module vcompress_cineform "$CINEFORM_COMPRESS_OBJ" "$CINEFORM_LIBS"
add_module vdecompress_cineform "$CINEFORM_DECOMPRESS_OBJ" "$CINEFORM_LIBS"
fi
ENSURE_FEATURE_PRESENT([$cineform_req], [$cineform], [CINEFORM not found])
# ---------------------------------------------------------------------
# NAT-PMP
# -----------------------------------
natpmp=no
AC_ARG_ENABLE(natpmp,
[ --disable-natpmp disable NAT-PMP suppport (default is auto)]
[ Requires: natpmp],
[natpmp_req=$enableval],
[natpmp_req=$build_default]
)
if test "$natpmp_req" != no; then
AC_CHECK_HEADER(natpmp.h, FOUND_NATPMP_H=yes, FOUND_NATPMP_H=no)
AC_CHECK_LIB(natpmp, initnatpmp, FOUND_NATPMP_L=yes, FOUND_NATPMP_L=no)
if test "$FOUND_NATPMP_H" = yes && test "$FOUND_NATPMP_L" = yes; then
LIBS="-lnatpmp $LIBS"
AC_DEFINE([HAVE_NATPMP], [1], [Build with NAT-PMP support])
if test $system = Windows; then
COMMON_FLAGS="$COMMON_FLAGS -DNATPMP_STATICLIB"
fi
natpmp=yes
fi
fi
ENSURE_FEATURE_PRESENT([$natpmp_req], [$natpmp], [NAT-PMP not found])
# ---------------------------------------------------------------------
# PCP
# -----------------------------------
pcp=no
AC_ARG_ENABLE(pcp,
[ --disable-pcp disable PCP suppport (default is auto)]
[ Requires: libpcp],
[pcp_req=$enableval],
[pcp_req=$build_default]
)
if test "$pcp_req" != no; then
PKG_CHECK_MODULES([PCP], [libpcpnatpmp], [FOUND_PCP=new],
[FOUND_PCP=no])
if test "$FOUND_PCP" = no; then
PKG_CHECK_MODULES([PCP], [libpcp-client], [FOUND_PCP=old],
[FOUND_PCP=no])
fi
if test "$FOUND_PCP" != no; then
LIBS="$PCP_LIBS $LIBS"
AC_DEFINE([HAVE_PCP], [1], [Build with PCP support])
if test "$FOUND_PCP" = new; then
AC_DEFINE([HAVE_PCP_NEW], [1], [Build with new PCP name])
fi
pcp=yes
fi
fi
ENSURE_FEATURE_PRESENT([$pcp_req], [$pcp], [PCP not found])
# ---------------------------------------------------------------------
# fluidsynth audio capture synthesizer
# ---------------------------------------------------------------------
AC_ARG_ENABLE(fluidsynth,
AS_HELP_STRING([--disable-fluidsynth],
[disable fluidtynth audio capture (default is auto)]),
[fluidsynth_req=$enableval],
[fluidsynth_req=$build_default])
fluidsynth=no
if test "${fluidsynth_req?}" != no; then
PKG_CHECK_MODULES([FLUIDSYNTH], [fluidsynth], [found_fluidsynth=yes],
[found_fluidsynth=no])
if test "${found_fluidsynth?}" = yes; then
add_module acap_fluidsynth src/audio/capture/fluidsynth.o "$FLUIDSYNTH_LIBS"
INC="$INC${FLUIDSYNTH_CFLAGS:+ $FLUIDSYNTH_CFLAGS}"
fluidsynth=yes
fi
fi
ENSURE_FEATURE_PRESENT([$fluidsynth_req], [$fluidsynth], [fluidsynth not found!])
# -----------------------------------------------------------------------------
# Reflector
# -----------------------------------------------------------------------------
AC_ARG_ENABLE(reflector,
AS_HELP_STRING([--disable-reflector], [disables reflector (default is enabled)]),
[reflector_req=$enableval],
[reflector_req=$build_default])
if test "$reflector_req" != no; then
REFLECTOR_TARGET=bin/hd-rum-transcode
if test "$man" = yes; then
MANPAGES="$MANPAGES hd-rum-transcode.1"
fi
fi
AC_SUBST(REFLECTOR_TARGET)
# ------------------------------------------------------------------------------
# Non-essential objs
# ------------------------------------------------------------------------------
AC_ARG_ENABLE(object,
AS_HELP_STRING([--enable-object], [enable specific object(s) ]
[compilation (typically when disabled non-essential features with ]
[--disable-all; comma-separated, "all" to enable all)]),
[req_files=$enableval],
[req_files=])
if test -n "$req_files" && test "$req_files" != all; then
OBJS="$OBJS $(echo "$req_files" | sed 's/,/ /g')"
fi
if test "$build_default" != no || test "$req_files" = all; then
ULTRAGRID_OBJS="$ULTRAGRID_OBJS
src/audio/capture/passive.o
src/audio/playback/dump.o
src/audio/playback/mixer.o
src/audio/filter/delay.o
src/audio/filter/discard.o
src/audio/filter/controlport_stats.o
src/audio/filter/silence.o
src/audio/filter/playback.o
src/audio/filter/channel_remap.o
src/capture_filter/change_pixfmt.o
src/capture_filter/color.o
src/capture_filter/display.o
src/capture_filter/disrupt.o
src/capture_filter/every.o
src/capture_filter/flip.o
src/capture_filter/gamma.o
src/capture_filter/grayscale.o
src/capture_filter/logo.o
src/capture_filter/matrix.o
src/capture_filter/matrix2.o
src/capture_filter/mirror.o
src/capture_filter/noise.o
src/capture_filter/override_prop.o
src/capture_filter/preview.o
src/capture_filter/ratelimit.o
src/capture_filter/split.o
src/capture_filter/temporal_3d.o
src/utils/sdp_parser.o
src/audio/capture/aes67.o
src/video_capture/aggregate.o
src/video_capture/import.o
src/video_capture/switcher.o
src/video_capture/ug_input.o
src/video_decompress/i420.o
src/video_display/aggregate.o
src/video_display/dump.o
src/video_display/multiplier.o
src/video_display/pipe.o
src/video_display/unix_sock.o
src/video_rxtx/h264_sdp.o
src/video_rxtx/ihdtv.o
src/video_rxtx/loopback.o
src/video_rxtx/sage.o
src/vo_postprocess/3d-interlaced.o
src/vo_postprocess/border.o
src/vo_postprocess/crop.o
src/vo_postprocess/deinterlace.o
src/vo_postprocess/delay.o
src/vo_postprocess/interlace.o
src/vo_postprocess/split.o
src/vo_postprocess/temporal-deint.o
src/vo_postprocess/temporal_3d.o
"
fi
# -------------------------------------------------------------------------------------------------
# We need to add libraries then
# -------------------------------------------------------------------------------------------------
TEST_LIBS="$LIB_MODULES $LIBS $UG_LIB_MODULES"
TEST_OBJS="$OBJS $LIB_OBJS $UG_LIB_OBJS"
REFLECTOR_OBJS="src/video_display/blend.o src/video_display/pipe.o"
# this is only needed when passing to "clean" make target
if test "$build_libraries" != yes
then
LIBS="$LIB_MODULES $LIBS"
OBJS="$OBJS $LIB_OBJS"
ULTRAGRID_OBJS="$ULTRAGRID_OBJS $UG_LIB_OBJS"
ULTRAGRID_LIBS="$UG_LIB_MODULES"
GENERATED_HEADERS="$GENERATED_HEADERS $LIB_GENERATED_HEADERS"
LIB_OBJS=
LIB_GENERATED_HEADERS=
MODULES=
TARGETS=
fi
TOREMOVE="$LIB_OBJS $UG_LIB_OBJS"
# remove duplicite objs
REFLECTOR_OBJS=`echo $REFLECTOR_OBJS $OBJS | tr ' ' '\n' | sort | uniq | tr '\n' ' '`
TEST_OBJS=`echo $TEST_OBJS | tr ' ' '\n' | sort | uniq | tr '\n' ' '`
ULTRAGRID_OBJS=`echo $ULTRAGRID_OBJS $OBJS | tr ' ' '\n' | sort | uniq | tr '\n' ' '`
AC_SUBST(BIN_DEPS)
AC_SUBST(GENERATED_HEADERS)
AC_SUBST(LIB_GENERATED_HEADERS)
AC_SUBST(MODULES)
AC_SUBST(REFLECTOR_OBJS)
AC_SUBST(TARGETS)
AC_SUBST(TEST_LIBS)
AC_SUBST(TEST_OBJS)
AC_SUBST(TOREMOVE)
# -------------------------------------------------------------------------------------------------
# Print summary + set it to AUTOCONF_RESULT
# -------------------------------------------------------------------------------------------------
start_section() {
printf "$1\n$2:"
true # set $? to zero -> causes add_column to start on new line
}
end_section() {
printf "$1
"
}
# params: <result> <feature> <bool> 0|1
# 0 - print left column; 1 - print right column
add_column() {
PAD_DOTS=31
# left column
if test "${4?}" -eq 0; then
printf "$1\n $2 $(for n in `seq ${#2} $PAD_DOTS`; do printf .; done) $(printf %-3s $3)"
return 1
else
# right column
printf "$1 $2 $(for n in `seq ${#2} $PAD_DOTS`; do printf .; done) $(printf %-3s $3)\n"
return 0
fi
}
RESULT="Target: $target\n"
# features
RESULT=`start_section "$RESULT" "Features"`
RESULT=`add_column "$RESULT" "Crypto$crypto_impl" $crypto $?`
RESULT=`add_column "$RESULT" "CUDA support$HOST_CC_REPORT" $FOUND_CUDA $?`
RESULT=`add_column "$RESULT" "Debug output" $debug_output $?`
RESULT=`add_column "$RESULT" "iHDTV support" $ihdtv $?`
RESULT=`add_column "$RESULT" "IPv6 support" $ipv6 $?`
RESULT=`add_column "$RESULT" "Library live555" $livemedia $?`
RESULT=`add_column "$RESULT" "Libbacktrace" $libbacktrace $?`
RESULT=`add_column "$RESULT" "Manual pages" $man $?`
RESULT=`add_column "$RESULT" "OpenCV" $opencv $?`
RESULT=`add_column "$RESULT" "Profiling support" $profile $?`
RESULT=`add_column "$RESULT" "Qt GUI" $qt_gui $?`
RESULT=`add_column "$RESULT" "RT priority" $use_rt $?`
RESULT=`add_column "$RESULT" "Soxr" $soxr $?`
RESULT=`add_column "$RESULT" "SpeexDSP" $speexdsp $?`
RESULT=`add_column "$RESULT" "Standalone modules" $build_libraries $?`
RESULT=`add_column "$RESULT" "zfec" $zfec $?`
RESULT=`end_section "$RESULT"`
# audio
RESULT=`start_section "$RESULT" "Audio"`
RESULT=`add_column "$RESULT" "ALSA" $alsa $?`
RESULT=`add_column "$RESULT" "CoreAudio" $coreaudio $?`
RESULT=`add_column "$RESULT" "FluidSynth" $fluidsynth $?`
RESULT=`add_column "$RESULT" "JACK" $jack $?`
RESULT=`add_column "$RESULT" "JACK transport" $jack_trans $?`
RESULT=`add_column "$RESULT" "Pipewire" $pipewire_audio $?`
RESULT=`add_column "$RESULT" "Portaudio" $portaudio $?`
RESULT=`add_column "$RESULT" "WASAPI" $wasapi $?`
RESULT=`end_section "$RESULT"`
# video
RESULT=`start_section "$RESULT" "Video"`
RESULT=`add_column "$RESULT" "AJA" $aja $?`
RESULT=`add_column "$RESULT" "AV Foundation" $avfoundation $?`
RESULT=`add_column "$RESULT" "BitFlow" $bitflow $?`
RESULT=`add_column "$RESULT" "Bluefish444" $bluefish444 $?`
RESULT=`add_column "$RESULT" "caca" $caca $?`
RESULT=`add_column "$RESULT" "DeckLink" $decklink $?`
RESULT=`add_column "$RESULT" "DELTACAST" $deltacast $?`
RESULT=`add_column "$RESULT" "DirectShow" $dshow $?`
RESULT=`add_column "$RESULT" "DRM" $drm_disp $?`
RESULT=`add_column "$RESULT" "DVS" $dvs $?`
RESULT=`add_column "$RESULT" "File" $file $?`
RESULT=`add_column "$RESULT" "Gpustitch" $gpustitch $?`
RESULT=`add_column "$RESULT" "NDI" $ndi $?`
RESULT=`add_column "$RESULT" "OpenGL" $gl_display $?`
RESULT=`add_column "$RESULT" "OpenXR VR Display" $xrgl_disp $?`
RESULT=`add_column "$RESULT" "Panorama Gl Display" $panogl_disp $?`
RESULT=`add_column "$RESULT" "Pipewire" $pipewire_video $?`
RESULT=`add_column "$RESULT" "RTSP capture client" $rtsp $?`
RESULT=`add_column "$RESULT" "SAGE" $sage $?`
RESULT=`add_column "$RESULT" "Screen capture$screen_modules" $screen_cap $?`
RESULT=`add_column "$RESULT" "SDL$sdl_version_str" $sdl $?`
RESULT=`add_column "$RESULT" "SW video mix" $swmix $?`
RESULT=`add_column "$RESULT" "V4L2" $v4l2 $?`
RESULT=`add_column "$RESULT" "Vulkan$vulkan_sdl_ver" $vulkan $?`
RESULT=`add_column "$RESULT" "XIMEA" $ximea $?`
RESULT=`end_section "$RESULT"`
# compressions
RESULT=`start_section "$RESULT" "Compressions"`
RESULT=`add_column "$RESULT" "Cineform" $cineform $?`
RESULT=`add_column "$RESULT" "Comprimato J2K" $cmpto_j2k $?`
RESULT=`add_column "$RESULT" "CUDA DXT" $cuda_dxt $?`
RESULT=`add_column "$RESULT" "GPUJPEG" $gpujpeg $?`
RESULT=`add_column "$RESULT" "GPUJPEG transcode to DXT" $gpujpeg_to_dxt $?`
RESULT=`add_column "$RESULT" "Lavc (VDP $lavc_hwacc_vdpau, VA $lavc_hwacc_vaapi)" $libavcodec $?`
RESULT=`add_column "$RESULT" "Realtime DXT" $rtdxt $?`
RESULT=`add_column "$RESULT" "UYVY dummy compression" $uyvy $?`
RESULT=`end_section "$RESULT"`
# other
RESULT=`start_section "$RESULT" "Others"`
RESULT=`add_column "$RESULT" "Blank capture filter" $blank $?`
RESULT=`add_column "$RESULT" "GPU accelerated LDGM" $ldgm_gpu $?`
RESULT=`add_column "$RESULT" "Hole punching" $libjuice $?`
RESULT=`add_column "$RESULT" "iHDTV support" $ihdtv $?`
RESULT=`add_column "$RESULT" "MCU-like video mixer" $video_mix $?`
RESULT=`add_column "$RESULT" "NAT-PMP traversal" $natpmp $?`
RESULT=`add_column "$RESULT" "PCP NAT traversal" $pcp $?`
RESULT=`add_column "$RESULT" "Resize capture filter" $resize $?`
RESULT=`add_column "$RESULT" "RTSP server" $rtsp_server $?`
RESULT=`add_column "$RESULT" "Scale postprocessor" $scale $?`
RESULT=`add_column "$RESULT" "SDP over HTTP" $sdp_http $?`
RESULT=`add_column "$RESULT" "Spout" $spout $?`
RESULT=`add_column "$RESULT" "Swscale support" $libswscale $?`
RESULT=`add_column "$RESULT" "Syphon" $syphon $?`
RESULT=`add_column "$RESULT" "Testcard2 (TTF: $FOUND_SDL_TTF)" \
$testcard2 $?`
RESULT=`add_column "$RESULT" "Text postprocess and filter" $text $?`
RESULT=`end_section "$RESULT"`
AC_MSG_RESULT(
[
UltraGrid configuration summary
===============================])
AC_MSG_RESULT([$RESULT])
if test -n "$WARNINGS"; then
printf "*** Following WARNINGS were issued:\n$WARNINGS\n"
fi
RES_STR=`printf "$RESULT" | sed 's/$/\\\\n/' | tr -d '\n'`
AC_DEFINE_UNQUOTED([AUTOCONF_RESULT], "$RES_STR", [Autoconf result])
# -------------------------------------------------------------------------------------------------
# Finally, substitute things into the Makefile and config.h
# -------------------------------------------------------------------------------------------------
AC_DEFINE_UNQUOTED([SRCDIR], "$srcdir", [path to src directory])
AC_CONFIG_HEADERS([src/config.h])
AC_CONFIG_FILES([Makefile])
AC_OUTPUT
Reference in New Issue View Git Blame Copy Permalink