configure.in

dnl Process this file with autoconf to produce a configure script.
AC_INIT(README)
AC_CONFIG_HEADER(include/SDL_config.h)
AC_GNU_SOURCE
AC_CONFIG_AUX_DIRS($srcdir/build-scripts)

dnl Set various version strings - taken gratefully from the GTk sources
#
# Making releases:
# Edit include/SDL/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=1
SDL_MINOR_VERSION=2
SDL_MICRO_VERSION=14
SDL_INTERFACE_AGE=3
SDL_BINARY_AGE=14
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
AC_CONFIG_AUX_DIR([build-scripts])
dnl AC_CANONICAL_HOST
AC_C_BIGENDIAN
if test x$ac_cv_c_bigendian = xyes; then
    AC_DEFINE(SDL_BYTEORDER, 4321)
else
    AC_DEFINE(SDL_BYTEORDER, 1234)
fi

dnl Check for tools
AC_PROG_LIBTOOL
AC_PROG_CC
AC_PROG_CXX
AC_PROG_INSTALL
AC_PROG_MAKE_SET
if test -z "$host_alias"; then
    hostaliaswindres=
else
    hostaliaswindres="$host_alias-windres"
fi
AC_CHECK_PROGS(WINDRES, [windres $hostaliaswindres $host_os-windres])

dnl Set up the compiler and linker flags
INCLUDE="-I$srcdir/include"
if test x$srcdir != x.; then
    # Remove SDL_config.h from the source directory, since it's the
    # default one, and we want to include the one that we generate.
    if test -f $srcdir/include/SDL_config.h; then
        rm $srcdir/include/SDL_config.h
    fi
    INCLUDE="-Iinclude $INCLUDE"
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="-D_GNU_SOURCE=1"
        BASE_LDFLAGS=""
        ;;
esac
BUILD_CFLAGS="$CFLAGS $CPPFLAGS"
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="-lSDL $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 | sort | sed 's/.*\/\(.*\)/\1/; q'`]
        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 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)

    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
    if test x$ac_cv_header_inttypes_h = xyes -o x$ac_cv_header_stdint_h = xyes; then
        AC_CHECK_TYPE(int64_t)
        if test x$ac_cv_type_int64_t = xyes; then
            AC_DEFINE(SDL_HAS_64BIT_TYPE)
        fi
        have_inttypes=yes
    fi

    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)
    fi
    AC_FUNC_STRTOD
    if test x$ac_cv_func_strtod = xyes; then
        AC_DEFINE(HAVE_STRTOD)
    fi
    AC_CHECK_FUNC(mprotect,
        AC_TRY_COMPILE([
          #include <sys/types.h>
          #include <sys/mman.h>
        ],[
        ],[
        AC_DEFINE(HAVE_MPROTECT)
        ]),
    )
    AC_CHECK_FUNCS(malloc calloc realloc free getenv 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 iconv sigaction setjmp nanosleep)

    AC_CHECK_LIB(iconv, libiconv_open, [EXTRA_LDFLAGS="$EXTRA_LDFLAGS -liconv"])
    AC_CHECK_LIB(m, pow, [EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lm"])
fi

if test x$have_inttypes != xyes; then
    AC_CHECK_SIZEOF(char, 1)
    AC_CHECK_SIZEOF(short, 2)
    AC_CHECK_SIZEOF(int, 4)
    AC_CHECK_SIZEOF(long, 4)
    AC_CHECK_SIZEOF(long long, 8)
    if test x$ac_cv_sizeof_char = x1; then
        AC_DEFINE(int8_t, signed char)
        AC_DEFINE(uint8_t, unsigned char)
    fi
    if test x$ac_cv_sizeof_short = x2; then
        AC_DEFINE(int16_t, signed short)
        AC_DEFINE(uint16_t, unsigned short)
    else
        if test x$ac_cv_sizeof_int = x2; then
            AC_DEFINE(int16_t, signed int)
            AC_DEFINE(uint16_t, unsigned int)
        fi
    fi
    if test x$ac_cv_sizeof_int = x4; then
        AC_DEFINE(int32_t, signed int)
        AC_DEFINE(uint32_t, unsigned int)
    else
        if test x$ac_cv_sizeof_long = x4; then
            AC_DEFINE(int32_t, signed long)
            AC_DEFINE(uint32_t, unsigned long)
        fi
    fi
    if test x$ac_cv_sizeof_long = x8; then
        AC_DEFINE(int64_t, signed long)
        AC_DEFINE(uint64_t, unsigned long)
        AC_DEFINE(SDL_HAS_64BIT_TYPE)
    else
        if test x$ac_cv_sizeof_long_long = x8; then
            AC_DEFINE(int64_t, signed long long)
            AC_DEFINE(uint64_t, unsigned long long)
            AC_DEFINE(SDL_HAS_64BIT_TYPE)
        fi
    fi
    AC_DEFINE(size_t, unsigned int)
    AC_DEFINE(uintptr_t, unsigned long)
fi

# Standard C sources
SOURCES="$SOURCES $srcdir/src/*.c"
SOURCES="$SOURCES $srcdir/src/audio/*.c"
SOURCES="$SOURCES $srcdir/src/cdrom/*.c"
SOURCES="$SOURCES $srcdir/src/cpuinfo/*.c"
SOURCES="$SOURCES $srcdir/src/events/*.c"
SOURCES="$SOURCES $srcdir/src/file/*.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(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)
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)
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)
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)
else
    SOURCES="$SOURCES $srcdir/src/joystick/*.c"
fi
AC_ARG_ENABLE(cdrom,
AC_HELP_STRING([--enable-cdrom], [Enable the cdrom subsystem [[default=yes]]]),
              , enable_cdrom=yes)
if test x$enable_cdrom != xyes; then
    AC_DEFINE(SDL_CDROM_DISABLED)
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)
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)
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)
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)
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)
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)
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)
            ])
        fi
        AC_MSG_RESULT($have_oss)
        if test x$have_oss = xyes; then
            AC_DEFINE(SDL_AUDIO_DRIVER_OSS)
            SOURCES="$SOURCES $srcdir/src/audio/dsp/*.c"
            SOURCES="$SOURCES $srcdir/src/audio/dma/*.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)
            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 Check whether we want to use IRIX 6.5+ native audio or not
CheckDMEDIA()
{
    if test x$enable_audio = xyes; then
        AC_MSG_CHECKING(for dmedia audio support)
        have_dmedia=no
        AC_TRY_COMPILE([
          #include <dmedia/audio.h>
        ],[
          ALport audio_port;
        ],[
        have_dmedia=yes
        ])
        AC_MSG_RESULT($have_dmedia)
        # Set up files for the audio library
        if test x$have_dmedia = xyes; then
            AC_DEFINE(SDL_AUDIO_DRIVER_DMEDIA)
            SOURCES="$SOURCES $srcdir/src/audio/dmedia/*.c"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -laudio"
            have_audio=yes
        fi
    fi
}

dnl Check whether we want to use Tru64 UNIX native audio or not
CheckMME()
{
    dnl Make sure we are running on an Tru64 UNIX
    case $ARCH in
        osf)
            ;;
        *)
            return
            ;;
    esac
    if test x$enable_audio = xyes; then
        AC_MSG_CHECKING(for MME audio support)
        MME_CFLAGS="-I/usr/include/mme"
        MME_LIBS="-lmme"
        have_mme=no
        save_CFLAGS="$CFLAGS"
        CFLAGS="$CFLAGS $MME_CFLAGS"
        AC_TRY_COMPILE([
          #include <mme_api.h>
        ],[
          HWAVEOUT sound;
        ],[
        have_mme=yes
        ])
        CFLAGS="$save_CFLAGS"
        AC_MSG_RESULT($have_mme)
        # Set up files for the audio library
        if test x$have_mme = xyes; then
            AC_DEFINE(SDL_AUDIO_DRIVER_MMEAUDIO)
            SOURCES="$SOURCES $srcdir/src/audio/mme/*.c"
            EXTRA_CFLAGS="$EXTRA_CFLAGS $MME_CFLAGS"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS $MME_LIBS"
            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)
            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_pulse=no

        PULSE_REQUIRED_VERSION=0.9

        AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
        AC_MSG_CHECKING(for PulseAudio $PULSE_REQUIRED_VERSION support)
        if test x$PKG_CONFIG != xno; then
            if $PKG_CONFIG --atleast-pkgconfig-version 0.7 && $PKG_CONFIG --atleast-version $PULSE_REQUIRED_VERSION libpulse-simple; then
                PULSE_CFLAGS=`$PKG_CONFIG --cflags libpulse-simple`
                PULSE_LIBS=`$PKG_CONFIG --libs libpulse-simple`
                audio_pulse=yes
            fi
        fi
        AC_MSG_RESULT($audio_pulse)

        if test x$audio_pulse = xyes; then
            AC_ARG_ENABLE(pulseaudio-shared,
AC_HELP_STRING([--enable-pulseaudio-shared], [dynamically load PulseAudio support [[default=yes]]]),
                          , enable_pulseaudio_shared=yes)
            pulse_lib=[`find_lib "libpulse-simple.so.*" "$PULSE_LIBS" | sed 's/.*\/\(.*\)/\1/; q'`]

            AC_DEFINE(SDL_AUDIO_DRIVER_PULSE)
            SOURCES="$SOURCES $srcdir/src/audio/pulse/*.c"
            EXTRA_CFLAGS="$EXTRA_CFLAGS $PULSE_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$pulse_lib != x; then
                echo "-- dynamic libpulse-simple -> $pulse_lib"
                AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_PULSE_DYNAMIC, "$pulse_lib")
            else
                EXTRA_LDFLAGS="$EXTRA_LDFLAGS $PULSE_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)
                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"

        dnl On IRIX, the NAS includes are in a different directory,
        dnl and libnas must be explicitly linked in

        elif test -r /usr/freeware/include/nas/audiolib.h; then
            have_nas=yes
            NAS_LIBS="-lnas -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)
            SOURCES="$SOURCES $srcdir/src/audio/nas/*.c"
            EXTRA_CFLAGS="$EXTRA_CFLAGS $NAS_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)
        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)
        SOURCES="$SOURCES $srcdir/src/audio/dummy/*.c"
    fi
}

