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

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=10
SDL_INTERFACE_AGE=3
SDL_BINARY_AGE=10
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_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`

AC_SUBST(LT_RELEASE)
AC_SUBST(LT_CURRENT)
AC_SUBST(LT_REVISION)
AC_SUBST(LT_AGE)

dnl Detect the canonical host and target build environment
AC_CONFIG_AUX_DIRS($srcdir/build-scripts)
AC_CANONICAL_SYSTEM
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 Set up the compiler and linker flags
INCLUDE="-I$srcdir/include"
if test x$srcdir != x.; then
    INCLUDE="-Iinclude $INCLUDE"
fi
case "$target" in
    *-*-cygwin*)
        # We build SDL on cygwin without the UNIX emulation layer
        CFLAGS="$CFLAGS -I/usr/include/mingw -mno-cygwin"
        BUILD_CFLAGS="$CFLAGS \$(INCLUDE)"
        BUILD_LDFLAGS="$LDFLAGS -mno-cygwin"
        SDL_CFLAGS="-I/usr/include/mingw -mno-cygwin"
        SDL_LIBS="-lSDL -mno-cygwin"
        ;;
    *)
        CFLAGS="$CFLAGS -D_GNU_SOURCE=1"
        BUILD_CFLAGS="$CFLAGS \$(INCLUDE)"
        BUILD_LDFLAGS="$LDFLAGS"
        SDL_CFLAGS=""
        SDL_LIBS="-lSDL"
        ;;
esac

dnl Check for tools
AC_LIBTOOL_WIN32_DLL
AC_PROG_LIBTOOL
AC_PROG_CC
AC_PROG_CXX
AC_PROG_INSTALL
AC_PROG_MAKE_SET

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 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.
    AC_FUNC_ALLOCA
    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_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 sscanf snprintf vsnprintf sigaction setjmp nanosleep)

    AC_CHECK_LIB(m, pow, [BUILD_LDFLAGS="$BUILD_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/joystick/*.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)
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

            # OpenBSD needs linking with ossaudio emulation library
            case "$target" in
                *-*-openbsd*|*-*-netbsd*)
                    BUILD_LDFLAGS="$BUILD_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)
            if test "x`echo $ALSA_LIBS | grep -- -L`" = "x"; then
                if test "x`ls /lib/libasound.so.* 2> /dev/null`" != "x"; then
                    ALSA_LIBS="-L/lib $ALSA_LIBS"
                elif test "x`ls /usr/lib/libasound.so.* 2> /dev/null`" != "x"; then
                    ALSA_LIBS="-L/usr/lib $ALSA_LIBS"
                elif test "x`ls /usr/local/lib/libasound.so.* 2> /dev/null`" != "x"; then
                    ALSA_LIBS="-L/usr/local/lib $ALSA_LIBS"
                fi
            fi
            alsa_lib_spec=`echo $ALSA_LIBS | sed 's/.*-L\([[^ ]]*\).*/\1\/libasound.so.*/'`
            alsa_lib=`ls $alsa_lib_spec | sed 's/.*\/\(.*\)/\1/; q'`
            echo "-- $alsa_lib_spec -> $alsa_lib"

            AC_DEFINE(SDL_AUDIO_DRIVER_ALSA)
            SOURCES="$SOURCES $srcdir/src/audio/alsa/*.c"
            BUILD_CFLAGS="$BUILD_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
                AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_ALSA_DYNAMIC, "$alsa_lib")
            else
                BUILD_LDFLAGS="$BUILD_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"
            BUILD_LDFLAGS="$BUILD_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"
            BUILD_CFLAGS="$BUILD_CFLAGS $MME_CFLAGS"
            BUILD_LDFLAGS="$BUILD_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_spec=`echo $ESD_LIBS | sed 's/.*-L\([[^ ]]*\).*/\1\/libesd.so.*/'`
            esd_lib=`ls $esd_lib_spec | sed 's/.*\/\(.*\)/\1/; q'`
            echo "-- $esd_lib_spec -> $esd_lib"

            AC_DEFINE(SDL_AUDIO_DRIVER_ESD)
            SOURCES="$SOURCES $srcdir/src/audio/esd/*.c"
            BUILD_CFLAGS="$BUILD_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
                AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_ESD_DYNAMIC, "$esd_lib")
            else
                BUILD_LDFLAGS="$BUILD_LDFLAGS $ESD_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`
            ARTS_PREFIX=`$ARTSCONFIG --arts-prefix`
            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_spec="$ARTS_PREFIX/lib/libartsc.so.*"
                arts_lib=`ls $arts_lib_spec | sed 's/.*\/\(.*\)/\1/; q'`
                echo "-- $arts_lib_spec -> $arts_lib"

                AC_DEFINE(SDL_AUDIO_DRIVER_ARTS)
                SOURCES="$SOURCES $srcdir/src/audio/arts/*.c"
                BUILD_CFLAGS="$BUILD_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
                    AC_DEFINE_UNQUOTED(SDL_AUDIO_DRIVER_ARTS_DYNAMIC, "$arts_lib")
                else
                    BUILD_LDFLAGS="$BUILD_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_MSG_CHECKING(for NAS audio support)
        have_nas=no
        if test -r /usr/X11R6/include/audio/audiolib.h; then
            have_nas=yes
            NAS_CFLAGS="-I/usr/X11R6/include/"
            NAS_LIBS="-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_DEFINE(SDL_AUDIO_DRIVER_NAS)
            SOURCES="$SOURCES $srcdir/src/audio/nas/*.c"
            BUILD_CFLAGS="$BUILD_CFLAGS $NAS_CFLAGS"
            BUILD_LDFLAGS="$BUILD_LDFLAGS $NAS_LIBS"
            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 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 $target in
        i?86*)
            ;;
        *)
        # Nope, bail early.
            return
            ;;
    esac
    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
        AC_PATH_PROG(NASM, nasm)
        if test x$NASM != x -a x$NASM != x'"$NASM"'; then
            AC_DEFINE(SDL_HERMES_BLITTERS)
            SOURCES="$SOURCES $srcdir/src/hermes/*.asm"
            case $ARCH in
              win32)
                  NASMFLAGS="-f win32"
                  ;;
              openbsd)
                  NASMFLAGS="-f aoutb"
                  ;;
              *)
                  NASMFLAGS="-f elf"
                  ;;
            esac
            AC_SUBST(NASM)
            AC_SUBST(NASMFLAGS)

            case "$target" in
                # this line is needed for QNX, because it's not defined the __ELF__
                *-*-qnx*)
                     BUILD_CFLAGS="$BUILD_CFLAGS -D__ELF__";;
                *-*-solaris*)
                     BUILD_CFLAGS="$BUILD_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
        have_altivec_h_hdr=no
        AC_CHECK_HEADER(altivec.h, have_altivec_h_hdr=yes)

        save_CFLAGS="$CFLAGS"
        have_gcc_altivec=no
        AC_MSG_CHECKING(for Altivec with GCC -maltivec option)
        altivec_CFLAGS="-maltivec"
        CFLAGS="$save_CFLAGS $altivec_CFLAGS"

        if test x$have_altivec_h_hdr = xyes; then
          AC_TRY_COMPILE([
          #include <altivec.h>
          vector unsigned int vzero() {
              return vec_splat_u32(0);
          }
          ],[
          ],[
          have_gcc_altivec=yes
          ])
          AC_MSG_RESULT($have_gcc_altivec)
        else
          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 -faltivec option)
            altivec_CFLAGS="-faltivec"
            CFLAGS="$save_CFLAGS $altivec_CFLAGS"
            if test x$have_altivec_h_hdr = xyes; then
              AC_TRY_COMPILE([
              #include <altivec.h>
              vector unsigned int vzero() {
                  return vec_splat_u32(0);
              }
              ],[
              ],[
              have_gcc_altivec=yes
              ])
              AC_MSG_RESULT($have_gcc_altivec)
            else
              AC_TRY_COMPILE([
              vector unsigned int vzero() {
                  return vec_splat_u32(0);
              }
              ],[
              ],[
              have_gcc_altivec=yes
              ])
              AC_MSG_RESULT($have_gcc_altivec)
            fi
        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
            BUILD_CFLAGS="$BUILD_CFLAGS $altivec_CFLAGS"
        fi
    fi
}

