dnl configure.ac: source for the configure script

dnl copyright by the mpg123 project - free software under the terms of the LGPL 2.1

dnl see COPYING and AUTHORS files in distribution or http://mpg123.org

dnl initially written by Nicholas J. Humfrey

dnl Require autoconf version >= 2.57

AC_PREREQ(2.57)

dnl ############# Initialisation

AC_INIT([mpg123], [1.25.10], [maintainer@mpg123.org])

dnl Increment API_VERSION when the API gets changes (new functions).

dnl libmpg123

API_VERSION=44

LIB_PATCHLEVEL=8

dnl libout123

OUTAPI_VERSION=2

OUTLIB_PATCHLEVEL=2

dnl Since we want to be backwards compatible, both sides get set to API_VERSION.

LIBMPG123_VERSION=$API_VERSION:$LIB_PATCHLEVEL:$API_VERSION

LIBOUT123_VERSION=$OUTAPI_VERSION:$OUTLIB_PATCHLEVEL:$OUTAPI_VERSION

AC_SUBST(LIBMPG123_VERSION)

AC_SUBST(API_VERSION)

AC_SUBST(LIBOUT123_VERSION)

AC_SUBST(OUTAPI_VERSION)

AC_CONFIG_SRCDIR(src/mpg123.c)

AC_CONFIG_AUX_DIR(build)

AC_CONFIG_SRCDIR(doc)

AC_CONFIG_MACRO_DIR([m4])

AC_CANONICAL_HOST

dnl Version 1.7 of automake is recommended

dnl Not sure what minimal version does not choke on sub directories.

dnl Testing with 1.14.

AM_INIT_AUTOMAKE([subdir-objects])

AC_CONFIG_HEADERS([src/config.h])

# You get strange symptoms like jack module build failing because the AC_C_CONST failed to detect the working const support.

# In that case, the test failed because -Werror, not because no const there...

# After looking again, there are possibly more tests being obscured by false failures.

AC_MSG_CHECKING([for -Werror in CFLAGS (It breaks tests)])

if echo "$CFLAGS" | grep Werror; then

	AC_MSG_RESULT([yes])

	AC_MSG_WARN([You have -Werror in CFLAGS. That may break some tests and make this configure bogus.

If you want paranoid compilation, use --enable-nagging option, which adds -Werror for gcc.

Also note that you shall not run make distcheck after configuring with --enable-nagging.

distcheck uses the generated CFLAGS...

Anyhow, continuing at your own risk.])

else

	AC_MSG_RESULT([no])

fi

buffer=enabled # try to build with buffer by default

dnl ############# Compiler and tools Checks

LT_LDFLAGS=-export-dynamic

EXEC_LT_LDFLAGS=

be_static=no

all_static=no

lib_static=no

AC_MSG_CHECKING([if you are up to something totally static with LDFLAGS/CFLAGS])

for f in $LDFLAGS $CFLAGS

do

	case "$f" in

		-all-static)

			be_static=yes

			all_static=yes

			lib_static=yes

		;;

		-static)

			be_static=yes

			lib_static=yes

		;;

		-static-libgcc)

			lib_static=yes

		;;

	esac

done

if test "x$be_static" = xyes; then

	AC_MSG_RESULT([yes])

	LT_LDFLAGS=-all-static

	EXEC_LT_LDFLAGS="$LT_LDFLAGS"

else

	AC_MSG_RESULT([no])

fi

if test "x$all_static" = xyes; then

	AC_MSG_WARN( Use -static in LDFLAGS for all-static linking! Your compiler may blow up on that -all-static. )

fi

AM_PROG_AS

AC_PROG_CC

AM_PROG_CC_C_O

AC_PROG_CPP

AC_PROG_INSTALL

AC_CHECK_LIBM

AC_SUBST(LIBM)

dnl "Checking for egrep is broken after removal of libltdl stuff... checks use $EGREP, so searching it here."

AC_PROG_EGREP

AC_C_CONST

AC_INLINE

AC_C_BIGENDIAN

if test "x$lib_static" = xyes; then

        CC="$CC -static-libgcc"

        CCLD="$CC"

	echo "Adding -static-libgcc"

fi

dnl ############# Use Libtool for dynamic module loading

modules=auto

OUTPUT_OBJ="module.\$(OBJEXT)"

