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

SDL_INTERFACE_AGE=0

SDL_BINARY_AGE=9

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

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

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,

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 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 wcscmp strlen strlcpy strlcat _strrev _strupr _strlwr strchr strrchr strstr 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)

    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,

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

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

else

    SUMMARY_modules="${SUMMARY_modules} atomic"

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

else

    SUMMARY_modules="${SUMMARY_modules} audio"

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

else

    SUMMARY_modules="${SUMMARY_modules} video"

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

else

    SUMMARY_modules="${SUMMARY_modules} render"

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

else

    SUMMARY_modules="${SUMMARY_modules} events"

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

else

    SUMMARY_modules="${SUMMARY_modules} joystick"

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

else

    SUMMARY_modules="${SUMMARY_modules} haptic"

fi

AC_ARG_ENABLE(sensor,

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

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

else

    SUMMARY_modules="${SUMMARY_modules} power"

fi

AC_ARG_ENABLE(filesystem,

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

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

else

    SUMMARY_modules="${SUMMARY_modules} threads"

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

else

    SUMMARY_modules="${SUMMARY_modules} timers"

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

else

    SUMMARY_modules="${SUMMARY_modules} file"

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

else

    SUMMARY_modules="${SUMMARY_modules} loadso"

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

else

    SUMMARY_modules="${SUMMARY_modules} cpuinfo"

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

    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,

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

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"

            SUMMARY_math="${SUMMARY_math} mmx"

        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"

            SUMMARY_math="${SUMMARY_math} 3dnow"

        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"

            SUMMARY_math="${SUMMARY_math} sse"

        fi

    fi

    AC_ARG_ENABLE(sse2,

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

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

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"

            SUMMARY_math="${SUMMARY_math} altivec"

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

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

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

                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,

AC_HELP_STRING([--enable-jack], [use JACK audio [[default=yes]]]),

                  , enable_jack=yes)

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

        audio_jack=no

        JACK_REQUIRED_VERSION=0.125

        AC_PATH_PROG(PKG_CONFIG, pkg-config, no)

        AC_MSG_CHECKING(for JACK $JACK_REQUIRED_VERSION support)

        if test x$PKG_CONFIG != xno; then

        if $PKG_CONFIG --atleast-pkgconfig-version 0.7 && $PKG_CONFIG --atleast-version $JACK_REQUIRED_VERSION jack; then

                JACK_CFLAGS=`$PKG_CONFIG --cflags jack`

                JACK_LIBS=`$PKG_CONFIG --libs jack`

                audio_jack=yes

            fi

        fi

        AC_MSG_RESULT($audio_jack)

        if test x$audio_jack = xyes; then

            AC_ARG_ENABLE(jack-shared,

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

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