dnl Do the iPod thing
CheckIPod()
{
    AC_ARG_ENABLE(ipod,
AC_HELP_STRING([--enable-ipod], [configure SDL to work with iPodLinux [default=yes on arm-elf]]),
        , enable_ipod=yes)

    if test x$enable_ipod = xyes; then
        BUILD_CFLAGS="$BUILD_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
            BUILD_CFLAGS="$BUILD_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
            BUILD_CFLAGS="$BUILD_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
            BUILD_CFLAGS="$BUILD_CFLAGS -DENABLE_NANOX_DIRECT_FB"
        fi

        AC_DEFINE(SDL_VIDEO_DRIVER_NANOX)
        SOURCES="$SOURCES $srcdir/src/video/nanox/*.c"
        BUILD_LDFLAGS="$BUILD_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
        AC_PATH_X
        AC_PATH_XTRA
        if test x$have_x = xyes; then
            AC_ARG_ENABLE(x11-shared,
AC_HELP_STRING([--enable-x11-shared], [dynamically load X11 support [default=yes]]),
                          , enable_x11_shared=yes)

            case "$target" in
                *-*-darwin*)
                    x11_lib='/usr/X11R6/lib/libX11.6.dylib'
                    x11ext_lib='/usr/X11R6/lib/libXext.6.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'
                    ;;
                *)
                    if test "x$X_LIBS" = "x"; then X_LIBS="-L/usr/lib"; fi
                    x11_lib_spec=[`echo $X_LIBS | sed 's/.*-L\([^ ]*\).*/\1\/libX11.so.[0-9]/'`]
                    x11_lib=`ls $x11_lib_spec 2>/dev/null | sort -r | sed 's/.*\/\(.*\)/\1/; q'`
                    x11ext_lib_spec=[`echo $X_LIBS | sed 's/.*-L\([^ ]*\).*/\1\/libXext.so.[0-9]/'`]
                    x11ext_lib=`ls $x11ext_lib_spec 2>/dev/null | sort -r | 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

            AC_DEFINE(SDL_VIDEO_DRIVER_X11)
            SOURCES="$SOURCES $srcdir/src/video/x11/*.c"
            BUILD_CFLAGS="$BUILD_CFLAGS $X_CFLAGS"
            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])
            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
                BUILD_LDFLAGS="$BUILD_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
        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"
            BUILD_LDFLAGS="$BUILD_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_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=no]]),
                  , enable_video_directfb=no)
    if test x$enable_video = xyes -a x$enable_video_directfb = xyes; then
        video_directfb=no

        AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
        if test x$PKG_CONFIG = xno ; then
            AC_MSG_WARN([*** pkg-config is required to build the DirectFB video driver.])
        else
            AC_MSG_CHECKING(for DirectFB support)

            if ! $PKG_CONFIG --atleast-pkgconfig-version 0.7 ; then
                AC_MSG_ERROR([*** pkg-config too old; version 0.7 or better required.])
            fi

            DIRECTFB_REQUIRED_VERSION=0.9.15

            if $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

        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"
            BUILD_CFLAGS="$BUILD_CFLAGS $DIRECTFB_CFLAGS"
            BUILD_LDFLAGS="$BUILD_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 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"
            BUILD_LDFLAGS="$BUILD_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=no]]),
                  , enable_video_svga=no)
    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"
            BUILD_LDFLAGS="$BUILD_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=no]]),
                  , enable_video_vgl=no)
    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;
         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"
            BUILD_LDFLAGS="$BUILD_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>
        ],[
        ],[
        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"
            BUILD_LDFLAGS="$BUILD_LDFLAGS -laa"
            have_video=yes
        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"
            BUILD_CFLAGS="$BUILD_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"
            BUILD_LDFLAGS="$BUILD_LDFLAGS -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>
        ],[
        ],[
        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)
            BUILD_LDFLAGS="$BUILD_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)
        BUILD_LDFLAGS="$BUILD_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 "$target" in
            *-*-darwin*)
                BUILD_LDFLAGS="$BUILD_LDFLAGS -framework OpenGL"
                # The following is probably not available in Darwin:
                BUILD_LDFLAGS="$BUILD_LDFLAGS -framework AGL"
        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)
        BUILD_CFLAGS="$BUILD_CFLAGS $OSMESA_CFLAGS"
        BUILD_LDFLAGS="$BUILD_LDFLAGS $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
}

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)
            BUILD_LDFLAGS="$BUILD_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 "$target" in
        *-*-linux*)
            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*)
            pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
            pthread_lib="-pthread"
            ;;
        *-*-netbsd*)
            pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
            pthread_lib="-L/usr/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)
            BUILD_CFLAGS="$BUILD_CFLAGS $pthread_cflags"
            BUILD_LDFLAGS="$BUILD_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
        BUILD_CFLAGS="$BUILD_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>
        ],[
        ],[
        have_dlopen=yes
        ])
        AC_MSG_RESULT($have_dlopen)

        if test x$have_dlopen = xyes; then
            AC_CHECK_LIB(c, dlopen, BUILD_LDFLAGS="$BUILD_LDFLAGS",
               AC_CHECK_LIB(dl, dlopen, BUILD_LDFLAGS="$BUILD_LDFLAGS -ldl",
                  AC_CHECK_LIB(ltdl, dlopen, BUILD_LDFLAGS="$BUILD_LDFLAGS -lltdl")))
            AC_CHECK_LIB(dl, dlvsym, have_dlvsym=yes)
            if test x$have_dlvsym = xyes; then
                AC_DEFINE(HAVE_DLVSYM)
            fi
            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"
            BUILD_LDFLAGS="$BUILD_LDFLAGS -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_HEADER(usb.h, [USB_CFLAGS="-DHAVE_USB_H"])
        AC_CHECK_HEADER(usbhid.h, [USB_CFLAGS="-DHAVE_USBHID_H"])
        AC_CHECK_HEADER(libusb.h, [USB_CFLAGS="-DHAVE_LIBUSB_H"])
        AC_CHECK_HEADER(libusbhid.h, [USB_CFLAGS="-DHAVE_LIBUSBHID_H"])
            
        AC_CHECK_LIB(usbhid, hid_init, [USB_LIBS="$USB_LIBS -lusbhid"])
        AC_CHECK_LIB(usb, hid_init, [USB_LIBS="$USB_LIBS -lusb"])

        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
          #include <dev/usb/usb.h>
          #include <dev/usb/usbhid.h>
          #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
              #include <dev/usb/usb.h>
              #include <dev/usb/usbhid.h>
              #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
              #include <dev/usb/usb.h>
              #include <dev/usb/usbhid.h>
              #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_DEFINE(SDL_JOYSTICK_USBHID)
            SOURCES="$SOURCES $srcdir/src/joystick/bsd/*.c"
            BUILD_CFLAGS="$BUILD_CFLAGS $USB_CFLAGS"
            BUILD_LDFLAGS="$BUILD_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)
            BUILD_LDFLAGS="$BUILD_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
        BUILD_CFLAGS="$BUILD_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 target platform!
case "$target" 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*|*-*-gnu*|*-*-k*bsd*-gnu|*-*-bsdi*|*-*-freebsd*|*-*-netbsd*|*-*-openbsd*|*-*-sysv5*|*-*-solaris*|*-*-hpux*|*-*-irix*|*-*-aix*|*-*-osf*)
        case "$target" in
            *-*-linux*)         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 ;;
            *-*-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
        CheckDummyVideo
        CheckDiskAudio
        CheckDLOPEN
        CheckNASM
        CheckAltivec
        CheckOSS
        CheckDMEDIA
        CheckMME
        CheckALSA
        CheckARTSC
        CheckESD
        CheckNAS
        CheckX11
        CheckNANOX
        CheckFBCON
        CheckDirectFB
        CheckPS2GS
        CheckGGI
        CheckSVGA
        CheckVGL
        CheckWscons
        CheckAAlib
        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
            netbsd|sysv5|solaris|hpux)
                AC_DEFINE(SDL_AUDIO_DRIVER_SUNAUDIO)
                SOURCES="$SOURCES $srcdir/src/audio/sun/*.c"
                have_audio=yes
            ;;
            openbsd)
                AC_DEFINE(SDL_AUDIO_DRIVER_OPENBSD)
                SOURCES="$SOURCES $srcdir/src/audio/openbsd/*.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
        # 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"
            BUILD_LDFLAGS="$BUILD_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" != "$target"; then # cross-compiling
            # Default cross-compile location
            ac_default_prefix=/usr/local/cross-tools/i386-mingw32msvc
        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
        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
        BUILD_LDFLAGS="$BUILD_LDFLAGS -luser32 -lgdi32 -lwinmm"
        if test x$have_directx = xyes; then
            BUILD_LDFLAGS="$BUILD_LDFLAGS -ldxguid"
        fi
        # The Win32 platform requires special setup
        SDLMAIN_SOURCES="$srcdir/src/main/win32/*.c"
        SDL_CFLAGS="$SDL_CFLAGS -Dmain=SDL_main"
        SDL_LIBS="-lmingw32 -lSDLmain $SDL_LIBS -mwindows"
        ;;
    *-*-beos*)
        ARCH=beos
        ac_default_prefix=/boot/develop/tools/gnupro
        CheckDummyVideo
        CheckDiskAudio
        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
            AC_DEFINE(SDL_LOADSO_BEOS)
            SOURCES="$SOURCES $srcdir/src/loadso/beos/*.c"
            have_loadso=yes
        fi
        # The BeOS platform requires special setup.
        SOURCES="$srcdir/src/main/beos/*.cc $SOURCES"
        BUILD_LDFLAGS="$BUILD_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
        CheckDummyVideo
        CheckDiskAudio
        CheckDLOPEN
        CheckCOCOA
        CheckCARBON
        CheckX11
        CheckMacGL
        CheckOpenGLX11
        CheckPTHREAD
        CheckAltivec

        # Need this or things might misbuild on a G3.
        BUILD_CFLAGS="$BUILD_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"
            AC_DEFINE(SDL_AUDIO_DRIVER_SNDMGR)
            SOURCES="$SOURCES $srcdir/src/audio/macrom/*.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"
            BUILD_LDFLAGS="$BUILD_LDFLAGS -framework IOKit"
            have_joystick=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
        # Set up files for the shared object loading library
        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
        # The MacOS X platform requires special setup.
        SDLMAIN_SOURCES="$srcdir/src/main/macosx/*.m"
        BUILD_CFLAGS="$BUILD_CFLAGS -fpascal-strings"
        SDL_LIBS="-lSDLmain $SDL_LIBS"
        if test x$enable_video_cocoa = xyes; then
            BUILD_LDFLAGS="$BUILD_LDFLAGS -framework Cocoa"
        fi
        if test x$enable_video_carbon = xyes -o x$enable_video_cocoa = xyes; then
            # The Cocoa backend still needs Carbon, and the YUV code QuickTime
            BUILD_LDFLAGS="$BUILD_LDFLAGS -framework QuickTime -framework ApplicationServices"
            BUILD_LDFLAGS="$BUILD_LDFLAGS -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
            BUILD_LDFLAGS="$BUILD_LDFLAGS -framework AudioToolbox -framework AudioUnit"
        fi
        ;;
    *-*-mint*)
        ARCH=mint
        CheckDummyVideo
        CheckDiskAudio
        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.
        BUILD_LDFLAGS="$BUILD_LDFLAGS -ljpeg -ltiff -lpng -lz"
        ;;
    *)
        AC_MSG_ERROR([
*** Unsupported target:  Please add to configure.in
        ])
        ;;
esac

# Verify that we have all the platform specific files we need
if test x$have_joystick != xyes; then
    if test x$enable_joystick = xyes; then
        AC_DEFINE(SDL_JOYSTICK_DISABLED)
    fi
    SOURCES="$SOURCES $srcdir/src/joystick/dummy/*.c"
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'`

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 = linux -o $ARCH = freebsd -o $ARCH = bsdi -o $ARCH = irix; then
    SDL_RLD_FLAGS="-Wl,-rpath,\${exec_prefix}/lib"
  fi
  if test $ARCH = solaris; then
    SDL_RLD_FLAGS="-R\${exec_prefix}/lib"
  fi