AC_ARG_ENABLE(modules,

[  --enable-modules=[no/yes] dynamically loadable output modules],

[

	if test "x$enableval" = xyes

	then

		modules=enabled

	else

		modules=disabled

	fi

],

[

	if test "x$be_static" = "xyes"; then

		modules=disabled

	else

		modules=auto

	fi

])

dnl We only want shared libraries by default

AC_DISABLE_STATIC

AC_ENABLE_SHARED

if test x"$enable_shared" = xno; then

	modules=disabled

	LT_LDFLAGS=

else

	AC_DEFINE(DYNAMIC_BUILD, 1, [ Define if building with dynamcally linked libmpg123])

fi

dnl We need the windows header also for checking the module mechanism.

AC_CHECK_HEADERS([windows.h])

if test x"$modules" = xdisabled

then

  echo "Modules disabled, not checking for dynamic loading."

else

  have_dl=no

  # The dlopen() API is either in libc or in libdl.

  if test x$ac_cv_header_windows_h = xyes; then

    AC_MSG_CHECKING([if LoadLibrary should be used])

    AC_LINK_IFELSE([AC_LANG_SOURCE([

#ifdef __CYGWIN__

#error Cygwin should use dlopen

#endif

#include <windows.h>

int main() {

  LoadLibraryW(0);

  GetProcAddress(0, 0);

  FreeLibrary(0);

}

    ])], [

    have_dl=yes

    AC_MSG_RESULT([Using LoadLibrary])

    ],

  [AC_MSG_RESULT([no])])

  else

    AC_SEARCH_LIBS(dlopen, dl)

    AC_CHECK_HEADER(dlfcn.h)

    AC_CHECK_FUNCS(dlopen dlsym dlclose, [ have_dl=yes ])

  fi

  if test x"$modules" = xenabled -a x"$have_dl" = xno; then

    AC_MSG_ERROR([Modules enabled but no runtime loader found! This will not work...])

  fi

  if test x"$modules" = xauto; then

    if test x"$have_dl" = xyes; then

      modules=enabled

      echo "We found a runtime loader: Modules enabled."

    else

      echo "We did not find a runtime loader: Modules disabled."

      modules=disabled

    fi

  fi

fi

dnl Configure libtool

AC_LIBTOOL_WIN32_DLL

AM_PROG_LIBTOOL

if test x"$modules" = xdisabled

then

  echo "Modules disabled."

else

  # Enable module support in source code

  AC_DEFINE( USE_MODULES, 1, [Define if modules are enabled] )

  # Export the module file suffix as LT_MODULE_EXT

  LT_SYS_MODULE_EXT

fi

AM_CONDITIONAL( [HAVE_MODULES], [test "x$modules" = xenabled] )

AC_SUBST(LT_LDFLAGS)

AC_SUBST(EXEC_LT_LDFLAGS)

dnl ############## Configurable Options

AC_ARG_ENABLE(debug,

              [  --enable-debug=[no/yes] turn on debugging],

              [

                if test "x$enableval" = xyes

                then

                  debugging="enabled"

                else

                  debugging="disabled"

                fi

              ],

              [ debugging="disabled" ]

)