dnl Set up the Atari Audio driver
CheckAtariAudio()
{
    AC_ARG_ENABLE(mintaudio,
AC_HELP_STRING([--enable-mintaudio], [support Atari audio driver [[default=yes]]]),
                  , enable_mintaudio=yes)
    if test x$enable_audio = xyes -a x$enable_mintaudio = xyes; then
        mintaudio=no
        AC_CHECK_HEADER(mint/falcon.h, have_mint_falcon_hdr=yes)
        if test x$have_mint_falcon_hdr = xyes; then
            mintaudio=yes
            AC_DEFINE(SDL_AUDIO_DRIVER_MINT)
            SOURCES="$SOURCES $srcdir/src/audio/mint/*.c"
            SOURCES="$SOURCES $srcdir/src/audio/mint/*.S"
            have_audio=yes
        fi
    fi
}

dnl See if we can use x86 assembly blitters
# NASM is available from: http://nasm.sourceforge.net
CheckNASM()
{
    dnl Make sure we are running on an x86 platform
    case $host in
        i?86*)
            ;;
        *)
        # Nope, bail early.
            return
            ;;
    esac

    dnl Mac OS X might report itself as "i386" but generate x86_64 code.
    dnl  So see what size we think a pointer is, and bail if not 32-bit.
    AC_CHECK_SIZEOF([void *], 4)
    if test x$ac_cv_sizeof_void_p != x4; then
        return
    fi

    dnl Check for NASM (for assembly blit routines)
    AC_ARG_ENABLE(nasm,
AC_HELP_STRING([--enable-nasm], [use nasm assembly blitters on x86 [[default=yes]]]),
                  , enable_nasm=yes)
    if test x$enable_video = xyes -a x$enable_assembly = xyes -a x$enable_nasm = xyes; then
        CompileNASM()
        {
            # Usage: CompileNASM <filename>
            AC_MSG_CHECKING(to see if $NASM supports $1)
            if $NASM $NASMFLAGS $1 -o $1.o >&AS_MESSAGE_LOG_FD 2>&1; then
                CompileNASM_ret="yes"
            else
                CompileNASM_ret="no"
            fi
            rm -f $1 $1.o
            AC_MSG_RESULT($CompileNASM_ret)
            test "$CompileNASM_ret" = "yes"
        }

        if test x"$NASMFLAGS" = x; then
            case $ARCH in
              win32)
                  NASMFLAGS="-f win32"
                  ;;
              openbsd)
                  NASMFLAGS="-f aoutb"
                  ;;
              macosx)
                  NASMFLAGS="-f macho"
                  ;;
              *)
                  NASMFLAGS="-f elf"
                  ;;
            esac
        fi

        AC_PATH_PROG(NASM, yasm)
        echo "%ifidn __OUTPUT_FORMAT__,elf" > unquoted-sections
        echo "section .note.GNU-stack noalloc noexec nowrite progbits" >> unquoted-sections
        echo "%endif" >> unquoted-sections
        CompileNASM unquoted-sections || NASM=""

        if test "x$NASM" = x -o "x$NASM" = x'"$NASM"'; then
            $as_unset ac_cv_path_NASM
            AC_PATH_PROG(NASM, nasm)
        fi
        if test "x$NASM" != x -a "x$NASM" != x'"$NASM"'; then
            AC_DEFINE(SDL_HERMES_BLITTERS)
            SOURCES="$SOURCES $srcdir/src/hermes/*.asm"
            NASMFLAGS="$NASMFLAGS -I $srcdir/src/hermes/"

            dnl See if hidden visibility is supported
            echo "GLOBAL _bar:function hidden" > symbol-visibility
            echo "_bar:" >> symbol-visibility
            CompileNASM symbol-visibility && NASMFLAGS="$NASMFLAGS -DHIDDEN_VISIBILITY"

            AC_SUBST(NASM)
            AC_SUBST(NASMFLAGS)

            case "$host" in
                # this line is needed for QNX, because it's not defined the __ELF__
                *-*-qnx*)
                     EXTRA_CFLAGS="$EXTRA_CFLAGS -D__ELF__";;
                *-*-solaris*)
                     EXTRA_CFLAGS="$EXTRA_CFLAGS -D__ELF__";;
            esac
        fi
    fi
}

dnl Check for altivec instruction support using gas syntax
CheckAltivec()
{
    AC_ARG_ENABLE(altivec,
AC_HELP_STRING([--enable-altivec], [use altivec assembly blitters on PPC [[default=yes]]]),
                  , enable_altivec=yes)
    if test x$enable_video = xyes -a x$enable_assembly = xyes -a 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)
            if test x$have_altivec_h_hdr = xyes; then
              AC_DEFINE(HAVE_ALTIVEC_H)
            fi
            EXTRA_CFLAGS="$EXTRA_CFLAGS $altivec_CFLAGS"
        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 Do the iPod thing
CheckIPod()
{
    AC_ARG_ENABLE(ipod,
AC_HELP_STRING([--enable-ipod], [configure SDL to work with iPodLinux [[default=no]]]),
        , enable_ipod=no)

    if test x$enable_ipod = xyes; then
        EXTRA_CFLAGS="$EXTRA_CFLAGS -DIPOD"
        AC_DEFINE(SDL_VIDEO_DRIVER_IPOD)
        SOURCES="$SOURCES $srcdir/src/video/ipod/*.c"
    fi
}

dnl Find the nanox include and library directories
CheckNANOX()
{
    AC_ARG_ENABLE(video-nanox,
        AC_HELP_STRING([--enable-video-nanox], [use nanox video driver [[default=no]]]),
        , enable_video_nanox=no)

    if test x$enable_video = xyes -a x$enable_video_nanox = xyes; then
        AC_ARG_ENABLE(nanox-debug,  
            AC_HELP_STRING([--enable-nanox-debug], [print debug messages [[default=no]]]),
            , enable_nanox_debug=no)
        if test x$enable_nanox_debug = xyes; then
            EXTRA_CFLAGS="$EXTRA_CFLAGS -DENABLE_NANOX_DEBUG"
        fi

        AC_ARG_ENABLE(nanox-share-memory,  
            AC_HELP_STRING([--enable-nanox-share-memory], [use share memory [[default=no]]]),
            , enable_nanox_share_memory=no)
        if test x$enable_nanox_share_memory = xyes; then
            EXTRA_CFLAGS="$EXTRA_CFLAGS -DNANOX_SHARE_MEMORY"
        fi

        AC_ARG_ENABLE(nanox_direct_fb, 
            AC_HELP_STRING([--enable-nanox-direct-fb], [use direct framebuffer access [[default=no]]]),
            , enable_nanox_direct_fb=no)
        if test x$enable_nanox_direct_fb = xyes; then
            EXTRA_CFLAGS="$EXTRA_CFLAGS -DENABLE_NANOX_DIRECT_FB"
        fi

        AC_DEFINE(SDL_VIDEO_DRIVER_NANOX)
        SOURCES="$SOURCES $srcdir/src/video/nanox/*.c"
        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lnano-X"
        have_video=yes
    fi
}

