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=0

SDL_INTERFACE_AGE=0

SDL_BINARY_AGE=0

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_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_CHECK_TOOL(WINDRES, [windres], [:])

dnl Set up the compiler and linker flags

INCLUDE="-I$srcdir/include"

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

case "$host" in

    *-*-cygwin*)

        # We build SDL on cygwin without the UNIX emulation layer

        BASE_CFLAGS="-I/usr/include/mingw -mno-cygwin"

        BASE_LDFLAGS="-mno-cygwin"

        ;;

    *)

        BASE_CFLAGS=""

        BASE_LDFLAGS=""

        ;;

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 $BASE_LDFLAGS"

CPPFLAGS="$CPPFLAGS $EXTRA_CFLAGS"

CFLAGS="$CFLAGS $EXTRA_CFLAGS"

LDFLAGS="$LDFLAGS $EXTRA_LDFLAGS"

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 $gcc_bin_path $gcc_lib_path $env_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

}

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,

AC_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,

AC_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

# Actually this doesn't work on OpenBSD and BeOS

#AC_MSG_CHECKING(for linker option --no-undefined)

#have_no_undefined=no

#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"

#AC_MSG_RESULT($have_no_undefined)

dnl See whether we are allowed to use the system C library

AC_ARG_ENABLE(libc,

AC_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 inttypes.h stdint.h ctype.h math.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 strlen strlcpy strlcat strdup _strrev _strupr _strlwr strchr strrchr strstr itoa _ltoa _uitoa _ultoa strtol strtoul _i64toa _ui64toa strtoll strtoull atoi atof strcmp strncmp _stricmp strcasecmp _strnicmp strncasecmp sscanf snprintf vsnprintf fseeko fseeko64 sigaction setjmp nanosleep sysconf sysctlbyname)

    AC_CHECK_LIB(m, pow, [LIBS="$LIBS -lm"; EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm"])

    AC_CHECK_FUNCS(atan atan2 ceil copysign cos cosf fabs floor log pow scalbn sin sinf sqrt)

    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)], ,[#include <signal.h>])

fi

AC_CHECK_SIZEOF(void*)

dnl See whether we can use gcc atomic operations on this architecture

AC_ARG_ENABLE(gcc-atomics,

AC_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/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/render/*.c"

SOURCES="$SOURCES $srcdir/src/render/*/*.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"

dnl Enable/disable various subsystems of the SDL library

AC_ARG_ENABLE(atomic,

AC_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, [ ])

fi

AC_ARG_ENABLE(audio,

AC_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, [ ])

fi

AC_ARG_ENABLE(video,

AC_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, [ ])

fi

AC_ARG_ENABLE(render,

AC_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, [ ])

fi

AC_ARG_ENABLE(events,

AC_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, [ ])

fi

AC_ARG_ENABLE(joystick,

AC_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, [ ])

fi

AC_ARG_ENABLE(haptic,

AC_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, [ ])

fi

AC_ARG_ENABLE(power,

AC_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, [ ])

fi

AC_ARG_ENABLE(threads,

AC_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, [ ])

fi

AC_ARG_ENABLE(timers,

AC_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, [ ])

fi

AC_ARG_ENABLE(file,

AC_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, [ ])

fi

AC_ARG_ENABLE(loadso,

AC_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, [ ])

fi

AC_ARG_ENABLE(cpuinfo,

AC_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, [ ])

fi

AC_ARG_ENABLE(atomic,

AC_HELP_STRING([--enable-atomic], [Enable the atomic operations [[default=yes]]]),

              , enable_atomic=yes)

if test x$enable_atomic != xyes; then

    AC_DEFINE(SDL_ATOMIC_DISABLED, 1, [ ])

fi

AC_ARG_ENABLE(assembly,

AC_HELP_STRING([--enable-assembly], [Enable assembly routines [[default=yes]]]),

              , enable_assembly=yes)

if test x$enable_assembly = xyes; then

    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,

AC_HELP_STRING([--enable-ssemath], [Allow GCC to use SSE floating point math [[default=no]]]),

                  , enable_ssemath=$default_ssemath)

    if test x$enable_ssemath = xno; then

        if test x$have_gcc_sse = xyes -o x$have_gcc_sse2 = xyes; then

            EXTRA_CFLAGS="$EXTRA_CFLAGS -mfpmath=387"

        fi

    fi

    dnl Check for various instruction support

    AC_ARG_ENABLE(mmx,

AC_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"

        fi

    fi

    AC_ARG_ENABLE(3dnow,

AC_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"

        fi

    fi

    AC_ARG_ENABLE(sse,

AC_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"

        fi

    fi

    AC_ARG_ENABLE(sse2,

AC_HELP_STRING([--enable-sse2], [use SSE2 assembly routines [[default=no]]]),

                  , 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"

        fi

    fi

    AC_ARG_ENABLE(altivec,

AC_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"

        fi

    fi

fi

dnl See if the OSS audio interface is supported

CheckOSS()

{

    AC_ARG_ENABLE(oss,

AC_HELP_STRING([--enable-oss], [support the OSS audio API [[default=yes]]]),

                  , enable_oss=yes)

    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

            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,

AC_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(0.9.0, 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,

AC_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", [ ])

            else

                EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ALSA_LIBS"

            fi

            have_audio=yes

        fi

    fi

}

dnl Find the ESD includes and libraries

CheckESD()

{

    AC_ARG_ENABLE(esd,

AC_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,

AC_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", [ ])

            else

                EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ESD_LIBS"

            fi

            have_audio=yes

        fi

    fi

}

dnl Find PulseAudio

CheckPulseAudio()

{

    AC_ARG_ENABLE(pulseaudio,

AC_HELP_STRING([--enable-pulseaudio], [use PulseAudio [[default=yes]]]),

                  , enable_pulseaudio=yes)

    if test x$enable_audio = xyes -a x$enable_pulseaudio = xyes; then

        audio_pulseaudio=no

        PULSEAUDIO_REQUIRED_VERSION=0.9

        AC_PATH_PROG(PKG_CONFIG, pkg-config, no)

        AC_MSG_CHECKING(for PulseAudio $PULSEAUDIO_REQUIRED_VERSION support)

        if test x$PKG_CONFIG != xno; then

        if $PKG_CONFIG --atleast-pkgconfig-version 0.7 && $PKG_CONFIG --atleast-version $PULSEAUDIO_REQUIRED_VERSION libpulse-simple; then

                PULSEAUDIO_CFLAGS=`$PKG_CONFIG --cflags libpulse-simple`

                PULSEAUDIO_LIBS=`$PKG_CONFIG --libs libpulse-simple`

                audio_pulseaudio=yes

            fi

        fi

        AC_MSG_RESULT($audio_pulseaudio)

        if test x$audio_pulseaudio = xyes; then

            AC_ARG_ENABLE(pulseaudio-shared,

AC_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", [ ])

                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"

            fi

            have_audio=yes

        fi

    fi

}

CheckARTSC()

{

    AC_ARG_ENABLE(arts,

AC_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,

AC_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", [ ])

                else

                    EXTRA_LDFLAGS="$EXTRA_LDFLAGS $ARTS_LIBS"

                fi

                have_audio=yes

            fi

        fi

    fi

}

dnl See if the NAS audio interface is supported

CheckNAS()

{

    AC_ARG_ENABLE(nas,

AC_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,

AC_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", [ ])

            else

                EXTRA_LDFLAGS="$EXTRA_LDFLAGS $NAS_LIBS"

            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,

AC_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,

AC_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", [ ])

            else

                EXTRA_LDFLAGS="$EXTRA_LDFLAGS $SNDIO_LIBS"

            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 rcg07142001 See if the user wants the disk writer audio driver...

CheckDiskAudio()

{

    AC_ARG_ENABLE(diskaudio,

AC_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"

    fi

}

dnl rcg03142006 See if the user wants the dummy audio driver...

CheckDummyAudio()

{

    AC_ARG_ENABLE(dummyaudio,

AC_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"

    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([