AC_ARG_ENABLE(nagging,

              [  --enable-nagging=[no/yes] turn on GCC's pedantic nagging with error on warnings, does not include --enable-debug anymore ],

              [

                if test "x$enableval" = xyes

                then

                  nagging="enabled"

               else

                  nagging="disabled"

                fi

              ],

              [ nagging="disabled" ]

)

if test x"$debugging" = xenabled; then

	AC_DEFINE(DEBUG, 1, [ Define if debugging is enabled. ])

fi

AC_ARG_ENABLE(gapless,

              [  --enable-gapless=[no/yes] turn on gapless (enabled per default)],

              [

                if test "x$enableval" = xyes

                then

                  gapless="enabled"

                  AC_DEFINE(GAPLESS, 1, [ Define if gapless is enabled. ])

                else

                  gapless="disabled"

                fi

              ],

              [

                gapless="enabled"

                AC_DEFINE(GAPLESS, 1, [ Define if gapless is enabled. ])

              ]

)

AC_ARG_ENABLE(fifo,

              [  --enable-fifo=[no/yes] FIFO support for control interface (auto-enabled on linux) ],

              [

                if test "x$enableval" = xyes

                then

                  fifo="enabled"

                else

                  fifo="disabled"

                fi

              ],

              [

                fifo="auto"

              ]

)

AC_ARG_ENABLE(ipv6,

              [  --enable-ipv6=[no/yes] IPv6 support (actually any protocol your libc does with getaddrinfo) ],

              [

                if test "x$enableval" = xyes

                then

                  ipv6="enabled"

                else

                  ipv6="disabled"

                fi

              ],

              [

                ipv6="auto"

              ]

)

AC_ARG_ENABLE(network,

              [  --enable-network=[no/yes] network support (http streams / webradio) ],

              [

                if test "x$enableval" = xyes

                then

                  network="enabled"

                else

                  network="disabled"

                fi

              ],

              [

                network="auto"

              ]

)

dnl Optional objects list, depends on decoder choice and core feature selection.

dnl Not just for specific decoders anymore...

s_fpu=

DECODER_OBJ=

DECODER_LOBJ=

dnl Core features that can be disabled to reduce binary size.

id3v2=enabled

AC_ARG_ENABLE(id3v2,

              [  --disable-id3v2=[no/yes] no ID3v2 parsing ],

              [

                if test "x$enableval" = xno; then

                  id3v2="disabled"

                fi

              ], [])

# id3v2 depends on strings... so check that in between.

string=enabled

AC_ARG_ENABLE(string,

              [  --disable-string=[no/yes] no string API (this will disable ID3v2; main mpg123 won't build anymore) ],

              [

                if test "x$enableval" = xno; then

                  string="disabled"

                fi

              ], [])

if test "x$string" = "xdisabled"; then

  AC_DEFINE(NO_STRING, 1, [ Define to disable string functions. ])

  id3v2=disabled

 	AC_MSG_WARN([ID3v2 support disabled because of string API being disabled.])

else

  DECODER_OBJ="$DECODER_OBJ stringbuf.\$(OBJEXT)"

  DECODER_LOBJ="$DECODER_LOBJ stringbuf.lo"

fi

if test "x$id3v2" = "xdisabled"; then

  AC_DEFINE(NO_ID3V2, 1, [ Define to disable ID3v2 parsing. ])

fi

icy=enabled

AC_ARG_ENABLE(icy,

              [  --disable-icy=[no/yes] no ICY metainfo parsing/conversion (main mpg123 won't build!) ],

              [

                if test "x$enableval" = xno; then

                  icy="disabled"

                fi

              ], [])

if test "x$icy" = "xdisabled"; then

  AC_DEFINE(NO_ICY, 1, [ Define to disable ICY handling. ])

else

  DECODER_OBJ="$DECODER_OBJ icy.\$(OBJEXT) icy2utf8.\$(OBJEXT)"

  DECODER_LOBJ="$DECODER_LOBJ icy.lo icy2utf8.lo"

fi

ntom=enabled

AC_ARG_ENABLE(ntom,

              [  --disable-ntom=[no/yes] no flexible resampling ],

              [

                if test "x$enableval" = xno; then

                  ntom="disabled"

                fi

              ], [])

if test "x$ntom" = "xdisabled"; then

  AC_DEFINE(NO_NTOM, 1, [ Define to disable ntom resampling. ])

else

  DECODER_OBJ="$DECODER_OBJ ntom.\$(OBJEXT)"

  DECODER_LOBJ="$DECODER_LOBJ ntom.lo"

fi

downsample=enabled

AC_ARG_ENABLE(downsample,

              [  --disable-downsample=[no/yes] no downsampled decoding ],

              [

                if test "x$enableval" = xno; then

                  downsample="disabled"

                fi

              ], [])

if test "x$downsample" = "xdisabled"; then

  AC_DEFINE(NO_DOWNSAMPLE, 1, [ Define to disable downsampled decoding. ])

fi

feeder=enabled

AC_ARG_ENABLE(feeder,

              [  --disable-feeder=[no/yes] no feeder decoding, no buffered readers ],

              [

                if test "x$enableval" = xno; then

                  feeder="disabled"

                fi

              ], [])

if test "x$feeder" = "xdisabled"; then

  AC_DEFINE(NO_FEEDER, 1, [ Define to disable feeder and buffered readers. ])

fi

messages=enabled

AC_ARG_ENABLE(messages,

              [  --disable-messages=[no/yes] no error/warning messages on the console ],

              [

                if test "x$enableval" = xno; then

                  messages="disabled"

                fi

              ], [])

if test "x$messages" = "xdisabled"; then

  AC_DEFINE(NO_WARNING, 1, [ Define to disable warning messages. ])

  AC_DEFINE(NO_ERRORMSG,   1, [ Define to disable error messages. ])

  AC_DEFINE(NO_ERETURN, 1, [ Define to disable error messages in combination with a return value (the return is left intact). ])

fi

newhuff=enabled

AC_ARG_ENABLE(new-huffman,

[  --enable-new-huffman=[yes/no] use new huffman decoding scheme by Taihei (faster on modern CPUs at least, so on by default) ],

[

  if test "x$enableval" = xno; then

    newhuff=disabled

  fi

]

, [])

if test "x$newhuff" = "xenabled"; then

  AC_DEFINE(USE_NEW_HUFFTABLE, 1, [ Define for new Huffman decoding scheme. ])

fi

integers=fast

AC_ARG_ENABLE(int-quality,

[  --enable-int-quality=[yes/no] use rounding instead of fast truncation for integer output, where possible ],

[

  if test "x$enableval" = xyes; then

    integers=quality

    AC_DEFINE(ACCURATE_ROUNDING,   1, [ Define to use proper rounding. ])

  fi

], [])

int16=enabled

AC_ARG_ENABLE(16bit,

              [  --disable-16bit=[no/yes] no 16 bit integer output ],

              [

                if test "x$enableval" = xno; then

                  int16="disabled"

                fi

              ], [])

int8=enabled

AC_ARG_ENABLE(8bit,

              [  --disable-8bit=[no/yes] no 8 bit integer output ],

              [

                if test "x$enableval" = xno; then

                  int8="disabled"

                fi

              ], [])

int32=enabled

AC_ARG_ENABLE(32bit,

              [  --disable-32bit=[no/yes] no 32 bit integer output (also 24 bit) ],

              [

                if test "x$enableval" = xno; then

                  int32="disabled"

                fi

              ], [])

real=enabled

AC_ARG_ENABLE(real,

              [  --disable-real=[no/yes] no real (floating point) output ],

              [

                if test "x$enableval" = xno; then

                  real="disabled"

                fi

              ], [])

equalizer=enabled

AC_ARG_ENABLE(equalizer,

              [  --disable-equalizer=[no/yes] no equalizer support ],

              [

                if test "x$enableval" = xno; then

                  equalizer="disabled"

                fi

              ], [])

AC_ARG_WITH([cpu], [

  --with-cpu=generic[[_fpu]]      Use generic processor code with floating point arithmetic

  --with-cpu=generic_float      Plain alias to generic_fpu now... float output is a normal runtime option!

  --with-cpu=generic_nofpu      Use generic processor code with fixed point arithmetic (p.ex. ARM)

  --with-cpu=generic_dither     Use generic processor code with floating point arithmetic and dithering for 1to1 16bit decoding.

  --with-cpu=i386[[_fpu]]         Use code optimized for i386 processors with floating point arithmetic

  --with-cpu=i386_nofpu         Use code optimized for i386 processors with fixed point arithmetic

  --with-cpu=i486         Use code optimized for i486 processors (only usable alone!)

  --with-cpu=i586         Use code optimized for i586 processors

  --with-cpu=i586_dither  Use code optimized for i586 processors with dithering (noise shaping), adds 256K to binary size

  --with-cpu=3dnow         Use code optimized for 3DNow processors

  --with-cpu=3dnow_vintage Use code optimized for older 3DNow processors (K6 family)

  --with-cpu=3dnowext      Use code optimized for 3DNowExt processors (K6-3+, Athlon)

  --with-cpu=3dnowext_alone     Really only 3DNowExt decoder, without 3DNow fallback for flexible rate

  --with-cpu=3dnow_vintage       Use code optimized for older extended 3DNow processors (like K6-III+)

  --with-cpu=mmx          Use code optimized for MMX processors

  --with-cpu=mmx_alone          Really only MMX decoder, without i586 fallback for flexible rate

  --with-cpu=sse          Use code optimized for SSE processors

  --with-cpu=sse_vintage  Use code optimized for older SSE processors (plain C DCT36)

  --with-cpu=sse_alone          Really only SSE decoder, without i586 fallback for flexible rate

  --with-cpu=avx          Use code optimized for x86-64 with AVX processors

  --with-cpu=x86          Pack all x86 opts into one binary (excluding i486, including dither)

  --with-cpu=x86-64       Use code optimized for x86-64 processors (AMD64 and Intel64, including AVX and dithered generic)

  --with-cpu=altivec      Use code optimized for Altivec processors (PowerPC G4 and G5)

  --with-cpu=ppc_nofpu    Use code optimized for PowerPC processors with fixed point arithmetic

  --with-cpu=neon         Use code optimized for ARM NEON SIMD engine (Cortex-A series)

  --with-cpu=arm_fpu      Pack neon and generic[[_dither]] decoders, for ARM processors with FPU and/or NEON

  --with-cpu=arm_nofpu    Use code optimized for ARM processors with fixed point arithmetic

  --with-cpu=neon64       Use code optimized for AArch64 NEON SIMD engine

  --with-cpu=aarch64      Pack neon64 and generic[[_dither]] decoders, for 64bit ARM processors

])

use_yasm=auto

AC_ARG_ENABLE(yasm,

              [  --enable-yasm=[no/yes] enforce yasm instad of default assembler for some optimizations (AVX, currently) ],

              [

                if test "x$enableval" = xyes; then

                  use_yasm="enabled"

                else

                  use_yasm="disabled"

                fi

              ], [])

AC_ARG_ENABLE(ieeefloat,

  [  --enable-ieeefloat=[yes/no] use special hackery relying on IEEE 754 floating point storage format (to accurately round to 16 bit integer at bit more efficiently in generic decoder, enabled by default, disable in case you have a very special computer) ],

  [

    if test "x$enableval" = xyes; then

      ieee=enabled

    else

      ieee=disabled

    fi

  ], [ ieee=enabled ])

if test "x$ieee" = xenabled; then

  echo "We assume IEEE754 floating point format."

  AC_DEFINE(IEEE_FLOAT,   1, [ Define to indicate that float storage follows IEEE754. ])

fi

sys_cppflags=

newoldwritesample=disabled

case $host in

  aarch64-*linux*|arm64-*linux*|aarch64-*bsd*|arm64-*bsd*|aarch64-apple-darwin*|arm64-apple-darwin*)

    cpu_type="aarch64"

  ;;

  arm*-*-linux*-*eabihf|armv7hl*-*-linux*)

    cpu_type="arm_fpu"

  ;;

  arm*-*-linux*)

    # check that... perhaps we are better off on arm with kernel math emulation

    cpu_type="arm_nofpu"

  ;;

  armv7*-apple-darwin*)

    cpu_type="arm_fpu"

  ;;

  i386-*-linux*|i386-*-kfreebsd*-gnu)

    cpu_type="i386_fpu"

    newoldwritesample=enabled

  ;;

  i486-*-linux*|i486-*-kfreebsd*-gnu)

    cpu_type="i486"

    newoldwritesample=enabled

  ;;

  i586-*-linux*|i586-*-kfreebsd*-gnu)

    cpu_type="x86"

    newoldwritesample=enabled

  ;;

  i686-*-linux*|i686-*-kfreebsd*-gnu)

    cpu_type="x86"

    newoldwritesample=enabled

  ;;

  x86_64-*-linux*|x86_64-*-kfreebsd*-gnu)

    cpu_type="x86-64"

  ;;

  *-*-linux*|*-*-kfreebsd*-gnu)

    cpu_type="generic_fpu"

  ;;

  i?86-apple-darwin10*)

    AC_MSG_CHECKING([if CPU type supports x86-64])

    case `sysctl -n hw.optional.x86_64` in

      1)

        AC_MSG_RESULT([yes])

        cpu_type="x86-64"

      ;;

      *)

        AC_MSG_RESULT([no])

        cpu_type="x86"

        newoldwritesample=enabled

      ;;

    esac

  ;;

  i?86-apple-darwin*)

    cpu_type="x86"

    newoldwritesample=enabled

  ;;

  x86_64-apple-darwin*)

    cpu_type="x86-64"

  ;;

  *-apple-darwin*)

    AC_MSG_CHECKING([if CPU type supports AltiVec])

    case `machine` in

      ppc7400 | ppc7450 | ppc970)

        AC_MSG_RESULT([yes])

        cpu_type="altivec"

      ;;

      *)

        AC_MSG_RESULT([no])

        cpu_type="generic_fpu"

      ;;

    esac

  ;;

  i?86-*-dragonfly* | i?86-*-freebsd* | i?86-*-midnightbsd* | i?86-*-mirbsd* | i?86-*-netbsd* | i?86-*-openbsd* | i?86-*-haiku*)

    cpu_type="x86"

    newoldwritesample=enabled

  ;;

  x86_64-*-dragonfly* | x86_64-*-freebsd* | x86_64-*-midnightbsd* | x86_64-*-mirbsd* | x86_64-*-netbsd* | x86_64-*-openbsd* | x86_64-*-haiku*)

    cpu_type="x86-64"

  ;;

  *-*-dragonfly* | *-*-freebsd* | *-*-midnightbsd* | *-*-mirbsd* | *-*-netbsd* | *-*-openbsd*)

    cpu_type="generic_fpu"

  ;;

  i386-*-solaris*)

    cpu_type=x86

    newoldwritesample=enabled

  ;;

  x86_64-*-solaris*)

    cpu_type=x86-64

  ;;

  *-*-solaris*)

    cpu_type="generic_fpu"

  ;;

  # os2-emx = OS/2 with some Unix fun; so p.ex. buffer works.

  # Till we sorted out the assembler troubles, generic CPU is default.

  i386-pc-os2-emx)

    cpu_type=generic_fpu

    newoldwritesample=enabled

  ;;

  x86_64-pc-os2-emx)

    # We are optimistic hat the future knows OS/2 on x86-64;-)

    cpu_type=generic_fpu

  ;;

  *-pc-os2-emx)

    cpu_type="generic_fpu"

  ;;

  *-dec-osf*)

    cpu_type="generic_fpu"

  ;;

  x86_64-*-cygwin*)

    cpu_type="x86-64"

  ;;

  i686-*-cygwin*)

    cpu_type="x86"

    newoldwritesample=enabled

  ;;

  i586-*-cygwin*)

    cpu_type="x86"

    newoldwritesample=enabled

  ;;

  i486-*-cygwin*)

    cpu_type="i486"

    newoldwritesample=enabled

  ;;

  i386-*-cygwin*)

    cpu_type="i386"

    newoldwritesample=enabled

  ;;

  *-cygwin*)

    cpu_type="generic_fpu"

  ;;

  i@<:@3-7@:>@86-*-mingw32*)

    LIBS="$LIBS"

    buffer=disabled

    cpu_type="x86"

    newoldwritesample=enabled

  ;;

  x86_64-*-mingw32*)

    LIBS="$LIBS"

    buffer=disabled

    cpu_type="x86-64"

  ;;

  i386-*-nto-qnx*)

    cpu_type="x86"

    newoldwritesample=enabled

  ;;

  *-ibm-aix*)

    AC_MSG_WARN([AIX system detected. You might want to --disable-largefile when trouble about conflicting types for lseek64 and friends occurs.])

    # Altivec instead? It is developed for MacOS ...

    cpu_type=generic_fpu

    # no struct winsize without _ALL_SOURCE

    sys_cppflags=-D_ALL_SOURCE

  ;;

	i386-*)

		AC_MSG_WARN([Unknown host operating system])

		cpu_type="i386"

		buffer=disabled

		sys_cppflags=-DGENERIC

    newoldwritesample=enabled

	;;

	i486-*)

		AC_MSG_WARN([Unknown host operating system])

		cpu_type="i486"

		buffer=disabled

		sys_cppflags=-DGENERIC

    newoldwritesample=enabled

	;;

	i586-*)

		AC_MSG_WARN([Unknown host operating system])

		cpu_type="x86"

		buffer=disabled

		sys_cppflags=-DGENERIC

    newoldwritesample=enabled

	;;

	i686-*)

		AC_MSG_WARN([Unknown host operating system])

		cpu_type="x86"

		buffer=disabled

		sys_cppflags=-DGENERIC

    newoldwritesample=enabled

	;;

	x86_64-*)

		AC_MSG_WARN([Unknown host operating system])

		cpu_type="x86-64"

		buffer=disabled

		sys_cppflags=-DGENERIC

	;;

  *)

  	AC_MSG_WARN([Unknown host operating system])

    cpu_type="generic_fpu"

    buffer=disabled

    sys_cppflags=-DGENERIC

  ;;