dnl Find the X11 include and library directories
CheckX11()
{
    AC_ARG_ENABLE(video-x11,
AC_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; then
                    x_includes="/usr/X11R6/include"
                    x_libraries="/usr/X11R6/lib"
                fi
                ;;
        esac
        AC_PATH_X
        AC_PATH_XTRA
        if test x$have_x = xyes; then
            # Only allow dynamically loaded X11 if the X11 function pointers
            # will not end up in the global namespace, which causes problems
            # with other libraries calling X11 functions.
            x11_symbols_private=$have_gcc_fvisibility

            AC_ARG_ENABLE(x11-shared,
AC_HELP_STRING([--enable-x11-shared], [dynamically load X11 support [[default=maybe]]]),
                          , enable_x11_shared=maybe)

            case "$host" in
                *-*-darwin*) # Latest Mac OS X actually ships with Xrandr/Xrender libs...
                    x11_symbols_private=yes
                    x11_lib='/usr/X11R6/lib/libX11.6.dylib'
                    x11ext_lib='/usr/X11R6/lib/libXext.6.dylib'
                    xrender_lib='/usr/X11R6/lib/libXrender.1.dylib'
                    xrandr_lib='/usr/X11R6/lib/libXrandr.2.dylib'
                    ;;
                *-*-osf*)
                    x11_lib='libX11.so'
                    x11ext_lib='libXext.so'
                    ;;
                *-*-irix*) # IRIX 6.5 requires that we use /usr/lib32
                    x11_lib='libX11.so'
                    x11ext_lib='libXext.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'`]
                    xrender_lib=[`find_lib "libXrender.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'`]
                    ;;
            esac

            X_CFLAGS="$X_CFLAGS -DXTHREADS"
            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_DEFINE(SDL_VIDEO_DRIVER_X11)
            SOURCES="$SOURCES $srcdir/src/video/x11/*.c"
            EXTRA_CFLAGS="$EXTRA_CFLAGS $X_CFLAGS"

            if test x$enable_x11_shared = xmaybe; then
                enable_x11_shared=$x11_symbols_private
            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$x11_symbols_private != xyes && \
               test x$enable_x11_shared = xyes; then
                AC_MSG_WARN([You must have gcc4 (-fvisibility=hidden) 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")
            else
                enable_x11_shared=no
                EXTRA_LDFLAGS="$EXTRA_LDFLAGS $X_LIBS -lX11 -lXext"
            fi
            have_video=yes

            AC_ARG_ENABLE(dga,
AC_HELP_STRING([--enable-dga], [allow use of X11 DGA code [[default=yes]]]),
                          , enable_dga=yes)
            if test x$enable_dga = xyes; then
                SOURCES="$SOURCES $srcdir/src/video/Xext/Xxf86dga/*.c"
            fi
            AC_ARG_ENABLE(video-dga,
AC_HELP_STRING([--enable-video-dga], [use DGA 2.0 video driver [[default=yes]]]),
                  , enable_video_dga=yes)
            if test x$enable_dga = xyes -a x$enable_video_dga = xyes; then
                AC_DEFINE(SDL_VIDEO_DRIVER_DGA)
                SOURCES="$SOURCES $srcdir/src/video/dga/*.c"
            fi
            AC_ARG_ENABLE(video-x11-dgamouse,
AC_HELP_STRING([--enable-video-x11-dgamouse], [use X11 DGA for mouse events [[default=yes]]]),
                          , enable_video_x11_dgamouse=yes)
            if test x$enable_dga = xyes -a x$enable_video_x11_dgamouse = xyes; then
                AC_DEFINE(SDL_VIDEO_DRIVER_X11_DGAMOUSE)
            fi
            AC_ARG_ENABLE(video-x11-vm,
AC_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
                AC_DEFINE(SDL_VIDEO_DRIVER_X11_VIDMODE)
                SOURCES="$SOURCES $srcdir/src/video/Xext/Xxf86vm/*.c"
            fi
            AC_ARG_ENABLE(video-x11-xv,
AC_HELP_STRING([--enable-video-x11-xv], [use X11 XvImage extension for video [[default=yes]]]),
                          , enable_video_x11_xv=yes)
            if test x$enable_video_x11_xv = xyes; then
                AC_DEFINE(SDL_VIDEO_DRIVER_X11_XV)
                SOURCES="$SOURCES $srcdir/src/video/Xext/Xv/*.c"
            fi
            AC_ARG_ENABLE(video-x11-xinerama,
AC_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
                AC_DEFINE(SDL_VIDEO_DRIVER_X11_XINERAMA)
                SOURCES="$SOURCES $srcdir/src/video/Xext/Xinerama/*.c"
            fi
            AC_ARG_ENABLE(video-x11-xme,
AC_HELP_STRING([--enable-video-x11-xme], [enable Xi Graphics XME for fullscreen [[default=yes]]]),
                            , enable_video_x11_xme=yes)
            if test x$enable_video_x11_xme = xyes; then
                AC_DEFINE(SDL_VIDEO_DRIVER_X11_XME)
                SOURCES="$SOURCES $srcdir/src/video/Xext/XME/*.c"
            fi
            AC_ARG_ENABLE(video-x11-xrandr,
AC_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
                definitely_enable_video_x11_xrandr=no
                AC_CHECK_HEADER(X11/extensions/Xrandr.h,
                                have_xrandr_h_hdr=yes,
                                have_xrandr_h_hdr=no,
                                [#include <X11/Xlib.h>
                                ])
                if test x$have_xrandr_h_hdr = xyes; then
                    if test x$enable_x11_shared = xyes && test x$xrandr_lib != x ; then
                        echo "-- dynamic libXrender -> $xrender_lib"
                        echo "-- dynamic libXrandr -> $xrandr_lib"
                        AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER, "$xrender_lib")
                        AC_DEFINE_UNQUOTED(SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR, "$xrandr_lib")
                        definitely_enable_video_x11_xrandr=yes
                    else
                        AC_CHECK_LIB(Xrender, XRenderQueryExtension, have_xrender_lib=yes)
                        AC_CHECK_LIB(Xrandr, XRRQueryExtension, have_xrandr_lib=yes)
                        if test x$have_xrender_lib = xyes && test x$have_xrandr_lib = xyes ; then
                            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lXrandr -lXrender"
                            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)
            fi
        fi
    fi
}

dnl Check for QNX photon video driver
CheckPHOTON()
{
    AC_ARG_ENABLE(video-photon,
AC_HELP_STRING([--enable-video-photon], [use QNX Photon video driver [[default=yes]]]),
                  , enable_video_photon=yes)
    if test x$enable_video = xyes -a x$enable_video_photon = xyes; then
        AC_MSG_CHECKING(for QNX Photon support)
        video_photon=no
        AC_TRY_COMPILE([
          #include <Ph.h>
          #include <Pt.h>
          #include <photon/Pg.h>
          #include <photon/PdDirect.h>
        ],[
         PgDisplaySettings_t *visual;
        ],[
        video_photon=yes
        ])
        AC_MSG_RESULT($video_photon)
        if test x$video_photon = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_PHOTON)
            SOURCES="$SOURCES $srcdir/src/video/photon/*.c"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lph"
            have_video=yes

            CheckOpenGLQNX
        fi
    fi
}

dnl Set up the BWindow video driver if enabled
CheckBWINDOW()
{
    if test x$enable_video = xyes; then
        AC_DEFINE(SDL_VIDEO_DRIVER_BWINDOW)
        SOURCES="$SOURCES $srcdir/src/video/bwindow/*.cc"
        have_video=yes
    fi
}

dnl Set up the Carbon/QuickDraw video driver for Mac OS X (but not Darwin)
CheckCARBON()
{
    AC_ARG_ENABLE(video-carbon,
AC_HELP_STRING([--enable-video-carbon], [use Carbon/QuickDraw video driver [[default=no]]]),
                  , enable_video_carbon=no)
    if test x$enable_video = xyes -a x$enable_video_carbon = xyes; then
        AC_MSG_CHECKING(for Carbon framework)
        have_carbon=no
        AC_TRY_COMPILE([
          #include <Carbon/Carbon.h>
        ],[
        ],[
        have_carbon=yes
        ])
        AC_MSG_RESULT($have_carbon)
        if test x$have_carbon = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_TOOLBOX)
            SOURCES="$SOURCES $srcdir/src/video/maccommon/*.c"
            SOURCES="$SOURCES $srcdir/src/video/macrom/*.c"
            have_video=yes
        fi
    fi
}

dnl Set up the Cocoa/Quartz video driver for Mac OS X (but not Darwin)
CheckCOCOA()
{
    AC_ARG_ENABLE(video-cocoa,
AC_HELP_STRING([--enable-video-cocoa], [use Cocoa/Quartz 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_QUARTZ)
            SOURCES="$SOURCES $srcdir/src/video/quartz/*.m"
            have_video=yes
        fi
    fi
}

dnl Find the framebuffer console includes
CheckFBCON()
{
    AC_ARG_ENABLE(video-fbcon,
AC_HELP_STRING([--enable-video-fbcon], [use framebuffer console video driver [[default=yes]]]),
                  , enable_video_fbcon=yes)
    if test x$enable_video = xyes -a x$enable_video_fbcon = xyes; then
        AC_MSG_CHECKING(for framebuffer console support)
        video_fbcon=no
        AC_TRY_COMPILE([
         #include <linux/fb.h>
         #include <linux/kd.h>
         #include <linux/keyboard.h>
        ],[
        ],[
        video_fbcon=yes
        ])
        AC_MSG_RESULT($video_fbcon)
        if test x$video_fbcon = xyes; then
            AC_CHECK_FUNCS(getpagesize)
            AC_DEFINE(SDL_VIDEO_DRIVER_FBCON)
            SOURCES="$SOURCES $srcdir/src/video/fbcon/*.c"
            have_video=yes
        fi
    fi
}

dnl Find DirectFB
CheckDirectFB()
{
    AC_ARG_ENABLE(video-directfb,
AC_HELP_STRING([--enable-video-directfb], [use DirectFB video driver [[default=yes]]]),
                  , enable_video_directfb=yes)
    if test x$enable_video = xyes -a x$enable_video_directfb = xyes; then
        video_directfb=no

        DIRECTFB_REQUIRED_VERSION=0.9.15

        AC_PATH_PROG(DIRECTFBCONFIG, directfb-config, no)
        if test x$DIRECTFBCONFIG = xno; then
            AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
            if test x$PKG_CONFIG != xno; then
                if $PKG_CONFIG --atleast-pkgconfig-version 0.7 && $PKG_CONFIG --atleast-version $DIRECTFB_REQUIRED_VERSION directfb; then
                    DIRECTFB_CFLAGS=`$PKG_CONFIG --cflags directfb`
                    DIRECTFB_LIBS=`$PKG_CONFIG --libs directfb`
                    video_directfb=yes
                fi
            fi
        else
            set -- `echo $DIRECTFB_REQUIRED_VERSION | sed 's/\./ /g'`
            NEED_VERSION=`expr $1 \* 10000 + $2 \* 100 + $3`
            set -- `directfb-config --version | sed 's/\./ /g'`
            HAVE_VERSION=`expr $1 \* 10000 + $2 \* 100 + $3`
            if test $HAVE_VERSION -ge $NEED_VERSION; then
                DIRECTFB_CFLAGS=`$DIRECTFBCONFIG --cflags`
                DIRECTFB_LIBS=`$DIRECTFBCONFIG --libs`
                video_directfb=yes
            fi
        fi
        if test x$video_directfb = xyes; then
            # SuSE 11.1 installs directfb-config without directfb-devel
            save_CFLAGS="$CFLAGS"
            CFLAGS="$CFLAGS $DIRECTFB_CFLAGS"
            AC_CHECK_HEADER(directfb.h, have_directfb_hdr=yes, have_directfb_hdr=no)
            CFLAGS="$save_CFLAGS"
            video_directfb=$have_directfb_hdr
        fi
        AC_MSG_CHECKING(for DirectFB $DIRECTFB_REQUIRED_VERSION support)
        AC_MSG_RESULT($video_directfb)

        if test x$video_directfb = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_DIRECTFB)
            SOURCES="$SOURCES $srcdir/src/video/directfb/*.c"
            EXTRA_CFLAGS="$EXTRA_CFLAGS $DIRECTFB_CFLAGS"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS $DIRECTFB_LIBS"
            have_video=yes
        fi
    fi
}

dnl See if we're running on PlayStation 2 hardware
CheckPS2GS()
{
    AC_ARG_ENABLE(video-ps2gs,
AC_HELP_STRING([--enable-video-ps2gs], [use PlayStation 2 GS video driver [[default=yes]]]),
                  , enable_video_ps2gs=yes)
    if test x$enable_video = xyes -a x$enable_video_ps2gs = xyes; then
        AC_MSG_CHECKING(for PlayStation 2 GS support)
        video_ps2gs=no
        AC_TRY_COMPILE([
         #include <linux/ps2/dev.h>
         #include <linux/ps2/gs.h>
        ],[
        ],[
        video_ps2gs=yes
        ])
        AC_MSG_RESULT($video_ps2gs)
        if test x$video_ps2gs = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_PS2GS)
            SOURCES="$SOURCES $srcdir/src/video/ps2gs/*.c"
            have_video=yes
        fi
    fi
}

