mirror of
https://github.com/libsdl-org/SDL.git
synced 2025-11-04 01:34:38 +00:00
4404 lines
158 KiB
Plaintext
4404 lines
158 KiB
Plaintext
dnl Process this file with autoconf to produce a configure script.
|
|
AC_INIT(README.txt)
|
|
AC_CONFIG_HEADER(include/SDL_config.h)
|
|
AC_CONFIG_AUX_DIR(build-scripts)
|
|
AC_CONFIG_MACRO_DIR([acinclude])
|
|
|
|
dnl Save the CFLAGS to see whether they were passed in or generated
|
|
orig_CFLAGS="$CFLAGS"
|
|
|
|
dnl Set various version strings - taken gratefully from the GTk sources
|
|
#
|
|
# Making releases:
|
|
# Edit include/SDL_version.h and change the version, then:
|
|
# SDL_MICRO_VERSION += 1;
|
|
# SDL_INTERFACE_AGE += 1;
|
|
# SDL_BINARY_AGE += 1;
|
|
# if any functions have been added, set SDL_INTERFACE_AGE to 0.
|
|
# if backwards compatibility has been broken,
|
|
# set SDL_BINARY_AGE and SDL_INTERFACE_AGE to 0.
|
|
#
|
|
SDL_MAJOR_VERSION=2
|
|
SDL_MINOR_VERSION=0
|
|
SDL_MICRO_VERSION=13
|
|
SDL_INTERFACE_AGE=1
|
|
SDL_BINARY_AGE=13
|
|
SDL_VERSION=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION.$SDL_MICRO_VERSION
|
|
|
|
AC_SUBST(SDL_MAJOR_VERSION)
|
|
AC_SUBST(SDL_MINOR_VERSION)
|
|
AC_SUBST(SDL_MICRO_VERSION)
|
|
AC_SUBST(SDL_INTERFACE_AGE)
|
|
AC_SUBST(SDL_BINARY_AGE)
|
|
AC_SUBST(SDL_VERSION)
|
|
|
|
# libtool versioning
|
|
LT_INIT([win32-dll])
|
|
LT_LANG([Windows Resource])
|
|
|
|
LT_RELEASE=$SDL_MAJOR_VERSION.$SDL_MINOR_VERSION
|
|
LT_CURRENT=`expr $SDL_MICRO_VERSION - $SDL_INTERFACE_AGE`
|
|
LT_REVISION=$SDL_INTERFACE_AGE
|
|
LT_AGE=`expr $SDL_BINARY_AGE - $SDL_INTERFACE_AGE`
|
|
m4_pattern_allow([^LT_])
|
|
|
|
AC_SUBST(LT_RELEASE)
|
|
AC_SUBST(LT_CURRENT)
|
|
AC_SUBST(LT_REVISION)
|
|
AC_SUBST(LT_AGE)
|
|
|
|
dnl Detect the canonical build and host environments
|
|
dnl AC_CANONICAL_HOST
|
|
|
|
dnl Check for tools
|
|
AC_PROG_LIBTOOL
|
|
AC_PROG_CC
|
|
AC_PROG_CXX
|
|
AC_PROG_INSTALL
|
|
AC_PROG_MAKE_SET
|
|
AC_LIBTOOL_RC
|
|
PKG_PROG_PKG_CONFIG
|
|
|
|
dnl Make sure that srcdir is a full pathname
|
|
case "$host" in
|
|
*-*-mingw32*)
|
|
# Except on msys, where make can't handle full pathnames (bug 1972)
|
|
;;
|
|
*)
|
|
srcdir=`cd $srcdir && pwd`
|
|
;;
|
|
esac
|
|
|
|
dnl Set up the compiler and linker flags
|
|
INCLUDE="-I$srcdir/include -idirafter $srcdir/src/video/khronos"
|
|
if test x$srcdir != x.; then
|
|
INCLUDE="-Iinclude $INCLUDE"
|
|
elif test -d .hg; then
|
|
AC_MSG_ERROR([
|
|
*** When building from Mercurial you should configure and build in a
|
|
separate directory so you don't clobber SDL_config.h, SDL_revision.h
|
|
])
|
|
fi
|
|
BASE_CFLAGS=""
|
|
BASE_LDFLAGS=""
|
|
case "$host" in
|
|
*-*-cygwin*)
|
|
# We build SDL on cygwin without the UNIX emulation layer
|
|
save_CFLAGS="$CFLAGS"
|
|
have_no_cygwin=no
|
|
AC_MSG_CHECKING(for GCC -mno-cygwin option)
|
|
CFLAGS="$save_CFLAGS -mno-cygwin"
|
|
|
|
AC_TRY_COMPILE([
|
|
],[
|
|
],[
|
|
have_no_cygwin=yes
|
|
])
|
|
AC_MSG_RESULT($have_no_cygwin)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_no_cygwin = xyes; then
|
|
BASE_CFLAGS="-mno-cygwin"
|
|
BASE_LDFLAGS="-mno-cygwin"
|
|
fi
|
|
BASE_CFLAGS="$BASE_CFLAGS -I/usr/include/mingw"
|
|
;;
|
|
esac
|
|
# Uncomment the following line if you want to force SDL and applications
|
|
# built with it to be compiled for a particular architecture.
|
|
#AX_GCC_ARCHFLAG([no], [BASE_CFLAGS="$BASE_CFLAGS $ax_cv_gcc_archflag]")
|
|
BUILD_CFLAGS="$CFLAGS $CPPFLAGS -DUSING_GENERATED_CONFIG_H"
|
|
# The default optimization for SDL is -O3 (Bug #31)
|
|
if test "x$orig_CFLAGS" = x; then
|
|
BUILD_CFLAGS=`echo $BUILD_CFLAGS | sed 's/-O2/-O3/'`
|
|
fi
|
|
EXTRA_CFLAGS="$INCLUDE $BASE_CFLAGS"
|
|
BUILD_LDFLAGS="$LDFLAGS"
|
|
EXTRA_LDFLAGS="$BASE_LDFLAGS"
|
|
## These are common directories to find software packages
|
|
#for path in /usr/freeware /usr/pkg /usr/X11R6 /usr/local; do
|
|
# if test -d $path/include; then
|
|
# EXTRA_CFLAGS="$EXTRA_CFLAGS -I$path/include"
|
|
# fi
|
|
# if test -d $path/lib; then
|
|
# EXTRA_LDFLAGS="$EXTRA_LDFLAGS -L$path/lib"
|
|
# fi
|
|
#done
|
|
SDL_CFLAGS="$BASE_CFLAGS"
|
|
SDL_LIBS="-lSDL2"
|
|
if test "x$BASE_LDFLAGS" != x; then
|
|
SDL_LIBS="$SDL_LIBS $BASE_LDFLAGS"
|
|
fi
|
|
if test "x$EXTRA_CFLAGS" != x; then
|
|
CPPFLAGS="$CPPFLAGS $EXTRA_CFLAGS"
|
|
CFLAGS="$CFLAGS $EXTRA_CFLAGS"
|
|
fi
|
|
if test "x$EXTRA_LDFLAGS" != x; then
|
|
LDFLAGS="$LDFLAGS $EXTRA_LDFLAGS"
|
|
fi
|
|
|
|
dnl set this to use on systems that use lib64 instead of lib
|
|
base_libdir=`echo \${libdir} | sed 's/.*\/\(.*\)/\1/; q'`
|
|
|
|
dnl Function to find a library in the compiler search path
|
|
find_lib()
|
|
{
|
|
gcc_bin_path=[`$CC -print-search-dirs 2>/dev/null | fgrep programs: | sed 's/[^=]*=\(.*\)/\1/' | sed 's/:/ /g'`]
|
|
gcc_lib_path=[`$CC -print-search-dirs 2>/dev/null | fgrep libraries: | sed 's/[^=]*=\(.*\)/\1/' | sed 's/:/ /g'`]
|
|
env_lib_path=[`echo $LIBS $LDFLAGS $* | sed 's/-L[ ]*//g'`]
|
|
if test "$cross_compiling" = yes; then
|
|
host_lib_path=""
|
|
else
|
|
host_lib_path="/usr/$base_libdir /usr/local/$base_libdir"
|
|
fi
|
|
for path in $env_lib_path $gcc_bin_path $gcc_lib_path $host_lib_path; do
|
|
lib=[`ls -- $path/$1 2>/dev/null | sed -e '/\.so\..*\./d' -e 's,.*/,,' | sort | tail -1`]
|
|
if test x$lib != x; then
|
|
echo $lib
|
|
return
|
|
fi
|
|
done
|
|
# Try again, this time allowing more than one version digit after the .so
|
|
for path in $env_lib_path $gcc_bin_path $gcc_lib_path $host_lib_path; do
|
|
lib=[`ls -- $path/$1 2>/dev/null | sed -e 's,.*/,,' | sort | tail -1`]
|
|
if test x$lib != x; then
|
|
echo $lib
|
|
return
|
|
fi
|
|
done
|
|
}
|
|
|
|
dnl Check for compiler characteristics
|
|
AC_C_CONST
|
|
AC_C_INLINE
|
|
AC_C_VOLATILE
|
|
|
|
dnl See whether we want assertions for debugging/sanity checking SDL itself.
|
|
AC_ARG_ENABLE(assertions,
|
|
AS_HELP_STRING([--enable-assertions],
|
|
[Enable internal sanity checks (auto/disabled/release/enabled/paranoid) [[default=auto]]]),
|
|
, enable_assertions=auto)
|
|
case "$enable_assertions" in
|
|
auto) # Use optimization settings to determine assertion level
|
|
;;
|
|
disabled)
|
|
AC_DEFINE(SDL_DEFAULT_ASSERT_LEVEL, 0, [ ])
|
|
;;
|
|
release)
|
|
AC_DEFINE(SDL_DEFAULT_ASSERT_LEVEL, 1, [ ])
|
|
;;
|
|
enabled)
|
|
AC_DEFINE(SDL_DEFAULT_ASSERT_LEVEL, 2, [ ])
|
|
;;
|
|
paranoid)
|
|
AC_DEFINE(SDL_DEFAULT_ASSERT_LEVEL, 3, [ ])
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([*** unknown assertion level. stop.])
|
|
;;
|
|
esac
|
|
|
|
dnl See whether we can use gcc style dependency tracking
|
|
AC_ARG_ENABLE(dependency-tracking,
|
|
AS_HELP_STRING([--enable-dependency-tracking],
|
|
[Use gcc -MMD -MT dependency tracking [[default=yes]]]),
|
|
, enable_dependency_tracking=yes)
|
|
if test x$enable_dependency_tracking = xyes; then
|
|
have_gcc_mmd_mt=no
|
|
AC_MSG_CHECKING(for GCC -MMD -MT option)
|
|
AC_TRY_COMPILE([
|
|
#if !defined(__GNUC__) || __GNUC__ < 3
|
|
#error Dependency tracking requires GCC 3.0 or newer
|
|
#endif
|
|
],[
|
|
],[
|
|
have_gcc_mmd_mt=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_mmd_mt)
|
|
|
|
if test x$have_gcc_mmd_mt = xyes; then
|
|
DEPENDENCY_TRACKING_OPTIONS="-MMD -MT \$@"
|
|
fi
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for linker option --no-undefined)
|
|
have_no_undefined=no
|
|
case "$host" in
|
|
dnl Skip this on platforms where it is just simply busted.
|
|
*-*-openbsd*)
|
|
;;
|
|
|
|
*)
|
|
save_LDFLAGS="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS -Wl,--no-undefined"
|
|
AC_TRY_LINK([
|
|
],[
|
|
],[
|
|
have_no_undefined=yes
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--no-undefined"
|
|
])
|
|
LDFLAGS="$save_LDFLAGS"
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($have_no_undefined)
|
|
|
|
AC_MSG_CHECKING(for linker option --dynamicbase)
|
|
have_dynamicbase=no
|
|
case "$host" in
|
|
*)
|
|
save_LDFLAGS="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS -Wl,--dynamicbase"
|
|
AC_TRY_LINK([
|
|
],[
|
|
],[
|
|
have_dynamicbase=yes
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--dynamicbase"
|
|
])
|
|
LDFLAGS="$save_LDFLAGS"
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($have_dynamicbase)
|
|
|
|
AC_MSG_CHECKING(for linker option --nxcompat)
|
|
have_nxcompat=no
|
|
case "$host" in
|
|
*)
|
|
save_LDFLAGS="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS -Wl,--nxcompat"
|
|
AC_TRY_LINK([
|
|
],[
|
|
],[
|
|
have_nxcompat=yes
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--nxcompat"
|
|
])
|
|
LDFLAGS="$save_LDFLAGS"
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($have_nxcompat)
|
|
|
|
AC_MSG_CHECKING(for linker option --high-entropy-va)
|
|
have_high_entropy_va=no
|
|
case "$host" in
|
|
*)
|
|
save_LDFLAGS="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS -Wl,--high-entropy-va"
|
|
AC_TRY_LINK([
|
|
],[
|
|
],[
|
|
have_high_entropy_va=yes
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,--high-entropy-va"
|
|
])
|
|
LDFLAGS="$save_LDFLAGS"
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($have_high_entropy_va)
|
|
|
|
dnl See whether we are allowed to use the system C library
|
|
AC_ARG_ENABLE(libc,
|
|
AS_HELP_STRING([--enable-libc], [Use the system C library [[default=yes]]]),
|
|
, enable_libc=yes)
|
|
if test x$enable_libc = xyes; then
|
|
AC_DEFINE(HAVE_LIBC, 1, [ ])
|
|
|
|
dnl Check for C library headers
|
|
AC_HEADER_STDC
|
|
AC_CHECK_HEADERS(sys/types.h stdio.h stdlib.h stddef.h stdarg.h malloc.h memory.h string.h strings.h wchar.h inttypes.h stdint.h limits.h ctype.h math.h float.h iconv.h signal.h)
|
|
|
|
dnl Check for typedefs, structures, etc.
|
|
AC_TYPE_SIZE_T
|
|
|
|
dnl Check for defines
|
|
AC_CHECK_DEFINE(M_PI, math.h)
|
|
|
|
dnl Checks for library functions.
|
|
case "$host" in
|
|
*-*-cygwin* | *-*-mingw32*)
|
|
;;
|
|
*)
|
|
AC_FUNC_ALLOCA
|
|
;;
|
|
esac
|
|
|
|
AC_FUNC_MEMCMP
|
|
if test x$ac_cv_func_memcmp_working = xyes; then
|
|
AC_DEFINE(HAVE_MEMCMP, 1, [ ])
|
|
fi
|
|
AC_FUNC_STRTOD
|
|
if test x$ac_cv_func_strtod = xyes; then
|
|
AC_DEFINE(HAVE_STRTOD, 1, [ ])
|
|
fi
|
|
AC_CHECK_FUNC(mprotect,
|
|
AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#include <sys/mman.h>
|
|
],[
|
|
],[
|
|
AC_DEFINE(HAVE_MPROTECT, 1, [ ])
|
|
]),
|
|
)
|
|
AC_CHECK_FUNCS(malloc calloc realloc free getenv setenv putenv unsetenv qsort abs bcopy memset memcpy memmove wcslen wcslcpy wcslcat wcsdup wcsstr wcscmp wcsncmp strlen strlcpy strlcat _strrev _strupr _strlwr strchr strrchr strstr strtok_r itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp vsscanf vsnprintf fopen64 fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname getauxval poll _Exit)
|
|
|
|
AC_CHECK_LIB(m, pow, [LIBS="$LIBS -lm"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm"])
|
|
AC_CHECK_FUNCS(acos acosf asin asinf atan atanf atan2 atan2f ceil ceilf copysign copysignf cos cosf exp expf fabs fabsf floor floorf fmod fmodf log logf log10 log10f pow powf scalbn scalbnf sin sinf sqrt sqrtf tan tanf)
|
|
|
|
AC_CHECK_LIB(iconv, iconv_open, [LIBS="$LIBS -liconv"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -liconv"])
|
|
AC_CHECK_FUNCS(iconv)
|
|
|
|
AC_CHECK_MEMBER(struct sigaction.sa_sigaction,[AC_DEFINE([HAVE_SA_SIGACTION], 1, [ ])], ,[#include <signal.h>])
|
|
|
|
dnl Check for additional non-standard headers
|
|
AC_CHECK_HEADERS(libunwind.h)
|
|
fi
|
|
|
|
dnl AC_CHECK_SIZEOF(void*)
|
|
|
|
dnl See whether we can use gcc atomic operations on this architecture
|
|
AC_ARG_ENABLE(gcc-atomics,
|
|
AS_HELP_STRING([--enable-gcc-atomics],
|
|
[Use gcc builtin atomics [[default=yes]]]),
|
|
, enable_gcc_atomics=yes)
|
|
if test x$enable_gcc_atomics = xyes; then
|
|
have_gcc_atomics=no
|
|
AC_MSG_CHECKING(for GCC builtin atomic operations)
|
|
AC_TRY_LINK([
|
|
],[
|
|
int a;
|
|
void *x, *y, *z;
|
|
__sync_lock_test_and_set(&a, 4);
|
|
__sync_lock_test_and_set(&x, y);
|
|
__sync_fetch_and_add(&a, 1);
|
|
__sync_bool_compare_and_swap(&a, 5, 10);
|
|
__sync_bool_compare_and_swap(&x, y, z);
|
|
],[
|
|
have_gcc_atomics=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_atomics)
|
|
|
|
if test x$have_gcc_atomics = xyes; then
|
|
AC_DEFINE(HAVE_GCC_ATOMICS, 1, [ ])
|
|
else
|
|
# See if we have the minimum operation needed for GCC atomics
|
|
AC_TRY_LINK([
|
|
],[
|
|
int a;
|
|
__sync_lock_test_and_set(&a, 1);
|
|
__sync_lock_release(&a);
|
|
],[
|
|
have_gcc_sync_lock_test_and_set=yes
|
|
])
|
|
if test x$have_gcc_sync_lock_test_and_set = xyes; then
|
|
AC_DEFINE(HAVE_GCC_SYNC_LOCK_TEST_AND_SET, 1, [ ])
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Standard C sources
|
|
SOURCES="$SOURCES $srcdir/src/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/atomic/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/audio/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/cpuinfo/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/dynapi/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/events/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/file/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/haptic/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/joystick/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/libm/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/power/*.c"
|
|
#SOURCES="$SOURCES $srcdir/src/filesystem/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/render/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/render/*/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/sensor/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/stdlib/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/thread/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/timer/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/video/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/video/yuv2rgb/*.c"
|
|
|
|
dnl Enable/disable various subsystems of the SDL library
|
|
|
|
AC_ARG_ENABLE(atomic,
|
|
AS_HELP_STRING([--enable-atomic], [Enable the atomic operations subsystem [[default=yes]]]),
|
|
, enable_atomic=yes)
|
|
if test x$enable_atomic != xyes; then
|
|
AC_DEFINE(SDL_ATOMIC_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} atomic"
|
|
fi
|
|
AC_ARG_ENABLE(audio,
|
|
AS_HELP_STRING([--enable-audio], [Enable the audio subsystem [[default=yes]]]),
|
|
, enable_audio=yes)
|
|
if test x$enable_audio != xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} audio"
|
|
fi
|
|
AC_ARG_ENABLE(video,
|
|
AS_HELP_STRING([--enable-video], [Enable the video subsystem [[default=yes]]]),
|
|
, enable_video=yes)
|
|
if test x$enable_video != xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} video"
|
|
fi
|
|
AC_ARG_ENABLE(render,
|
|
AS_HELP_STRING([--enable-render], [Enable the render subsystem [[default=yes]]]),
|
|
, enable_render=yes)
|
|
if test x$enable_render != xyes; then
|
|
AC_DEFINE(SDL_RENDER_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} render"
|
|
fi
|
|
AC_ARG_ENABLE(events,
|
|
AS_HELP_STRING([--enable-events], [Enable the events subsystem [[default=yes]]]),
|
|
, enable_events=yes)
|
|
if test x$enable_events != xyes; then
|
|
AC_DEFINE(SDL_EVENTS_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} events"
|
|
fi
|
|
AC_ARG_ENABLE(joystick,
|
|
AS_HELP_STRING([--enable-joystick], [Enable the joystick subsystem [[default=yes]]]),
|
|
, enable_joystick=yes)
|
|
if test x$enable_joystick != xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} joystick"
|
|
fi
|
|
AC_ARG_ENABLE(haptic,
|
|
AS_HELP_STRING([--enable-haptic], [Enable the haptic (force feedback) subsystem [[default=yes]]]),
|
|
, enable_haptic=yes)
|
|
if test x$enable_haptic != xyes; then
|
|
AC_DEFINE(SDL_HAPTIC_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} haptic"
|
|
fi
|
|
AC_ARG_ENABLE(sensor,
|
|
AS_HELP_STRING([--enable-sensor], [Enable the sensor subsystem [[default=yes]]]),
|
|
, enable_sensor=yes)
|
|
if test x$enable_sensor != xyes; then
|
|
AC_DEFINE(SDL_SENSOR_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} sensor"
|
|
fi
|
|
AC_ARG_ENABLE(power,
|
|
AS_HELP_STRING([--enable-power], [Enable the power subsystem [[default=yes]]]),
|
|
, enable_power=yes)
|
|
if test x$enable_power != xyes; then
|
|
AC_DEFINE(SDL_POWER_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} power"
|
|
fi
|
|
AC_ARG_ENABLE(filesystem,
|
|
AS_HELP_STRING([--enable-filesystem], [Enable the filesystem subsystem [[default=yes]]]),
|
|
, enable_filesystem=yes)
|
|
if test x$enable_filesystem != xyes; then
|
|
AC_DEFINE(SDL_FILESYSTEM_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} filesystem"
|
|
fi
|
|
AC_ARG_ENABLE(threads,
|
|
AS_HELP_STRING([--enable-threads], [Enable the threading subsystem [[default=yes]]]),
|
|
, enable_threads=yes)
|
|
if test x$enable_threads != xyes; then
|
|
AC_DEFINE(SDL_THREADS_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} threads"
|
|
fi
|
|
AC_ARG_ENABLE(timers,
|
|
AS_HELP_STRING([--enable-timers], [Enable the timer subsystem [[default=yes]]]),
|
|
, enable_timers=yes)
|
|
if test x$enable_timers != xyes; then
|
|
AC_DEFINE(SDL_TIMERS_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} timers"
|
|
fi
|
|
AC_ARG_ENABLE(file,
|
|
AS_HELP_STRING([--enable-file], [Enable the file subsystem [[default=yes]]]),
|
|
, enable_file=yes)
|
|
if test x$enable_file != xyes; then
|
|
AC_DEFINE(SDL_FILE_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} file"
|
|
fi
|
|
AC_ARG_ENABLE(loadso,
|
|
AS_HELP_STRING([--enable-loadso], [Enable the shared object loading subsystem [[default=yes]]]),
|
|
, enable_loadso=yes)
|
|
if test x$enable_loadso != xyes; then
|
|
AC_DEFINE(SDL_LOADSO_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} loadso"
|
|
fi
|
|
AC_ARG_ENABLE(cpuinfo,
|
|
AS_HELP_STRING([--enable-cpuinfo], [Enable the cpuinfo subsystem [[default=yes]]]),
|
|
, enable_cpuinfo=yes)
|
|
if test x$enable_cpuinfo != xyes; then
|
|
AC_DEFINE(SDL_CPUINFO_DISABLED, 1, [ ])
|
|
else
|
|
SUMMARY_modules="${SUMMARY_modules} cpuinfo"
|
|
fi
|
|
AC_ARG_ENABLE(assembly,
|
|
AS_HELP_STRING([--enable-assembly], [Enable assembly routines [[default=yes]]]),
|
|
, enable_assembly=yes)
|
|
if test x$enable_assembly = xyes; then
|
|
SUMMARY_modules="${SUMMARY_modules} assembly"
|
|
|
|
AC_DEFINE(SDL_ASSEMBLY_ROUTINES, 1, [ ])
|
|
|
|
# Make sure that we don't generate floating point code that would
|
|
# cause illegal instruction exceptions on older processors
|
|
case "$host" in
|
|
*-*-darwin*)
|
|
# Don't need to worry about Apple hardware, it's all SSE capable
|
|
default_ssemath=yes
|
|
;;
|
|
*64-*-*)
|
|
# x86 64-bit architectures all have SSE instructions
|
|
default_ssemath=yes
|
|
;;
|
|
*)
|
|
default_ssemath=no
|
|
;;
|
|
esac
|
|
AC_ARG_ENABLE(ssemath,
|
|
AS_HELP_STRING([--enable-ssemath], [Allow GCC to use SSE floating point math [[default=maybe]]]),
|
|
, enable_ssemath=$default_ssemath)
|
|
if test x$enable_ssemath = xno; then
|
|
if test x$have_gcc_sse = xyes -o x$have_gcc_sse2 = xyes -o x$have_gcc_sse3 = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -mfpmath=387"
|
|
fi
|
|
fi
|
|
|
|
dnl Check for various instruction support
|
|
AC_ARG_ENABLE(mmx,
|
|
AS_HELP_STRING([--enable-mmx], [use MMX assembly routines [[default=yes]]]),
|
|
, enable_mmx=yes)
|
|
if test x$enable_mmx = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
have_gcc_mmx=no
|
|
AC_MSG_CHECKING(for GCC -mmmx option)
|
|
mmx_CFLAGS="-mmmx"
|
|
CFLAGS="$save_CFLAGS $mmx_CFLAGS"
|
|
|
|
AC_TRY_COMPILE([
|
|
#ifdef __MINGW32__
|
|
#include <_mingw.h>
|
|
#ifdef __MINGW64_VERSION_MAJOR
|
|
#include <intrin.h>
|
|
#else
|
|
#include <mmintrin.h>
|
|
#endif
|
|
#else
|
|
#include <mmintrin.h>
|
|
#endif
|
|
#ifndef __MMX__
|
|
#error Assembler CPP flag not enabled
|
|
#endif
|
|
],[
|
|
],[
|
|
have_gcc_mmx=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_mmx)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_mmx = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $mmx_CFLAGS"
|
|
SUMMARY_math="${SUMMARY_math} mmx"
|
|
fi
|
|
fi
|
|
|
|
AC_ARG_ENABLE(3dnow,
|
|
AS_HELP_STRING([--enable-3dnow], [use 3DNow! assembly routines [[default=yes]]]),
|
|
, enable_3dnow=yes)
|
|
if test x$enable_3dnow = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
have_gcc_3dnow=no
|
|
AC_MSG_CHECKING(for GCC -m3dnow option)
|
|
amd3dnow_CFLAGS="-m3dnow"
|
|
CFLAGS="$save_CFLAGS $amd3dnow_CFLAGS"
|
|
|
|
AC_TRY_LINK([
|
|
#include <mm3dnow.h>
|
|
#ifndef __3dNOW__
|
|
#error Assembler CPP flag not enabled
|
|
#endif
|
|
],[
|
|
void *p = 0;
|
|
_m_prefetch(p);
|
|
],[
|
|
have_gcc_3dnow=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_3dnow)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_3dnow = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $amd3dnow_CFLAGS"
|
|
SUMMARY_math="${SUMMARY_math} 3dnow"
|
|
fi
|
|
fi
|
|
|
|
AC_ARG_ENABLE(sse,
|
|
AS_HELP_STRING([--enable-sse], [use SSE assembly routines [[default=yes]]]),
|
|
, enable_sse=yes)
|
|
if test x$enable_sse = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
have_gcc_sse=no
|
|
AC_MSG_CHECKING(for GCC -msse option)
|
|
sse_CFLAGS="-msse"
|
|
CFLAGS="$save_CFLAGS $sse_CFLAGS"
|
|
|
|
AC_TRY_COMPILE([
|
|
#ifdef __MINGW32__
|
|
#include <_mingw.h>
|
|
#ifdef __MINGW64_VERSION_MAJOR
|
|
#include <intrin.h>
|
|
#else
|
|
#include <xmmintrin.h>
|
|
#endif
|
|
#else
|
|
#include <xmmintrin.h>
|
|
#endif
|
|
#ifndef __SSE__
|
|
#error Assembler CPP flag not enabled
|
|
#endif
|
|
],[
|
|
],[
|
|
have_gcc_sse=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_sse)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_sse = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $sse_CFLAGS"
|
|
SUMMARY_math="${SUMMARY_math} sse"
|
|
fi
|
|
fi
|
|
|
|
AC_ARG_ENABLE(sse2,
|
|
AS_HELP_STRING([--enable-sse2], [use SSE2 assembly routines [[default=maybe]]]),
|
|
, enable_sse2=$default_ssemath)
|
|
if test x$enable_sse2 = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
have_gcc_sse2=no
|
|
AC_MSG_CHECKING(for GCC -msse2 option)
|
|
sse2_CFLAGS="-msse2"
|
|
CFLAGS="$save_CFLAGS $sse2_CFLAGS"
|
|
|
|
AC_TRY_COMPILE([
|
|
#ifdef __MINGW32__
|
|
#include <_mingw.h>
|
|
#ifdef __MINGW64_VERSION_MAJOR
|
|
#include <intrin.h>
|
|
#else
|
|
#include <emmintrin.h>
|
|
#endif
|
|
#else
|
|
#include <emmintrin.h>
|
|
#endif
|
|
#ifndef __SSE2__
|
|
#error Assembler CPP flag not enabled
|
|
#endif
|
|
],[
|
|
],[
|
|
have_gcc_sse2=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_sse2)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_sse2 = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $sse2_CFLAGS"
|
|
SUMMARY_math="${SUMMARY_math} sse2"
|
|
fi
|
|
fi
|
|
|
|
AC_ARG_ENABLE(sse3,
|
|
AS_HELP_STRING([--enable-sse3], [use SSE3 assembly routines [[default=maybe]]]),
|
|
, enable_sse3=$default_ssemath)
|
|
if test x$enable_sse3 = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
have_gcc_sse3=no
|
|
AC_MSG_CHECKING(for GCC -msse3 option)
|
|
sse3_CFLAGS="-msse3"
|
|
CFLAGS="$save_CFLAGS $sse3_CFLAGS"
|
|
|
|
AC_TRY_COMPILE([
|
|
#ifdef __MINGW32__
|
|
#include <_mingw.h>
|
|
#ifdef __MINGW64_VERSION_MAJOR
|
|
#include <intrin.h>
|
|
#else
|
|
#include <pmmintrin.h>
|
|
#endif
|
|
#else
|
|
#include <pmmintrin.h>
|
|
#endif
|
|
#ifndef __SSE2__
|
|
#error Assembler CPP flag not enabled
|
|
#endif
|
|
],[
|
|
],[
|
|
have_gcc_sse3=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_sse3)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_sse3 = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $sse3_CFLAGS"
|
|
SUMMARY_math="${SUMMARY_math} sse3"
|
|
fi
|
|
fi
|
|
|
|
AC_CHECK_HEADER(immintrin.h,
|
|
have_immintrin_h_hdr=yes,
|
|
have_immintrin_h_hdr=no)
|
|
if test x$have_immintrin_h_hdr = xyes; then
|
|
AC_DEFINE(HAVE_IMMINTRIN_H, 1, [ ])
|
|
fi
|
|
|
|
AC_ARG_ENABLE(altivec,
|
|
AS_HELP_STRING([--enable-altivec], [use Altivec assembly routines [[default=yes]]]),
|
|
, enable_altivec=yes)
|
|
if test x$enable_altivec = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
have_gcc_altivec=no
|
|
have_altivec_h_hdr=no
|
|
altivec_CFLAGS="-maltivec"
|
|
CFLAGS="$save_CFLAGS $altivec_CFLAGS"
|
|
|
|
AC_MSG_CHECKING(for Altivec with GCC altivec.h and -maltivec option)
|
|
AC_TRY_COMPILE([
|
|
#include <altivec.h>
|
|
vector unsigned int vzero() {
|
|
return vec_splat_u32(0);
|
|
}
|
|
],[
|
|
],[
|
|
have_gcc_altivec=yes
|
|
have_altivec_h_hdr=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_altivec)
|
|
|
|
if test x$have_gcc_altivec = xno; then
|
|
AC_MSG_CHECKING(for Altivec with GCC -maltivec option)
|
|
AC_TRY_COMPILE([
|
|
vector unsigned int vzero() {
|
|
return vec_splat_u32(0);
|
|
}
|
|
],[
|
|
],[
|
|
have_gcc_altivec=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_altivec)
|
|
fi
|
|
|
|
if test x$have_gcc_altivec = xno; then
|
|
AC_MSG_CHECKING(for Altivec with GCC altivec.h and -faltivec option)
|
|
altivec_CFLAGS="-faltivec"
|
|
CFLAGS="$save_CFLAGS $altivec_CFLAGS"
|
|
AC_TRY_COMPILE([
|
|
#include <altivec.h>
|
|
vector unsigned int vzero() {
|
|
return vec_splat_u32(0);
|
|
}
|
|
],[
|
|
],[
|
|
have_gcc_altivec=yes
|
|
have_altivec_h_hdr=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_altivec)
|
|
fi
|
|
|
|
if test x$have_gcc_altivec = xno; then
|
|
AC_MSG_CHECKING(for Altivec with GCC -faltivec option)
|
|
AC_TRY_COMPILE([
|
|
vector unsigned int vzero() {
|
|
return vec_splat_u32(0);
|
|
}
|
|
],[
|
|
],[
|
|
have_gcc_altivec=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_altivec)
|
|
fi
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_altivec = xyes; then
|
|
AC_DEFINE(SDL_ALTIVEC_BLITTERS, 1, [ ])
|
|
if test x$have_altivec_h_hdr = xyes; then
|
|
AC_DEFINE(HAVE_ALTIVEC_H, 1, [ ])
|
|
fi
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $altivec_CFLAGS"
|
|
SUMMARY_math="${SUMMARY_math} altivec"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
dnl See if the OSS audio interface is supported
|
|
CheckOSS()
|
|
{
|
|
AC_ARG_ENABLE(oss,
|
|
AS_HELP_STRING([--enable-oss], [support the OSS audio API [[default=maybe]]]),
|
|
, enable_oss=maybe)
|
|
|
|
# OpenBSD "has" OSS, but it's not really for app use. They want you to
|
|
# use sndio instead. So on there, we default to disabled. You can force
|
|
# it on if you really want, though.
|
|
if test x$enable_oss = xmaybe; then
|
|
enable_oss=yes
|
|
case "$host" in
|
|
*-*-openbsd*)
|
|
enable_oss=no;;
|
|
esac
|
|
fi
|
|
|
|
if test x$enable_audio = xyes -a x$enable_oss = xyes; then
|
|
AC_MSG_CHECKING(for OSS audio support)
|
|
have_oss=no
|
|
if test x$have_oss != xyes; then
|
|
AC_TRY_COMPILE([
|
|
#include <sys/soundcard.h>
|
|
],[
|
|
int arg = SNDCTL_DSP_SETFRAGMENT;
|
|
],[
|
|
have_oss=yes
|
|
])
|
|
fi
|
|
if test x$have_oss != xyes; then
|
|
AC_TRY_COMPILE([
|
|
#include <soundcard.h>
|
|
],[
|
|
int arg = SNDCTL_DSP_SETFRAGMENT;
|
|
],[
|
|
have_oss=yes
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H, 1, [ ])
|
|
])
|
|
fi
|
|
AC_MSG_RESULT($have_oss)
|
|
if test x$have_oss = xyes; then
|
|
SUMMARY_audio="${SUMMARY_audio} oss"
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_OSS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/dsp/*.c"
|
|
have_audio=yes
|
|
|
|
# We may need to link with ossaudio emulation library
|
|
case "$host" in
|
|
*-*-openbsd*|*-*-netbsd*)
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lossaudio";;
|
|
esac
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl See if the ALSA audio interface is supported
|
|
CheckALSA()
|
|
{
|
|
AC_ARG_ENABLE(alsa,
|
|
AS_HELP_STRING([--enable-alsa], [support the ALSA audio API [[default=yes]]]),
|
|
, enable_alsa=yes)
|
|
if test x$enable_audio = xyes -a x$enable_alsa = xyes; then
|
|
AM_PATH_ALSA(1.0.11, have_alsa=yes, have_alsa=no)
|
|
# Restore all flags from before the ALSA detection runs
|
|
CFLAGS="$alsa_save_CFLAGS"
|
|
LDFLAGS="$alsa_save_LDFLAGS"
|
|
LIBS="$alsa_save_LIBS"
|
|
if test x$have_alsa = xyes; then
|
|
AC_ARG_ENABLE(alsa-shared,
|
|
AS_HELP_STRING([--enable-alsa-shared], [dynamically load ALSA audio support [[default=yes]]]),
|
|
, enable_alsa_shared=yes)
|
|
alsa_lib=[`find_lib "libasound.so.*" "$ALSA_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_ALSA, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/alsa/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $ALSA_CFLAGS"
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_alsa_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic ALSA loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_alsa_shared = xyes && test x$alsa_lib != x; then
|
|
echo "-- dynamic libasound -> $alsa_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_ALSA_DYNAMIC, "$alsa_lib", [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} alsa(dynamic)"
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ALSA_LIBS"
|
|
SUMMARY_audio="${SUMMARY_audio} alsa"
|
|
fi
|
|
have_audio=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Find JACK Audio
|
|
CheckJACK()
|
|
{
|
|
AC_ARG_ENABLE(jack,
|
|
AS_HELP_STRING([--enable-jack], [use JACK audio [[default=yes]]]),
|
|
, enable_jack=yes)
|
|
if test x$enable_audio = xyes -a x$enable_jack = xyes; then
|
|
PKG_CHECK_MODULES([JACK], [jack >= 0.125], audio_jack=yes, audio_jack=no)
|
|
|
|
if test x$audio_jack = xyes; then
|
|
AC_ARG_ENABLE(jack-shared,
|
|
AS_HELP_STRING([--enable-jack-shared], [dynamically load JACK audio support [[default=yes]]]),
|
|
, enable_jack_shared=yes)
|
|
jack_lib=[`find_lib "libjack.so.*" "$JACK_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_JACK, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/jack/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $JACK_CFLAGS"
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_jack_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic JACK audio loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_jack_shared = xyes && test x$jack_lib != x; then
|
|
echo "-- dynamic libjack -> $jack_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_JACK_DYNAMIC, "$jack_lib", [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} jack(dynamic)"
|
|
|
|
case "$host" in
|
|
# On Solaris, jack must be linked deferred explicitly
|
|
# to prevent undefined symbol failures.
|
|
*-*-solaris*)
|
|
JACK_LIBS=`echo $JACK_LIBS | sed 's/\-l/-Wl,-l/g'`
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-zdeferred $JACK_LIBS -Wl,-znodeferred"
|
|
esac
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $JACK_LIBS"
|
|
SUMMARY_audio="${SUMMARY_audio} jack"
|
|
fi
|
|
have_audio=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Find the ESD includes and libraries
|
|
CheckESD()
|
|
{
|
|
AC_ARG_ENABLE(esd,
|
|
AS_HELP_STRING([--enable-esd], [support the Enlightened Sound Daemon [[default=yes]]]),
|
|
, enable_esd=yes)
|
|
if test x$enable_audio = xyes -a x$enable_esd = xyes; then
|
|
AM_PATH_ESD(0.2.8, have_esd=yes, have_esd=no)
|
|
if test x$have_esd = xyes; then
|
|
AC_ARG_ENABLE(esd-shared,
|
|
AS_HELP_STRING([--enable-esd-shared], [dynamically load ESD audio support [[default=yes]]]),
|
|
, enable_esd_shared=yes)
|
|
esd_lib=[`find_lib "libesd.so.*" "$ESD_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_ESD, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/esd/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $ESD_CFLAGS"
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_esd_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic ESD loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_esd_shared = xyes && test x$esd_lib != x; then
|
|
echo "-- dynamic libesd -> $esd_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_ESD_DYNAMIC, "$esd_lib", [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} esd(dynamic)"
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ESD_LIBS"
|
|
SUMMARY_audio="${SUMMARY_audio} esd"
|
|
fi
|
|
have_audio=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Find PulseAudio
|
|
CheckPulseAudio()
|
|
{
|
|
AC_ARG_ENABLE(pulseaudio,
|
|
AS_HELP_STRING([--enable-pulseaudio], [use PulseAudio [[default=yes]]]),
|
|
, enable_pulseaudio=yes)
|
|
if test x$enable_audio = xyes -a x$enable_pulseaudio = xyes; then
|
|
PKG_CHECK_MODULES([PULSEAUDIO], [libpulse-simple >= 0.9], audio_pulseaudio=yes, audio_pulseaudio=no)
|
|
|
|
if test x$audio_pulseaudio = xyes; then
|
|
AC_ARG_ENABLE(pulseaudio-shared,
|
|
AS_HELP_STRING([--enable-pulseaudio-shared], [dynamically load PulseAudio support [[default=yes]]]),
|
|
, enable_pulseaudio_shared=yes)
|
|
pulseaudio_lib=[`find_lib "libpulse-simple.so.*" "$PULSEAUDIO_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_PULSEAUDIO, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/pulseaudio/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $PULSEAUDIO_CFLAGS"
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_pulseaudio_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic PulseAudio loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_pulseaudio_shared = xyes && test x$pulseaudio_lib != x; then
|
|
echo "-- dynamic libpulse-simple -> $pulseaudio_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC, "$pulseaudio_lib", [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} pulse(dynamic)"
|
|
|
|
case "$host" in
|
|
# On Solaris, pulseaudio must be linked deferred explicitly
|
|
# to prevent undefined symbol failures.
|
|
*-*-solaris*)
|
|
PULSEAUDIO_LIBS=`echo $PULSEAUDIO_LIBS | sed 's/\-l/-Wl,-l/g'`
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-zdeferred $PULSEAUDIO_LIBS -Wl,-znodeferred"
|
|
esac
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $PULSEAUDIO_LIBS"
|
|
SUMMARY_audio="${SUMMARY_audio} pulse"
|
|
fi
|
|
have_audio=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
CheckARTSC()
|
|
{
|
|
AC_ARG_ENABLE(arts,
|
|
AS_HELP_STRING([--enable-arts], [support the Analog Real Time Synthesizer [[default=yes]]]),
|
|
, enable_arts=yes)
|
|
if test x$enable_audio = xyes -a x$enable_arts = xyes; then
|
|
AC_PATH_PROG(ARTSCONFIG, artsc-config)
|
|
if test x$ARTSCONFIG = x -o x$ARTSCONFIG = x'"$ARTSCONFIG"'; then
|
|
: # arts isn't installed
|
|
else
|
|
ARTS_CFLAGS=`$ARTSCONFIG --cflags`
|
|
ARTS_LIBS=`$ARTSCONFIG --libs`
|
|
AC_MSG_CHECKING(for aRts development environment)
|
|
audio_arts=no
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS $ARTS_CFLAGS"
|
|
AC_TRY_COMPILE([
|
|
#include <artsc.h>
|
|
],[
|
|
arts_stream_t stream;
|
|
],[
|
|
audio_arts=yes
|
|
])
|
|
CFLAGS="$save_CFLAGS"
|
|
AC_MSG_RESULT($audio_arts)
|
|
if test x$audio_arts = xyes; then
|
|
AC_ARG_ENABLE(arts-shared,
|
|
AS_HELP_STRING([--enable-arts-shared], [dynamically load aRts audio support [[default=yes]]]),
|
|
, enable_arts_shared=yes)
|
|
arts_lib=[`find_lib "libartsc.so.*" "$ARTS_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_ARTS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/arts/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $ARTS_CFLAGS"
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_arts_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic ARTS loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_arts_shared = xyes && test x$arts_lib != x; then
|
|
echo "-- dynamic libartsc -> $arts_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_ARTS_DYNAMIC, "$arts_lib", [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} arts(dynamic)"
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ARTS_LIBS"
|
|
SUMMARY_audio="${SUMMARY_audio} arts"
|
|
fi
|
|
have_audio=yes
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl See if the NAS audio interface is supported
|
|
CheckNAS()
|
|
{
|
|
AC_ARG_ENABLE(nas,
|
|
AS_HELP_STRING([--enable-nas], [support the NAS audio API [[default=yes]]]),
|
|
, enable_nas=yes)
|
|
if test x$enable_audio = xyes -a x$enable_nas = xyes; then
|
|
AC_CHECK_HEADER(audio/audiolib.h, have_nas_hdr=yes)
|
|
AC_CHECK_LIB(audio, AuOpenServer, have_nas_lib=yes)
|
|
|
|
AC_MSG_CHECKING(for NAS audio support)
|
|
have_nas=no
|
|
|
|
if test x$have_nas_hdr = xyes -a x$have_nas_lib = xyes; then
|
|
have_nas=yes
|
|
NAS_LIBS="-laudio"
|
|
|
|
elif test -r /usr/X11R6/include/audio/audiolib.h; then
|
|
have_nas=yes
|
|
NAS_CFLAGS="-I/usr/X11R6/include/"
|
|
NAS_LIBS="-L/usr/X11R6/lib -laudio -lXt"
|
|
|
|
fi
|
|
|
|
AC_MSG_RESULT($have_nas)
|
|
|
|
if test x$have_nas = xyes; then
|
|
AC_ARG_ENABLE(nas-shared,
|
|
AS_HELP_STRING([--enable-nas-shared], [dynamically load NAS audio support [[default=yes]]]),
|
|
, enable_nas_shared=yes)
|
|
nas_lib=[`find_lib "libaudio.so.*" "$NAS_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_nas_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic NAS loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_nas_shared = xyes && test x$nas_lib != x; then
|
|
echo "-- dynamic libaudio -> $nas_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_NAS_DYNAMIC, "$nas_lib", [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} nas(dynamic)"
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $NAS_LIBS"
|
|
SUMMARY_audio="${SUMMARY_audio} nas"
|
|
fi
|
|
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_NAS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/nas/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $NAS_CFLAGS"
|
|
have_audio=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl See if the sndio audio interface is supported
|
|
CheckSNDIO()
|
|
{
|
|
AC_ARG_ENABLE(sndio,
|
|
AS_HELP_STRING([--enable-sndio], [support the sndio audio API [[default=yes]]]),
|
|
, enable_sndio=yes)
|
|
if test x$enable_audio = xyes -a x$enable_sndio = xyes; then
|
|
AC_CHECK_HEADER(sndio.h, have_sndio_hdr=yes)
|
|
AC_CHECK_LIB(sndio, sio_open, have_sndio_lib=yes)
|
|
|
|
AC_MSG_CHECKING(for sndio audio support)
|
|
have_sndio=no
|
|
|
|
if test x$have_sndio_hdr = xyes -a x$have_sndio_lib = xyes; then
|
|
have_sndio=yes
|
|
SNDIO_LIBS="-lsndio"
|
|
fi
|
|
|
|
AC_MSG_RESULT($have_sndio)
|
|
|
|
if test x$have_sndio = xyes; then
|
|
AC_ARG_ENABLE(sndio-shared,
|
|
AS_HELP_STRING([--enable-sndio-shared], [dynamically load sndio audio support [[default=yes]]]),
|
|
, enable_sndio_shared=yes)
|
|
sndio_lib=[`find_lib "libsndio.so.*" "$SNDIO_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_sndio_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic sndio loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_sndio_shared = xyes && test x$sndio_lib != x; then
|
|
echo "-- dynamic libsndio -> $sndio_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_SNDIO_DYNAMIC, "$sndio_lib", [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} sndio(dynamic)"
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $SNDIO_LIBS"
|
|
SUMMARY_audio="${SUMMARY_audio} sndio"
|
|
fi
|
|
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_SNDIO, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/sndio/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $SNDIO_CFLAGS"
|
|
have_audio=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Find FusionSound
|
|
CheckFusionSound()
|
|
{
|
|
AC_ARG_ENABLE(fusionsound,
|
|
AS_HELP_STRING([--enable-fusionsound], [use FusionSound audio driver [[default=no]]]),
|
|
, enable_fusionsound=no)
|
|
if test x$enable_audio = xyes -a x$enable_fusionsound = xyes; then
|
|
PKG_CHECK_MODULES([FUSIONSOUND], [fusionsound >= 1.1.1], fusionsound=yes, fusionsound=no)
|
|
|
|
if test x$fusionsound = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_FUSIONSOUND, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/fusionsound/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $FUSIONSOUND_CFLAGS"
|
|
|
|
AC_ARG_ENABLE(fusionsound-shared,
|
|
AS_HELP_STRING([--enable-fusionsound-shared], [dynamically load fusionsound audio support [[default=yes]]]),
|
|
, enable_fusionsound_shared=yes)
|
|
fusionsound_shared=no
|
|
AC_MSG_CHECKING(for FusionSound dynamic loading support)
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_fusionsound_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic fusionsound loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_fusionsound_shared = xyes; then
|
|
AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC, "libfusionsound.so", [ ])
|
|
fusionsound_shared=yes
|
|
SUMMARY_audio="${SUMMARY_audio} fusionsound(dynamic)"
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $FUSIONSOUND_LIBS"
|
|
SUMMARY_audio="${SUMMARY_audio} fusionsound"
|
|
fi
|
|
AC_MSG_RESULT($fusionsound_shared)
|
|
|
|
have_audio=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl rcg07142001 See if the user wants the disk writer audio driver...
|
|
CheckDiskAudio()
|
|
{
|
|
AC_ARG_ENABLE(diskaudio,
|
|
AS_HELP_STRING([--enable-diskaudio], [support the disk writer audio driver [[default=yes]]]),
|
|
, enable_diskaudio=yes)
|
|
if test x$enable_audio = xyes -a x$enable_diskaudio = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_DISK, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/disk/*.c"
|
|
SUMMARY_audio="${SUMMARY_audio} disk"
|
|
fi
|
|
}
|
|
|
|
dnl rcg03142006 See if the user wants the dummy audio driver...
|
|
CheckDummyAudio()
|
|
{
|
|
AC_ARG_ENABLE(dummyaudio,
|
|
AS_HELP_STRING([--enable-dummyaudio], [support the dummy audio driver [[default=yes]]]),
|
|
, enable_dummyaudio=yes)
|
|
if test x$enable_audio = xyes -a x$enable_dummyaudio = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_DUMMY, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/dummy/*.c"
|
|
SUMMARY_audio="${SUMMARY_audio} dummy"
|
|
fi
|
|
}
|
|
|
|
dnl See if libsamplerate is available
|
|
CheckLibSampleRate()
|
|
{
|
|
AC_ARG_ENABLE(libsamplerate,
|
|
AS_HELP_STRING([--enable-libsamplerate], [use libsamplerate for audio rate conversion [[default=yes]]]),
|
|
, enable_libsamplerate=yes)
|
|
if test x$enable_libsamplerate = xyes; then
|
|
AC_CHECK_HEADER(samplerate.h,
|
|
have_samplerate_h_hdr=yes,
|
|
have_samplerate_h_hdr=no)
|
|
if test x$have_samplerate_h_hdr = xyes; then
|
|
AC_DEFINE(HAVE_LIBSAMPLERATE_H, 1, [ ])
|
|
|
|
AC_ARG_ENABLE(libsamplerate-shared,
|
|
AS_HELP_STRING([--enable-libsamplerate-shared], [dynamically load libsamplerate [[default=yes]]]),
|
|
, enable_libsamplerate_shared=yes)
|
|
|
|
samplerate_lib=[`find_lib "libsamplerate.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_libsamplerate_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic libsamplerate loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_libsamplerate_shared = xyes && test x$samplerate_lib != x; then
|
|
echo "-- dynamic libsamplerate -> $samplerate_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_LIBSAMPLERATE_DYNAMIC, "$samplerate_lib", [ ])
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lsamplerate"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Check for ARM instruction support using gas syntax
|
|
CheckARM()
|
|
{
|
|
AC_ARG_ENABLE(arm-simd,
|
|
AC_HELP_STRING([--enable-arm-simd], [use SIMD assembly blitters on ARM [[default=yes]]]),
|
|
enable_arm_simd=$enableval, enable_arm_simd=yes)
|
|
if test x$enable_video = xyes -a x$enable_assembly = xyes -a x$enable_arm_simd = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
have_arm_simd=no
|
|
CFLAGS="-x assembler-with-cpp $CFLAGS"
|
|
|
|
AC_MSG_CHECKING(for ARM SIMD)
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
|
.text
|
|
.arch armv6
|
|
.object_arch armv4
|
|
.arm
|
|
.altmacro
|
|
#ifndef __ARM_EABI__
|
|
#error EABI is required (to be sure that calling conventions are compatible)
|
|
#endif
|
|
pld [r0]
|
|
uqadd8 r0, r0, r0
|
|
]])], have_arm_simd=yes)
|
|
AC_MSG_RESULT($have_arm_simd)
|
|
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_arm_simd = xyes; then
|
|
AC_DEFINE(SDL_ARM_SIMD_BLITTERS, 1, [ ])
|
|
dnl SOURCES="$SOURCES $srcdir/src/video/arm/pixman-arm-simd*.c"
|
|
SOURCES="$SOURCES $srcdir/src/video/arm/pixman-arm-simd*.S"
|
|
WARN_ABOUT_ARM_SIMD_ASM_MIT="yes"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Check for ARM NEON instruction support using gas syntax
|
|
CheckNEON()
|
|
{
|
|
AC_ARG_ENABLE(arm-neon,
|
|
AC_HELP_STRING([--enable-arm-neon], [use NEON assembly blitters on ARM [[default=no]]]),
|
|
enable_arm_neon=$enableval, enable_arm_neon=no)
|
|
if test x$enable_video = xyes -a x$enable_assembly = xyes -a x$enable_arm_neon = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
have_arm_neon=no
|
|
CFLAGS="-x assembler-with-cpp $CFLAGS"
|
|
|
|
AC_MSG_CHECKING(for ARM NEON)
|
|
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
|
|
.text
|
|
.fpu neon
|
|
.arch armv7a
|
|
.object_arch armv4
|
|
.eabi_attribute 10, 0
|
|
.arm
|
|
.altmacro
|
|
#ifndef __ARM_EABI__
|
|
#error EABI is required (to be sure that calling conventions are compatible)
|
|
#endif
|
|
pld [r0]
|
|
vmovn.u16 d0, q0
|
|
]])], have_arm_neon=yes)
|
|
AC_MSG_RESULT($have_arm_neon)
|
|
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_arm_neon = xyes; then
|
|
AC_DEFINE(SDL_ARM_NEON_BLITTERS, 1, [ ])
|
|
dnl SOURCES="$SOURCES $srcdir/src/video/arm/pixman-arm-neon*.c"
|
|
SOURCES="$SOURCES $srcdir/src/video/arm/pixman-arm-neon*.S"
|
|
WARN_ABOUT_ARM_NEON_ASM_MIT="yes"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl See if GCC's -fvisibility=hidden is supported (gcc4 and later, usually).
|
|
dnl Details of this flag are here: http://gcc.gnu.org/wiki/Visibility
|
|
CheckVisibilityHidden()
|
|
{
|
|
AC_MSG_CHECKING(for GCC -fvisibility=hidden option)
|
|
have_gcc_fvisibility=no
|
|
|
|
visibility_CFLAGS="-fvisibility=hidden"
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$save_CFLAGS $visibility_CFLAGS -Werror"
|
|
AC_TRY_COMPILE([
|
|
#if !defined(__GNUC__) || __GNUC__ < 4
|
|
#error SDL only uses visibility attributes in GCC 4 or newer
|
|
#endif
|
|
],[
|
|
],[
|
|
have_gcc_fvisibility=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_fvisibility)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_fvisibility = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $visibility_CFLAGS"
|
|
fi
|
|
}
|
|
|
|
dnl See if GCC's -fno-strict-aliasingis supported.
|
|
dnl Reference: https://bugzilla.libsdl.org/show_bug.cgi?id=4254
|
|
CheckNoStrictAliasing()
|
|
{
|
|
AC_MSG_CHECKING(for GCC -fno-strict-aliasing option)
|
|
have_gcc_no_strict_aliasing=no
|
|
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$save_CFLAGS -fno-strict-aliasing"
|
|
AC_TRY_COMPILE([
|
|
int x = 0;
|
|
],[
|
|
],[
|
|
have_gcc_no_strict_aliasing=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_no_strict_aliasing)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_no_strict_aliasing = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -fno-strict-aliasing"
|
|
fi
|
|
}
|
|
|
|
dnl See if GCC's -mpreferred-stack-boundary is supported.
|
|
dnl Reference: http://bugzilla.libsdl.org/show_bug.cgi?id=1296
|
|
CheckStackBoundary()
|
|
{
|
|
AC_MSG_CHECKING(for GCC -mpreferred-stack-boundary option)
|
|
have_gcc_preferred_stack_boundary=no
|
|
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$save_CFLAGS -mpreferred-stack-boundary=2"
|
|
AC_TRY_COMPILE([
|
|
int x = 0;
|
|
],[
|
|
],[
|
|
have_gcc_preferred_stack_boundary=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_preferred_stack_boundary)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_preferred_stack_boundary = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -mpreferred-stack-boundary=2"
|
|
fi
|
|
}
|
|
|
|
dnl See if GCC's -Wdeclaration-after-statement is supported.
|
|
dnl This lets us catch things that would fail on a C89 compiler when using
|
|
dnl a modern GCC.
|
|
CheckDeclarationAfterStatement()
|
|
{
|
|
AC_MSG_CHECKING(for GCC -Wdeclaration-after-statement option)
|
|
have_gcc_declaration_after_statement=no
|
|
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$save_CFLAGS -Wdeclaration-after-statement -Werror=declaration-after-statement"
|
|
AC_TRY_COMPILE([
|
|
int x = 0;
|
|
],[
|
|
],[
|
|
have_gcc_declaration_after_statement=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_declaration_after_statement)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_declaration_after_statement = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -Wdeclaration-after-statement -Werror=declaration-after-statement"
|
|
fi
|
|
}
|
|
|
|
dnl See if GCC's -Wall is supported.
|
|
CheckWarnAll()
|
|
{
|
|
AC_MSG_CHECKING(for GCC -Wall option)
|
|
have_gcc_Wall=no
|
|
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$save_CFLAGS -Wall"
|
|
AC_TRY_COMPILE([
|
|
int x = 0;
|
|
],[
|
|
],[
|
|
have_gcc_Wall=yes
|
|
])
|
|
AC_MSG_RESULT($have_gcc_Wall)
|
|
CFLAGS="$save_CFLAGS"
|
|
|
|
if test x$have_gcc_Wall = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -Wall"
|
|
|
|
dnl Haiku headers use multicharacter constants all over the place. Ignore these warnings when using -Wall.
|
|
AC_MSG_CHECKING(for necessary GCC -Wno-multichar option)
|
|
need_gcc_Wno_multichar=no
|
|
case "$host" in
|
|
*-*-haiku*)
|
|
need_gcc_Wno_multichar=yes
|
|
;;
|
|
esac
|
|
AC_MSG_RESULT($need_gcc_Wno_multichar)
|
|
if test x$need_gcc_Wno_multichar = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -Wno-multichar"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Check for Wayland
|
|
CheckWayland()
|
|
{
|
|
AC_ARG_ENABLE(video-wayland,
|
|
AS_HELP_STRING([--enable-video-wayland], [use Wayland video driver [[default=yes]]]),
|
|
,enable_video_wayland=yes)
|
|
|
|
AC_ARG_ENABLE(video-wayland-qt-touch,
|
|
AS_HELP_STRING([--enable-video-wayland-qt-touch], [QtWayland server support for Wayland video driver [[default=yes]]]),
|
|
,enable_video_wayland_qt_touch=yes)
|
|
|
|
if test x$enable_video = xyes -a x$enable_video_wayland = xyes; then
|
|
AC_MSG_CHECKING(for Wayland support)
|
|
video_wayland=no
|
|
if test x$video_opengl_egl = xyes && \
|
|
test x$video_opengles_v2 = xyes; then
|
|
if $PKG_CONFIG --exists wayland-client wayland-scanner wayland-egl wayland-cursor egl xkbcommon ; then
|
|
WAYLAND_CFLAGS=`$PKG_CONFIG --cflags wayland-client wayland-egl wayland-cursor xkbcommon`
|
|
WAYLAND_LIBS=`$PKG_CONFIG --libs wayland-client wayland-egl wayland-cursor xkbcommon`
|
|
WAYLAND_SCANNER=`$PKG_CONFIG --variable=wayland_scanner wayland-scanner`
|
|
video_wayland=yes
|
|
fi
|
|
fi
|
|
AC_MSG_RESULT($video_wayland)
|
|
|
|
if test x$video_wayland = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_WAYLAND, 1, [ ])
|
|
if test x$enable_video_wayland_qt_touch = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH, 1, [ ])
|
|
fi
|
|
|
|
WAYLAND_SOURCES="$srcdir/src/video/wayland/*.c"
|
|
SOURCES="$SOURCES $WAYLAND_SOURCES"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $WAYLAND_CFLAGS -I\$(gen)"
|
|
AC_ARG_ENABLE(wayland-shared,
|
|
AS_HELP_STRING([--enable-wayland-shared], [dynamically load Wayland support [[default=maybe]]]),
|
|
, enable_wayland_shared=maybe)
|
|
|
|
dnl FIXME: Do BSD and OS X need special cases?
|
|
case "$host" in
|
|
*)
|
|
wayland_client_lib=[`find_lib "libwayland-client.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
wayland_egl_lib=[`find_lib "libwayland-egl.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
if test x$wayland_egl_lib = x; then
|
|
dnl This works in Ubuntu 13.10, maybe others
|
|
wayland_egl_lib=[`find_lib "mesa-egl/libwayland-egl.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
fi
|
|
wayland_cursor_lib=[`find_lib "libwayland-cursor.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
xkbcommon_lib=[`find_lib "libxkbcommon.so.*" "$WAYLAND_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
;;
|
|
esac
|
|
|
|
if test x$enable_wayland_shared = xmaybe; then
|
|
enable_wayland_shared=yes
|
|
fi
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_wayland_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic Wayland loading])
|
|
enable_wayland_shared=no
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_wayland_shared = xyes && \
|
|
test x$wayland_client_lib != x && \
|
|
test x$wayland_egl_lib != x && \
|
|
test x$wayland_cursor_lib != x && \
|
|
test x$xkbcommon_lib != x; then
|
|
echo "-- dynamic libwayland-client -> $wayland_client_lib"
|
|
echo "-- dynamic libwayland-egl -> $wayland_egl_lib"
|
|
echo "-- dynamic libwayland-cursor -> $wayland_cursor_lib"
|
|
echo "-- dynamic libxkbcommon -> $xkbcommon_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC, "$wayland_client_lib", [ ])
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_EGL, "$wayland_egl_lib", [ ])
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR, "$wayland_cursor_lib", [ ])
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_XKBCOMMON, "$xkbcommon_lib", [ ])
|
|
SUMMARY_video="${SUMMARY_video} wayland(dynamic)"
|
|
else
|
|
enable_wayland_shared=no
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $WAYLAND_LIBS"
|
|
SUMMARY_video="${SUMMARY_video} wayland"
|
|
fi
|
|
have_video=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
|
|
dnl Check for Native Client stuff
|
|
CheckNativeClient()
|
|
{
|
|
AC_TRY_COMPILE([
|
|
#if !defined(__native_client__)
|
|
#error "NO NACL"
|
|
#endif
|
|
],[
|
|
],[
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_NACL, 1, [ ])
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_NACL, 1, [ ])
|
|
AC_DEFINE(HAVE_POW, 1, [ ])
|
|
AC_DEFINE(HAVE_OPENGLES2, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_ES2, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES2, 1, [ ])
|
|
|
|
SDL_LIBS="-lppapi_simple -lppapi_gles2 $SDL_LIBS"
|
|
|
|
SDLMAIN_SOURCES="$srcdir/src/main/nacl/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/audio/nacl/*.c"
|
|
SUMMARY_audio="${SUMMARY_audio} nacl"
|
|
SOURCES="$SOURCES $srcdir/src/video/nacl/*.c"
|
|
SUMMARY_video="${SUMMARY_video} nacl opengles2"
|
|
])
|
|
}
|
|
|
|
|
|
CheckRPI()
|
|
{
|
|
AC_ARG_ENABLE(video-rpi,
|
|
AS_HELP_STRING([--enable-video-rpi], [use Raspberry Pi video driver [[default=yes]]]),
|
|
, enable_video_rpi=yes)
|
|
if test x$enable_video = xyes -a x$enable_video_rpi = xyes; then
|
|
PKG_CHECK_MODULES([RPI], [bcm_host brcmegl], video_rpi=yes, video_rpi=no)
|
|
|
|
if test x$video_rpi = xno; then
|
|
if test x$ARCH = xnetbsd; then
|
|
RPI_CFLAGS="-I/usr/pkg/include -I/usr/pkg/include/interface/vcos/pthreads -I/usr/pkg/include/interface/vmcs_host/linux"
|
|
RPI_LIBS="-Wl,-R/usr/pkg/lib -L/usr/pkg/lib -lbcm_host"
|
|
else
|
|
RPI_CFLAGS="-I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads -I/opt/vc/include/interface/vmcs_host/linux"
|
|
RPI_LIBS="-Wl,-rpath,/opt/vc/lib -L/opt/vc/lib -lbcm_host"
|
|
fi
|
|
fi
|
|
|
|
# Save the original compiler flags and libraries
|
|
ac_save_cflags="$CFLAGS"; ac_save_libs="$LIBS"
|
|
|
|
# Add the Raspberry Pi compiler flags and libraries
|
|
CFLAGS="$CFLAGS $RPI_CFLAGS"; LIBS="$LIBS $RPI_LIBS"
|
|
|
|
AC_MSG_CHECKING(for Raspberry Pi)
|
|
have_video_rpi=no
|
|
AC_TRY_LINK([
|
|
#include <bcm_host.h>
|
|
],[
|
|
bcm_host_init();
|
|
],[
|
|
have_video_rpi=yes
|
|
],[
|
|
])
|
|
AC_MSG_RESULT($have_video_rpi)
|
|
|
|
# Restore the compiler flags and libraries
|
|
CFLAGS="$ac_save_cflags"; LIBS="$ac_save_libs"
|
|
|
|
if test x$have_video_rpi = xyes; then
|
|
CFLAGS="$CFLAGS $RPI_CFLAGS"
|
|
SDL_CFLAGS="$SDL_CFLAGS $RPI_CFLAGS"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $RPI_CFLAGS"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $RPI_LIBS"
|
|
SOURCES="$SOURCES $srcdir/src/video/raspberry/*.c"
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_RPI, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} rpi"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Find the X11 include and library directories
|
|
CheckX11()
|
|
{
|
|
AC_ARG_ENABLE(video-x11,
|
|
AS_HELP_STRING([--enable-video-x11], [use X11 video driver [[default=yes]]]),
|
|
, enable_video_x11=yes)
|
|
if test x$enable_video = xyes -a x$enable_video_x11 = xyes; then
|
|
case "$host" in
|
|
*-*-darwin*)
|
|
# This isn't necessary for X11, but fixes GLX detection
|
|
if test "x$x_includes" = xNONE && \
|
|
test "x$x_libraries" = xNONE && \
|
|
test -d /opt/X11/include && \
|
|
test -d /opt/X11/lib; then
|
|
x_includes="/opt/X11/include"
|
|
x_libraries="/opt/X11/lib"
|
|
fi
|
|
;;
|
|
esac
|
|
AC_PATH_X
|
|
AC_PATH_XTRA
|
|
if test x$have_x = xyes; then
|
|
AC_ARG_ENABLE(x11-shared,
|
|
AS_HELP_STRING([--enable-x11-shared], [dynamically load X11 support [[default=maybe]]]),
|
|
, enable_x11_shared=maybe)
|
|
|
|
case "$host" in
|
|
*-*-darwin*)
|
|
# Apple now puts this in /opt/X11
|
|
x11_lib='/opt/X11/lib/libX11.6.dylib'
|
|
x11ext_lib='/opt/X11/lib/libXext.6.dylib'
|
|
xcursor_lib='/opt/X11/lib/libXcursor.1.dylib'
|
|
xinerama_lib='/opt/X11/lib/libXinerama.1.dylib'
|
|
xinput_lib='/opt/X11/lib/libXi.6.dylib'
|
|
xrandr_lib='/opt/X11/lib/libXrandr.2.dylib'
|
|
xrender_lib='/opt/X11/lib/libXrender.1.dylib'
|
|
xss_lib='/opt/X11/lib/libXss.1.dylib'
|
|
xvidmode_lib='/opt/X11/lib/libXxf86vm.1.dylib'
|
|
;;
|
|
*-*-openbsd*)
|
|
x11_lib='libX11.so'
|
|
x11ext_lib='libXext.so'
|
|
xcursor_lib='libXcursor.so'
|
|
xinerama_lib='libXinerama.so'
|
|
xinput_lib='libXi.so'
|
|
xrandr_lib='libXrandr.so'
|
|
xrender_lib='libXrender.so'
|
|
xss_lib='libXss.so'
|
|
xvidmode_lib='libXxf86vm.so'
|
|
;;
|
|
*)
|
|
x11_lib=[`find_lib "libX11.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
x11ext_lib=[`find_lib "libXext.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
xcursor_lib=[`find_lib "libXcursor.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
xinerama_lib=[`find_lib "libXinerama.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
xinput_lib=[`find_lib "libXi.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
xrandr_lib=[`find_lib "libXrandr.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
xrender_lib=[`find_lib "libXrender.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
xss_lib=[`find_lib "libXss.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
xvidmode_lib=[`find_lib "libXxf86vm.so.*" "$X_LIBS -L/usr/X11/$base_libdir -L/usr/X11R6/$base_libdir" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
;;
|
|
esac
|
|
|
|
if test x$ac_cv_func_shmat != xyes; then
|
|
X_CFLAGS="$X_CFLAGS -DNO_SHARED_MEMORY"
|
|
fi
|
|
CFLAGS="$CFLAGS $X_CFLAGS"
|
|
LDFLAGS="$LDFLAGS $X_LIBS"
|
|
|
|
AC_CHECK_HEADER(X11/extensions/Xext.h,
|
|
have_xext_h_hdr=yes,
|
|
have_xext_h_hdr=no,
|
|
[#include <X11/Xlib.h>
|
|
#include <X11/Xproto.h>
|
|
])
|
|
if test x$have_xext_h_hdr != xyes; then
|
|
AC_MSG_ERROR([
|
|
*** Missing Xext.h, maybe you need to install the libxext-dev package?
|
|
])
|
|
fi
|
|
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_X11, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/x11/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $X_CFLAGS"
|
|
|
|
# Needed so SDL applications can include SDL_syswm.h
|
|
SDL_CFLAGS="$SDL_CFLAGS $X_CFLAGS"
|
|
|
|
if test x$enable_x11_shared = xmaybe; then
|
|
enable_x11_shared=yes
|
|
fi
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_x11_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic X11 loading])
|
|
enable_x11_shared=no
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_x11_shared = xyes && test x$x11_lib != x && test x$x11ext_lib != x; then
|
|
echo "-- dynamic libX11 -> $x11_lib"
|
|
echo "-- dynamic libX11ext -> $x11ext_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC, "$x11_lib", [ ])
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT, "$x11ext_lib", [ ])
|
|
SUMMARY_video="${SUMMARY_video} x11(dynamic)"
|
|
else
|
|
enable_x11_shared=no
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $X_LIBS -lX11 -lXext"
|
|
SUMMARY_video="${SUMMARY_video} x11"
|
|
fi
|
|
have_video=yes
|
|
|
|
AC_MSG_CHECKING(for const parameter to XextAddDisplay)
|
|
have_const_param_XextAddDisplay=no
|
|
AC_TRY_COMPILE([
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xproto.h>
|
|
#include <X11/extensions/Xext.h>
|
|
#include <X11/extensions/extutil.h>
|
|
extern XExtDisplayInfo* XextAddDisplay(XExtensionInfo* a,Display* b,_Xconst char* c,XExtensionHooks* d,int e,XPointer f);
|
|
],[
|
|
],[
|
|
have_const_param_XextAddDisplay=yes
|
|
AC_DEFINE([SDL_VIDEO_DRIVER_X11_CONST_PARAM_XEXTADDDISPLAY], 1, [ ])
|
|
])
|
|
AC_MSG_RESULT($have_const_param_XextAddDisplay)
|
|
|
|
dnl AC_CHECK_LIB(X11, XGetEventData, AC_DEFINE(SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS, 1, [Have XGenericEvent]))
|
|
AC_MSG_CHECKING([for XGenericEvent])
|
|
have_XGenericEvent=no
|
|
AC_TRY_COMPILE([
|
|
#include <X11/Xlib.h>
|
|
],[
|
|
Display *display;
|
|
XEvent event;
|
|
XGenericEventCookie *cookie = &event.xcookie;
|
|
XNextEvent(display, &event);
|
|
XGetEventData(display, cookie);
|
|
XFreeEventData(display, cookie);
|
|
],[
|
|
have_XGenericEvent=yes
|
|
AC_DEFINE([SDL_VIDEO_DRIVER_X11_SUPPORTS_GENERIC_EVENTS], 1, [ ])
|
|
])
|
|
AC_MSG_RESULT($have_XGenericEvent)
|
|
|
|
AC_CHECK_LIB(X11, XkbKeycodeToKeysym, AC_DEFINE(SDL_VIDEO_DRIVER_X11_HAS_XKBKEYCODETOKEYSYM, 1, [Have XkbKeycodeToKeysym]))
|
|
|
|
AC_ARG_ENABLE(video-x11-xcursor,
|
|
AS_HELP_STRING([--enable-video-x11-xcursor], [enable X11 Xcursor support [[default=yes]]]),
|
|
, enable_video_x11_xcursor=yes)
|
|
if test x$enable_video_x11_xcursor = xyes; then
|
|
definitely_enable_video_x11_xcursor=no
|
|
AC_CHECK_HEADER(X11/Xcursor/Xcursor.h,
|
|
have_xcursor_h_hdr=yes,
|
|
have_xcursor_h_hdr=no,
|
|
[#include <X11/Xlib.h>
|
|
])
|
|
if test x$have_xcursor_h_hdr = xyes; then
|
|
if test x$enable_x11_shared = xyes && test x$xcursor_lib != x ; then
|
|
echo "-- dynamic libXcursor -> $xcursor_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XCURSOR, "$xcursor_lib", [ ])
|
|
definitely_enable_video_x11_xcursor=yes
|
|
else
|
|
AC_CHECK_LIB(Xcursor, XcursorImageCreate, have_xcursor_lib=yes)
|
|
if test x$have_xcursor_lib = xyes ; then
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXcursor"
|
|
definitely_enable_video_x11_xcursor=yes
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
if test x$definitely_enable_video_x11_xcursor = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_X11_XCURSOR, 1, [ ])
|
|
SUMMARY_video_x11="${SUMMARY_video_x11} xcursor"
|
|
fi
|
|
AC_ARG_ENABLE(video-x11-xdbe,
|
|
AS_HELP_STRING([--enable-video-x11-xdbe], [enable X11 Xdbe support [[default=yes]]]),
|
|
, enable_video_x11_xdbe=yes)
|
|
if test x$enable_video_x11_xdbe = xyes; then
|
|
AC_CHECK_HEADER(X11/extensions/Xdbe.h,
|
|
have_dbe_h_hdr=yes,
|
|
have_dbe_h_hdr=no,
|
|
[#include <X11/Xlib.h>
|
|
])
|
|
if test x$have_dbe_h_hdr = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_X11_XDBE, 1, [ ])
|
|
SUMMARY_video_x11="${SUMMARY_video_x11} xdbe"
|
|
fi
|
|
fi
|
|
AC_ARG_ENABLE(video-x11-xinerama,
|
|
AS_HELP_STRING([--enable-video-x11-xinerama], [enable X11 Xinerama support [[default=yes]]]),
|
|
, enable_video_x11_xinerama=yes)
|
|
if test x$enable_video_x11_xinerama = xyes; then
|
|
definitely_enable_video_x11_xinerama=no
|
|
AC_CHECK_HEADER(X11/extensions/Xinerama.h,
|
|
have_xinerama_h_hdr=yes,
|
|
have_xinerama_h_hdr=no,
|
|
[#include <X11/Xlib.h>
|
|
])
|
|
if test x$have_xinerama_h_hdr = xyes; then
|
|
if test x$enable_x11_shared = xyes && test x$xinerama_lib != x ; then
|
|
echo "-- dynamic libXinerama -> $xinerama_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINERAMA, "$xinerama_lib", [ ])
|
|
definitely_enable_video_x11_xinerama=yes
|
|
else
|
|
AC_CHECK_LIB(Xinerama, XineramaQueryExtension, have_xinerama_lib=yes)
|
|
if test x$have_xinerama_lib = xyes ; then
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXinerama"
|
|
definitely_enable_video_x11_xinerama=yes
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
if test x$definitely_enable_video_x11_xinerama = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_X11_XINERAMA, 1, [ ])
|
|
SUMMARY_video_x11="${SUMMARY_video_x11} xinerama"
|
|
fi
|
|
AC_ARG_ENABLE(video-x11-xinput,
|
|
AS_HELP_STRING([--enable-video-x11-xinput], [enable X11 XInput extension for manymouse, tablets, etc [[default=yes]]]),
|
|
, enable_video_x11_xinput=yes)
|
|
if test x$enable_video_x11_xinput = xyes; then
|
|
definitely_enable_video_x11_xinput=no
|
|
AC_CHECK_HEADER(X11/extensions/XInput2.h,
|
|
have_xinput_h_hdr=yes,
|
|
have_xinput_h_hdr=no,
|
|
[#include <X11/Xlib.h>
|
|
])
|
|
if test x$have_xinput_h_hdr = xyes; then
|
|
if test x$enable_x11_shared = xyes && test x$xinput_lib != x ; then
|
|
echo "-- dynamic libXi -> $xinput_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT2, "$xinput_lib", [ ])
|
|
definitely_enable_video_x11_xinput=yes
|
|
else
|
|
AC_CHECK_LIB(Xi, XOpenDevice, have_xinput_lib=yes)
|
|
if test x$have_xinput_lib = xyes ; then
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXi"
|
|
definitely_enable_video_x11_xinput=yes
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
if test x$definitely_enable_video_x11_xinput = xyes; then
|
|
SUMMARY_video_x11="${SUMMARY_video_x11} xinput2"
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_X11_XINPUT2, 1, [ ])
|
|
AC_MSG_CHECKING(for xinput2 multitouch)
|
|
have_xinput2_multitouch=no
|
|
AC_TRY_COMPILE([
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xproto.h>
|
|
#include <X11/extensions/XInput2.h>
|
|
],[
|
|
int event_type = XI_TouchBegin;
|
|
XITouchClassInfo *t;
|
|
],[
|
|
have_xinput2_multitouch=yes
|
|
AC_DEFINE([SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH], 1, [ ])
|
|
SUMMARY_video_x11="${SUMMARY_video_x11} xinput2_multitouch"
|
|
])
|
|
AC_MSG_RESULT($have_xinput2_multitouch)
|
|
fi
|
|
AC_ARG_ENABLE(video-x11-xrandr,
|
|
AS_HELP_STRING([--enable-video-x11-xrandr], [enable X11 Xrandr extension for fullscreen [[default=yes]]]),
|
|
, enable_video_x11_xrandr=yes)
|
|
if test x$enable_video_x11_xrandr = xyes; then
|
|
dnl XRRScreenResources is only present in Xrandr >= 1.2, we use that as a test.
|
|
definitely_enable_video_x11_xrandr=no
|
|
have_xrandr_h_hdr=no
|
|
AC_TRY_COMPILE([
|
|
#include <X11/Xlib.h>
|
|
#include <X11/extensions/Xrandr.h>
|
|
],[
|
|
XRRScreenResources *res = NULL;
|
|
],[
|
|
have_xrandr_h_hdr=yes
|
|
])
|
|
if test x$have_xrandr_h_hdr = xyes; then
|
|
if test x$enable_x11_shared = xyes && test x$xrandr_lib != x ; then
|
|
echo "-- dynamic libXrandr -> $xrandr_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR, "$xrandr_lib", [ ])
|
|
definitely_enable_video_x11_xrandr=yes
|
|
else
|
|
AC_CHECK_LIB(Xrandr, XRRQueryExtension, have_xrandr_lib=yes)
|
|
if test x$have_xrandr_lib = xyes ; then
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXrandr"
|
|
definitely_enable_video_x11_xrandr=yes
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
if test x$definitely_enable_video_x11_xrandr = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_X11_XRANDR, 1, [ ])
|
|
SUMMARY_video_x11="${SUMMARY_video_x11} xrandr"
|
|
fi
|
|
AC_ARG_ENABLE(video-x11-scrnsaver,
|
|
AS_HELP_STRING([--enable-video-x11-scrnsaver], [enable X11 screensaver extension [[default=yes]]]),
|
|
, enable_video_x11_scrnsaver=yes)
|
|
if test x$enable_video_x11_scrnsaver = xyes; then
|
|
AC_CHECK_HEADER(X11/extensions/scrnsaver.h,
|
|
have_scrnsaver_h_hdr=yes,
|
|
have_scrnsaver_h_hdr=no,
|
|
[#include <X11/Xlib.h>
|
|
])
|
|
if test x$have_scrnsaver_h_hdr = xyes; then
|
|
if test x$enable_x11_shared = xyes && test x$xss_lib != x ; then
|
|
echo "-- dynamic libXss -> $xss_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS, "$xss_lib", [ ])
|
|
definitely_enable_video_x11_scrnsaver=yes
|
|
else
|
|
AC_CHECK_LIB(Xss, XScreenSaverSuspend, have_xss_lib=yes)
|
|
if test x$have_xss_lib = xyes ; then
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXss"
|
|
definitely_enable_video_x11_scrnsaver=yes
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
if test x$definitely_enable_video_x11_scrnsaver = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_X11_XSCRNSAVER, 1, [ ])
|
|
SUMMARY_video_x11="${SUMMARY_video_x11} xscrnsaver"
|
|
fi
|
|
AC_ARG_ENABLE(video-x11-xshape,
|
|
AS_HELP_STRING([--enable-video-x11-xshape], [enable X11 XShape support [[default=yes]]]),
|
|
, enable_video_x11_xshape=yes)
|
|
if test x$enable_video_x11_xshape = xyes; then
|
|
AC_CHECK_HEADER(X11/extensions/shape.h,
|
|
have_shape_h_hdr=yes,
|
|
have_shape_h_hdr=no,
|
|
[#include <X11/Xlib.h>
|
|
])
|
|
if test x$have_shape_h_hdr = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_X11_XSHAPE, 1, [ ])
|
|
SUMMARY_video_x11="${SUMMARY_video_x11} xshape"
|
|
fi
|
|
fi
|
|
AC_ARG_ENABLE(video-x11-vm,
|
|
AS_HELP_STRING([--enable-video-x11-vm], [use X11 VM extension for fullscreen [[default=yes]]]),
|
|
, enable_video_x11_vm=yes)
|
|
if test x$enable_video_x11_vm = xyes; then
|
|
definitely_enable_video_x11_vm=no
|
|
AC_CHECK_HEADER(X11/extensions/xf86vmode.h,
|
|
have_vm_h_hdr=yes,
|
|
have_vm_h_hdr=no,
|
|
[#include <X11/Xlib.h>
|
|
])
|
|
if test x$have_vm_h_hdr = xyes; then
|
|
if test x$enable_x11_shared = xyes && test x$xvidmode_lib != x ; then
|
|
echo "-- dynamic libXxf86vm -> $xvidmode_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XVIDMODE, "$xvidmode_lib", [ ])
|
|
definitely_enable_video_x11_vm=yes
|
|
else
|
|
AC_CHECK_LIB(Xxf86vm, XF86VidModeQueryVersion, have_vm_lib=yes)
|
|
if test x$have_vm_lib = xyes ; then
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXxf86vm"
|
|
definitely_enable_video_x11_vm=yes
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
if test x$definitely_enable_video_x11_vm = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_X11_XVIDMODE, 1, [ ])
|
|
SUMMARY_video_x11="${SUMMARY_video_x11} xvidmode"
|
|
fi
|
|
fi
|
|
else
|
|
# Prevent Mesa from including X11 headers
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -DMESA_EGL_NO_X11_HEADERS -DEGL_NO_X11"
|
|
fi
|
|
}
|
|
|
|
dnl Set up the Vivante video driver if enabled
|
|
CheckVivanteVideo()
|
|
{
|
|
AC_ARG_ENABLE(video-vivante,
|
|
AS_HELP_STRING([--enable-video-vivante], [use Vivante EGL video driver [[default=yes]]]),
|
|
, enable_video_vivante=yes)
|
|
if test x$enable_video = xyes -a x$enable_video_vivante = xyes; then
|
|
AC_MSG_CHECKING(for Vivante VDK API)
|
|
have_vivante_vdk=no
|
|
AC_TRY_COMPILE([
|
|
#define LINUX
|
|
#define EGL_API_FB
|
|
#include <gc_vdk.h>
|
|
],[
|
|
],[
|
|
have_vivante_vdk=yes
|
|
])
|
|
AC_MSG_RESULT($have_vivante_vdk)
|
|
|
|
AC_MSG_CHECKING(for Vivante FB API)
|
|
have_vivante_egl=no
|
|
AC_TRY_COMPILE([
|
|
#define LINUX
|
|
#define EGL_API_FB
|
|
#include <EGL/eglvivante.h>
|
|
],[
|
|
],[
|
|
have_vivante_egl=yes
|
|
])
|
|
AC_MSG_RESULT($have_vivante_egl)
|
|
|
|
if test x$have_vivante_vdk = xyes -o x$have_vivante_egl = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_VIVANTE, 1, [ ])
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -DLINUX -DEGL_API_FB"
|
|
if test x$have_vivante_vdk = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_VIVANTE_VDK, 1, [ ])
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lVDK"
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/video/vivante/*.c"
|
|
SUMMARY_video="${SUMMARY_video} vivante"
|
|
have_video=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Set up the Haiku video driver if enabled
|
|
CheckHaikuVideo()
|
|
{
|
|
if test x$enable_video = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_HAIKU, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/haiku/*.cc"
|
|
have_video=yes
|
|
SUMMARY_video="${SUMMARY_video} haiku"
|
|
fi
|
|
}
|
|
|
|
dnl Set up the Cocoa video driver for Mac OS X (but not Darwin)
|
|
CheckCOCOA()
|
|
{
|
|
AC_ARG_ENABLE(video-cocoa,
|
|
AS_HELP_STRING([--enable-video-cocoa], [use Cocoa video driver [[default=yes]]]),
|
|
, enable_video_cocoa=yes)
|
|
if test x$enable_video = xyes -a x$enable_video_cocoa = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
dnl Work around that we don't have Objective-C support in autoconf
|
|
CFLAGS="$CFLAGS -x objective-c"
|
|
AC_MSG_CHECKING(for Cocoa framework)
|
|
have_cocoa=no
|
|
AC_TRY_COMPILE([
|
|
#import <Cocoa/Cocoa.h>
|
|
],[
|
|
],[
|
|
have_cocoa=yes
|
|
])
|
|
AC_MSG_RESULT($have_cocoa)
|
|
CFLAGS="$save_CFLAGS"
|
|
if test x$have_cocoa = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_COCOA, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/cocoa/*.m"
|
|
SUMMARY_video="${SUMMARY_video} cocoa"
|
|
have_video=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
CheckMETAL()
|
|
{
|
|
AC_ARG_ENABLE(video-metal,
|
|
AC_HELP_STRING([--enable-video-metal], [include Metal support [[default=yes]]]),
|
|
, enable_video_metal=yes)
|
|
AC_ARG_ENABLE(render-metal,
|
|
AS_HELP_STRING([--enable-render-metal], [enable the Metal render driver [[default=yes]]]),
|
|
, enable_render_metal=yes)
|
|
if test x$enable_video = xyes -a x$enable_video_metal = xyes; then
|
|
save_CFLAGS="$CFLAGS"
|
|
dnl Work around that we don't have Objective-C support in autoconf
|
|
CFLAGS="$CFLAGS -x objective-c"
|
|
AC_MSG_CHECKING(for Metal framework)
|
|
have_metal=no
|
|
AC_TRY_COMPILE([
|
|
#import <Cocoa/Cocoa.h>
|
|
#import <Metal/Metal.h>
|
|
#import <QuartzCore/CAMetalLayer.h>
|
|
|
|
#if !TARGET_CPU_X86_64
|
|
#error Metal doesn't work on this configuration
|
|
#endif
|
|
],[
|
|
],[
|
|
have_metal=yes
|
|
])
|
|
CFLAGS="$save_CFLAGS"
|
|
AC_MSG_RESULT($have_metal)
|
|
if test x$have_metal = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_METAL, 1, [ ])
|
|
if test x$enable_render = xyes -a x$enable_render_metal = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_RENDER_METAL, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/render/metal/*.m"
|
|
fi
|
|
SUMMARY_video="${SUMMARY_video} metal"
|
|
else
|
|
enable_video_metal=no
|
|
enable_render_metal=no
|
|
fi
|
|
fi
|
|
}
|
|
|
|
|
|
dnl Find DirectFB
|
|
CheckDirectFB()
|
|
{
|
|
AC_ARG_ENABLE(video-directfb,
|
|
AS_HELP_STRING([--enable-video-directfb], [use DirectFB video driver [[default=no]]]),
|
|
, enable_video_directfb=no)
|
|
if test x$enable_video = xyes -a x$enable_video_directfb = xyes; then
|
|
PKG_CHECK_MODULES([DIRECTFB], [directfb >= 1.0.0], video_directfb=yes, video_directfb=no)
|
|
|
|
if test x$video_directfb = xyes; then
|
|
# SuSE 11.1 installs directfb-config without directfb-devel
|
|
save_CPPFLAGS="$CPPFLAGS"
|
|
CPPFLAGS="$CPPFLAGS $DIRECTFB_CFLAGS"
|
|
AC_CHECK_HEADER(directfb.h, have_directfb_hdr=yes, have_directfb_hdr=no)
|
|
CPPFLAGS="$save_CPPFLAGS"
|
|
video_directfb=$have_directfb_hdr
|
|
fi
|
|
|
|
if test x$video_directfb = xyes; then
|
|
AC_ARG_ENABLE(directfb-shared,
|
|
AS_HELP_STRING([--enable-directfb-shared], [dynamically load directfb support [[default=yes]]]),
|
|
, enable_directfb_shared=yes)
|
|
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_DIRECTFB, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_DIRECTFB, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/directfb/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $DIRECTFB_CFLAGS"
|
|
|
|
AC_MSG_CHECKING(for directfb dynamic loading support)
|
|
directfb_shared=no
|
|
directfb_lib=[`find_lib "libdirectfb*.so.*" "$DIRECTFB_LIBS"`]
|
|
# | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
AC_MSG_WARN("directfb $directfb_lib")
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_directfb_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic directfb loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_directfb_shared = xyes && test x$directfb_lib != x; then
|
|
directfb_shared=yes
|
|
echo "-- $directfb_lib_spec -> $directfb_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC, "$directfb_lib", [ ])
|
|
SUMMARY_video="${SUMMARY_video} directfb(dynamic)"
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $DIRECTFB_LIBS"
|
|
SUMMARY_video="${SUMMARY_video} directfb"
|
|
fi
|
|
AC_MSG_RESULT($directfb_shared)
|
|
SDL_CFLAGS="$SDL_CFLAGS $DIRECTFB_CFLAGS"
|
|
have_video=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Find KMSDRM
|
|
CheckKMSDRM()
|
|
{
|
|
AC_ARG_ENABLE(video-kmsdrm,
|
|
AS_HELP_STRING([--enable-video-kmsdrm], [use KMSDRM video driver [[default=no]]]),
|
|
, enable_video_kmsdrm=no)
|
|
|
|
if test x$enable_video = xyes -a x$enable_video_kmsdrm = xyes; then
|
|
video_kmsdrm=no
|
|
|
|
PKG_CHECK_MODULES([LIBDRM], [libdrm >= 2.4.46], libdrm_avail=yes, libdrm_avail=no)
|
|
PKG_CHECK_MODULES([LIBGBM], [gbm >= 9.0.0], libgbm_avail=yes, libgbm_avail=no)
|
|
|
|
if test x$libdrm_avail = xyes -a x$libgbm_avail = xyes; then
|
|
video_kmsdrm=yes
|
|
fi
|
|
|
|
if test x$video_kmsdrm = xyes; then
|
|
AC_ARG_ENABLE(kmsdrm-shared,
|
|
AS_HELP_STRING([--enable-kmsdrm-shared], [dynamically load kmsdrm support [[default=yes]]]),
|
|
, enable_kmsdrm_shared=yes)
|
|
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_KMSDRM, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/kmsdrm/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $LIBDRM_CFLAGS $LIBGBM_CFLAGS"
|
|
|
|
AC_MSG_CHECKING(for kmsdrm dynamic loading support)
|
|
kmsdrm_shared=no
|
|
drm_lib=[`find_lib "libdrm.so.*" "$DRM_LIBS"`]
|
|
gbm_lib=[`find_lib "libgbm.so.*" "$DRM_LIBS"`]
|
|
if test x$have_loadso != xyes && \
|
|
test x$enable_kmsdrm_shared = xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic kmsdrm loading])
|
|
fi
|
|
if test x$have_loadso = xyes && \
|
|
test x$enable_kmsdrm_shared = xyes && test x$drm_lib != x && test x$gbm_lib != x; then
|
|
kmsdrm_shared=yes
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC, "$drm_lib", [ ])
|
|
AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_KMSDRM_DYNAMIC_GBM, "$gbm_lib", [ ])
|
|
AC_DEFINE_UNQUOTED(HAVE_KMSDRM_SHARED, "TRUE", [ ])
|
|
SUMMARY_video="${SUMMARY_video} kmsdrm(dynamic)"
|
|
else
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $LIBDRM_LIBS $LIBGBM_LIBS"
|
|
SUMMARY_video="${SUMMARY_video} kmsdrm"
|
|
fi
|
|
AC_MSG_RESULT($kmsdrm_shared)
|
|
have_video=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl rcg04172001 Set up the Null video driver.
|
|
CheckDummyVideo()
|
|
{
|
|
AC_ARG_ENABLE(video-dummy,
|
|
AS_HELP_STRING([--enable-video-dummy], [use dummy video driver [[default=yes]]]),
|
|
, enable_video_dummy=yes)
|
|
if test x$enable_video_dummy = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_DUMMY, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/dummy/*.c"
|
|
have_video=yes
|
|
SUMMARY_video="${SUMMARY_video} dummy"
|
|
fi
|
|
}
|
|
|
|
dnl Set up the QNX video driver if enabled
|
|
CheckQNXVideo()
|
|
{
|
|
if test x$enable_video = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_QNX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/qnx/*.c"
|
|
have_video=yes
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lscreen -lEGL -lGLESv2"
|
|
SUMMARY_video="${SUMMARY_video} qnx"
|
|
fi
|
|
}
|
|
|
|
dnl Set up the QNX audio driver if enabled
|
|
CheckQNXAudio()
|
|
{
|
|
if test x$enable_audio = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_QSA, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/qsa/*.c"
|
|
have_audio=yes
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lasound"
|
|
SUMMARY_audio="${SUMMARY_audio} qsa"
|
|
fi
|
|
}
|
|
|
|
dnl Check to see if OpenGL support is desired
|
|
AC_ARG_ENABLE(video-opengl,
|
|
AS_HELP_STRING([--enable-video-opengl], [include OpenGL support [[default=yes]]]),
|
|
, enable_video_opengl=yes)
|
|
|
|
dnl Find OpenGL
|
|
CheckOpenGLX11()
|
|
{
|
|
if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
|
|
AC_MSG_CHECKING(for OpenGL (GLX) support)
|
|
video_opengl=no
|
|
AC_TRY_COMPILE([
|
|
#include <GL/gl.h>
|
|
#include <GL/glx.h>
|
|
],[
|
|
],[
|
|
video_opengl=yes
|
|
])
|
|
AC_MSG_RESULT($video_opengl)
|
|
if test x$video_opengl = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_GLX, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} opengl"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Check to see if OpenGL ES support is desired
|
|
AC_ARG_ENABLE(video-opengles,
|
|
AS_HELP_STRING([--enable-video-opengles], [include OpenGL ES support [[default=yes]]]),
|
|
, enable_video_opengles=yes)
|
|
AC_ARG_ENABLE(video-opengles1,
|
|
AS_HELP_STRING([--enable-video-opengles1], [include OpenGL ES 1.1 support [[default=yes]]]),
|
|
, enable_video_opengles1=yes)
|
|
AC_ARG_ENABLE(video-opengles2,
|
|
AS_HELP_STRING([--enable-video-opengles2], [include OpenGL ES 2.0 support [[default=yes]]]),
|
|
, enable_video_opengles2=yes)
|
|
|
|
dnl Find OpenGL ES
|
|
CheckOpenGLESX11()
|
|
{
|
|
if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
|
|
AC_MSG_CHECKING(for EGL support)
|
|
video_opengl_egl=no
|
|
AC_TRY_COMPILE([
|
|
#define LINUX
|
|
#define EGL_API_FB
|
|
#define MESA_EGL_NO_X11_HEADERS
|
|
#include <EGL/egl.h>
|
|
#include <EGL/eglext.h>
|
|
],[
|
|
],[
|
|
video_opengl_egl=yes
|
|
])
|
|
AC_MSG_RESULT($video_opengl_egl)
|
|
if test x$video_opengl_egl = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_EGL, 1, [ ])
|
|
fi
|
|
|
|
if test x$enable_video_opengles1 = xyes; then
|
|
AC_MSG_CHECKING(for OpenGL ES v1 headers)
|
|
video_opengles_v1=no
|
|
AC_TRY_COMPILE([
|
|
#include <GLES/gl.h>
|
|
#include <GLES/glext.h>
|
|
],[
|
|
],[
|
|
video_opengles_v1=yes
|
|
])
|
|
AC_MSG_RESULT($video_opengles_v1)
|
|
if test x$video_opengles_v1 = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_ES, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} opengl_es1"
|
|
fi
|
|
fi
|
|
|
|
if test x$enable_video_opengles2 = xyes; then
|
|
AC_MSG_CHECKING(for OpenGL ES v2 headers)
|
|
video_opengles_v2=no
|
|
AC_TRY_COMPILE([
|
|
#include <GLES2/gl2.h>
|
|
#include <GLES2/gl2ext.h>
|
|
],[
|
|
],[
|
|
video_opengles_v2=yes
|
|
])
|
|
AC_MSG_RESULT($video_opengles_v2)
|
|
if test x$video_opengles_v2 = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_ES2, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES2, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} opengl_es2"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Check for Windows OpenGL
|
|
CheckWINDOWSGL()
|
|
{
|
|
if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_WGL, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} opengl"
|
|
fi
|
|
}
|
|
|
|
dnl Check for Windows OpenGL
|
|
CheckWINDOWSGLES()
|
|
{
|
|
if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
|
|
|
|
AC_MSG_CHECKING(for EGL support)
|
|
video_opengl_egl=no
|
|
AC_TRY_COMPILE([
|
|
#include <EGL/egl.h>
|
|
],[
|
|
],[
|
|
video_opengl_egl=yes
|
|
])
|
|
AC_MSG_RESULT($video_opengl_egl)
|
|
if test x$video_opengl_egl = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_EGL, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} opengl_es1"
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for OpenGL ES v2 headers)
|
|
video_opengles_v2=no
|
|
AC_TRY_COMPILE([
|
|
#include <GLES2/gl2.h>
|
|
#include <GLES2/gl2ext.h>
|
|
],[
|
|
],[
|
|
video_opengles_v2=yes
|
|
])
|
|
AC_MSG_RESULT($video_opengles_v2)
|
|
if test x$video_opengles_v2 = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_ES2, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES2, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} opengl_es2"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Check for Haiku OpenGL
|
|
CheckHaikuGL()
|
|
{
|
|
if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_HAIKU, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL, 1, [ ])
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lGL"
|
|
SUMMARY_video="${SUMMARY_video} opengl"
|
|
fi
|
|
}
|
|
|
|
dnl Check for MacOS OpenGL
|
|
CheckMacGL()
|
|
{
|
|
if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_CGL, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} opengl"
|
|
fi
|
|
}
|
|
|
|
dnl Check for MacOS OpenGLES
|
|
CheckMacGLES()
|
|
{
|
|
if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
|
|
video_opengl_egl=yes
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_EGL, 1, [ ])
|
|
video_opengles_v2=yes
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_ES2, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES2, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} opengl_es2"
|
|
fi
|
|
}
|
|
|
|
CheckEmscriptenGLES()
|
|
{
|
|
if test x$enable_video = xyes -a x$enable_video_opengles = xyes; then
|
|
AC_MSG_CHECKING(for EGL support)
|
|
video_opengl_egl=no
|
|
AC_TRY_COMPILE([
|
|
#include <EGL/egl.h>
|
|
],[
|
|
],[
|
|
video_opengl_egl=yes
|
|
])
|
|
AC_MSG_RESULT($video_opengl_egl)
|
|
if test x$video_opengl_egl = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_EGL, 1, [ ])
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for OpenGL ES v2 headers)
|
|
video_opengles_v2=no
|
|
AC_TRY_COMPILE([
|
|
#include <GLES2/gl2.h>
|
|
#include <GLES2/gl2ext.h>
|
|
],[
|
|
],[
|
|
video_opengles_v2=yes
|
|
])
|
|
AC_MSG_RESULT($video_opengles_v2)
|
|
if test x$video_opengles_v2 = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_ES2, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES2, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} opengl_es2"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Check to see if Vulkan support is desired
|
|
AC_ARG_ENABLE(video-vulkan,
|
|
AS_HELP_STRING([--enable-video-vulkan], [include Vulkan support [[default=yes]]]),
|
|
, enable_video_vulkan=yes)
|
|
|
|
dnl Find Vulkan Header
|
|
CheckVulkan()
|
|
{
|
|
if test x$enable_video = xyes -a x$enable_video_vulkan = xyes; then
|
|
case "$host" in
|
|
*-*-android*)
|
|
AC_TRY_COMPILE([
|
|
#if defined(__ARM_ARCH) && __ARM_ARCH < 7
|
|
#error Vulkan doesn't work on this configuration
|
|
#endif
|
|
],[
|
|
],[
|
|
],[
|
|
enable_video_vulkan=no
|
|
])
|
|
;;
|
|
*-*-darwin*)
|
|
save_CFLAGS="$CFLAGS"
|
|
dnl Work around that we don't have Objective-C support in autoconf
|
|
CFLAGS="$CFLAGS -x objective-c"
|
|
AC_TRY_COMPILE([
|
|
#include <Cocoa/Cocoa.h>
|
|
#include <Metal/Metal.h>
|
|
#include <QuartzCore/CAMetalLayer.h>
|
|
|
|
#if !TARGET_CPU_X86_64
|
|
#error Vulkan doesn't work on this configuration
|
|
#endif
|
|
],[
|
|
],[
|
|
],[
|
|
enable_video_vulkan=no
|
|
])
|
|
CFLAGS="$save_CFLAGS"
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
if test x$enable_video_vulkan = xno; then
|
|
# For reasons I am totally unable to see, I get an undefined macro error if
|
|
# I put this in the AC_TRY_COMPILE.
|
|
AC_MSG_WARN([Vulkan does not work on this configuration.])
|
|
fi
|
|
fi
|
|
if test x$enable_video_vulkan = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_VULKAN, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} vulkan"
|
|
fi
|
|
}
|
|
|
|
dnl See if we can use the new unified event interface in Linux 2.4
|
|
CheckInputEvents()
|
|
{
|
|
dnl Check for Linux 2.4 unified input event interface support
|
|
AC_MSG_CHECKING(for Linux 2.4 unified input interface)
|
|
use_input_events=no
|
|
AC_TRY_COMPILE([
|
|
#include <linux/input.h>
|
|
],[
|
|
#ifndef EVIOCGNAME
|
|
#error EVIOCGNAME() ioctl not available
|
|
#endif
|
|
],[
|
|
use_input_events=yes
|
|
])
|
|
AC_MSG_RESULT($use_input_events)
|
|
if test x$use_input_events = xyes; then
|
|
AC_DEFINE(SDL_INPUT_LINUXEV, 1, [ ])
|
|
SUMMARY_input="${SUMMARY_input} linuxev"
|
|
fi
|
|
}
|
|
|
|
dnl See if we can use the kernel kd.h header
|
|
CheckInputKD()
|
|
{
|
|
|
|
AC_MSG_CHECKING(for Linux kd.h)
|
|
use_input_kd=no
|
|
AC_TRY_COMPILE([
|
|
#include <linux/kd.h>
|
|
#include <linux/keyboard.h>
|
|
],[
|
|
struct kbentry kbe;
|
|
kbe.kb_table = KG_CTRL;
|
|
ioctl(0, KDGKBENT, &kbe);
|
|
],[
|
|
use_input_kd=yes
|
|
])
|
|
AC_MSG_RESULT($use_input_kd)
|
|
if test x$use_input_kd = xyes; then
|
|
AC_DEFINE(SDL_INPUT_LINUXKD, 1, [ ])
|
|
SUMMARY_input="${SUMMARY_input} linuxkd"
|
|
fi
|
|
}
|
|
|
|
dnl See if the platform offers libudev for device enumeration and hotplugging.
|
|
CheckLibUDev()
|
|
{
|
|
AC_ARG_ENABLE(libudev,
|
|
AS_HELP_STRING([--enable-libudev], [enable libudev support [[default=yes]]]),
|
|
, enable_libudev=yes)
|
|
if test x$enable_libudev = xyes; then
|
|
AC_CHECK_HEADER(libudev.h,
|
|
have_libudev_h_hdr=yes,
|
|
have_libudev_h_hdr=no)
|
|
if test x$have_libudev_h_hdr = xyes; then
|
|
AC_DEFINE(HAVE_LIBUDEV_H, 1, [ ])
|
|
|
|
udev_lib=[`find_lib "libudev.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
if test x$udev_lib != x; then
|
|
echo "-- dynamic udev -> $udev_lib"
|
|
AC_DEFINE_UNQUOTED(SDL_UDEV_DYNAMIC, "$udev_lib", [ ])
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl See if the platform offers libdbus for various IPC techniques.
|
|
CheckDBus()
|
|
{
|
|
AC_ARG_ENABLE(dbus,
|
|
AS_HELP_STRING([--enable-dbus], [enable D-Bus support [[default=yes]]]),
|
|
, enable_dbus=yes)
|
|
if test x$enable_dbus = xyes; then
|
|
PKG_CHECK_MODULES([DBUS], [dbus-1], have_dbus=yes, have_dbus=no)
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$save_CFLAGS $DBUS_CFLAGS"
|
|
AC_CHECK_HEADER(dbus/dbus.h,
|
|
have_dbus_dbus_h_hdr=yes,
|
|
have_dbus_dbus_h_hdr=no)
|
|
CFLAGS="$save_CFLAGS"
|
|
if test x$have_dbus_dbus_h_hdr = xyes; then
|
|
AC_DEFINE(HAVE_DBUS_DBUS_H, 1, [ ])
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $DBUS_CFLAGS"
|
|
SOURCES="$SOURCES $srcdir/src/core/linux/SDL_dbus.c"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl See if the platform wanna IME support.
|
|
CheckIME()
|
|
{
|
|
AC_ARG_ENABLE(ime,
|
|
AS_HELP_STRING([--enable-ime], [enable IME support [[default=yes]]]),
|
|
, enable_ime=yes)
|
|
if test x$enable_ime = xyes; then
|
|
AC_DEFINE(SDL_USE_IME, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/core/linux/SDL_ime.c"
|
|
fi
|
|
}
|
|
|
|
dnl See if the platform has libibus IME support.
|
|
CheckIBus()
|
|
{
|
|
AC_ARG_ENABLE(ibus,
|
|
AS_HELP_STRING([--enable-ibus], [enable IBus support [[default=yes]]]),
|
|
, enable_ibus=yes)
|
|
if test x$enable_ibus = xyes; then
|
|
PKG_CHECK_MODULES([IBUS], [ibus-1.0], have_ibus=yes, have_ibus=no)
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$save_CFLAGS $IBUS_CFLAGS"
|
|
AC_CHECK_HEADER(ibus-1.0/ibus.h,
|
|
have_ibus_ibus_h_hdr=yes,
|
|
have_ibus_ibus_h_hdr=no)
|
|
AC_CHECK_HEADER(sys/inotify.h,
|
|
have_inotify_inotify_h_hdr=yes,
|
|
have_inotify_inotify_h_hdr=no)
|
|
CFLAGS="$save_CFLAGS"
|
|
if test x$have_ibus_ibus_h_hdr = xyes; then
|
|
if test x$enable_ime != xyes; then
|
|
AC_MSG_WARN([IME support is required for IBus.])
|
|
have_ibus_ibus_h_hdr=no
|
|
elif test x$enable_dbus != xyes; then
|
|
AC_MSG_WARN([DBus support is required for IBus.])
|
|
have_ibus_ibus_h_hdr=no
|
|
elif test x$have_inotify_inotify_h_hdr != xyes; then
|
|
AC_MSG_WARN([INotify support is required for IBus.])
|
|
have_ibus_ibus_h_hdr=no
|
|
else
|
|
AC_DEFINE(HAVE_IBUS_IBUS_H, 1, [ ])
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $IBUS_CFLAGS"
|
|
SOURCES="$SOURCES $srcdir/src/core/linux/SDL_ibus.c"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl See if the platform has fcitx IME support.
|
|
CheckFcitx()
|
|
{
|
|
AC_ARG_ENABLE(fcitx,
|
|
AS_HELP_STRING([--enable-fcitx], [enable fcitx support [[default=yes]]]),
|
|
, enable_fcitx=yes)
|
|
if test x$enable_fcitx = xyes; then
|
|
PKG_CHECK_MODULES([FCITX], [fcitx], have_fcitx=yes, have_fcitx=no)
|
|
CFLAGS="$CFLAGS $FCITX_CFLAGS"
|
|
AC_CHECK_HEADER(fcitx/frontend.h,
|
|
have_fcitx_frontend_h_hdr=yes,
|
|
have_fcitx_frontend_h_hdr=no)
|
|
CFLAGS="$save_CFLAGS"
|
|
if test x$have_fcitx_frontend_h_hdr = xyes; then
|
|
if test x$enable_ime != xyes; then
|
|
AC_MSG_WARN([IME support is required for fcitx.])
|
|
have_fcitx_frontend_h_hdr=no
|
|
elif test x$enable_dbus != xyes; then
|
|
AC_MSG_WARN([DBus support is required for fcitx.])
|
|
have_fcitx_frontend_h_hdr=no
|
|
else
|
|
AC_DEFINE(HAVE_FCITX_FRONTEND_H, 1, [ ])
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $FCITX_CFLAGS"
|
|
SOURCES="$SOURCES $srcdir/src/core/linux/SDL_fcitx.c"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl See if we can use the Touchscreen input library
|
|
CheckTslib()
|
|
{
|
|
AC_ARG_ENABLE(input-tslib,
|
|
AS_HELP_STRING([--enable-input-tslib], [use the Touchscreen library for input [[default=yes]]]),
|
|
, enable_input_tslib=yes)
|
|
if test x$enable_input_tslib = xyes; then
|
|
AC_MSG_CHECKING(for Touchscreen library support)
|
|
enable_input_tslib=no
|
|
AC_TRY_COMPILE([
|
|
#include "tslib.h"
|
|
],[
|
|
],[
|
|
enable_input_tslib=yes
|
|
])
|
|
AC_MSG_RESULT($enable_input_tslib)
|
|
if test x$enable_input_tslib = xyes; then
|
|
AC_DEFINE(SDL_INPUT_TSLIB, 1, [ ])
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lts"
|
|
SUMMARY_input="${SUMMARY_input} ts"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl See what type of thread model to use on Linux and Solaris
|
|
CheckPTHREAD()
|
|
{
|
|
dnl Check for pthread support
|
|
AC_ARG_ENABLE(pthreads,
|
|
AS_HELP_STRING([--enable-pthreads], [use POSIX threads for multi-threading [[default=yes]]]),
|
|
, enable_pthreads=yes)
|
|
dnl This is used on Linux for glibc binary compatibility (Doh!)
|
|
AC_ARG_ENABLE(pthread-sem,
|
|
AS_HELP_STRING([--enable-pthread-sem], [use pthread semaphores [[default=yes]]]),
|
|
, enable_pthread_sem=yes)
|
|
case "$host" in
|
|
*-*-android*)
|
|
pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
|
|
pthread_lib=""
|
|
;;
|
|
*-*-linux*|*-*-uclinux*)
|
|
pthread_cflags="-D_REENTRANT"
|
|
pthread_lib="-lpthread"
|
|
;;
|
|
*-*-bsdi*)
|
|
pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
|
|
pthread_lib=""
|
|
;;
|
|
*-*-darwin*)
|
|
pthread_cflags="-D_THREAD_SAFE"
|
|
# causes Carbon.p complaints?
|
|
# pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
|
|
;;
|
|
*-*-freebsd*|*-*-dragonfly*)
|
|
pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
|
|
pthread_lib="-pthread"
|
|
;;
|
|
*-*-netbsd*)
|
|
pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
|
|
pthread_lib="-lpthread"
|
|
;;
|
|
*-*-openbsd*)
|
|
pthread_cflags="-D_REENTRANT"
|
|
pthread_lib="-pthread"
|
|
;;
|
|
*-*-solaris2.9)
|
|
# From Solaris 9+, posix4's preferred name is rt.
|
|
pthread_cflags="-D_REENTRANT"
|
|
pthread_lib="-lpthread -lrt"
|
|
;;
|
|
*-*-solaris2.10)
|
|
# Solaris 10+ merged pthread into libc.
|
|
pthread_cflags="-D_REENTRANT"
|
|
pthread_lib="-lrt"
|
|
;;
|
|
*-*-solaris*)
|
|
# Solaris 11+ merged rt into libc.
|
|
pthread_cflags="-D_REENTRANT"
|
|
pthread_lib=""
|
|
;;
|
|
*-*-sysv5*)
|
|
pthread_cflags="-D_REENTRANT -Kthread"
|
|
pthread_lib=""
|
|
;;
|
|
*-*-aix*)
|
|
pthread_cflags="-D_REENTRANT -mthreads"
|
|
pthread_lib="-lpthread"
|
|
;;
|
|
*-*-hpux11*)
|
|
pthread_cflags="-D_REENTRANT"
|
|
pthread_lib="-L/usr/lib -lpthread"
|
|
;;
|
|
*-*-haiku*)
|
|
pthread_cflags="-D_REENTRANT"
|
|
pthread_lib=""
|
|
;;
|
|
*-*-nto*)
|
|
pthread_cflags="-D_REENTRANT"
|
|
pthread_lib=""
|
|
;;
|
|
*)
|
|
pthread_cflags="-D_REENTRANT"
|
|
pthread_lib="-lpthread"
|
|
;;
|
|
esac
|
|
if test x$enable_threads = xyes -a x$enable_pthreads = xyes; then
|
|
# Save the original compiler flags and libraries
|
|
ac_save_cflags="$CFLAGS"; ac_save_libs="$LIBS"
|
|
# Add the pthread compiler flags and libraries
|
|
CFLAGS="$CFLAGS $pthread_cflags"; LIBS="$LIBS $pthread_lib"
|
|
# Check to see if we have pthread support on this system
|
|
AC_MSG_CHECKING(for pthreads)
|
|
use_pthreads=no
|
|
AC_TRY_LINK([
|
|
#include <pthread.h>
|
|
],[
|
|
pthread_attr_t type;
|
|
pthread_attr_init(&type);
|
|
],[
|
|
use_pthreads=yes
|
|
])
|
|
AC_MSG_RESULT($use_pthreads)
|
|
# Restore the compiler flags and libraries
|
|
CFLAGS="$ac_save_cflags"; LIBS="$ac_save_libs"
|
|
|
|
# Do futher testing if we have pthread support...
|
|
if test x$use_pthreads = xyes; then
|
|
AC_DEFINE(SDL_THREAD_PTHREAD, 1, [ ])
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $pthread_cflags"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $pthread_lib"
|
|
SDL_CFLAGS="$SDL_CFLAGS $pthread_cflags"
|
|
|
|
# Save the original compiler flags and libraries
|
|
ac_save_cflags="$CFLAGS"; ac_save_libs="$LIBS"
|
|
# Add the pthread compiler flags and libraries
|
|
CFLAGS="$CFLAGS $pthread_cflags"; LIBS="$LIBS $pthread_lib"
|
|
|
|
# Check to see if recursive mutexes are available
|
|
AC_MSG_CHECKING(for recursive mutexes)
|
|
has_recursive_mutexes=no
|
|
if test x$has_recursive_mutexes = xno; then
|
|
AC_TRY_LINK([
|
|
#define _GNU_SOURCE 1
|
|
#include <pthread.h>
|
|
],[
|
|
pthread_mutexattr_t attr;
|
|
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
|
],[
|
|
has_recursive_mutexes=yes
|
|
AC_DEFINE(SDL_THREAD_PTHREAD_RECURSIVE_MUTEX, 1, [ ])
|
|
])
|
|
fi
|
|
if test x$has_recursive_mutexes = xno; then
|
|
AC_TRY_LINK([
|
|
#define _GNU_SOURCE 1
|
|
#include <pthread.h>
|
|
],[
|
|
pthread_mutexattr_t attr;
|
|
pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
|
|
],[
|
|
has_recursive_mutexes=yes
|
|
AC_DEFINE(SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP, 1, [ ])
|
|
])
|
|
fi
|
|
AC_MSG_RESULT($has_recursive_mutexes)
|
|
|
|
# Check to see if pthread semaphore support is missing
|
|
if test x$enable_pthread_sem = xyes; then
|
|
AC_MSG_CHECKING(for pthread semaphores)
|
|
have_pthread_sem=no
|
|
AC_TRY_COMPILE([
|
|
#include <pthread.h>
|
|
#include <semaphore.h>
|
|
],[
|
|
],[
|
|
have_pthread_sem=yes
|
|
])
|
|
AC_MSG_RESULT($have_pthread_sem)
|
|
fi
|
|
if test x$have_pthread_sem = xyes; then
|
|
AC_MSG_CHECKING(for sem_timedwait)
|
|
have_sem_timedwait=no
|
|
AC_TRY_LINK([
|
|
#include <pthread.h>
|
|
#include <semaphore.h>
|
|
],[
|
|
sem_timedwait(NULL, NULL);
|
|
],[
|
|
have_sem_timedwait=yes
|
|
AC_DEFINE([HAVE_SEM_TIMEDWAIT], 1, [ ])
|
|
])
|
|
AC_MSG_RESULT($have_sem_timedwait)
|
|
fi
|
|
|
|
AC_CHECK_HEADER(pthread_np.h, have_pthread_np_h=yes, have_pthread_np_h=no, [ #include <pthread.h> ])
|
|
if test x$have_pthread_np_h = xyes; then
|
|
AC_DEFINE(HAVE_PTHREAD_NP_H, 1, [ ])
|
|
fi
|
|
|
|
# Check to see if pthread naming is available
|
|
AC_MSG_CHECKING(for pthread_setname_np)
|
|
AC_TRY_LINK_FUNC(pthread_setname_np, [
|
|
has_pthread_setname_np=yes
|
|
AC_DEFINE(HAVE_PTHREAD_SETNAME_NP, 1, [ ])
|
|
],[
|
|
has_pthread_setname_np=no
|
|
])
|
|
AC_MSG_RESULT($has_pthread_setname_np)
|
|
|
|
AC_MSG_CHECKING(for pthread_set_name_np)
|
|
AC_TRY_LINK_FUNC(pthread_set_name_np, [
|
|
has_pthread_set_name_np=yes
|
|
AC_DEFINE(HAVE_PTHREAD_SET_NAME_NP, 1, [ ])
|
|
],[
|
|
has_pthread_set_name_np=no
|
|
])
|
|
AC_MSG_RESULT($has_pthread_set_name_np)
|
|
|
|
# Restore the compiler flags and libraries
|
|
CFLAGS="$ac_save_cflags"; LIBS="$ac_save_libs"
|
|
|
|
# Basic thread creation functions
|
|
SOURCES="$SOURCES $srcdir/src/thread/pthread/SDL_systhread.c"
|
|
|
|
# Semaphores
|
|
# We can fake these with mutexes and condition variables if necessary
|
|
if test x$have_pthread_sem = xyes; then
|
|
SOURCES="$SOURCES $srcdir/src/thread/pthread/SDL_syssem.c"
|
|
else
|
|
SOURCES="$SOURCES $srcdir/src/thread/generic/SDL_syssem.c"
|
|
fi
|
|
|
|
# Mutexes
|
|
# We can fake these with semaphores if necessary
|
|
SOURCES="$SOURCES $srcdir/src/thread/pthread/SDL_sysmutex.c"
|
|
|
|
# Condition variables
|
|
# We can fake these with semaphores and mutexes if necessary
|
|
SOURCES="$SOURCES $srcdir/src/thread/pthread/SDL_syscond.c"
|
|
|
|
# Thread local storage
|
|
SOURCES="$SOURCES $srcdir/src/thread/pthread/SDL_systls.c"
|
|
|
|
have_threads=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Determine whether the compiler can produce Windows executables
|
|
CheckWINDOWS()
|
|
{
|
|
AC_MSG_CHECKING(Windows compiler)
|
|
have_win32_gcc=no
|
|
AC_TRY_COMPILE([
|
|
#include <windows.h>
|
|
],[
|
|
],[
|
|
have_win32_gcc=yes
|
|
])
|
|
AC_MSG_RESULT($have_win32_gcc)
|
|
if test x$have_win32_gcc != xyes; then
|
|
AC_MSG_ERROR([
|
|
*** Your compiler ($CC) does not produce Windows executables!
|
|
])
|
|
fi
|
|
|
|
AC_MSG_CHECKING(Windows CE)
|
|
have_wince=no
|
|
AC_TRY_COMPILE([
|
|
#if !defined(_WIN32_WCE) && !defined(__MINGW32CE__)
|
|
#error This is not Windows CE
|
|
#endif
|
|
],[
|
|
],[
|
|
have_wince=yes
|
|
AC_MSG_ERROR([
|
|
*** Sorry, Windows CE is no longer supported.
|
|
])
|
|
])
|
|
AC_MSG_RESULT($have_wince)
|
|
|
|
# This fixes Windows stack alignment with newer GCC
|
|
CheckStackBoundary
|
|
}
|
|
|
|
dnl Find the DirectX includes and libraries
|
|
CheckDIRECTX()
|
|
{
|
|
AC_ARG_ENABLE(directx,
|
|
AS_HELP_STRING([--enable-directx], [use DirectX for Windows audio/video [[default=yes]]]),
|
|
, enable_directx=yes)
|
|
if test x$enable_directx = xyes; then
|
|
AC_CHECK_HEADER(d3d9.h, have_d3d=yes)
|
|
AC_CHECK_HEADER(d3d11_1.h, have_d3d11=yes)
|
|
AC_CHECK_HEADER(ddraw.h, have_ddraw=yes)
|
|
AC_CHECK_HEADER(dsound.h, have_dsound=yes)
|
|
AC_CHECK_HEADER(dinput.h, have_dinput=yes)
|
|
AC_CHECK_HEADER(dxgi.h, have_dxgi=yes)
|
|
AC_CHECK_HEADER(xinput.h, have_xinput=yes)
|
|
AC_TRY_COMPILE([
|
|
#include <windows.h>
|
|
#include <xinput.h>
|
|
XINPUT_GAMEPAD_EX x1;
|
|
],[],[have_xinput_gamepadex=yes])
|
|
AC_TRY_COMPILE([
|
|
#include <windows.h>
|
|
#include <xinput.h>
|
|
XINPUT_STATE_EX s1;
|
|
],[],[have_xinput_stateex=yes])
|
|
|
|
if test x$have_ddraw = xyes; then
|
|
AC_DEFINE(HAVE_DDRAW_H, 1, [ ])
|
|
fi
|
|
if test x$have_dinput = xyes; then
|
|
AC_DEFINE(HAVE_DINPUT_H, 1, [ ])
|
|
fi
|
|
if test x$have_dsound = xyes; then
|
|
AC_DEFINE(HAVE_DSOUND_H, 1, [ ])
|
|
fi
|
|
if test x$have_dxgi = xyes; then
|
|
AC_DEFINE(HAVE_DXGI_H, 1, [ ])
|
|
fi
|
|
if test x$have_xinput = xyes; then
|
|
AC_DEFINE(HAVE_XINPUT_H, 1, [ ])
|
|
fi
|
|
if test x$have_xinput_gamepadex = xyes; then
|
|
AC_DEFINE(HAVE_XINPUT_GAMEPAD_EX, 1, [ ])
|
|
fi
|
|
if test x$have_xinput_stateex = xyes; then
|
|
AC_DEFINE(HAVE_XINPUT_STATE_EX, 1, [ ])
|
|
fi
|
|
|
|
# FIXME: latest Cygwin finds dinput headers, but we die on other win32 headers.
|
|
# FIXME: ...so force it off for now.
|
|
case "$host" in
|
|
*-*-cygwin*)
|
|
have_dinput=false
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
AC_CHECK_HEADER(mmdeviceapi.h, have_wasapi=yes)
|
|
if test x$have_wasapi = xyes; then
|
|
AC_DEFINE(HAVE_MMDEVICEAPI_H, 1, [ ])
|
|
fi
|
|
AC_CHECK_HEADER(audioclient.h,,have_wasapi=no)
|
|
if test x$have_wasapi = xyes; then
|
|
AC_DEFINE(HAVE_AUDIOCLIENT_H, 1, [ ])
|
|
fi
|
|
|
|
AC_ARG_ENABLE(wasapi,
|
|
AS_HELP_STRING([--enable-wasapi], [use the Windows WASAPI audio driver [[default=yes]]]),
|
|
, enable_wasapi=yes)
|
|
}
|
|
|
|
dnl Check for the dlfcn.h interface for dynamically loading objects
|
|
CheckDLOPEN()
|
|
{
|
|
AC_ARG_ENABLE(sdl-dlopen,
|
|
AS_HELP_STRING([--enable-sdl-dlopen], [use dlopen for shared object loading [[default=yes]]]),
|
|
, enable_sdl_dlopen=yes)
|
|
if test x$enable_sdl_dlopen = xyes; then
|
|
AC_MSG_CHECKING(for dlopen)
|
|
have_dlopen=no
|
|
AC_TRY_COMPILE([
|
|
#include <dlfcn.h>
|
|
],[
|
|
void *handle = dlopen("", RTLD_NOW);
|
|
const char *loaderror = (char *) dlerror();
|
|
],[
|
|
have_dlopen=yes
|
|
])
|
|
AC_MSG_RESULT($have_dlopen)
|
|
|
|
if test x$have_dlopen = xyes; then
|
|
AC_CHECK_LIB(c, dlopen, EXTRA_LDFLAGS="$EXTRA_LDFLAGS",
|
|
AC_CHECK_LIB(dl, dlopen, EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldl",
|
|
AC_CHECK_LIB(ltdl, dlopen, EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lltdl")))
|
|
AC_DEFINE(SDL_LOADSO_DLOPEN, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/loadso/dlopen/*.c"
|
|
have_loadso=yes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Check for the usbhid(3) library on *BSD
|
|
CheckUSBHID()
|
|
{
|
|
case "$host" in
|
|
*-*-*bsd*)
|
|
if test x$enable_joystick = xyes; then
|
|
AC_CHECK_LIB(usbhid, hid_init, have_libusbhid=yes)
|
|
if test x$have_libusbhid = xyes; then
|
|
AC_CHECK_HEADER(usbhid.h, [USB_CFLAGS="-DHAVE_USBHID_H"])
|
|
AC_CHECK_HEADER(libusbhid.h, [USB_CFLAGS="-DHAVE_LIBUSBHID_H"])
|
|
USB_LIBS="$USB_LIBS -lusbhid"
|
|
else
|
|
AC_CHECK_HEADER(usb.h, [USB_CFLAGS="-DHAVE_USB_H"])
|
|
AC_CHECK_HEADER(libusb.h, [USB_CFLAGS="-DHAVE_LIBUSB_H"])
|
|
AC_CHECK_LIB(usb, hid_init, [USB_LIBS="$USB_LIBS -lusb"])
|
|
fi
|
|
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$CFLAGS $USB_CFLAGS"
|
|
|
|
AC_MSG_CHECKING(for usbhid)
|
|
have_usbhid=no
|
|
AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#if defined(HAVE_USB_H)
|
|
#include <usb.h>
|
|
#endif
|
|
#ifdef __DragonFly__
|
|
# include <bus/usb/usb.h>
|
|
# include <bus/usb/usbhid.h>
|
|
#else
|
|
# include <dev/usb/usb.h>
|
|
# include <dev/usb/usbhid.h>
|
|
#endif
|
|
#if defined(HAVE_USBHID_H)
|
|
#include <usbhid.h>
|
|
#elif defined(HAVE_LIBUSB_H)
|
|
#include <libusb.h>
|
|
#elif defined(HAVE_LIBUSBHID_H)
|
|
#include <libusbhid.h>
|
|
#endif
|
|
],[
|
|
struct report_desc *repdesc;
|
|
struct usb_ctl_report *repbuf;
|
|
hid_kind_t hidkind;
|
|
],[
|
|
have_usbhid=yes
|
|
])
|
|
AC_MSG_RESULT($have_usbhid)
|
|
|
|
if test x$have_usbhid = xyes; then
|
|
AC_MSG_CHECKING(for ucr_data member of usb_ctl_report)
|
|
have_usbhid_ucr_data=no
|
|
AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#if defined(HAVE_USB_H)
|
|
#include <usb.h>
|
|
#endif
|
|
#ifdef __DragonFly__
|
|
# include <bus/usb/usb.h>
|
|
# include <bus/usb/usbhid.h>
|
|
#else
|
|
# include <dev/usb/usb.h>
|
|
# include <dev/usb/usbhid.h>
|
|
#endif
|
|
#if defined(HAVE_USBHID_H)
|
|
#include <usbhid.h>
|
|
#elif defined(HAVE_LIBUSB_H)
|
|
#include <libusb.h>
|
|
#elif defined(HAVE_LIBUSBHID_H)
|
|
#include <libusbhid.h>
|
|
#endif
|
|
],[
|
|
struct usb_ctl_report buf;
|
|
if (buf.ucr_data) { }
|
|
],[
|
|
have_usbhid_ucr_data=yes
|
|
])
|
|
if test x$have_usbhid_ucr_data = xyes; then
|
|
USB_CFLAGS="$USB_CFLAGS -DUSBHID_UCR_DATA"
|
|
fi
|
|
AC_MSG_RESULT($have_usbhid_ucr_data)
|
|
|
|
AC_MSG_CHECKING(for new usbhid API)
|
|
have_usbhid_new=no
|
|
AC_TRY_COMPILE([
|
|
#include <sys/types.h>
|
|
#if defined(HAVE_USB_H)
|
|
#include <usb.h>
|
|
#endif
|
|
#ifdef __DragonFly__
|
|
#include <bus/usb/usb.h>
|
|
#include <bus/usb/usbhid.h>
|
|
#else
|
|
#include <dev/usb/usb.h>
|
|
#include <dev/usb/usbhid.h>
|
|
#endif
|
|
#if defined(HAVE_USBHID_H)
|
|
#include <usbhid.h>
|
|
#elif defined(HAVE_LIBUSB_H)
|
|
#include <libusb.h>
|
|
#elif defined(HAVE_LIBUSBHID_H)
|
|
#include <libusbhid.h>
|
|
#endif
|
|
],[
|
|
report_desc_t d;
|
|
hid_start_parse(d, 1, 1);
|
|
],[
|
|
have_usbhid_new=yes
|
|
])
|
|
if test x$have_usbhid_new = xyes; then
|
|
USB_CFLAGS="$USB_CFLAGS -DUSBHID_NEW"
|
|
fi
|
|
AC_MSG_RESULT($have_usbhid_new)
|
|
|
|
AC_MSG_CHECKING(for struct joystick in machine/joystick.h)
|
|
have_machine_joystick=no
|
|
AC_TRY_COMPILE([
|
|
#include <machine/joystick.h>
|
|
],[
|
|
struct joystick t;
|
|
],[
|
|
have_machine_joystick=yes
|
|
])
|
|
if test x$have_machine_joystick = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H, 1, [ ])
|
|
fi
|
|
AC_MSG_RESULT($have_machine_joystick)
|
|
|
|
AC_DEFINE(SDL_JOYSTICK_USBHID, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/joystick/bsd/*.c"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $USB_CFLAGS"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $USB_LIBS"
|
|
have_joystick=yes
|
|
fi
|
|
CFLAGS="$save_CFLAGS"
|
|
fi
|
|
;;
|
|
esac
|
|
}
|
|
|
|
dnl Check for HIDAPI joystick drivers
|
|
CheckHIDAPI()
|
|
{
|
|
# The hidraw support doesn't catch Xbox, PS4 and Nintendo controllers,
|
|
# so we'll just use libusb when it's available.
|
|
case "$host" in
|
|
# libusb does not support iOS
|
|
arm*-apple-darwin* | *-ios-* )
|
|
skiplibusb=yes
|
|
;;
|
|
# On the other hand, *BSD specifically uses libusb only
|
|
*-*-*bsd* )
|
|
onlylibusb=yes
|
|
;;
|
|
# RAWINPUT is only available on Win32, but can be enabled if HIDAPI is
|
|
*-*-cygwin* | *-*-mingw32*)
|
|
userawinput=yes
|
|
;;
|
|
esac
|
|
|
|
AC_ARG_ENABLE(hidapi,
|
|
AS_HELP_STRING([--enable-hidapi], [use HIDAPI for low level joystick drivers [[default=no]]]),
|
|
, enable_hidapi=no)
|
|
if test x$enable_joystick = xyes -a x$enable_hidapi = xyes; then
|
|
if test x$skiplibusb = xyes; then
|
|
hidapi_support=yes
|
|
else
|
|
PKG_CHECK_MODULES([LIBUSB], [libusb-1.0], have_libusb=yes, have_libusb=no)
|
|
save_CFLAGS="$CFLAGS"
|
|
CFLAGS="$save_CFLAGS $LIBUSB_CFLAGS"
|
|
AC_CHECK_HEADER(libusb.h, have_libusb_h=yes)
|
|
CFLAGS="$save_CFLAGS"
|
|
if test x$have_libusb_h = xyes; then
|
|
hidapi_support=yes
|
|
elif test x$onlylibusb = xyes; then
|
|
hidapi_support=no
|
|
else
|
|
hidapi_support=yes
|
|
fi
|
|
fi
|
|
|
|
if test x$hidapi_support = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_HIDAPI, 1, [ ])
|
|
if test x$userawinput = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_RAWINPUT, 1, [ ])
|
|
fi
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -I$srcdir/src/hidapi/hidapi"
|
|
SOURCES="$SOURCES $srcdir/src/joystick/hidapi/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/hidapi/SDL_hidapi.c"
|
|
|
|
if test x$have_libusb_h = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $LIBUSB_CFLAGS"
|
|
if test x$onlylibusb = xyes; then
|
|
SOURCES="$SOURCES $srcdir/src/hidapi/libusb/hid.c"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS $LIBUSB_LIBS"
|
|
else
|
|
if test x$have_loadso != xyes; then
|
|
AC_MSG_WARN([You must have SDL_LoadObject() support for dynamic libusb loading])
|
|
fi
|
|
# libusb is loaded dynamically, so don't add it to LDFLAGS
|
|
libusb_lib=""
|
|
case "$host" in
|
|
*-*-darwin* )
|
|
libusb_lib="libusb-1.0.0.dylib"
|
|
;;
|
|
*-*-cygwin* | *-*-mingw32* )
|
|
libusb_lib="libusb-1.0.dll"
|
|
;;
|
|
esac
|
|
if test x$libusb_lib = x; then
|
|
libusb_lib=[`find_lib "libusb-1.0.so.*" "" | sed 's/.*\/\(.*\)/\1/; q'`]
|
|
fi
|
|
AC_DEFINE_UNQUOTED(SDL_LIBUSB_DYNAMIC, "$libusb_lib", [ ])
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
AC_MSG_CHECKING(for hidapi support)
|
|
AC_MSG_RESULT($hidapi_support)
|
|
fi
|
|
}
|
|
|
|
dnl Check for clock_gettime()
|
|
CheckClockGettime()
|
|
{
|
|
AC_ARG_ENABLE(clock_gettime,
|
|
AS_HELP_STRING([--enable-clock_gettime], [use clock_gettime() instead of gettimeofday() on UNIX [[default=yes]]]),
|
|
, enable_clock_gettime=yes)
|
|
if test x$enable_clock_gettime = xyes; then
|
|
AC_CHECK_LIB(rt, clock_gettime, have_clock_gettime=yes)
|
|
if test x$have_clock_gettime = xyes; then
|
|
AC_DEFINE(HAVE_CLOCK_GETTIME, 1, [ ])
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lrt"
|
|
else
|
|
AC_CHECK_LIB(c, clock_gettime, have_clock_gettime=yes)
|
|
if test x$have_clock_gettime = xyes; then
|
|
AC_DEFINE(HAVE_CLOCK_GETTIME, 1, [ ])
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
dnl Check for a valid linux/version.h
|
|
CheckLinuxVersion()
|
|
{
|
|
AC_CHECK_HEADER(linux/version.h, have_linux_version_h=yes)
|
|
if test x$have_linux_version_h = xyes; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -DHAVE_LINUX_VERSION_H"
|
|
fi
|
|
}
|
|
|
|
dnl Check if we want to use RPATH
|
|
CheckRPATH()
|
|
{
|
|
AC_ARG_ENABLE(rpath,
|
|
AS_HELP_STRING([--enable-rpath], [use an rpath when linking SDL [[default=yes]]]),
|
|
, enable_rpath=yes)
|
|
}
|
|
|
|
dnl Check if we want to use custom signals to fake iOS/Android's backgrounding
|
|
dnl events. These could be useful if you're building a custom embedded
|
|
dnl environment, etc, but most people don't need this.
|
|
CheckEventSignals()
|
|
{
|
|
AC_ARG_ENABLE(backgrounding-signal,
|
|
AS_HELP_STRING([--enable-backgrounding-signal], [number to use for magic backgrounding signal or 'no' [[default=no]]]),
|
|
, enable_backgrounding_signal=no)
|
|
if test x$enable_backgrounding_signal != xno; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -DSDL_BACKGROUNDING_SIGNAL=$enable_backgrounding_signal"
|
|
fi
|
|
|
|
AC_ARG_ENABLE(foregrounding-signal,
|
|
AS_HELP_STRING([--enable-foregrounding-signal], [number to use for magic foregrounding signal or 'no' [[default=no]]]),
|
|
, enable_foregrounding_signal=no)
|
|
if test x$enable_foregrounding_signal != xno; then
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -DSDL_FOREGROUNDING_SIGNAL=$enable_foregrounding_signal"
|
|
fi
|
|
}
|
|
|
|
dnl Set up the Virtual joystick driver.
|
|
CheckVirtualJoystick()
|
|
{
|
|
AC_ARG_ENABLE(joystick-virtual,
|
|
AS_HELP_STRING([--enable-joystick-virtual], [enable virtual joystick APIs [[default=no]]]),
|
|
, enable_joystick_virtual=no)
|
|
if test x$enable_joystick = xyes -a x$enable_joystick_virtual = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_VIRTUAL, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/joystick/virtual/*.c"
|
|
have_joystick_virtual=yes
|
|
fi
|
|
}
|
|
|
|
|
|
|
|
dnl Do this on all platforms, before everything else (other things might want to override it).
|
|
CheckWarnAll
|
|
CheckNoStrictAliasing
|
|
|
|
dnl Do this for every platform, but for some it doesn't mean anything, but better to catch it here anyhow.
|
|
CheckEventSignals
|
|
|
|
dnl Set up the configuration based on the host platform!
|
|
case "$host" in
|
|
*-*-linux*|*-*-uclinux*|*-*-gnu*|*-*-k*bsd*-gnu|*-*-bsdi*|*-*-freebsd*|*-*-dragonfly*|*-*-netbsd*|*-*-openbsd*|*-*-sysv5*|*-*-solaris*|*-*-hpux*|*-*-aix*|*-*-minix*|*-*-nto*)
|
|
case "$host" in
|
|
*-*-android*)
|
|
# Android
|
|
ARCH=android
|
|
ANDROID_CFLAGS="-DGL_GLEXT_PROTOTYPES"
|
|
CFLAGS="$CFLAGS $ANDROID_CFLAGS"
|
|
SDL_CFLAGS="$SDL_CFLAGS $ANDROID_CFLAGS"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS $ANDROID_CFLAGS"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldl -lGLESv1_CM -lGLESv2 -llog -landroid"
|
|
SDLMAIN_SOURCES="$srcdir/src/main/android/*.c"
|
|
|
|
if test x$enable_video = xyes; then
|
|
SOURCES="$SOURCES $srcdir/src/core/android/*.c $srcdir/src/video/android/*.c"
|
|
# FIXME: confdefs? Not AC_DEFINE?
|
|
$as_echo "#define SDL_VIDEO_DRIVER_ANDROID 1" >>confdefs.h
|
|
SUMMARY_video="${SUMMARY_video} android"
|
|
fi
|
|
;;
|
|
*-*-linux*) ARCH=linux ;;
|
|
*-*-uclinux*) ARCH=linux ;;
|
|
*-*-kfreebsd*-gnu) ARCH=kfreebsd-gnu ;;
|
|
*-*-knetbsd*-gnu) ARCH=knetbsd-gnu ;;
|
|
*-*-kopenbsd*-gnu) ARCH=kopenbsd-gnu ;;
|
|
*-*-gnu*) ARCH=gnu ;; # must be last of the gnu variants
|
|
*-*-bsdi*) ARCH=bsdi ;;
|
|
*-*-freebsd*) ARCH=freebsd ;;
|
|
*-*-dragonfly*) ARCH=freebsd ;;
|
|
*-*-netbsd*) ARCH=netbsd ;;
|
|
*-*-openbsd*) ARCH=openbsd ;;
|
|
*-*-sysv5*) ARCH=sysv5 ;;
|
|
*-*-solaris*) ARCH=solaris ;;
|
|
*-*-hpux*) ARCH=hpux ;;
|
|
*-*-aix*) ARCH=aix ;;
|
|
*-*-minix*) ARCH=minix ;;
|
|
*-*-nto*) ARCH=nto
|
|
CheckQNXVideo
|
|
;;
|
|
esac
|
|
CheckVisibilityHidden
|
|
CheckDeclarationAfterStatement
|
|
CheckDummyVideo
|
|
CheckDiskAudio
|
|
CheckDummyAudio
|
|
CheckDLOPEN
|
|
CheckARM
|
|
CheckNEON
|
|
CheckOSS
|
|
CheckALSA
|
|
CheckPulseAudio
|
|
CheckJACK
|
|
CheckARTSC
|
|
CheckESD
|
|
CheckNAS
|
|
CheckSNDIO
|
|
CheckFusionSound
|
|
CheckLibSampleRate
|
|
# Need to check for Raspberry PI first and add platform specific compiler flags, otherwise the test for GLES fails!
|
|
CheckRPI
|
|
CheckX11
|
|
CheckDirectFB
|
|
CheckKMSDRM
|
|
CheckOpenGLX11
|
|
CheckOpenGLESX11
|
|
CheckVulkan
|
|
CheckWayland
|
|
CheckInputEvents
|
|
CheckLibUDev
|
|
CheckDBus
|
|
CheckIME
|
|
CheckIBus
|
|
CheckFcitx
|
|
case $ARCH in
|
|
linux)
|
|
CheckInputKD
|
|
;;
|
|
esac
|
|
CheckTslib
|
|
CheckUSBHID
|
|
CheckHIDAPI
|
|
CheckPTHREAD
|
|
CheckClockGettime
|
|
CheckLinuxVersion
|
|
CheckRPATH
|
|
CheckVivanteVideo
|
|
|
|
# Set up files for the audio library
|
|
if test x$enable_audio = xyes; then
|
|
case $ARCH in
|
|
sysv5|solaris|hpux)
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_SUNAUDIO, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/sun/*.c"
|
|
SUMMARY_audio="${SUMMARY_audio} sun"
|
|
have_audio=yes
|
|
;;
|
|
netbsd) # Don't use this on OpenBSD, it's busted.
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_NETBSD, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/netbsd/*.c"
|
|
SUMMARY_audio="${SUMMARY_audio} netbsd"
|
|
have_audio=yes
|
|
;;
|
|
aix)
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_PAUDIO, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/paudio/*.c"
|
|
SUMMARY_audio="${SUMMARY_audio} paudio"
|
|
have_audio=yes
|
|
;;
|
|
android)
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_ANDROID, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/android/*.c"
|
|
SUMMARY_audio="${SUMMARY_audio} android"
|
|
have_audio=yes
|
|
;;
|
|
nto)
|
|
CheckQNXAudio
|
|
;;
|
|
esac
|
|
fi
|
|
# Set up files for the joystick library
|
|
if test x$enable_joystick = xyes; then
|
|
case $ARCH in
|
|
linux)
|
|
AC_DEFINE(SDL_JOYSTICK_LINUX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/joystick/linux/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/joystick/steam/*.c"
|
|
have_joystick=yes
|
|
;;
|
|
android)
|
|
AC_DEFINE(SDL_JOYSTICK_ANDROID, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/joystick/android/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/joystick/steam/*.c"
|
|
have_joystick=yes
|
|
;;
|
|
esac
|
|
fi
|
|
# Set up files for the haptic library
|
|
if test x$enable_haptic = xyes; then
|
|
case $ARCH in
|
|
linux)
|
|
if test x$use_input_events = xyes; then
|
|
AC_DEFINE(SDL_HAPTIC_LINUX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/haptic/linux/*.c"
|
|
have_haptic=yes
|
|
fi
|
|
;;
|
|
android)
|
|
AC_DEFINE(SDL_HAPTIC_ANDROID, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/haptic/android/*.c"
|
|
have_haptic=yes
|
|
;;
|
|
esac
|
|
fi
|
|
# Set up files for the sensor library
|
|
if test x$enable_sensor = xyes; then
|
|
case $ARCH in
|
|
android)
|
|
AC_DEFINE(SDL_SENSOR_ANDROID, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/sensor/android/*.c"
|
|
have_sensor=yes
|
|
;;
|
|
esac
|
|
fi
|
|
# Set up files for the power library
|
|
if test x$enable_power = xyes; then
|
|
case $ARCH in
|
|
linux)
|
|
AC_DEFINE(SDL_POWER_LINUX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/power/linux/*.c"
|
|
have_power=yes
|
|
;;
|
|
android)
|
|
AC_DEFINE(SDL_POWER_ANDROID, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/power/android/*.c"
|
|
have_power=yes
|
|
;;
|
|
esac
|
|
fi
|
|
# Set up files for the filesystem library
|
|
if test x$enable_filesystem = xyes; then
|
|
case $ARCH in
|
|
android)
|
|
AC_DEFINE(SDL_FILESYSTEM_ANDROID, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/filesystem/android/*.c"
|
|
have_filesystem=yes
|
|
;;
|
|
*)
|
|
AC_DEFINE(SDL_FILESYSTEM_UNIX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/filesystem/unix/*.c"
|
|
have_filesystem=yes
|
|
;;
|
|
esac
|
|
fi
|
|
# Set up files for the timer library
|
|
if test x$enable_timers = xyes; then
|
|
AC_DEFINE(SDL_TIMER_UNIX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
|
|
have_timers=yes
|
|
fi
|
|
# Set up files for udev hotplugging support
|
|
if test x$enable_libudev = xyes && test x$have_libudev_h_hdr = xyes; then
|
|
SOURCES="$SOURCES $srcdir/src/core/linux/SDL_udev.c"
|
|
fi
|
|
# Set up files for evdev input
|
|
if test x$use_input_events = xyes; then
|
|
SOURCES="$SOURCES $srcdir/src/core/linux/SDL_evdev*.c"
|
|
fi
|
|
# Set up other core UNIX files
|
|
SOURCES="$SOURCES $srcdir/src/core/linux/SDL_threadprio.c"
|
|
SOURCES="$SOURCES $srcdir/src/core/unix/*.c"
|
|
;;
|
|
*-*-cygwin* | *-*-mingw32*)
|
|
ARCH=win32
|
|
if test "$build" != "$host"; then # cross-compiling
|
|
# Default cross-compile location
|
|
ac_default_prefix=/usr/local/cross-tools/$host
|
|
else
|
|
# Look for the location of the tools and install there
|
|
if test "$BUILD_PREFIX" != ""; then
|
|
ac_default_prefix=$BUILD_PREFIX
|
|
fi
|
|
fi
|
|
CheckDeclarationAfterStatement
|
|
CheckDummyVideo
|
|
CheckDiskAudio
|
|
CheckDummyAudio
|
|
CheckWINDOWS
|
|
CheckWINDOWSGL
|
|
CheckWINDOWSGLES
|
|
CheckVulkan
|
|
CheckDIRECTX
|
|
CheckHIDAPI
|
|
|
|
# Set up the core platform files
|
|
SOURCES="$SOURCES $srcdir/src/core/windows/*.c"
|
|
|
|
# Set up files for the video library
|
|
if test x$enable_video = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_WINDOWS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/windows/*.c"
|
|
have_video=yes
|
|
AC_ARG_ENABLE(render-d3d,
|
|
AS_HELP_STRING([--enable-render-d3d], [enable the Direct3D render driver [[default=yes]]]),
|
|
, enable_render_d3d=yes)
|
|
if test x$enable_render_d3d = xyes -a x$have_d3d = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_RENDER_D3D, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} d3d9"
|
|
fi
|
|
if test x$enable_render_d3d = xyes -a x$have_d3d11 = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_RENDER_D3D11, 1, [ ])
|
|
SUMMARY_video="${SUMMARY_video} d3d11"
|
|
fi
|
|
fi
|
|
# Set up files for the audio library
|
|
if test x$enable_audio = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_WINMM, 1, [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} winmm"
|
|
SOURCES="$SOURCES $srcdir/src/audio/winmm/*.c"
|
|
if test x$have_dsound = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_DSOUND, 1, [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} directsound"
|
|
SOURCES="$SOURCES $srcdir/src/audio/directsound/*.c"
|
|
fi
|
|
if test x$have_wasapi = xyes -a x$enable_wasapi = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_WASAPI, 1, [ ])
|
|
SUMMARY_audio="${SUMMARY_audio} wasapi"
|
|
SOURCES="$SOURCES $srcdir/src/audio/wasapi/*.c"
|
|
fi
|
|
have_audio=yes
|
|
fi
|
|
# Set up files for the joystick library
|
|
if test x$enable_joystick = xyes; then
|
|
if test x$have_dinput = xyes -o x$have_xinput = xyes; then
|
|
if test x$have_xinput = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_XINPUT, 1, [ ])
|
|
fi
|
|
if test x$have_dinput = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_DINPUT, 1, [ ])
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldinput8 -ldxguid -ldxerr8"
|
|
fi
|
|
else
|
|
AC_DEFINE(SDL_JOYSTICK_WINMM, 1, [ ])
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/joystick/windows/*.c"
|
|
have_joystick=yes
|
|
fi
|
|
if test x$enable_haptic = xyes; then
|
|
if test x$have_dinput = xyes -o x$have_xinput = xyes; then
|
|
if test x$have_xinput = xyes; then
|
|
AC_DEFINE(SDL_HAPTIC_XINPUT, 1, [ ])
|
|
fi
|
|
if test x$have_dinput = xyes; then
|
|
AC_DEFINE(SDL_HAPTIC_DINPUT, 1, [ ])
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/haptic/windows/*.c"
|
|
have_haptic=yes
|
|
fi
|
|
fi
|
|
# Set up files for the sensor library
|
|
if test x$enable_sensor = xyes; then
|
|
AC_DEFINE(SDL_SENSOR_WINDOWS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/sensor/windows/*.c"
|
|
have_sensor=yes
|
|
fi
|
|
# Set up files for the power library
|
|
if test x$enable_power = xyes; then
|
|
AC_DEFINE(SDL_POWER_WINDOWS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/power/windows/SDL_syspower.c"
|
|
have_power=yes
|
|
fi
|
|
# Set up files for the filesystem library
|
|
if test x$enable_filesystem = xyes; then
|
|
AC_DEFINE(SDL_FILESYSTEM_WINDOWS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/filesystem/windows/SDL_sysfilesystem.c"
|
|
have_filesystem=yes
|
|
fi
|
|
# Set up files for the thread library
|
|
if test x$enable_threads = xyes; then
|
|
AC_DEFINE(SDL_THREAD_WINDOWS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/thread/windows/*.c"
|
|
SOURCES="$SOURCES $srcdir/src/thread/generic/SDL_syscond.c"
|
|
have_threads=yes
|
|
fi
|
|
# Set up files for the timer library
|
|
if test x$enable_timers = xyes; then
|
|
AC_DEFINE(SDL_TIMER_WINDOWS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/timer/windows/*.c"
|
|
have_timers=yes
|
|
fi
|
|
# Set up files for the shared object loading library
|
|
if test x$enable_loadso = xyes; then
|
|
AC_DEFINE(SDL_LOADSO_WINDOWS, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/loadso/windows/*.c"
|
|
have_loadso=yes
|
|
fi
|
|
# Set up the system libraries we need
|
|
if test -f /lib/w32api/libuuid.a; then
|
|
LIBUUID=/lib/w32api/libuuid.a
|
|
else
|
|
LIBUUID=-luuid
|
|
fi
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -luser32 -lgdi32 -lwinmm -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion $LIBUUID -static-libgcc"
|
|
# The Windows platform requires special setup
|
|
VERSION_SOURCES="$srcdir/src/main/windows/*.rc"
|
|
SDLMAIN_SOURCES="$srcdir/src/main/windows/*.c"
|
|
SDL_CFLAGS="$SDL_CFLAGS -Dmain=SDL_main"
|
|
SDL_LIBS="-lSDL2main $SDL_LIBS -mwindows"
|
|
|
|
# Check to see if this is a mingw or cygwin build
|
|
have_mingw32=
|
|
AC_CHECK_LIB(mingw32, main, [have_mingw32=yes])
|
|
if test x$have_mingw32 = xyes; then
|
|
SDL_LIBS="-lmingw32 $SDL_LIBS"
|
|
else
|
|
SDL_LIBS="-lcygwin $SDL_LIBS"
|
|
fi
|
|
;;
|
|
|
|
dnl BeOS support removed after SDL 2.0.1. Haiku still works. --ryan.
|
|
*-*-beos*)
|
|
AC_MSG_ERROR([
|
|
*** BeOS support has been removed as of SDL 2.0.2.
|
|
])
|
|
;;
|
|
|
|
*-*-haiku*)
|
|
ARCH=haiku
|
|
ac_default_prefix=/boot/system
|
|
CheckDummyVideo
|
|
CheckDiskAudio
|
|
CheckDummyAudio
|
|
CheckDLOPEN
|
|
CheckHaikuVideo
|
|
CheckHaikuGL
|
|
CheckPTHREAD
|
|
|
|
# Set up files for the audio library
|
|
if test x$enable_audio = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_HAIKU, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/haiku/*.cc"
|
|
SUMMARY_audio="${SUMMARY_audio} haiku"
|
|
have_audio=yes
|
|
fi
|
|
# Set up files for the joystick library
|
|
if test x$enable_joystick = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_HAIKU, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/joystick/haiku/*.cc"
|
|
have_joystick=yes
|
|
fi
|
|
# Set up files for the timer library
|
|
if test x$enable_timers = xyes; then
|
|
AC_DEFINE(SDL_TIMER_HAIKU, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/timer/haiku/*.c"
|
|
have_timers=yes
|
|
fi
|
|
# Set up files for the system power library
|
|
if test x$enable_power = xyes; then
|
|
AC_DEFINE(SDL_POWER_HAIKU, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/power/haiku/*.c"
|
|
have_power=yes
|
|
fi
|
|
# Set up files for the system filesystem library
|
|
if test x$enable_filesystem = xyes; then
|
|
AC_DEFINE(SDL_FILESYSTEM_HAIKU, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/filesystem/haiku/*.cc"
|
|
have_filesystem=yes
|
|
fi
|
|
# The Haiku platform requires special setup.
|
|
SOURCES="$srcdir/src/main/haiku/*.cc $SOURCES"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lroot -lbe -lmedia -lgame -ldevice -ltextencoding"
|
|
# Haiku's x86 spins use libstdc++.r4.so (for binary compat?), but
|
|
# other spins, like x86-64, use a more standard "libstdc++.so.*"
|
|
AC_CHECK_FILE("/boot/system/lib/libstdc++.r4.so", EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lstdc++.r4", EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lstdc++")
|
|
;;
|
|
arm*-apple-darwin*|*-ios-*)
|
|
ARCH=ios
|
|
|
|
CheckVisibilityHidden
|
|
CheckDeclarationAfterStatement
|
|
CheckDummyVideo
|
|
CheckDiskAudio
|
|
CheckDummyAudio
|
|
CheckDLOPEN
|
|
CheckMETAL
|
|
CheckVulkan
|
|
CheckPTHREAD
|
|
|
|
# Set up files for the audio library
|
|
if test x$enable_audio = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_COREAUDIO, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/coreaudio/*.m"
|
|
SUMMARY_audio="${SUMMARY_audio} coreaudio"
|
|
have_audio=yes
|
|
fi
|
|
# Set up files for the joystick library
|
|
if test x$enable_joystick = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_MFI, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/joystick/iphoneos/*.m"
|
|
SOURCES="$SOURCES $srcdir/src/joystick/steam/*.c"
|
|
have_joystick=yes
|
|
fi
|
|
# Set up files for the haptic library
|
|
#if test x$enable_haptic = xyes; then
|
|
# SOURCES="$SOURCES $srcdir/src/haptic/darwin/*.c"
|
|
# have_haptic=yes
|
|
# EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,ForceFeedback"
|
|
#fi
|
|
# Set up files for the sensor library
|
|
if test x$enable_sensor = xyes; then
|
|
AC_DEFINE(SDL_SENSOR_COREMOTION, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/sensor/coremotion/*.m"
|
|
have_sensor=yes
|
|
fi
|
|
# Set up files for the power library
|
|
if test x$enable_power = xyes; then
|
|
AC_DEFINE(SDL_POWER_UIKIT, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/power/uikit/*.m"
|
|
have_power=yes
|
|
fi
|
|
# Set up files for the filesystem library
|
|
if test x$enable_filesystem = xyes; then
|
|
SOURCES="$SOURCES $srcdir/src/filesystem/cocoa/*.m"
|
|
have_filesystem=yes
|
|
fi
|
|
# Set up additional files for the file library
|
|
if test x$enable_file = xyes; then
|
|
AC_DEFINE(SDL_FILESYSTEM_COCOA, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/file/cocoa/*.m"
|
|
fi
|
|
# Set up files for the timer library
|
|
if test x$enable_timers = xyes; then
|
|
AC_DEFINE(SDL_TIMER_UNIX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
|
|
have_timers=yes
|
|
fi
|
|
# Set up other core UNIX files
|
|
SOURCES="$SOURCES $srcdir/src/core/unix/*.c"
|
|
# The iOS platform requires special setup.
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_UIKIT, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_ES2, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_OPENGL_ES, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES, 1, [ ])
|
|
AC_DEFINE(SDL_VIDEO_RENDER_OGL_ES2, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/uikit/*.m"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm -liconv -lobjc"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,AVFoundation"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,AudioToolbox"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,CoreAudio"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,CoreGraphics"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,CoreMotion"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Foundation"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,GameController"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,OpenGLES"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,QuartzCore"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,UIKit"
|
|
|
|
if test x$enable_video_metal = xyes -o x$enable_video_vulkan = xyes; then
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Metal"
|
|
fi
|
|
;;
|
|
*-*-darwin* )
|
|
# This could be either full "Mac OS X", or plain "Darwin" which is
|
|
# just the OS X kernel sans upper layers like Carbon and Cocoa.
|
|
# Next line is broken, and a few files below require Mac OS X (full)
|
|
ARCH=macosx
|
|
|
|
# Mac OS X builds with both the Carbon and OSX APIs at the moment
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -DTARGET_API_MAC_CARBON"
|
|
EXTRA_CFLAGS="$EXTRA_CFLAGS -DTARGET_API_MAC_OSX"
|
|
|
|
CheckVisibilityHidden
|
|
CheckDeclarationAfterStatement
|
|
CheckDummyVideo
|
|
CheckDiskAudio
|
|
CheckDummyAudio
|
|
CheckDLOPEN
|
|
CheckCOCOA
|
|
CheckMETAL
|
|
CheckX11
|
|
CheckMacGL
|
|
CheckMacGLES
|
|
CheckOpenGLX11
|
|
CheckVulkan
|
|
CheckPTHREAD
|
|
CheckHIDAPI
|
|
|
|
# Set up files for the audio library
|
|
if test x$enable_audio = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_COREAUDIO, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/coreaudio/*.m"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,CoreAudio -Wl,-framework,AudioToolbox"
|
|
SUMMARY_audio="${SUMMARY_audio} coreaudio"
|
|
have_audio=yes
|
|
fi
|
|
# Set up files for the joystick library
|
|
if test x$enable_joystick = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_IOKIT, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/joystick/darwin/*.c"
|
|
have_joystick=yes
|
|
fi
|
|
# Set up files for the haptic library
|
|
if test x$enable_haptic = xyes; then
|
|
AC_DEFINE(SDL_HAPTIC_IOKIT, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/haptic/darwin/*.c"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,ForceFeedback"
|
|
have_haptic=yes
|
|
fi
|
|
# Set up files for the power library
|
|
if test x$enable_power = xyes; then
|
|
AC_DEFINE(SDL_POWER_MACOSX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/power/macosx/*.c"
|
|
have_power=yes
|
|
fi
|
|
# Set up files for the filesystem library
|
|
if test x$enable_filesystem = xyes; then
|
|
AC_DEFINE(SDL_FILESYSTEM_COCOA, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/filesystem/cocoa/*.m"
|
|
have_filesystem=yes
|
|
fi
|
|
# Set up files for the timer library
|
|
if test x$enable_timers = xyes; then
|
|
AC_DEFINE(SDL_TIMER_UNIX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
|
|
have_timers=yes
|
|
fi
|
|
# Set up additional files for the file library
|
|
if test x$enable_file = xyes; then
|
|
SOURCES="$SOURCES $srcdir/src/file/cocoa/*.m"
|
|
fi
|
|
# Set up other core UNIX files
|
|
SOURCES="$SOURCES $srcdir/src/core/unix/*.c"
|
|
# The Mac OS X platform requires special setup.
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lobjc"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,CoreVideo"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Cocoa"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Carbon"
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,IOKit"
|
|
|
|
if test x$enable_video_metal = xyes -o x$enable_video_vulkan = xyes; then
|
|
EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-weak_framework,QuartzCore -Wl,-weak_framework,Metal"
|
|
fi
|
|
;;
|
|
*-nacl|*-pnacl)
|
|
ARCH=nacl
|
|
CheckNativeClient
|
|
CheckDummyAudio
|
|
CheckDummyVideo
|
|
CheckInputEvents
|
|
CheckPTHREAD
|
|
|
|
# Set up files for the timer library
|
|
if test x$enable_timers = xyes; then
|
|
AC_DEFINE(SDL_TIMER_UNIX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
|
|
have_timers=yes
|
|
fi
|
|
|
|
if test x$enable_filesystem = xyes; then
|
|
AC_DEFINE(SDL_FILESYSTEM_NACL, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/filesystem/nacl/*.c"
|
|
have_filesystem=yes
|
|
fi
|
|
;;
|
|
*-*-emscripten* )
|
|
if test x$enable_video = xyes; then
|
|
AC_DEFINE(SDL_VIDEO_DRIVER_EMSCRIPTEN, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/video/emscripten/*.c"
|
|
have_video=yes
|
|
SUMMARY_video="${SUMMARY_video} emscripten"
|
|
fi
|
|
|
|
if test x$enable_audio = xyes; then
|
|
AC_DEFINE(SDL_AUDIO_DRIVER_EMSCRIPTEN, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/audio/emscripten/*.c"
|
|
have_audio=yes
|
|
SUMMARY_audio="${SUMMARY_audio} emscripten"
|
|
fi
|
|
|
|
CheckVisibilityHidden
|
|
CheckDeclarationAfterStatement
|
|
CheckDummyVideo
|
|
CheckDiskAudio
|
|
CheckDummyAudio
|
|
CheckDLOPEN
|
|
CheckClockGettime
|
|
CheckEmscriptenGLES
|
|
|
|
# Set up files for the power library
|
|
if test x$enable_power = xyes; then
|
|
AC_DEFINE(SDL_POWER_EMSCRIPTEN, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/power/emscripten/*.c"
|
|
have_power=yes
|
|
fi
|
|
|
|
# Set up files for the power library
|
|
if test x$enable_joystick = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_EMSCRIPTEN, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/joystick/emscripten/*.c"
|
|
have_joystick=yes
|
|
fi
|
|
|
|
# Set up files for the filesystem library
|
|
if test x$enable_filesystem = xyes; then
|
|
AC_DEFINE(SDL_FILESYSTEM_EMSCRIPTEN, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/filesystem/emscripten/*.c"
|
|
have_filesystem=yes
|
|
fi
|
|
# Set up files for the timer library
|
|
if test x$enable_timers = xyes; then
|
|
AC_DEFINE(SDL_TIMER_UNIX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
|
|
have_timers=yes
|
|
fi
|
|
;;
|
|
*-*-riscos*)
|
|
ARCH=riscos
|
|
CheckVisibilityHidden
|
|
CheckDeclarationAfterStatement
|
|
CheckDummyVideo
|
|
CheckDiskAudio
|
|
CheckDummyAudio
|
|
CheckDLOPEN
|
|
CheckOSS
|
|
CheckPTHREAD
|
|
CheckClockGettime
|
|
|
|
# Set up files for the timer library
|
|
if test x$enable_timers = xyes; then
|
|
AC_DEFINE(SDL_TIMER_UNIX, 1, [ ])
|
|
SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
|
|
have_timers=yes
|
|
fi
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([
|
|
*** Unsupported host: Please add to configure.ac
|
|
])
|
|
;;
|
|
esac
|
|
|
|
dnl Permit use of virtual joystick APIs on any platform (subject to configure options)
|
|
CheckVirtualJoystick
|
|
|
|
# Check whether to install sdl2-config
|
|
AC_MSG_CHECKING(whether to install sdl2-config)
|
|
AC_ARG_ENABLE([sdl2-config],
|
|
AS_HELP_STRING([--enable-sdl2-config], [Install sdl2-config [default=yes]]),
|
|
[case "${enableval}" in
|
|
yes) enable_sdl2_config="TRUE" ;;
|
|
no) enable_sdl2_config="FALSE" ;;
|
|
*) AC_MSG_ERROR([bad value '${enableval}' for --enable-sdl2-config]) ;;
|
|
esac], [enable_sdl2_config="TRUE"])
|
|
if test "$enable_sdl2_config" = "TRUE"; then
|
|
AC_MSG_RESULT(yes)
|
|
else
|
|
AC_MSG_RESULT(no)
|
|
fi
|
|
AC_SUBST([INSTALL_SDL2_CONFIG], [$enable_sdl2_config])
|
|
|
|
# Verify that we have all the platform specific files we need
|
|
|
|
if test x$have_joystick != xyes; then
|
|
if test x$enable_joystick = xyes; then
|
|
AC_DEFINE(SDL_JOYSTICK_DUMMY, 1, [ ])
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/joystick/dummy/*.c"
|
|
fi
|
|
if test x$have_haptic != xyes; then
|
|
if test x$enable_haptic = xyes; then
|
|
AC_DEFINE(SDL_HAPTIC_DUMMY, 1, [ ])
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/haptic/dummy/*.c"
|
|
fi
|
|
if test x$have_sensor != xyes; then
|
|
if test x$enable_sensor = xyes; then
|
|
AC_DEFINE(SDL_SENSOR_DUMMY, 1, [ ])
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/sensor/dummy/*.c"
|
|
fi
|
|
if test x$have_threads != xyes; then
|
|
if test x$enable_threads = xyes; then
|
|
AC_DEFINE(SDL_THREADS_DISABLED, 1, [ ])
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/thread/generic/*.c"
|
|
fi
|
|
if test x$have_timers != xyes; then
|
|
if test x$enable_timers = xyes; then
|
|
AC_DEFINE(SDL_TIMERS_DISABLED, 1, [ ])
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/timer/dummy/*.c"
|
|
fi
|
|
if test x$have_filesystem != xyes; then
|
|
if test x$enable_filesystem = xyes; then
|
|
AC_DEFINE(SDL_FILESYSTEM_DISABLED, 1, [ ])
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/filesystem/dummy/*.c"
|
|
fi
|
|
if test x$have_loadso != xyes; then
|
|
if test x$enable_loadso = xyes; then
|
|
AC_DEFINE(SDL_LOADSO_DISABLED, 1, [ ])
|
|
fi
|
|
SOURCES="$SOURCES $srcdir/src/loadso/dummy/*.c"
|
|
fi
|
|
if test x$SDLMAIN_SOURCES = x; then
|
|
SDLMAIN_SOURCES="$srcdir/src/main/dummy/*.c"
|
|
fi
|
|
SDLTEST_SOURCES="$srcdir/src/test/*.c"
|
|
|
|
if test x$video_wayland = xyes; then
|
|
WAYLAND_PROTOCOLS=`cd $srcdir/wayland-protocols ; for p in *.xml ; do echo -n "\$p" |sed 's,\\.xml\$, ,g' ; done`
|
|
WAYLAND_PROTOCOLS_SOURCES=`for p in $WAYLAND_PROTOCOLS ; do echo -n "\\$(gen)/\$p-protocol.c " ; done`
|
|
WAYLAND_PROTOCOLS_HEADERS=`for p in $WAYLAND_PROTOCOLS ; do echo -n "\\$(gen)/\$p-client-protocol.h " ; done`
|
|
GEN_SOURCES="$GEN_SOURCES $WAYLAND_PROTOCOLS_SOURCES"
|
|
GEN_HEADERS="$GEN_HEADERS $WAYLAND_PROTOCOLS_HEADERS"
|
|
|
|
WAYLAND_PROTOCOLS_DEPENDS=`for p in $WAYLAND_PROTOCOLS ; do\
|
|
echo ;\
|
|
echo "\\$(gen)/\$p-client-protocol.h: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
|
|
echo " @\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
|
|
echo " \\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) client-header \\$< \\$@" ;\
|
|
echo ;\
|
|
echo "\\$(gen)/\$p-protocol.c: \\$(srcdir)/wayland-protocols/\$p.xml" ;\
|
|
echo " @\\$(SHELL) \\$(auxdir)/mkinstalldirs \\$(gen)" ;\
|
|
echo " \\$(RUN_CMD_GEN)\\$(WAYLAND_SCANNER) code \\$< \\$@" ;\
|
|
echo ;\
|
|
echo "\\$(objects)/\$p-protocol.lo: \\$(gen)/\$p-protocol.c \\$(gen)/\$p-client-protocol.h" ;\
|
|
echo " \\$(RUN_CMD_CC)\\$(LIBTOOL) --tag=CC --mode=compile \\$(CC) \\$(CFLAGS) \\$(EXTRA_CFLAGS) $DEPENDENCY_TRACKING_OPTIONS -c \\$< -o \\$@" ;\
|
|
done ;\
|
|
echo ;\
|
|
for s in $WAYLAND_SOURCES ; do echo -n "\$s:" ; for p in $WAYLAND_PROTOCOLS ; do echo -n " \\$(gen)/\$p-client-protocol.h" ; done ; echo ; done ; echo`
|
|
fi
|
|
|
|
OBJECTS=`echo $SOURCES`
|
|
DEPENDS=`echo $SOURCES | tr ' ' '\n'`
|
|
for EXT in asm cc m c S; do
|
|
OBJECTS=`echo "$OBJECTS" | sed 's,[[^ ]]*/\([[^ ]]*\)\.'$EXT',$(objects)/\1.lo,g'`
|
|
DEPENDS=`echo "$DEPENDS" | sed "s,^\\([[^ ]]*\\)/\\([[^ ]]*\\)\\.$EXT\\$,\\\\
|
|
\\$(objects)/\\2.lo: \\1/\\2.$EXT \\$(objects)/.created\\\\
|
|
\\$(RUN_CMD_CC)\\$(LIBTOOL) --tag=CC --mode=compile \\$(CC) \\$(CFLAGS) \\$(EXTRA_CFLAGS) $DEPENDENCY_TRACKING_OPTIONS -c \\$< -o \\$@,g"`
|
|
done
|
|
|
|
GEN_OBJECTS=`echo "$GEN_SOURCES" | sed 's,[[^ ]]*/\([[^ ]]*\)\.c,$(objects)/\1.lo,g'`
|
|
|
|
VERSION_OBJECTS=`echo $VERSION_SOURCES`
|
|
VERSION_DEPENDS=`echo $VERSION_SOURCES`
|
|
VERSION_OBJECTS=`echo "$VERSION_OBJECTS" | sed 's,[[^ ]]*/\([[^ ]]*\)\.rc,$(objects)/\1.lo,g'`
|
|
VERSION_DEPENDS=`echo "$VERSION_DEPENDS" | sed "s,\\([[^ ]]*\\)/\\([[^ ]]*\\)\\.rc,\\\\
|
|
\\$(objects)/\\2.lo: \\1/\\2.rc \\$(objects)/.created\\\\
|
|
\\$(RUN_CMD_RC)\\$(LIBTOOL) --mode=compile --tag=RC \\$(RC) -i \\$< -o \\$@,g"`
|
|
|
|
SDLMAIN_OBJECTS=`echo $SDLMAIN_SOURCES`
|
|
SDLMAIN_DEPENDS=`echo $SDLMAIN_SOURCES`
|
|
SDLMAIN_OBJECTS=`echo "$SDLMAIN_OBJECTS" | sed 's,[[^ ]]*/\([[^ ]]*\)\.c,$(objects)/\1.lo,g'`
|
|
SDLMAIN_DEPENDS=`echo "$SDLMAIN_DEPENDS" | sed "s,\\([[^ ]]*\\)/\\([[^ ]]*\\)\\.c,\\\\
|
|
\\$(objects)/\\2.lo: \\1/\\2.c \\$(objects)/.created\\\\
|
|
\\$(RUN_CMD_CC)\\$(LIBTOOL) --tag=CC --mode=compile \\$(CC) \\$(CFLAGS) \\$(EXTRA_CFLAGS) $DEPENDENCY_TRACKING_OPTIONS -c \\$< -o \\$@,g"`
|
|
|
|
SDLTEST_OBJECTS=`echo $SDLTEST_SOURCES`
|
|
SDLTEST_DEPENDS=`echo $SDLTEST_SOURCES`
|
|
SDLTEST_OBJECTS=`echo "$SDLTEST_OBJECTS" | sed 's,[[^ ]]*/\([[^ ]]*\)\.c,$(objects)/\1.lo,g'`
|
|
SDLTEST_DEPENDS=`echo "$SDLTEST_DEPENDS" | sed "s,\\([[^ ]]*\\)/\\([[^ ]]*\\)\\.c,\\\\
|
|
\\$(objects)/\\2.lo: \\1/\\2.c \\$(objects)/.created\\\\
|
|
\\$(RUN_CMD_CC)\\$(LIBTOOL) --tag=CC --mode=compile \\$(CC) \\$(CFLAGS) \\$(EXTRA_CFLAGS) $DEPENDENCY_TRACKING_OPTIONS -c \\$< -o \\$@,g"`
|
|
|
|
# Set runtime shared library paths as needed
|
|
|
|
if test "x$enable_rpath" = "xyes"; then
|
|
if test $ARCH = bsdi -o $ARCH = freebsd -o $ARCH = linux -o $ARCH = netbsd; then
|
|
SDL_RLD_FLAGS="-Wl,-rpath,\${libdir}"
|
|
|
|
AC_MSG_CHECKING(for linker option --enable-new-dtags)
|
|
have_enable_new_dtags=no
|
|
save_LDFLAGS="$LDFLAGS"
|
|
LDFLAGS="$LDFLAGS -Wl,--enable-new-dtags"
|
|
AC_TRY_LINK([
|
|
],[
|
|
],[
|
|
have_enable_new_dtags=yes
|
|
SDL_RLD_FLAGS="$SDL_RLD_FLAGS -Wl,--enable-new-dtags"
|
|
])
|
|
LDFLAGS="$save_LDFLAGS"
|
|
AC_MSG_RESULT($have_enable_new_dtags)
|
|
fi
|
|
if test $ARCH = solaris; then
|
|
SDL_RLD_FLAGS="-R\${libdir}"
|
|
fi
|
|
else
|
|
SDL_RLD_FLAGS=""
|
|
fi
|
|
|
|
SDL_STATIC_LIBS="$SDL_LIBS $EXTRA_LDFLAGS"
|
|
|
|
dnl Expand the cflags and libraries needed by apps using SDL
|
|
AC_SUBST(SDL_CFLAGS)
|
|
AC_SUBST(SDL_LIBS)
|
|
AC_SUBST(SDL_STATIC_LIBS)
|
|
AC_SUBST(SDL_RLD_FLAGS)
|
|
if test x$enable_shared = xyes; then
|
|
ENABLE_SHARED_TRUE=
|
|
ENABLE_SHARED_FALSE="#"
|
|
else
|
|
ENABLE_SHARED_TRUE="#"
|
|
ENABLE_SHARED_FALSE=
|
|
fi
|
|
if test x$enable_static = xyes; then
|
|
ENABLE_STATIC_TRUE=
|
|
ENABLE_STATIC_FALSE="#"
|
|
else
|
|
ENABLE_STATIC_TRUE="#"
|
|
ENABLE_STATIC_FALSE=
|
|
fi
|
|
AC_SUBST(ENABLE_SHARED_TRUE)
|
|
AC_SUBST(ENABLE_SHARED_FALSE)
|
|
AC_SUBST(ENABLE_STATIC_TRUE)
|
|
AC_SUBST(ENABLE_STATIC_FALSE)
|
|
|
|
dnl Expand the sources and objects needed to build the library
|
|
AC_SUBST(ac_aux_dir)
|
|
AC_SUBST(INCLUDE)
|
|
AC_SUBST(OBJECTS)
|
|
AC_SUBST(GEN_HEADERS)
|
|
AC_SUBST(GEN_OBJECTS)
|
|
AC_SUBST(VERSION_OBJECTS)
|
|
AC_SUBST(SDLMAIN_OBJECTS)
|
|
AC_SUBST(SDLTEST_OBJECTS)
|
|
AC_SUBST(BUILD_CFLAGS)
|
|
AC_SUBST(EXTRA_CFLAGS)
|
|
AC_SUBST(BUILD_LDFLAGS)
|
|
AC_SUBST(EXTRA_LDFLAGS)
|
|
AC_SUBST(WAYLAND_SCANNER)
|
|
|
|
cat >Makefile.rules <<__EOF__
|
|
|
|
# Build rules for objects
|
|
-include \$(OBJECTS:.lo=.d)
|
|
|
|
# Special dependency for SDL.c, since it depends on SDL_revision.h
|
|
$srcdir/src/SDL.c: update-revision
|
|
$DEPENDS
|
|
$VERSION_DEPENDS
|
|
$SDLMAIN_DEPENDS
|
|
$SDLTEST_DEPENDS
|
|
$WAYLAND_PROTOCOLS_DEPENDS
|
|
__EOF__
|
|
|
|
AC_CONFIG_FILES([
|
|
Makefile:Makefile.in:Makefile.rules sdl2-config sdl2-config.cmake sdl2-config-version.cmake SDL2.spec sdl2.pc
|
|
])
|
|
AC_CONFIG_COMMANDS([sdl2_config],[chmod a+x sdl2-config])
|
|
|
|
SUMMARY="SDL2 Configure Summary:\n"
|
|
if test x$enable_shared = xyes; then
|
|
SUMMARY="${SUMMARY}Building Shared Libraries\n"
|
|
fi
|
|
if test x$enable_static = xyes; then
|
|
SUMMARY="${SUMMARY}Building Static Libraries\n"
|
|
fi
|
|
SUMMARY="${SUMMARY}Enabled modules :${SUMMARY_modules}\n"
|
|
SUMMARY="${SUMMARY}Assembly Math :${SUMMARY_math}\n"
|
|
SUMMARY="${SUMMARY}Audio drivers :${SUMMARY_audio}\n"
|
|
SUMMARY="${SUMMARY}Video drivers :${SUMMARY_video}\n"
|
|
if test x$have_x = xyes; then
|
|
SUMMARY="${SUMMARY}X11 libraries :${SUMMARY_video_x11}\n"
|
|
fi
|
|
SUMMARY="${SUMMARY}Input drivers :${SUMMARY_input}\n"
|
|
if test x$have_joystick_virtual = xyes; then
|
|
SUMMARY="${SUMMARY}Enable virtual joystick APIs : YES\n"
|
|
else
|
|
SUMMARY="${SUMMARY}Enable virtual joystick APIs : NO\n"
|
|
fi
|
|
if test x$have_samplerate_h_hdr = xyes; then
|
|
SUMMARY="${SUMMARY}Using libsamplerate : YES\n"
|
|
else
|
|
SUMMARY="${SUMMARY}Using libsamplerate : NO\n"
|
|
fi
|
|
if test x$have_libudev_h_hdr = xyes; then
|
|
SUMMARY="${SUMMARY}Using libudev : YES\n"
|
|
else
|
|
SUMMARY="${SUMMARY}Using libudev : NO\n"
|
|
fi
|
|
if test x$have_dbus_dbus_h_hdr = xyes; then
|
|
SUMMARY="${SUMMARY}Using dbus : YES\n"
|
|
else
|
|
SUMMARY="${SUMMARY}Using dbus : NO\n"
|
|
fi
|
|
if test x$enable_ime = xyes; then
|
|
SUMMARY="${SUMMARY}Using ime : YES\n"
|
|
else
|
|
SUMMARY="${SUMMARY}Using ime : NO\n"
|
|
fi
|
|
if test x$have_ibus_ibus_h_hdr = xyes; then
|
|
SUMMARY="${SUMMARY}Using ibus : YES\n"
|
|
else
|
|
SUMMARY="${SUMMARY}Using ibus : NO\n"
|
|
fi
|
|
if test x$have_fcitx_frontend_h_hdr = xyes; then
|
|
SUMMARY="${SUMMARY}Using fcitx : YES\n"
|
|
else
|
|
SUMMARY="${SUMMARY}Using fcitx : NO\n"
|
|
fi
|
|
|
|
if test x$WARN_ABOUT_ARM_SIMD_ASM_MIT = xyes; then
|
|
SUMMARY="${SUMMARY}\nSDL is being built with ARM SIMD optimizations, which\n"
|
|
SUMMARY="${SUMMARY}uses code licensed under the MIT license. If this is a\n"
|
|
SUMMARY="${SUMMARY}problem, please disable that code by rerunning the\n"
|
|
SUMMARY="${SUMMARY}configure script with:\n"
|
|
SUMMARY="${SUMMARY}\n --disable-arm-simd\n"
|
|
fi
|
|
|
|
if test x$WARN_ABOUT_ARM_NEON_ASM_MIT = xyes; then
|
|
SUMMARY="${SUMMARY}\nSDL is being built with ARM NEON optimizations, which\n"
|
|
SUMMARY="${SUMMARY}uses code licensed under the MIT license. If this is a\n"
|
|
SUMMARY="${SUMMARY}problem, please disable that code by rerunning the\n"
|
|
SUMMARY="${SUMMARY}configure script with:\n"
|
|
SUMMARY="${SUMMARY}\n --disable-arm-neon\n"
|
|
fi
|
|
|
|
AC_CONFIG_COMMANDS([summary], [echo -en "$SUMMARY"], [SUMMARY="$SUMMARY"])
|
|
|
|
AC_OUTPUT
|