else
  SDL_RLD_FLAGS=""
fi

case "$ARCH" in
  openbsd | netbsd | bsdi)
    SHARED_SYSTEM_LIBS="$SYSTEM_LIBS"
    ;;
  qnx)
    SHARED_SYSTEM_LIBS="$SYSTEM_LIBS"
    ;;
  macosx)
    SHARED_SYSTEM_LIBS=""
    if test x$enable_video = xyes -a x$enable_video_cocoa = xyes; then
      SHARED_SYSTEM_LIBS="$SHARED_SYSTEM_LIBS -framework Cocoa"
    fi
    if test x$enable_video = xyes -a x$enable_video_carbon = xyes; then
      SHARED_SYSTEM_LIBS="$SHARED_SYSTEM_LIBS -framework Carbon"
    fi
    if test x$enable_video = xyes -a x$enable_video_opengl = xyes; then
      SHARED_SYSTEM_LIBS="$SHARED_SYSTEM_LIBS -framework OpenGL"
    fi
    ;;
  *)
    SHARED_SYSTEM_LIBS=""
    ;;
esac

case "$ARCH" in
  macosx)
    # Evil hack to allow static linking on Mac OS X
    SDL_STATIC_LIBS="\${exec_prefix}/lib/libSDLmain.a \${exec_prefix}/lib/libSDL.a"
    ;;
  *)
    SDL_STATIC_LIBS="$SDL_LIBS"
    ;;
esac

STATIC_SYSTEM_LIBS="$SYSTEM_LIBS"

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 libraries needed for static and dynamic linking
AC_SUBST(STATIC_SYSTEM_LIBS)
AC_SUBST(SHARED_SYSTEM_LIBS)
AC_SUBST(SYSTEM_LIBS)

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(BUILD_LDFLAGS)

AC_OUTPUT([
    Makefile sdl-config SDL.spec SDL.qpg
], [
    : >build-deps
    make depend
])