dnl See if we're running on PlayStation 3 Cell hardware
CheckPS3()
{
  AC_ARG_ENABLE(video-ps3,
                AC_HELP_STRING([--enable-video-ps3], [use PlayStation 3 Cell driver [[default=yes]]]),
                , enable_video_ps3=yes)
  if test x$enable_video = xyes -a x$enable_video_ps3 = xyes; then
    AC_MSG_CHECKING(for PlayStation 3 Cell support)
    video_ps3=no
    AC_TRY_COMPILE([
      #include <linux/fb.h>
      #include <asm/ps3fb.h>
      #include <libspe2.h>
    ],[
    ],[
      video_ps3=yes
    ])
    AC_MSG_RESULT($video_ps3)
    if test x$video_ps3 = xyes; then
      AC_DEFINE(SDL_VIDEO_DRIVER_PS3)
      SOURCES="$SOURCES $srcdir/src/video/ps3/*.c"
      EXTRA_CFLAGS="$EXTRA_CFLAGS -I/opt/cell/sdk/usr/include"
      EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lbilin_scaler_spu -lfb_writer_spu -lyuv2rgb_spu -L/opt/cell/sdk/usr/lib -lspe2"
      have_video=yes
    fi
  fi
}

dnl Find the GGI includes
CheckGGI()
{
    AC_ARG_ENABLE(video-ggi,
AC_HELP_STRING([--enable-video-ggi], [use GGI video driver [[default=no]]]),
                  , enable_video_ggi=no)
    if test x$enable_video = xyes -a x$enable_video_ggi = xyes; then
        AC_MSG_CHECKING(for GGI support)
        video_ggi=no
        AC_TRY_COMPILE([
         #include <ggi/ggi.h>
         #include <ggi/gii.h>
        ],[
        ],[
        video_ggi=yes
        ])
        AC_MSG_RESULT($video_ggi)
        if test x$video_ggi = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_GGI)
            SOURCES="$SOURCES $srcdir/src/video/ggi/*.c"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lggi -lgii -lgg"
            have_video=yes
        fi
    fi
}

dnl Find the SVGAlib includes and libraries
CheckSVGA()
{
    AC_ARG_ENABLE(video-svga,
AC_HELP_STRING([--enable-video-svga], [use SVGAlib video driver [[default=yes]]]),
                  , enable_video_svga=yes)
    if test x$enable_video = xyes -a x$enable_video_svga = xyes; then
        AC_MSG_CHECKING(for SVGAlib (1.4.0+) support)
        video_svga=no
        AC_TRY_COMPILE([
         #include <vga.h>
         #include <vgamouse.h>
         #include <vgakeyboard.h>
        ],[
         if ( SCANCODE_RIGHTWIN && SCANCODE_LEFTWIN ) {
             exit(0);
         }
        ],[
        video_svga=yes
        ])
        AC_MSG_RESULT($video_svga)
        if test x$video_svga = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_SVGALIB)
            SOURCES="$SOURCES $srcdir/src/video/svga/*.c"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lvga"
            have_video=yes
        fi
    fi
}

dnl Find the VGL includes and libraries
CheckVGL()
{
    AC_ARG_ENABLE(video-vgl,
AC_HELP_STRING([--enable-video-vgl], [use VGL video driver [[default=yes]]]),
                  , enable_video_vgl=yes)
    if test x$enable_video = xyes -a x$enable_video_vgl = xyes; then
        AC_MSG_CHECKING(for libVGL support)
        video_vgl=no
        AC_TRY_COMPILE([
         #include <sys/fbio.h>
         #include <sys/consio.h>
         #include <sys/kbio.h>
         #include <vgl.h>
        ],[
         VGLBitmap bitmap;
         bitmap.Type = VIDBUF32;
         bitmap.PixelBytes = 4;
         exit(bitmap.Bitmap);
        ],[
        video_vgl=yes
        ])
        AC_MSG_RESULT($video_vgl)
        if test x$video_vgl = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_VGL)
            SOURCES="$SOURCES $srcdir/src/video/vgl/*.c"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lvgl"
            have_video=yes
        fi
    fi
}

dnl Set up the wscons video driver if enabled
CheckWscons()
{
    AC_ARG_ENABLE(video-wscons,
AC_HELP_STRING([--enable-video-wscons], [use wscons video driver [[default=yes]]]),
                  , enable_video_wscons=yes)
    if test x$enable_video = xyes -a x$enable_video_wscons = xyes; then
        AC_MSG_CHECKING(for wscons support)
        video_wscons=no
        AC_TRY_COMPILE([
         #include <sys/time.h>
         #include <dev/wscons/wsconsio.h>
         #include <dev/wscons/wsdisplay_usl_io.h>
        ],[
         int wsmode = WSDISPLAYIO_MODE_DUMBFB;
        ],[
        video_wscons=yes
        ])
        AC_MSG_RESULT($video_wscons)
        if test x$video_wscons = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_WSCONS)
            SOURCES="$SOURCES $srcdir/src/video/wscons/*.c"
            have_video=yes
        fi
    fi
}


dnl Find the AAlib includes
CheckAAlib()
{
    AC_ARG_ENABLE(video-aalib,
AC_HELP_STRING([--enable-video-aalib], [use AAlib video driver [[default=no]]]),
                  , enable_video_aalib=no)
    if test x$enable_video = xyes -a x$enable_video_aalib = xyes; then
        AC_MSG_CHECKING(for AAlib support)
        video_aalib=no
        AC_TRY_COMPILE([
         #include <aalib.h>
        ],[
        ],[
        video_aalib=yes
        ])
        AC_MSG_RESULT($video_aalib)
        if test x$video_aalib = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_AALIB)
            SOURCES="$SOURCES $srcdir/src/video/aalib/*.c"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -laa"
            have_video=yes
        fi
    fi
}

dnl Find the libcaca includes
CheckCaca()
{
    AC_ARG_ENABLE(video-caca,
AC_HELP_STRING([--enable-video-caca], [use libcaca video driver [[default=no]]]),
                  , enable_video_caca=no)
    if test x$enable_video = xyes -a x$enable_video_caca = xyes; then
        video_caca=no
        AC_PATH_PROG(CACACONFIG, caca-config, no)
        if test x$CACACONFIG != xno; then
            AC_MSG_CHECKING(for libcaca support)
            CACA_CFLAGS=`$CACACONFIG --cflags`
            CACA_LDFLAGS=`$CACACONFIG --libs`
            save_CFLAGS="$CFLAGS"
            AC_TRY_COMPILE([
             #include <caca.h>
            ],[
            ],[
             video_caca=yes
            ])
            CFLAGS="$save_CFLAGS"
            AC_MSG_RESULT($video_caca)
            if test x$video_caca = xyes; then
                AC_DEFINE(SDL_VIDEO_DRIVER_CACA)
                EXTRA_CFLAGS="$EXTRA_CFLAGS $CACA_CFLAGS"
                EXTRA_LDFLAGS="$EXTRA_LDFLAGS $CACA_LDFLAGS"
                SOURCES="$SOURCES $srcdir/src/video/caca/*.c"
            fi
        fi
    fi
}