esac

AC_ARG_ENABLE(buffer,

  [  --enable-buffer=[yes/no] disable audio buffer code (default uses system whitelist... proper checks later) ],

  [

    if test "x$enableval" = xyes

    then

      echo "Note: Enabling buffer per request... perhaps it will not build anyway."

      buffer="enabled"

    else

      echo "Note: Disabling buffer per request."

      buffer="disabled"

    fi

  ]

)

AC_ARG_ENABLE(newoldwritesample,

[  --enable-newoldwritesample=[no/yes] enable new/old WRITE_SAMPLE macro for non-accurate 16 bit output, faster on certain CPUs (default on on x86-32)],

[

	if test "x$enableval" = xyes

	then

		newoldwritesample=enabled

	else

		newoldwritesample=disabled

	fi

])

dnl Did user choose other CPU type ?

if test "x$with_cpu" != "x"; then

	cpu_type=$with_cpu

fi

# Flag for 32 bit synth output or post-processing.

case "$cpu_type" in

*_nofpu)

  synth32=false

  AC_DEFINE(NO_SYNTH32, 1, [ Define for post-processed 32 bit formats. ])

;;

*)

  synth32=true

;;

esac

if test "x$int16" = "xdisabled"; then

  AC_DEFINE(NO_16BIT, 1, [ Define to disable 16 bit integer output. ])