dnl Set up the QTopia video driver if enabled
CheckQtopia()
{
    AC_ARG_ENABLE(video-qtopia,
AC_HELP_STRING([--enable-video-qtopia], [use Qtopia video driver [[default=no]]]),
                  , enable_video_qtopia=no)
    if test x$enable_video = xyes -a x$enable_video_qtopia = xyes; then
        AC_MSG_CHECKING(for Qtopia support)
        video_qtopia=no
        QTOPIA_FLAGS="-DQT_QWS_EBX -DQT_QWS_CUSTOM -DQWS -I${QPEDIR}/include -I${QTDIR}/include/ -DNO_DEBUG -fno-rtti -fno-exceptions"
        AC_LANG_CPLUSPLUS
        OLD_CXX="$CXXFLAGS"
        CXXFLAGS="$QTOPIA_FLAGS"
        AC_TRY_COMPILE([
         #include <qpe/qpeapplication.h>
        ],[
        ],[
        video_qtopia=yes
        ])
        CXXFLAGS="$OLD_CXX"
        AC_MSG_RESULT($video_qtopia)
        if test x$video_qtopia = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_QTOPIA)
            SOURCES="$SOURCES $srcdir/src/video/qtopia/*.cc"
            SDLMAIN_SOURCES="$srcdir/src/main/qtopia/*.cc"
            EXTRA_CFLAGS="$EXTRA_CFLAGS $QTOPIA_FLAGS"
            SDL_CFLAGS="$SDL_CFLAGS -DQWS -Dmain=SDL_main"
            SDL_LIBS="-lSDLmain $SDL_LIBS -L${QPEDIR}/lib -L${QTDIR}/lib/ -lqpe -lqte"
            have_video=yes
        fi
        AC_LANG_C
    fi
}

dnl Set up the PicoGUI video driver if enabled
CheckPicoGUI()
{
    AC_ARG_ENABLE(video-picogui,
AC_HELP_STRING([--enable-video-picogui], [use PicoGUI video driver [[default=no]]]),
                  , enable_video_picogui=no)
    if test x$enable_video = xyes -a x$enable_video_picogui = xyes; then
        AC_MSG_CHECKING(for PicoGUI support)
        video_picogui=no
        AC_TRY_COMPILE([
         #include <picogui.h>
        ],[
        ],[
        video_picogui=yes
        ])
        AC_MSG_RESULT($video_picogui)
        if test x$video_picogui = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_PICOGUI)
            SOURCES="$SOURCES $srcdir/src/video/picogui/*.c"
            SDL_LIBS="$SDL_LIBS -lpgui"
            have_video=yes
        fi
    fi
}

dnl Set up the Atari Bios keyboard driver
CheckAtariBiosEvent()
{
    SOURCES="$SOURCES $srcdir/src/video/ataricommon/*.c"
    SOURCES="$SOURCES $srcdir/src/video/ataricommon/*.S"
}

dnl Set up the Atari Xbios driver
CheckAtariXbiosVideo()
{
    AC_ARG_ENABLE(xbios,
AC_HELP_STRING([--enable-video-xbios], [use Atari Xbios video driver [[default=yes]]]),
                  , enable_video_xbios=yes)
    video_xbios=no
    if test x$enable_video = xyes -a x$enable_video_xbios = xyes; then
        video_xbios=yes
        AC_DEFINE(SDL_VIDEO_DRIVER_XBIOS)
        SOURCES="$SOURCES $srcdir/src/video/xbios/*.c"
        have_video=yes
    fi
}

dnl Set up the Atari Gem driver
CheckAtariGemVideo()
{
    AC_ARG_ENABLE(gem,
AC_HELP_STRING([--enable-video-gem], [use Atari Gem video driver [[default=yes]]]),
                  , enable_video_gem=yes)
    if test x$enable_video = xyes -a x$enable_video_gem = xyes; then
        video_gem=no
        AC_CHECK_HEADER(gem.h, have_gem_hdr=yes)
        AC_CHECK_LIB(gem, appl_init, have_gem_lib=yes)
        if test x$have_gem_hdr = xyes -a x$have_gem_lib = xyes; then
            video_gem=yes
            AC_DEFINE(SDL_VIDEO_DRIVER_GEM)
            SOURCES="$SOURCES $srcdir/src/video/gem/*.c"
            SDL_LIBS="$SDL_LIBS -lgem"
            have_video=yes
        fi
    fi
}

dnl rcg04172001 Set up the Null video driver.
CheckDummyVideo()
{
    AC_ARG_ENABLE(video-dummy,
AC_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)
        SOURCES="$SOURCES $srcdir/src/video/dummy/*.c"
        have_video=yes
    fi
}

dnl Check to see if OpenGL support is desired
AC_ARG_ENABLE(video-opengl,
AC_HELP_STRING([--enable-video-opengl], [include OpenGL context creation [[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>
         #include <GL/glu.h>
        ],[
        ],[
        video_opengl=yes
        ])
        AC_MSG_RESULT($video_opengl)
        if test x$video_opengl = xyes; then
            AC_DEFINE(SDL_VIDEO_OPENGL)
            AC_DEFINE(SDL_VIDEO_OPENGL_GLX)
        fi
    fi
}

dnl Find QNX RtP OpenGL
CheckOpenGLQNX()
{
    if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
        AC_MSG_CHECKING(for OpenGL (Photon) support)
        video_opengl=no
        AC_TRY_COMPILE([
         #include <GL/gl.h>
        ],[
        ],[
        video_opengl=yes
        ])
        AC_MSG_RESULT($video_opengl)
        if test x$video_opengl = xyes; then
            AC_DEFINE(SDL_VIDEO_OPENGL)
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lGL"
        fi
    fi
}

dnl Check for Win32 OpenGL
CheckWIN32GL()
{
    if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
        AC_DEFINE(SDL_VIDEO_OPENGL)
        AC_DEFINE(SDL_VIDEO_OPENGL_WGL)
    fi
}

dnl Check for BeOS OpenGL
CheckBeGL()
{
    if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
        AC_DEFINE(SDL_VIDEO_OPENGL)
        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lGL"
    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)
        case "$host" in
            *-*-darwin*)
                if test x$enable_video_cocoa = xyes; then
                    EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,OpenGL"
                fi
                if test x$enable_video_carbon = xyes; then
                    EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,AGL"
                fi
        esac
    fi
}

dnl Check for Mesa offscreen rendering
CheckAtariOSMesa()
{
    if test "x$enable_video" = "xyes" -a "x$enable_video_opengl" = "xyes"; then
        AC_CHECK_HEADER(GL/osmesa.h, have_osmesa_hdr=yes)
        AC_CHECK_LIB(OSMesa, OSMesaCreateContext, have_osmesa_lib=yes, have_osmesa_lib=no, -lm)

        # Static linking to -lOSMesa
        AC_PATH_PROG(OSMESA_CONFIG, osmesa-config, no)
        if test "x$OSMESA_CONFIG" = "xno" -o "x$enable_atari_ldg" = "xno"; then
            # -lOSMesa is really the static library
            if test "x$have_osmesa_hdr" = "xyes" -a "x$have_osmesa_lib" = "xyes"; then
                OSMESA_LIBS="-lOSMesa"
            fi
        else
            # -lOSMesa is a loader for OSMesa.ldg
            OSMESA_CFLAGS=`$OSMESA_CONFIG --cflags`
            OSMESA_LIBS=`$OSMESA_CONFIG --libs`
        fi
        AC_DEFINE(SDL_VIDEO_OPENGL)
        AC_DEFINE(SDL_VIDEO_OPENGL_OSMESA)
        SDL_CFLAGS="$SDL_CFLAGS $OSMESA_CFLAGS"
        SDL_LIBS="$SDL_LIBS $OSMESA_LIBS"

        AC_ARG_ENABLE(osmesa-shared,
AC_HELP_STRING([--enable-osmesa-shared], [dynamically load OSMesa OpenGL support [[default=yes]]]),
                              , enable_osmesa_shared=yes)
        if test "x$enable_osmesa_shared" = "xyes" -a "x$enable_atari_ldg" = "xyes"; then
            # Dynamic linking
            if test "x$have_osmesa_hdr" = "xyes"; then
                AC_DEFINE(SDL_VIDEO_OPENGL_OSMESA_DYNAMIC)
            fi
        fi
    fi
}

AC_ARG_ENABLE(screensaver,
AC_HELP_STRING([--enable-screensaver], [enable screensaver by default while any SDL application is running [[default=no]]]),
              , enable_screensaver=no)
if test x$enable_screensaver = xno; then
    AC_DEFINE(SDL_VIDEO_DISABLE_SCREENSAVER)
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_ARG_ENABLE(input-events,
AC_HELP_STRING([--enable-input-events], [use Linux 2.4 unified input interface [[default=yes]]]),
                  , enable_input_events=yes)
    if test x$enable_input_events = xyes; then
        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)
        fi
    fi
}

dnl See if we can use the Touchscreen input library
CheckTslib()
{
    AC_ARG_ENABLE(input-tslib,
AC_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)
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lts"
        fi
    fi
}

dnl See if we can use GNU pth library for threads
CheckPTH()
{
    dnl Check for pth support
    AC_ARG_ENABLE(pth,
AC_HELP_STRING([--enable-pth], [use GNU pth library for multi-threading [[default=yes]]]),
                  , enable_pth=yes)
    if test x$enable_threads = xyes -a x$enable_pth = xyes; then
        AC_PATH_PROG(PTH_CONFIG, pth-config, no)
        if test "$PTH_CONFIG" = "no"; then
            use_pth=no
        else
            use_pth=yes
        fi
        AC_MSG_CHECKING(pth)
        AC_MSG_RESULT($use_pth)
        if test "x$use_pth" = xyes; then
            AC_DEFINE(SDL_THREAD_PTH)
            SOURCES="$SOURCES $srcdir/src/thread/pth/*.c"
            SOURCES="$SOURCES $srcdir/src/thread/generic/SDL_syssem.c"
            SDL_CFLAGS="$SDL_CFLAGS `$PTH_CONFIG --cflags`"
            SDL_LIBS="$SDL_LIBS `$PTH_CONFIG --libs --all`"
            have_threads=yes
        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,
AC_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,
AC_HELP_STRING([--enable-pthread-sem], [use pthread semaphores [[default=yes]]]),
                  , enable_pthread_sem=yes)
    case "$host" in
        *-*-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"
            ;;
        *-*-solaris*)
            pthread_cflags="-D_REENTRANT"
            pthread_lib="-lpthread -lposix4"
            ;;
        *-*-sysv5*)
            pthread_cflags="-D_REENTRANT -Kthread"
            pthread_lib=""
            ;;
        *-*-irix*)
            pthread_cflags="-D_SGI_MP_SOURCE"
            pthread_lib="-lpthread"
            ;;
        *-*-aix*)
            pthread_cflags="-D_REENTRANT -mthreads"
            pthread_lib="-lpthread"
            ;;
        *-*-hpux11*)
            pthread_cflags="-D_REENTRANT"
            pthread_lib="-L/usr/lib -lpthread"
            ;;
        *-*-qnx*)
            pthread_cflags=""
            pthread_lib=""
            ;;
        *-*-osf*)
            pthread_cflags="-D_REENTRANT"
            if test x$ac_cv_prog_gcc = xyes; then
                pthread_lib="-lpthread -lrt"
            else
                pthread_lib="-lpthread -lexc -lrt"
            fi
            ;;
        *)
            pthread_cflags="-D_REENTRANT"
            pthread_lib="-lpthread"
            ;;
    esac
    if test x$enable_threads = xyes -a x$enable_pthreads = xyes -a x$enable_ipod != 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)
            EXTRA_CFLAGS="$EXTRA_CFLAGS $pthread_cflags"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS $pthread_lib"
            SDL_CFLAGS="$SDL_CFLAGS $pthread_cflags"
            SDL_LIBS="$SDL_LIBS $pthread_lib"

            # 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_COMPILE([
                  #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)
                ])
            fi
            if test x$has_recursive_mutexes = xno; then
                AC_TRY_COMPILE([
                  #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)
                ])
            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

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

            have_threads=yes
        else
            CheckPTH
        fi
    fi
}

dnl Determine whether the compiler can produce Win32 executables
CheckWIN32()
{
    AC_MSG_CHECKING(Win32 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 Win32 executables!
       ])
    fi

    dnl See if the user wants to redirect standard output to files
    AC_ARG_ENABLE(stdio-redirect,
AC_HELP_STRING([--enable-stdio-redirect], [Redirect STDIO to files on Win32 [[default=yes]]]),
                  , enable_stdio_redirect=yes)
    if test x$enable_stdio_redirect != xyes; then
        EXTRA_CFLAGS="$EXTRA_CFLAGS -DNO_STDIO_REDIRECT"
    fi

    if test x$enable_video = xyes; then
        AC_DEFINE(SDL_VIDEO_DRIVER_WINDIB)
        SOURCES="$SOURCES $srcdir/src/video/wincommon/*.c"
        SOURCES="$SOURCES $srcdir/src/video/windib/*.c"
        have_video=yes
    fi
}

dnl Find the DirectX includes and libraries
CheckDIRECTX()
{
    AC_ARG_ENABLE(directx,
AC_HELP_STRING([--enable-directx], [use DirectX for Win32 audio/video [[default=yes]]]),
                  , enable_directx=yes)
    if test x$enable_directx = xyes; then
        have_directx=no
        AC_CHECK_HEADER(ddraw.h, have_ddraw=yes)
        AC_CHECK_HEADER(dsound.h, have_dsound=yes)
        AC_CHECK_HEADER(dinput.h, use_dinput=yes)
        if test x$have_ddraw = xyes -a x$have_dsound = xyes -a x$use_dinput = xyes; then
            have_directx=yes
        fi
        if test x$enable_video = xyes -a x$have_directx = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_DDRAW)
            SOURCES="$SOURCES $srcdir/src/video/windx5/*.c"
            have_video=yes
        fi
    fi
}

dnl Check for the dlfcn.h interface for dynamically loading objects
CheckDLOPEN()
{
    AC_ARG_ENABLE(sdl-dlopen,
AC_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>
        ],[
         #if defined(MAC_OS_X_VERSION_MIN_REQUIRED) && MAC_OS_X_VERSION_MIN_REQUIRED <= 1020
         #error Use dlcompat for Mac OS X 10.2 compatibility
         #endif
        ],[
        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)
            SOURCES="$SOURCES $srcdir/src/loadso/dlopen/*.c"
            have_loadso=yes
        fi
    fi
}

dnl Set up the Atari LDG (shared object loader)
CheckAtariLdg()
{
    AC_ARG_ENABLE(atari-ldg,
AC_HELP_STRING([--enable-atari-ldg], [use Atari LDG for shared object loading [[default=yes]]]),
                  , enable_atari_ldg=yes)
    if test x$video_gem = xyes -a x$enable_atari_ldg = xyes; then
        AC_CHECK_HEADER(ldg.h, have_ldg_hdr=yes)
        AC_CHECK_LIB(ldg, ldg_open, have_ldg_lib=yes, have_ldg_lib=no, -lgem)
        if test x$have_ldg_hdr = xyes -a x$have_ldg_lib = xyes; then
            AC_DEFINE(SDL_LOADSO_LDG)
            SOURCES="$SOURCES $srcdir/src/loadso/mint/*.c"
            SDL_LIBS="$SDL_LIBS -lldg -lgem"
            have_loadso=yes
        fi
    fi
}

dnl Check for the usbhid(3) library on *BSD
CheckUSBHID()
{
    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)
            fi
            AC_MSG_RESULT($have_machine_joystick)

            AC_DEFINE(SDL_JOYSTICK_USBHID)
            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
}

dnl Check for clock_gettime()
CheckClockGettime()
{
    AC_ARG_ENABLE(clock_gettime,
AC_HELP_STRING([--enable-clock_gettime], [use clock_gettime() instead of gettimeofday() on UNIX [[default=no]]]),
                  , enable_clock_gettime=no)
    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)
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lrt"
        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,
AC_HELP_STRING([--enable-rpath], [use an rpath when linking SDL [[default=yes]]]),
                  , enable_rpath=yes)
}