else

  DECODER_OBJ="$DECODER_OBJ synth.\$(OBJEXT)"

  DECODER_LOBJ="$DECODER_LOBJ synth.lo"

fi

# 8bit works only through 16bit

if test "x$int16" = "xdisabled"; then

  int8=disabled

fi

if test "x$int8" = "xdisabled"; then

  AC_DEFINE(NO_8BIT, 1, [ Define to disable 8 bit integer output. ])

else

  DECODER_OBJ="$DECODER_OBJ synth_8bit.\$(OBJEXT)"

  DECODER_LOBJ="$DECODER_LOBJ synth_8bit.lo"

fi

if test "x$int32" = "xdisabled"; then

  AC_DEFINE(NO_32BIT, 1, [ Define to disable 32 bit and 24 bit integer output. ])

else

  if $synth32; then

    s_fpu="$s_fpu synth_s32"

  fi

fi

if test "x$real" = "xdisabled"; then

  AC_DEFINE(NO_REAL, 1, [ Define to disable real output. ])

else

  if $synth32; then

    s_fpu="$s_fpu synth_real"

  fi

fi

if test "x$equalizer" = "xdisabled"; then

  AC_DEFINE(NO_EQUALIZER, 1, [ Define to disable equalizer. ])

fi

layer1=enabled