dnl Set up the configuration based on the host platform!
case "$host" in
    arm-*-elf*) # FIXME: Can we get more specific for iPodLinux?
        ARCH=linux
        CheckDummyVideo
        CheckIPod
        # Set up files for the timer library
        if test x$enable_timers = xyes; then
            AC_DEFINE(SDL_TIMER_UNIX)
            SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
            have_timers=yes
        fi
        ;;
    *-*-linux*|*-*-uclinux*|*-*-gnu*|*-*-k*bsd*-gnu|*-*-bsdi*|*-*-freebsd*|*-*-dragonfly*|*-*-netbsd*|*-*-openbsd*|*-*-sysv5*|*-*-solaris*|*-*-hpux*|*-*-irix*|*-*-aix*|*-*-osf*)
        case "$host" in
            *-*-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 ;;
            *-*-irix*)          ARCH=irix ;;
            *-*-aix*)           ARCH=aix ;;
            *-*-osf*)           ARCH=osf ;;
        esac
        CheckVisibilityHidden
        CheckDummyVideo
        CheckDiskAudio
        CheckDummyAudio
        CheckDLOPEN
        CheckNASM
        CheckAltivec
        CheckOSS
        CheckDMEDIA
        CheckMME
        CheckALSA
        CheckARTSC
        CheckESD
        CheckPulseAudio
        CheckNAS
        CheckX11
        CheckNANOX
        CheckFBCON
        CheckDirectFB
        CheckPS2GS
        CheckPS3
        CheckGGI
        CheckSVGA
        CheckVGL
        CheckWscons
        CheckAAlib
        CheckCaca
        CheckQtopia
        CheckPicoGUI
        CheckOpenGLX11
        CheckInputEvents
        CheckTslib
        CheckUSBHID
        CheckPTHREAD
        CheckClockGettime
        CheckLinuxVersion
        CheckRPATH
        # 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)
                SOURCES="$SOURCES $srcdir/src/audio/sun/*.c"
                have_audio=yes
            ;;
            netbsd|openbsd)
                AC_DEFINE(SDL_AUDIO_DRIVER_BSD)
                SOURCES="$SOURCES $srcdir/src/audio/bsd/*.c"
                have_audio=yes
            ;;
            aix)
                AC_DEFINE(SDL_AUDIO_DRIVER_PAUD)
                SOURCES="$SOURCES $srcdir/src/audio/paudio/*.c"
                have_audio=yes
            ;;
          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)
                SOURCES="$SOURCES $srcdir/src/joystick/linux/*.c"
                have_joystick=yes
            ;;
          esac
        fi
        # Set up files for the cdrom library
        if test x$enable_cdrom = xyes; then
          case $ARCH in
            linux|solaris)
                AC_DEFINE(SDL_CDROM_LINUX)
                SOURCES="$SOURCES $srcdir/src/cdrom/linux/*.c"
                have_cdrom=yes
            ;;
            *freebsd*)
                AC_DEFINE(SDL_CDROM_FREEBSD)
                SOURCES="$SOURCES $srcdir/src/cdrom/freebsd/*.c"
                have_cdrom=yes
            ;;
            *openbsd*|*netbsd*)
                AC_DEFINE(SDL_CDROM_OPENBSD)
                SOURCES="$SOURCES $srcdir/src/cdrom/openbsd/*.c"
                have_cdrom=yes
            ;;
            bsdi)
                AC_DEFINE(SDL_CDROM_BSDI)
                SOURCES="$SOURCES $srcdir/src/cdrom/bsdi/*.c"
                have_cdrom=yes
            ;;
            aix)
                AC_DEFINE(SDL_CDROM_AIX)
                SOURCES="$SOURCES $srcdir/src/cdrom/aix/*.c"
                have_cdrom=yes
            ;;
            osf)
                AC_DEFINE(SDL_CDROM_OSF)
                SOURCES="$SOURCES $srcdir/src/cdrom/osf/*.c"
                have_cdrom=yes
            ;;
          esac
        fi
        # Set up files for the thread library
        if test x$enable_threads = xyes -a x$use_pthreads != xyes -a x$use_pth != xyes -a x$ARCH = xirix; then
            AC_DEFINE(SDL_THREAD_SPROC)
            SOURCES="$SOURCES $srcdir/src/thread/irix/*.c"
            SOURCES="$SOURCES $srcdir/src/thread/generic/SDL_sysmutex.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_UNIX)
            SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
            have_timers=yes
        fi
        ;;
    *-*-qnx*)
        ARCH=qnx
        CheckDummyVideo
        CheckDiskAudio
        CheckDummyAudio
        # CheckNASM
        CheckDLOPEN
        CheckNAS
        CheckPHOTON
        CheckX11
        CheckOpenGLX11
        CheckPTHREAD
        # Set up files for the audio library
        if test x$enable_audio = xyes; then
            AC_DEFINE(SDL_AUDIO_DRIVER_QNXNTO)
            SOURCES="$SOURCES $srcdir/src/audio/nto/*.c"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lasound"
            have_audio=yes
        fi
        # Set up files for the cdrom library
        if test x$enable_cdrom = xyes; then
            AC_DEFINE(SDL_CDROM_QNX)
            SOURCES="$SOURCES $srcdir/src/cdrom/qnx/*.c"
            have_cdrom=yes
        fi
        # Set up files for the timer library
        if test x$enable_timers = xyes; then
            AC_DEFINE(SDL_TIMER_UNIX)
            SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
            have_timers=yes
        fi
        ;;
    *-*-cygwin* | *-*-mingw32*)
        ARCH=win32
        if test "$build" != "$host"; then # cross-compiling
            # Default cross-compile location
            ac_default_prefix=/usr/local/cross-tools/i386-mingw32
        else
            # Look for the location of the tools and install there
            if test "$BUILD_PREFIX" != ""; then
                ac_default_prefix=$BUILD_PREFIX
            fi
        fi
        CheckDummyVideo
        CheckDiskAudio
        CheckDummyAudio
        CheckWIN32
        CheckWIN32GL
        CheckDIRECTX
        CheckNASM
        # Set up files for the audio library
        if test x$enable_audio = xyes; then
            AC_DEFINE(SDL_AUDIO_DRIVER_WAVEOUT)
            SOURCES="$SOURCES $srcdir/src/audio/windib/*.c"
            if test x$have_directx = xyes; then
                AC_DEFINE(SDL_AUDIO_DRIVER_DSOUND)
                SOURCES="$SOURCES $srcdir/src/audio/windx5/*.c"
            fi
            have_audio=yes
        fi
        # Set up files for the joystick library
        if test x$enable_joystick = xyes; then
            AC_DEFINE(SDL_JOYSTICK_WINMM)
            SOURCES="$SOURCES $srcdir/src/joystick/win32/*.c"
            have_joystick=yes
        fi
        # Set up files for the cdrom library
        if test x$enable_cdrom = xyes; then
            AC_DEFINE(SDL_CDROM_WIN32)
            SOURCES="$SOURCES $srcdir/src/cdrom/win32/*.c"
            have_cdrom=yes
        fi
        # Set up files for the thread library
        if test x$enable_threads = xyes; then
            AC_DEFINE(SDL_THREAD_WIN32)
            SOURCES="$SOURCES $srcdir/src/thread/win32/SDL_sysmutex.c"
            SOURCES="$SOURCES $srcdir/src/thread/win32/SDL_syssem.c"
            SOURCES="$SOURCES $srcdir/src/thread/win32/SDL_systhread.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_WIN32)
            SOURCES="$SOURCES $srcdir/src/timer/win32/*.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_WIN32)
            SOURCES="$SOURCES $srcdir/src/loadso/win32/*.c"
            have_loadso=yes
        fi
        # Set up the system libraries we need
        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -luser32 -lgdi32 -lwinmm"
        if test x$have_directx = xyes; then
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ldxguid"
        fi
        # The Win32 platform requires special setup
        SOURCES="$SOURCES $srcdir/src/main/win32/*.rc"
        SDLMAIN_SOURCES="$srcdir/src/main/win32/*.c"
        SDL_CFLAGS="$SDL_CFLAGS -Dmain=SDL_main"
        SDL_LIBS="-lmingw32 -lSDLmain $SDL_LIBS -mwindows"
        ;;
    *-wince*)
        ARCH=win32
        CheckDummyVideo
        CheckDiskAudio
        CheckDummyAudio
        CheckWIN32
        CheckNASM
        SOURCES="$SOURCES $srcdir/src/video/gapi/*.c"
        EXTRA_CFLAGS="$EXTRA_CFLAGS -D_WIN32_WCE=0x420"
        if test x$enable_audio = xyes; then
            AC_DEFINE(SDL_AUDIO_DRIVER_WAVEOUT)
            SOURCES="$SOURCES $srcdir/src/audio/windib/*.c"
            have_audio=yes
        fi
        # Set up files for the thread library
        if test x$enable_threads = xyes; then
            AC_DEFINE(SDL_THREAD_WIN32)
            SOURCES="$SOURCES $srcdir/src/thread/win32/SDL_sysmutex.c"
            SOURCES="$SOURCES $srcdir/src/thread/win32/SDL_syssem.c"
            SOURCES="$SOURCES $srcdir/src/thread/win32/SDL_systhread.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_WINCE)
            SOURCES="$SOURCES $srcdir/src/timer/wince/*.c"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lcoredll -lmmtimer"
            have_timers=yes
        fi
        # Set up files for the shared object loading library
        if test x$enable_loadso = xyes; then
            AC_DEFINE(SDL_LOADSO_WIN32)
            SOURCES="$SOURCES $srcdir/src/loadso/win32/*.c"
            have_loadso=yes
        fi
        # Set up the system libraries we need
        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lcoredll -lcommctrl"
        # The Win32 platform requires special setup
        SDLMAIN_SOURCES="$srcdir/src/main/win32/*.c"
        SDL_CFLAGS="$SDL_CFLAGS -Dmain=SDL_main -D_WIN32_WCE=0x420"
        SDL_LIBS="-lSDLmain $SDL_LIBS"
        ;;
    *-*-beos* | *-*-haiku*)
        ARCH=beos
        ac_default_prefix=/boot/develop/tools/gnupro
        CheckDummyVideo
        CheckDiskAudio
        CheckDummyAudio
        CheckNASM
        CheckBWINDOW
        CheckBeGL
        # Set up files for the audio library
        if test x$enable_audio = xyes; then
            AC_DEFINE(SDL_AUDIO_DRIVER_BAUDIO)
            SOURCES="$SOURCES $srcdir/src/audio/baudio/*.cc"
            have_audio=yes
        fi
        # Set up files for the joystick library
        if test x$enable_joystick = xyes; then
            AC_DEFINE(SDL_JOYSTICK_BEOS)
            SOURCES="$SOURCES $srcdir/src/joystick/beos/*.cc"
            have_joystick=yes
        fi
        # Set up files for the cdrom library
        if test x$enable_cdrom = xyes; then
            AC_DEFINE(SDL_CDROM_BEOS)
            SOURCES="$SOURCES $srcdir/src/cdrom/beos/*.cc"
            have_cdrom=yes
        fi
        # Set up files for the thread library
        if test x$enable_threads = xyes; then
            AC_DEFINE(SDL_THREAD_BEOS)
            SOURCES="$SOURCES $srcdir/src/thread/beos/*.c"
            SOURCES="$SOURCES $srcdir/src/thread/generic/SDL_sysmutex.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_BEOS)
            SOURCES="$SOURCES $srcdir/src/timer/beos/*.c"
            have_timers=yes
        fi
        # Set up files for the shared object loading library
        if test x$enable_loadso = xyes; then
            case "$host" in
                *-*-beos*)
                    AC_DEFINE(SDL_LOADSO_BEOS)
                    SOURCES="$SOURCES $srcdir/src/loadso/beos/*.c"
                ;;
                *-*-haiku*)
                    AC_DEFINE(SDL_LOADSO_DLOPEN)
                    SOURCES="$SOURCES $srcdir/src/loadso/dlopen/*.c"
                ;;
            esac    
            have_loadso=yes
        fi
        # The BeOS platform requires special setup.
        SOURCES="$srcdir/src/main/beos/*.cc $SOURCES"
        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -lroot -lbe -lmedia -lgame -ldevice -ltextencoding"
        ;;
    *-*-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"

        # HACK: Reset EXTRA_LDFLAGS; the only thing it contains at this point
        # is -lm which is not needed under Mac OS X. But for some reasons it
        # also tends to contain spurious -L switches, which we don't want to
        # use here or in sdl-config. Hence we reset it.
        EXTRA_LDFLAGS=""

        CheckVisibilityHidden
        CheckDummyVideo
        CheckDiskAudio
        CheckDummyAudio
        CheckDLOPEN
        CheckNASM

        # Set up files for the shared object loading library
        # (this needs to be done before the dynamic X11 check)
        if test x$enable_loadso = xyes -a x$have_dlopen != xyes; then
            AC_DEFINE(SDL_LOADSO_DLCOMPAT)
            SOURCES="$SOURCES $srcdir/src/loadso/macosx/*.c"
            have_loadso=yes
        fi

        CheckCOCOA
        CheckCARBON
        CheckX11
        CheckMacGL
        CheckOpenGLX11
        CheckPTHREAD
        CheckAltivec

        # Need this or things might misbuild on a G3.
        EXTRA_CFLAGS="$EXTRA_CFLAGS -force_cpusubtype_ALL"

        # Set up files for the audio library
        if test x$enable_audio = xyes; then
            AC_DEFINE(SDL_AUDIO_DRIVER_COREAUDIO)
            SOURCES="$SOURCES $srcdir/src/audio/macosx/*.c"
            have_audio=yes
        fi
        # Set up files for the joystick library
        if test x$enable_joystick = xyes; then
            AC_DEFINE(SDL_JOYSTICK_IOKIT)
            SOURCES="$SOURCES $srcdir/src/joystick/darwin/*.c"
            have_joystick=yes
            need_iokit_framework=yes
        fi
        # Set up files for the cdrom library
        if test x$enable_cdrom = xyes; then
            AC_DEFINE(SDL_CDROM_MACOSX)
            SOURCES="$SOURCES $srcdir/src/cdrom/macosx/*.c"
            have_cdrom=yes
        fi
        # Set up files for the timer library
        if test x$enable_timers = xyes; then
            AC_DEFINE(SDL_TIMER_UNIX)
            SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
            have_timers=yes
        fi
        # The Mac OS X platform requires special setup.
        SDLMAIN_SOURCES="$srcdir/src/main/macosx/*.m"
        EXTRA_CFLAGS="$EXTRA_CFLAGS -fpascal-strings"
        SDL_LIBS="-lSDLmain $SDL_LIBS"
        if test x$enable_video_cocoa = xyes; then
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Cocoa"
            need_iokit_framework=yes
        fi
        if test x$enable_video_carbon = xyes -o x$enable_video_cocoa = xyes; then
            # The Cocoa backend still needs Carbon
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,ApplicationServices"
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,Carbon"
        fi
        # If either the audio or CD driver is used, add the AudioUnit framework
        if test x$enable_audio = xyes -o x$enable_cdrom = xyes; then
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,AudioToolbox -Wl,-framework,AudioUnit"
        fi
        # Some subsystems reference IOKit...
        if test x$need_iokit_framework = xyes; then
            EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-framework,IOKit"
        fi
        ;;
    *-*-mint*)
        ARCH=mint
        CheckDummyVideo
        CheckDiskAudio
        CheckDummyAudio
        CheckAtariBiosEvent
        CheckAtariXbiosVideo
        CheckAtariGemVideo
        CheckAtariAudio
        CheckAtariLdg
        CheckAtariOSMesa
        CheckPTH
        # Set up files for the audio library
        if test x$enable_threads = xyes -a x$enable_pth = xyes; then
            if test x$enable_audio = xyes; then
                AC_DEFINE(SDL_AUDIO_DRIVER_SUNAUDIO)
                SOURCES="$SOURCES $srcdir/src/audio/sun/*.c"
                have_audio=yes
            fi
        fi
        # Set up files for the joystick library
        if test x$enable_joystick = xyes; then
            AC_DEFINE(SDL_JOYSTICK_MINT)
            SOURCES="$SOURCES $srcdir/src/joystick/mint/*.c"
            have_joystick=yes
        fi
        # Set up files for the cdrom library
        if test x$enable_cdrom = xyes; then
            AC_DEFINE(SDL_CDROM_MINT)
            SOURCES="$SOURCES $srcdir/src/cdrom/mint/*.c"
            have_cdrom=yes
        fi
        # Set up files for the timer library
        if test x$enable_timers = xyes; then
            if test x$enable_threads = xyes -a x$enable_pth = xyes; then
                AC_DEFINE(SDL_TIMER_UNIX)
                SOURCES="$SOURCES $srcdir/src/timer/unix/*.c"
            else
                AC_DEFINE(SDL_TIMER_MINT)
                SOURCES="$SOURCES $srcdir/src/timer/mint/*.c"
                SOURCES="$SOURCES $srcdir/src/timer/mint/*.S"
            fi
            have_timers=yes
        fi
        ;;
    *-riscos)
        ARCH=riscos
        CheckOSS
        CheckPTHREAD
        # Set up files for the video library
        if test x$enable_video = xyes; then
            AC_DEFINE(SDL_VIDEO_DRIVER_RISCOS)
            SOURCES="$SOURCES $srcdir/src/video/riscos/*.c"
            SOURCES="$SOURCES $srcdir/src/video/riscos/*.S"
            have_video=yes
        fi
        # Set up files for the joystick library
        if test x$enable_joystick = xyes; then
            AC_DEFINE(SDL_JOYSTICK_RISCOS)
            SOURCES="$SOURCES $srcdir/src/joystick/riscos/*.c"
            have_joystick=yes
        fi
        # Set up files for the timer library
        if test x$enable_timers = xyes; then
            AC_DEFINE(SDL_TIMER_RISCOS)
            SOURCES="$SOURCES $srcdir/src/timer/riscos/*.c"
            have_timers=yes
        fi
        # The RISC OS platform requires special setup.
        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -ljpeg -ltiff -lpng -lz"
        ;;
    *)
        AC_MSG_ERROR([
*** Unsupported host:  Please add to configure.in
        ])
        ;;
esac

# Verify that we have all the platform specific files we need

if test x$enable_joystick = xyes; then
  if test x$have_joystick != xyes; then
    # Wants joystick subsystem, but doesn't have a platform-specific backend...
    AC_DEFINE(SDL_JOYSTICK_DUMMY)
    SOURCES="$SOURCES $srcdir/src/joystick/dummy/*.c"
  fi
fi
if test x$have_cdrom != xyes; then
    if test x$enable_cdrom = xyes; then
        AC_DEFINE(SDL_CDROM_DISABLED)
    fi
    SOURCES="$SOURCES $srcdir/src/cdrom/dummy/*.c"
fi
if test x$have_threads != xyes; then
    if test x$enable_threads = xyes; then
        AC_DEFINE(SDL_THREADS_DISABLED)
    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)
    fi
    SOURCES="$SOURCES $srcdir/src/timer/dummy/*.c"
fi
if test x$have_loadso != xyes; then
    if test x$enable_loadso = xyes; then
        AC_DEFINE(SDL_LOADSO_DISABLED)
    fi
    SOURCES="$SOURCES $srcdir/src/loadso/dummy/*.c"
fi
if test x$SDLMAIN_SOURCES = x; then
    SDLMAIN_SOURCES="$srcdir/src/main/dummy/*.c"
fi

OBJECTS=`echo $SOURCES | sed 's,[[^ ]]*/\([[^ ]]*\)\.asm,$(objects)/\1.lo,g'`
OBJECTS=`echo $OBJECTS | sed 's,[[^ ]]*/\([[^ ]]*\)\.cc,$(objects)/\1.lo,g'`
OBJECTS=`echo $OBJECTS | sed 's,[[^ ]]*/\([[^ ]]*\)\.m,$(objects)/\1.lo,g'`
OBJECTS=`echo $OBJECTS | sed 's,[[^ ]]*/\([[^ ]]*\)\.c,$(objects)/\1.lo,g'`
OBJECTS=`echo $OBJECTS | sed 's,[[^ ]]*/\([[^ ]]*\)\.S,$(objects)/\1.lo,g'`
OBJECTS=`echo $OBJECTS | sed 's,[[^ ]]*/\([[^ ]]*\)\.rc,$(objects)/\1.o,g'`

SDLMAIN_OBJECTS=`echo $SDLMAIN_SOURCES | sed 's,[[^ ]]*/\([[^ ]]*\)\.cc,$(objects)/\1.o,g'`
SDLMAIN_OBJECTS=`echo $SDLMAIN_OBJECTS | sed 's,[[^ ]]*/\([[^ ]]*\)\.m,$(objects)/\1.o,g'`
SDLMAIN_OBJECTS=`echo $SDLMAIN_OBJECTS | sed 's,[[^ ]]*/\([[^ ]]*\)\.c,$(objects)/\1.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 = irix -o $ARCH = linux -o $ARCH = netbsd; then
    SDL_RLD_FLAGS="-Wl,-rpath,\${libdir}"
  fi
  if test $ARCH = solaris; then
    SDL_RLD_FLAGS="-R\${libdir}"
  fi
else
  SDL_RLD_FLAGS=""
fi

case "$ARCH" in
  macosx)
    if test x$enable_video = xyes -a x$enable_video_cocoa = xyes; then
      SDL_LIBS="$SDL_LIBS -Wl,-framework,Cocoa"
    fi
    if test x$enable_video = xyes -a x$enable_video_carbon = xyes; then
      SDL_LIBS="$SDL_LIBS -Wl,-framework,Carbon"
    fi
    # Evil hack to allow static linking on Mac OS X
    SDL_STATIC_LIBS="\${libdir}/libSDLmain.a \${libdir}/libSDL.a $EXTRA_LDFLAGS"
    ;;
  *)
    SDL_STATIC_LIBS="$SDL_LIBS $EXTRA_LDFLAGS"
    ;;
esac

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(SOURCES)
AC_SUBST(OBJECTS)
AC_SUBST(SDLMAIN_SOURCES)
AC_SUBST(SDLMAIN_OBJECTS)
AC_SUBST(BUILD_CFLAGS)
AC_SUBST(EXTRA_CFLAGS)
AC_SUBST(BUILD_LDFLAGS)
AC_SUBST(EXTRA_LDFLAGS)
AC_SUBST(WINDRES)

AC_OUTPUT([
    Makefile sdl-config SDL.spec SDL.qpg sdl.pc
], [
    : >build-deps
    if test x"$MAKE" = x; then MAKE=make; fi; $MAKE depend
])