AC_ARG_ENABLE(layer1,

              [  --disable-layer1=[no/yes] no layer I decoding ],

              [

                if test "x$enableval" = xno; then

                  layer1="disabled"

                fi

              ], [])

if test "x$layer1" = "xdisabled"; then

  AC_DEFINE(NO_LAYER1, 1, [ Define to disable layer I. ])

else

  # layer1 needs code in layer2

  DECODER_OBJ="$DECODER_OBJ layer1.\$(OBJEXT) layer2.\$(OBJEXT)"

  DECODER_LOBJ="$DECODER_LOBJ layer1.lo layer2.lo"

fi

layer2=enabled

AC_ARG_ENABLE(layer2,

              [  --disable-layer2=[no/yes] no layer II decoding ],

              [

                if test "x$enableval" = xno; then

                  layer2="disabled"

                fi

              ], [])

if test "x$layer2" = "xdisabled"; then

  AC_DEFINE(NO_LAYER2, 1, [ Define to disable layer II. ])

else

  # layer1 may have added the objects already

  if test "x$layer1" = "xdisabled"; then

    DECODER_OBJ="$DECODER_OBJ layer2.\$(OBJEXT)"

    DECODER_LOBJ="$DECODER_LOBJ layer2.lo"

  fi

fi

layer3=enabled

AC_ARG_ENABLE(layer3,

              [  --disable-layer3=[no/yes] no layer III decoding ],

              [

                if test "x$enableval" = xno; then

                  layer3="disabled"

                fi

              ], [])

if test "x$layer3" = "xdisabled"; then

  AC_DEFINE(NO_LAYER3, 1, [ Define to disable layer III. ])

else

  DECODER_OBJ="$DECODER_OBJ layer3.\$(OBJEXT)"

  DECODER_LOBJ="$DECODER_LOBJ layer3.lo"

fi

AC_ARG_WITH([audio], [

  --with-audio=<list of modules>  Select a list (or only one) of audio output modules (comma or space separated list).

])

AC_ARG_WITH([default-audio], [

  --with-default-audio=aix            Use AIX as default audio output sub-system