#                                               -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.

AC_PREREQ([2.61])

AC_INIT([paraslash], [m4_esyscmd_s(./GIT-VERSION-GEN)],
	[maan@tuebingen.mpg.de], [], [http://people.tuebingen.mpg.de/maan/paraslash/])
AC_CONFIG_HEADERS([config.h])

AC_CONFIG_FILES([Makefile])
AC_DEFUN([add_dot_o],[$(for i in $@; do printf "$i.o "; done)])
AC_DEFUN([add_cmdline],[$(for i in $@; do printf "${i}.cmdline "; done)])
AC_DEFUN([make_errlist_defines], \
	$(for i in $@; do \
		printf "DEFINE_ERRLIST($(echo $i | tr 'a-z' 'A-Z'));"; \
	done) \
)
AC_DEFUN([make_para_errlists], \
	$(for i in $@; do \
		printf "PARA_ERRLIST($(echo $i | tr 'a-z' 'A-Z')), "; \
	done) \
)
AC_DEFUN([objlist_to_errlist],[ \
	make_errlist_defines($@) \
	[const char **para_errlist[[]]] = {make_para_errlists($@)} \
])

AC_PATH_PROG(UNAMEPATH, uname, no)
if test "$UNAMEPATH" = "no"; then
	AC_MSG_ERROR(unable to determine system type)
fi
AC_MSG_CHECKING(os type)
OSTYPE="`$UNAMEPATH -s`"
AC_MSG_RESULT("$OSTYPE")

if test "$OSTYPE" = "SunOS"; then
	# needed on SunOS for socket magic
	arch_cppflags="-D_XOPEN_SOURCE=500 -D__EXTENSIONS__"
	AC_SUBST(arch_cppflags)
fi

AC_C_BIGENDIAN()

AC_PATH_PROG([gengetopt], [gengetopt])
test -z "$gengetopt" && AC_MSG_ERROR(
	[gengetopt is required to build this package])

AC_PATH_PROG([help2man], [help2man])
test -z "$help2man" && AC_MSG_ERROR(
	[help2man is required to build this package])

AC_PATH_PROG([install], [install])
test -z "$install" && AC_MSG_ERROR(
	[The install program is required to build this package])

AC_PROG_CC
AC_PROG_CPP

executables="recv filter audioc write afh play"
################################################################## clock_gettime
clock_gettime_lib=
AC_CHECK_LIB([c], [clock_gettime], [clock_gettime_lib=c], [
	AC_CHECK_LIB([rt], [clock_gettime], [clock_gettime_lib=rt], [], [])
])
if test -n "$clock_gettime_lib"; then
	AC_DEFINE(HAVE_CLOCK_GETTIME, 1, [
		define to 1 if clock_gettime() is supported])
fi
if test "$clock_gettime_lib" = "rt"; then
	AC_SUBST(clock_gettime_ldflags, -lrt)
fi
########################################################################### osl
have_osl=yes
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"
AC_ARG_WITH(osl_headers, [AS_HELP_STRING(--with-osl-headers=dir,
	[look for osl.h also in dir])])
if test -n "$with_osl_headers"; then
	osl_cppflags="-I$with_osl_headers"
	CPPFLAGS="$CPPFLAGS $osl_cppflags"
fi
AC_ARG_WITH(osl_libs, [AS_HELP_STRING(--with-osl-libs=dir,
	[look for libosl also in dir])])
if test -n "$with_osl_libs"; then
	osl_libs="-L$with_osl_libs"
	LDFLAGS="$LDFLAGS $osl_libs"
fi

AC_CHECK_HEADER(osl.h, [], have_osl=no)
AC_CHECK_LIB([osl], [osl_open_table], [], have_osl=no)
if test "$have_osl" = "yes"; then
	AC_SUBST(osl_cppflags)
	osl_ldflags="$osl_libs -losl"
	AC_SUBST(osl_ldflags)
else
	AC_MSG_WARN([libosl not found, can not build para_server.
Download libosl at
	http://people.tuebingen.mpg.de/maan/osl/
or execute
	git clone git://git.tuebingen.mpg.de/osl
	])
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### crypto
AC_ARG_ENABLE(cryptolib, [AS_HELP_STRING(--enable-cryptolib=lib, [
	Force using crypto library "lib". This package requires either
	openssl or libgcrypt being installed. Possible values for "lib"
	are thus "openssl" and "gcrypt". If this option is not given,
	openssl is tried first. If openssl was not found, gcrypt is
	tried next.])])

case "$enable_cryptolib" in
	"openssl") check_openssl="yes"; check_gcrypt="no";;
	"gcrypt") check_openssl="no"; check_gcrypt="yes";;
	"") check_openssl="yes"; check_gcrypt="yes";;
	*) AC_MSG_ERROR([invalid value "$enable_cryptolib" for --enable-cryptolib]);;
esac
###################################################################### openssl
if test "$check_openssl" = "yes"; then
	OLD_CPPFLAGS="$CPPFLAGS"
	OLD_LDFLAGS="$LDFLAGS"
	OLD_LIBS="$LIBS"
	have_openssl="yes"
	AC_ARG_WITH(openssl_headers, [AS_HELP_STRING(--with-openssl-headers=dir,
		[look for openssl headers also in dir])])
	if test -n "$with_openssl_headers"; then
		openssl_cppflags="-I$with_openssl_headers"
		CPPFLAGS="$CPPFLAGS $openssl_cppflags"
	fi
	AC_ARG_WITH(openssl_libs, [AS_HELP_STRING(--with-openssl-libs=dir,
		[look for openssl libraries also in dir])])
	if test -n "$with_openssl_libs"; then
		openssl_libs="-L$with_openssl_libs"
		LDFLAGS="$LDFLAGS $openssl_libs"
	fi
	AC_CHECK_HEADER(openssl/ssl.h, [], [have_openssl="no"])
	AC_CHECK_LIB([crypto], [RAND_bytes], [], [have_openssl="no"])
	if test "$have_openssl" = "no" -a -z "$with_openssl_headers$with_openssl_libs"; then
		# try harder: openssl is sometimes installed in /usr/local/ssl
		openssl_cppflags="-I/usr/local/ssl/include"
		CPPFLAGS="$CPPFLAGS $openssl_cppflags"
		openssl_libs="-L/usr/local/ssl/lib"
		LDFLAGS="$LDFLAGS $openssl_libs"
		# clear cache
		unset ac_cv_header_openssl_ssl_h 2> /dev/null
		unset ac_cv_lib_crypto_RAND_bytes 2> /dev/null
		AC_CHECK_HEADER(openssl/ssl.h, [have_openssl="yes"], [])
		if test "$have_openssl" = "yes"; then
			AC_CHECK_LIB([crypto], [RAND_bytes], [], [have_openssl="no"])
		fi
	fi
	if test "$have_openssl" = "yes"; then
		AC_DEFINE(HAVE_OPENSSL, 1, [define to 1 to turn on openssl support])
		AC_SUBST(openssl_cppflags)
		openssl_ldflags="$openssl_libs -lssl -lcrypto"
		AC_SUBST(openssl_ldflags)

		check_gcrypt="no"
	else
		AC_MSG_WARN([openssl libraries not found])
	fi
	CPPFLAGS="$OLD_CPPFLAGS"
	LDFLAGS="$OLD_LDFLAGS"
	LIBS="$OLD_LIBS"
else
	have_openssl="no"
fi
########################################################################### gcrypt
if test "$check_gcrypt" = "yes"; then
	OLD_CPPFLAGS="$CPPFLAGS"
	OLD_LDFLAGS="$LDFLAGS"
	OLD_LIBS="$LIBS"
	have_gcrypt="yes"
	AC_ARG_WITH(gcrypt_headers, [AS_HELP_STRING(--with-gcrypt-headers=dir,
		[look for gcrypt headers also in dir])])
	if test -n "$with_gcrypt_headers"; then
		gcrypt_cppflags="-I$with_gcrypt_headers"
		CPPFLAGS="$CPPFLAGS $gcrypt_cppflags"
	fi
	AC_ARG_WITH(gcrypt_libs, [AS_HELP_STRING(--with-gcrypt-libs=dir,
		[look for libgcrypt also in dir])])
	if test -n "$with_gcrypt_libs"; then
		gcrypt_libs="-L$with_gcrypt_libs"
		LDFLAGS="$LDFLAGS $gcrypt_libs"
	fi
	AC_CHECK_HEADER(gcrypt.h, [], [have_gcrypt="no"])
	AC_CHECK_LIB([gcrypt], [gcry_randomize], [], [have_gcrypt="no"])
	if test "$have_gcrypt" = "yes"; then
		AC_DEFINE(HAVE_GCRYPT, 1, [define to 1 to turn on gcrypt support])
		AC_SUBST(gcrypt_cppflags)
		gcrypt_ldflags="$gcrypt_libs -lgcrypt"
		AC_SUBST(gcrypt_ldflags)
	else
		AC_MSG_WARN([gcrypt library not found])
	fi
	CPPFLAGS="$OLD_CPPFLAGS"
	LDFLAGS="$OLD_LDFLAGS"
	LIBS="$OLD_LIBS"
else
	have_gcrypt="no"
fi
########################################################################### libsocket
AC_CHECK_LIB([c], [socket],
	[socket_ldlflags=],
	[socket_ldflags="-lsocket"]
)
AC_SUBST(socket_ldflags)
########################################################################### libnsl
AC_CHECK_LIB([c], [gethostbyname],
	[nsl_ldflags=],
	[nsl_ldflags="-lnsl"]
)
AC_SUBST(nsl_ldflags)
########################################################################### ucred
AC_MSG_CHECKING(for struct ucred)
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	#define _GNU_SOURCE
	#include <sys/types.h>
	#include <sys/socket.h>
]], [[
	struct ucred sucred; sucred.pid=0;
]])],[have_ucred=yes],[have_ucred=no])
AC_MSG_RESULT($have_ucred)
if test ${have_ucred} = yes; then
	AC_DEFINE(HAVE_UCRED, 1, define to 1 you have struct ucred)
fi
########################################################################### gengetopt
echo 'option "z" z "" flag off' | $gengetopt --file-name conftest-ggo &&
AC_CHECK_DECL(
	[gengetopt_args_info_description],
	[ggo_descriptions_declared=yes],
	[ggo_descriptions_declared=no],
	[#include "conftest-ggo.h"]
)
AC_SUBST(ggo_descriptions_declared)
########################################################################### curses
have_curses="yes"
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"
AC_ARG_WITH(curses_headers, [AS_HELP_STRING(--with-curses-headers=dir,
	[look for curses.h also in dir])])
if test -n "$with_curses_headers"; then
	curses_cppflags="-I$with_curses_headers"
	CPPFLAGS="$CPPFLAGS $curses_cppflags"
fi
AC_ARG_WITH(curses_libs, [AS_HELP_STRING(--with-curses-libs=dir,
	[look for libcurses also in dir])])
if test -n "$with_curses_libs"; then
	curses_libs="-L$with_curses_libs"
	LDFLAGS="$LDFLAGS $curses_libs"
fi
AC_CHECK_HEADER(curses.h, [], [
	have_curses="no"
])
curses_ldflags="$curses_libs"
AC_CHECK_LIB([ncursesw], [initscr],
	[curses_ldflags="$curses_libs -lncursesw"], [
		AC_CHECK_LIB([curses], [initscr],
			[curses_ldflags="$curses_libs -lcurses"],
			[have_curses="no"]
		)
	]
)
AC_SUBST(curses_cppflags)
AC_SUBST(curses_ldflags)
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### ip_mreqn
AC_MSG_CHECKING(for struct ip_mreqn (UDPv4 multicast))
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	#include <netdb.h>
	#include <net/if.h>
]], [[
	struct ip_mreqn mn;
	mn.imr_ifindex = 0;
]])],[have_ip_mreqn=yes],[have_ip_mreqn=no])
AC_MSG_RESULT($have_ip_mreqn)
if test ${have_ip_mreqn} = yes; then
	AC_DEFINE(HAVE_IP_MREQN, 1, define to 1 you have struct ip_mreqn)
fi
########################################################################### osx

AC_MSG_CHECKING(for CoreAudio (MacOs))
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	#include <CoreAudio/CoreAudio.h>
]], [[
	AudioDeviceID id;
]])],[have_core_audio=yes],[have_core_audio=no])
AC_MSG_RESULT($have_core_audio)
if test ${have_core_audio} = yes; then
	f1="-framework CoreAudio"
	f2="-framework AudioToolbox"
	f3="-framework AudioUnit"
	f4="-framework CoreServices"
	core_audio_ldflags="$f1 $f2 $f3 $f4"
	AC_SUBST(core_audio_ldflags)
	AC_DEFINE(HAVE_CORE_AUDIO, 1, define to 1 on Mac Os X)
fi
####################################################### ogg/vorbis/speex/opus
have_ogg="yes"
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"
AC_ARG_WITH(ogg_headers, [AS_HELP_STRING(--with-ogg-headers=dir,
	[look for ogg headers also in dir])])
AC_ARG_WITH(ogg_libs, [AS_HELP_STRING(--with-ogg-libs=dir,
	[look for ogg libs also in dir])])
AC_ARG_WITH(vorbis_headers, [AS_HELP_STRING(--with-vorbis-headers=dir,
	[look for vorbis headers also in dir])])
AC_ARG_WITH(vorbis_libs, [AS_HELP_STRING(--with-vorbis-libs=dir,
	[look for vorbis libs also in dir])])
AC_ARG_WITH(speex_headers, [AS_HELP_STRING(--with-speex-headers=dir,
	[look for speex headers also in dir])])
AC_ARG_WITH(speex_libs, [AS_HELP_STRING(--with-speex-libs=dir,
	[look for speex libs also in dir])])
AC_ARG_WITH(opus_headers, [AS_HELP_STRING(--with-opus-headers=dir,
	[look for opus headers also in dir])])
AC_ARG_WITH(opus_libs, [AS_HELP_STRING(--with-opus-libs=dir,
	[look for opus libs also in dir])])

if test -n "$with_ogg_headers"; then
	ogg_cppflags="-I$with_ogg_headers"
	CPPFLAGS="$CPPFLAGS $ogg_cppflags"
fi
if test -n "$with_ogg_libs"; then
	ogg_libs="-L$with_ogg_libs"
	LDFLAGS="$LDFLAGS $ogg_libs"
fi
AC_CHECK_HEADERS([ogg/ogg.h], [], [ have_ogg="no"; ])
AC_CHECK_LIB([ogg], [ogg_stream_init], [], [ have_ogg="no" ])
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"

have_vorbis="yes"
have_speex="yes"
have_opus="yes"
if test "$have_ogg" = "yes"; then
	OLD_CPPFLAGS="$CPPFLAGS"
	OLD_LDFLAGS="$LDFLAGS"
	OLD_LIBS="$LIBS"
	# vorbis
	if test -n "$with_vorbis_headers"; then
		vorbis_cppflags="-I$with_vorbis_headers"
		CPPFLAGS="$CPPFLAGS $vorbis_cppflags"
	fi
	if test -n "$with_vorbis_libs"; then
		vorbis_libs="-L$with_vorbis_libs"
		LDFLAGS="$LDFLAGS $vorbis_libs"
	fi
	AC_CHECK_HEADERS([vorbis/codec.h], [], [ have_vorbis="no" ])
	AC_CHECK_LIB([vorbis], [vorbis_info_init], [], [ have_vorbis="no" ])
	CPPFLAGS="$OLD_CPPFLAGS"
	LDFLAGS="$OLD_LDFLAGS"
	LIBS="$OLD_LIBS"

	# speex
	OLD_CPPFLAGS="$CPPFLAGS"
	OLD_LDFLAGS="$LDFLAGS"
	OLD_LIBS="$LIBS"
	if test -n "$with_speex_headers"; then
		speex_cppflags="-I$with_speex_headers"
		CPPFLAGS="$CPPFLAGS $speex_cppflags"
	fi
	if test -n "$with_speex_libs"; then
		speex_libs="-L$with_speex_libs"
		LDFLAGS="$LDFLAGS $speex_libs"
	fi
	AC_CHECK_LIB([speex], [speex_decoder_init], [], [ have_speex="no" ])
	AC_CHECK_HEADERS([speex/speex.h], [], [ have_speex="no" ])
	CPPFLAGS="$OLD_CPPFLAGS"
	LDFLAGS="$OLD_LDFLAGS"
	LIBS="$OLD_LIBS"

	# opus
	OLD_CPPFLAGS="$CPPFLAGS"
	OLD_LDFLAGS="$LDFLAGS"
	OLD_LIBS="$LIBS"
	if test -n "$with_opus_headers"; then
		opus_cppflags="-I$with_opus_headers"
		CPPFLAGS="$CPPFLAGS $opus_cppflags"
	fi
	if test -n "$with_opus_libs"; then
		opus_libs="-L$with_opus_libs"
		LDFLAGS="$LDFLAGS $opus_libs"
	fi
	AC_CHECK_LIB([opus], [opus_multistream_decode], [], [ have_opus="no" ])
	AC_CHECK_HEADERS([opus/opus.h], [], [ have_opus="no" ])
	CPPFLAGS="$OLD_CPPFLAGS"
	LDFLAGS="$OLD_LDFLAGS"
	LIBS="$OLD_LIBS"
else
	AC_MSG_WARN([vorbis/speex/opus depend on libogg, which was not detected])
	have_vorbis="no"
	have_speex="no"
	have_opus="no"
fi

msg="support in para_server/para_filter/para_afh"
if test "$have_vorbis" = "yes" || \
		test "$have_speex" = "yes" || \
		test "$have_opus" = "yes"; then
	AC_SUBST(ogg_cppflags)
	ogg_ldflags="$ogg_libs -logg"
	if test "$OSTYPE" = "Darwin"; then
		ogg_ldflags="-Wl,-bind_at_load $ogg_ldflags"
	fi
	AC_SUBST(ogg_ldflags)
fi
if test "$have_vorbis" = "yes"; then
	AC_DEFINE(HAVE_OGGVORBIS, 1, define to 1 to turn on ogg/vorbis support)
	AC_SUBST(vorbis_cppflags)
	vorbis_ldflags="$vorbis_libs -lvorbis -lvorbisfile"
	AC_SUBST(vorbis_ldflags)
fi
if test "$have_speex" = "yes"; then
	AC_DEFINE(HAVE_SPEEX, 1, define to 1 to turn on ogg/speex support)
	AC_SUBST(speex_cppflags)
	speex_ldflags="$speex_libs -lspeex"
	AC_SUBST(speex_ldflags)
else
	AC_MSG_WARN([no ogg/speex $msg])
fi
if test "$have_opus" = "yes"; then
	AC_DEFINE(HAVE_OPUS, 1, define to 1 to turn on ogg/opus support)
	AC_SUBST(opus_cppflags)
	opus_ldflags="$opus_libs -lopus"
	AC_SUBST(opus_ldflags)
	audio_format_handlers="$audio_format_handlers opus"
else
	AC_MSG_WARN([no ogg/opus $msg])
fi
########################################################################### faad
have_faad=yes
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"
AC_ARG_WITH(faad_headers, [AS_HELP_STRING(--with-faad-headers=dir,
	[look for neaacdec.h also in dir])])
if test -n "$with_faad_headers"; then
	faad_cppflags="-I$with_faad_headers"
	CPPFLAGS="$CPPFLAGS $faad_cppflags"
fi
AC_ARG_WITH(faad_libs, [AS_HELP_STRING(--with-faad-libs=dir,
	[look for libfaad also in dir])])
if test -n "$with_faad_libs"; then
	faad_libs="-L$with_faad_libs"
	LDFLAGS="$LDFLAGS $faad_libs"
fi
AC_CHECK_HEADER(neaacdec.h, [], have_faad=no)
AC_CHECK_LIB([faad], [NeAACDecOpen], [], have_faad=no)
if test "$have_faad" = "yes"; then
	AC_DEFINE(HAVE_FAAD, 1, define to 1 if you want to build the aacdec filter)
	AC_SUBST(faad_cppflags)
	faad_ldflags="$faad_libs -lfaad"
	AC_SUBST(faad_ldflags)
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### mad
have_mad="yes"
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

AC_ARG_WITH(mad_headers, [AS_HELP_STRING(--with-mad-headers=dir,
	[look for mad.h also in dir])])
if test -n "$with_mad_headers"; then
	mad_cppflags="-I$with_mad_headers"
	CPPFLAGS="$CPPFLAGS $mad_cppflags"
fi
AC_ARG_WITH(mad_libs, [AS_HELP_STRING(--with-mad-libs=dir,
	[look for libmad also in dir])])
if test -n "$with_mad_libs"; then
	mad_libs="-L$with_mad_libs"
	LDFLAGS="$LDFLAGS $mad_libs"
fi
AC_CHECK_HEADERS([mad.h], [], [
	have_mad="no"
])
AC_CHECK_LIB([mad], [mad_stream_init], [], [
	have_mad="no"
])
if test "$have_mad" = "yes"; then
	AC_DEFINE(HAVE_MAD, 1, define to 1 if you want to build the mp3dec filter)
	AC_SUBST(mad_cppflags)
	mad_ldflags="$mad_libs -lmad"
	AC_SUBST(mad_ldflags)
else
	AC_MSG_WARN([no mp3dec support in para_audiod/para_filter])
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
###################################################################### libid3tag
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

have_libid3tag="yes"
AC_ARG_WITH(id3tag_headers, [AS_HELP_STRING(--with-id3tag-headers=dir,
	[look for id3tag header files also in dir])])
if test -n "$with_id3tag_headers"; then
	id3tag_cppflags="-I$with_id3tag_headers"
	CPPFLAGS="$CPPFLAGS $id3tag_cppflags"
fi
AC_ARG_WITH(id3tag_libs, [AS_HELP_STRING(--with-id3tag-libs=dir,
	[look for id3tag libs also in dir])])
if test -n "$with_id3tag_libs"; then
	id3tag_libs="-L$with_id3tag_libs"
	LDFLAGS="$LDFLAGS $id3tag_libs"
fi

AC_MSG_CHECKING(for libid3tag)
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	#include <id3tag.h>
]], [[
	struct id3_tag t = {.flags = 0};
]])],[],[have_libid3tag=no])
AC_MSG_RESULT($have_libid3tag)

if test ${have_libid3tag} = yes; then
	AC_DEFINE(HAVE_LIBID3TAG, 1, define to 1 you have libid3tag)
	AC_SUBST(id3tag_cppflags)
	AC_SUBST(id3tag_ldflags, "$id3tag_libs -lid3tag -lz")
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### flac
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

have_flac="yes"
AC_ARG_WITH(flac_headers, [AS_HELP_STRING(--with-flac-headers=dir,
	[look for flac headers also in dir])])
if test -n "$with_flac_headers"; then
	flac_cppflags="-I$with_flac_headers"
	CPPFLAGS="$CPPFLAGS $flac_cppflags"
fi
AC_ARG_WITH(flac_libs, [AS_HELP_STRING(--with-flac-libs=dir,
	[look for flac libs also in dir])])
if test -n "$with_flac_libs"; then
	flac_libs="-L$with_flac_libs"
	LDFLAGS="$LDFLAGS $flac_libs"
fi
AC_CHECK_HEADER(FLAC/stream_decoder.h, [], have_flac=no)
AC_CHECK_LIB([FLAC], [FLAC__stream_decoder_init_file], [], [
	# nope, try again with -logg
	AC_CHECK_LIB([FLAC], [FLAC__stream_decoder_init_file], [],
		have_flac=no, -lm -logg)
	], -lm)
if test "$have_flac" = "yes"; then
	AC_DEFINE(HAVE_FLAC, 1, define to 1 if you want to build the flacdec filter)
	AC_SUBST(flac_cppflags)
	flac_ldflags="$flac_libs -lFLAC"
	AC_SUBST(flac_ldflags)
else
	AC_MSG_WARN([no flac support in para_audiod/para_filter/para_afh/para_server])
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### oss
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

have_oss="yes"
msg="=> will not build oss writer"

AC_CHECK_HEADER(sys/soundcard.h, [
	AC_CHECK_LIB(ossaudio, _oss_ioctl, [
			oss_ldflags="-lossaudio"
			AC_SUBST(oss_ldflags)
		]
	)
	],
	[
		have_oss="no"
		AC_MSG_WARN([no sys/soundcard.h $msg])
	]
)
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"

########################################################################### alsa
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

msg="=> no alsa support for para_audiod/para_write"
if test "$OSTYPE" != "Linux"; then
	have_alsa="no"
else
	have_alsa="yes"
fi
if test "$have_alsa" = "yes"; then
	AC_CHECK_HEADERS([alsa/asoundlib.h], [], [
		have_alsa="no"
		AC_MSG_WARN([no alsa/asoundlib $msg])
	])
fi

if test "$have_alsa" = "yes"; then
	AC_CHECK_LIB([asound], [snd_pcm_open], [], [
		have_alsa="no"
		AC_MSG_WARN([no libasound $msg])
	])
fi

if test "$have_alsa" = "yes"; then
	alsa_ldflags="-lasound"
	AC_SUBST(alsa_ldflags)
fi

CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### libao
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

have_ao="yes"
AC_ARG_WITH(ao_headers, [AS_HELP_STRING(--with-ao-headers=dir,
	[look for ao/ao.h also in dir])])
if test -n "$with_ao_headers"; then
	ao_cppflags="-I$with_ao_headers"
	CPPFLAGS="$CPPFLAGS $ao_cppflags"
fi
AC_ARG_WITH(ao_libs, [AS_HELP_STRING(--with-ao-libs=dir,
	[look for libao also in dir])])
if test -n "$with_ao_libs"; then
	ao_libs="-L$with_ao_libs"
	LDFLAGS="$LDFLAGS $ao_libs"
fi
msg="no libao support for para_audiod/para_write"
AC_CHECK_HEADERS([ao/ao.h], [
	], [
	have_ao="no"
	AC_MSG_WARN([ao.h not found, $msg])
])
if test "$have_ao" = "yes"; then
	AC_CHECK_LIB([ao], [ao_initialize], [], [
		have_ao="no"
		AC_MSG_WARN([ao lib not found or not working, $msg])
	])
fi
if test "$have_ao" = "yes"; then
	AC_CHECK_HEADERS([pthread.h], [
		], [
		have_ao="no"
		AC_MSG_WARN([pthread.h not found, $msg])
	])
fi
if test "$have_ao" = "yes"; then
	AC_CHECK_LIB([pthread], [pthread_create], [], [
		have_ao="no"
		AC_MSG_WARN([pthread lib not found or not working, $msg])
	])
fi
if test "$have_ao" = "yes"; then
	AC_SUBST(ao_cppflags)
	ao_ldflags="$ao_libs -lao -lpthread"
	AC_SUBST(ao_ldflags)
fi

CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
############################################################# readline
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

have_readline="yes"
AC_ARG_WITH(readline_headers, [AS_HELP_STRING(--with-readline-headers=dir,
	[look for libreadline header files also in dir])])
if test -n "$with_readline_headers"; then
	readline_cppflags="-I$with_readline_headers"
	CPPFLAGS="$CPPFLAGS $readline_cppflags"
fi

AC_ARG_WITH(readline_libs, [AS_HELP_STRING(--with-readline-libs=dir,
	[look for readline library also in dir])])
if test -n "$with_readline_libs"; then
	readline_libs="-L$with_readline_libs"
	LDFLAGS="$LDFLAGS $readline_libs"
fi
msg="no interactive cli support"
AC_CHECK_HEADERS([readline/readline.h], [
	], [
	have_readline="no"
	AC_MSG_WARN([readline/readline.h not found, $msg])
])

if test "$have_readline" = "yes"; then
	readline_ldflags="$readline_libs"
	AC_SEARCH_LIBS([rl_free_keymap], [readline], [
		readline_ldflags="$readline_ldflags -lreadline"
	], [have_readline="no"])
	if test "$have_readline" = "no"; then # try with -lcurses
                # clear cache
		AC_MSG_NOTICE([trying again with -lcurses])
                unset ac_cv_search_rl_free_keymap 2> /dev/null
		AC_SEARCH_LIBS([rl_free_keymap], [readline], [
			have_readline=yes
			readline_ldflags="$readline_ldflags -lreadline -lcurses"
		], [], [-lcurses])
	fi
	if test "$have_readline" = "no"; then # try with -ltermcap
                # clear cache
		AC_MSG_NOTICE([trying again with -ltermcap])
                unset ac_cv_search_rl_free_keymap 2> /dev/null
		AC_SEARCH_LIBS([rl_free_keymap], [readline], [
			have_readline=yes
			readline_ldflags="$readline_ldflags -lreadline -ltermcap"
		], [], [-ltermcap])
	fi
fi

if test "$have_readline" = "yes"; then
	AC_CHECK_DECL(
		[rl_free_keymap],
		[AC_DEFINE(RL_FREE_KEYMAP_DECLARED, 1, readline >= 6.3)],
		[],
		[
			#include <stdio.h>
			#include <readline/readline.h>
		]
	)
	AC_SUBST(readline_cppflags)
	AC_SUBST(readline_ldflags)
	AC_DEFINE(HAVE_READLINE, 1, define to 1 to turn on readline support)
else
	AC_MSG_WARN([libreadline not found or unusable])
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
############################################################# libsamplerate
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LDFLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

have_samplerate="yes"
AC_ARG_WITH(samplerate_headers, [AS_HELP_STRING(--with-samplerate-headers=dir,
	[look for samplerate headers also in dir])])
if test -n "$with_samplerate_headers"; then
	samplerate_cppflags="-I$with_samplerate_headers"
	CPPFLAGS="$CPPFLAGS $samplerate_cppflags"
fi
AC_ARG_WITH(samplerate_libs, [AS_HELP_STRING(--with-samplerate-libs=dir,
	[look for samplerate libs also in dir])])
if test -n "$with_samplerate_libs"; then
	samplerate_libs="-L$with_samplerate_libs"
	LDFLAGS="$LDFLAGS $samplerate_libs"
fi

AC_CHECK_HEADER(samplerate.h, [], have_samplerate=no)
AC_CHECK_LIB([samplerate], [src_process], [], have_samplerate=no, [])

if test "$have_samplerate" = "yes"; then
	AC_SUBST(samplerate_cppflags)
	samplerate_ldflags="$samplerate_libs -lsamplerate"
	AC_SUBST(samplerate_ldflags)
else
	AC_MSG_WARN([no resample support in para_audiod/para_filter])
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
######################################################################### server
if test \( "$have_openssl" = "yes" -o "$have_gcrypt" = "yes" \) \
	-a "$have_osl" = "yes" ; then

	build_server="yes"
	executables="$executables server"
	server_cmdline_objs="server"
	server_errlist_objs="
		server
		afh_common
		mp3_afh
		vss
		command
		net
		string
		signal
		time
		daemon
		http_send
		close_on_fork
		mm
		crypt_common
		ipc
		dccp_send
		fd
		user_list
		chunk_queue
		afs
		aft
		mood
		score
		attribute
		blob
		playlist
		sched
		acl
		send_common
		udp_send
		color
		fec
		wma_afh
		wma_common
		sideband
		version
		ggo
	"
	if test "$have_openssl" = "yes"; then
		server_errlist_objs="$server_errlist_objs crypt"
	fi
	if test "$have_gcrypt" = "yes"; then
		server_errlist_objs="$server_errlist_objs gcrypt"
	fi
	if test "$have_vorbis" = "yes" || \
			test "$have_speex" = "yes" || \
			test "$have_opus" = "yes"; then
		server_errlist_objs="$server_errlist_objs ogg_afh_common"
	fi
	if test "$have_vorbis" = "yes"; then
		server_errlist_objs="$server_errlist_objs ogg_afh"
	fi
	if test "$have_speex" = "yes"; then
		server_errlist_objs="$server_errlist_objs spx_afh spx_common"
	fi
	if test "$have_opus" = "yes"; then
		server_errlist_objs="$server_errlist_objs opus_afh opus_common"
	fi
	if test "$have_faad" = "yes"; then
		server_errlist_objs="$server_errlist_objs aac_afh aac_common"
	fi
	if test "$have_flac" = "yes"; then
		server_errlist_objs="$server_errlist_objs flac_afh"
	fi
	server_objs="add_cmdline($server_cmdline_objs) $server_errlist_objs"
	AC_SUBST(server_objs, add_dot_o($server_objs))
	AC_DEFINE_UNQUOTED(INIT_SERVER_ERRLISTS,
		objlist_to_errlist($server_errlist_objs), errors used by para_server)
else
	build_server="no"
fi
############################################################# client
if test "$have_openssl" = "yes" -o "$have_gcrypt" = "yes"; then
	build_client="yes"
	executables="$executables client"
	client_cmdline_objs="client"
	client_errlist_objs="
		client
		net
		string
		fd
		sched
		stdin
		stdout
		time
		sideband
		client_common
		buffer_tree
		crypt_common
		version
		ggo
	"
	if test "$have_openssl" = "yes"; then
		client_errlist_objs="$client_errlist_objs crypt"
	fi
	if test "$have_gcrypt" = "yes"; then
		client_errlist_objs="$client_errlist_objs gcrypt"
	fi
	if test "$have_readline" = "yes"; then
		client_errlist_objs="$client_errlist_objs interactive"
	fi
	client_objs="add_cmdline($client_cmdline_objs) $client_errlist_objs"
	AC_SUBST(client_objs, add_dot_o($client_objs))
	AC_DEFINE_UNQUOTED(INIT_CLIENT_ERRLISTS,
		objlist_to_errlist($client_errlist_objs), errors used by para_client)
else
	build_client="no"
fi
############################################################# audiod
if test "$have_openssl" = "yes" -o "$have_gcrypt" = "yes"; then
	build_audiod="yes"
	executables="$executables audiod"
	audiod_audio_formats="wma"
	audiod_cmdline_objs="$audiod_cmdline_objs
		audiod
		compress_filter
		http_recv
		dccp_recv
		file_write
		client
		amp_filter
		udp_recv
		prebuffer_filter
		sync_filter
	"
	audiod_errlist_objs="$audiod_errlist_objs
		audiod
		signal
		string
		daemon
		stat
		net
		crypt_common
		sideband
		time
		grab_client
		filter_common
		wav_filter
		compress_filter
		amp_filter
		http_recv
		dccp_recv
		recv_common
		fd
		sched
		write_common
		file_write
		audiod_command
		fecdec_filter
		client_common
		ggo
		udp_recv
		color
		fec
		prebuffer_filter
		version
		bitstream
		imdct
		wma_common
		wmadec_filter
		buffer_tree
		sync_filter
	"
	if test "$have_openssl" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs crypt"
	fi
	if test "$have_gcrypt" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs gcrypt"
	fi
	if test "$have_core_audio" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs osx_write ipc"
		audiod_cmdline_objs="$audiod_cmdline_objs osx_write"
	fi
	if test "$have_vorbis" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs oggdec_filter"
		audiod_audio_formats="$audiod_audio_formats ogg"
	fi
	if test "$have_speex" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs spxdec_filter spx_common"
		audiod_audio_formats="$audiod_audio_formats spx"
	fi
	if test "$have_opus" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs opusdec_filter opus_common"
		audiod_audio_formats="$audiod_audio_formats opus"
	fi
	if test "$have_faad" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs aacdec_filter aac_common"
		audiod_audio_formats="$audiod_audio_formats aac"
	fi
	if test "$have_mad" = "yes"; then
		audiod_audio_formats="$audiod_audio_formats mp3"
		audiod_cmdline_objs="$audiod_cmdline_objs mp3dec_filter"
		audiod_errlist_objs="$audiod_errlist_objs mp3dec_filter"
	fi
	if test "$have_flac" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs flacdec_filter"
		audiod_audio_formats="$audiod_audio_formats flac"
	fi
	if test "$have_oss" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs oss_write"
		audiod_cmdline_objs="$audiod_cmdline_objs oss_write"
	fi
	if test "$have_alsa" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs alsa_write"
		audiod_cmdline_objs="$audiod_cmdline_objs alsa_write"
	fi
	if test "$have_ao" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs ao_write"
		audiod_cmdline_objs="$audiod_cmdline_objs ao_write"
	fi
	if test "$have_samplerate" = "yes"; then
		audiod_errlist_objs="$audiod_errlist_objs resample_filter check_wav"
		audiod_cmdline_objs="$audiod_cmdline_objs resample_filter"
	fi
	audiod_objs="add_cmdline($audiod_cmdline_objs) $audiod_errlist_objs"
	AC_SUBST(audiod_objs, add_dot_o($audiod_objs))
	AC_DEFINE_UNQUOTED(INIT_AUDIOD_ERRLISTS, objlist_to_errlist($audiod_errlist_objs),
		errors used by para_audiod)

	enum="$(for i in $audiod_audio_formats; do printf "AUDIO_FORMAT_${i}, " | tr '[a-z]' '[A-Z]'; done)"
	AC_DEFINE_UNQUOTED(AUDIOD_AUDIO_FORMATS_ENUM, $enum NUM_AUDIO_FORMATS,
		enum of audio formats supported by audiod)
	names="$(for i in $audiod_audio_formats; do printf \"$i\",' ' ; done)"
	AC_DEFINE_UNQUOTED(AUDIOD_AUDIO_FORMAT_ARRAY, $names, array of audio formats supported by audiod)
else
	build_audiod="no"
fi
########################################################################### fade
if test "$have_oss" = "yes" -o "$have_alsa" = "yes"; then
	build_fade="yes"
	executables="$executables fade"
	fade_cmdline_objs="fade"
	fade_errlist_objs="fade exec string fd version ggo"
	if test "$have_oss" = "yes"; then
		fade_errlist_objs="$fade_errlist_objs oss_mix"
		mixers="${mixers}oss "
		default_mixer="OSS_MIX"
	fi
	if test "$have_alsa" = "yes"; then
		fade_errlist_objs="$fade_errlist_objs alsa_mix"
		mixers="${mixers}alsa "
		default_mixer="ALSA_MIX"
	fi
	fade_objs="add_cmdline($fade_cmdline_objs) $fade_errlist_objs"
	AC_SUBST(fade_objs, add_dot_o($fade_objs))
	AC_DEFINE_UNQUOTED(INIT_FADE_ERRLISTS,
		objlist_to_errlist($fade_errlist_objs),
		errors used by para_fade)
	enum="$(
		for i in $mixers; do
			printf "${i}_MIX, " | tr '[a-z]' '[A-Z]'
		done
	)"
	AC_DEFINE_UNQUOTED(MIXER_ENUM, $enum NUM_SUPPORTED_MIXERS,
		enum of supported mixers)
	AC_DEFINE_UNQUOTED(DEFAULT_MIXER, $default_mixer,
		use this mixer if none was specified)
	names="$(for i in $mixers; do printf \"$i\",' ' ; done)"
	AC_DEFINE_UNQUOTED(MIXER_NAMES, $names, supported mixer names)
	inits="$(
		for i in $mixers; do
			printf 'extern void '$i'_mix_init(struct mixer *); '
		done
	)"
	AC_DEFINE_UNQUOTED(DECLARE_MIXER_INITS, $inits,
		init functions of the supported mixers)
	array="$(for i in $mixers; do printf '{.init = '$i'_mix_init},'; done)"
	AC_DEFINE_UNQUOTED(MIXER_ARRAY, $array, array of supported mixers)
else
	build_fade="no"
	AC_MSG_WARN([no mixer support])
fi
########################################################################### gui
if test "$have_curses" = "yes"; then
	build_gui="yes"
	executables="$executables gui"
	gui_cmdline_objs="gui"
	gui_errlist_objs="
		exec
		signal
		string
		stat
		ringbuffer
		fd
		gui
		gui_theme
		time
		sched
		version
		ggo
	"
	gui_objs="add_cmdline($gui_cmdline_objs) $gui_errlist_objs"
	AC_SUBST(gui_objs, add_dot_o($gui_objs))
	AC_DEFINE_UNQUOTED(INIT_GUI_ERRLISTS,
		objlist_to_errlist($gui_errlist_objs), errors used by para_gui)
else
	build_gui="no"
	AC_MSG_WARN([no curses lib, cannot build para_gui])
fi
######################################################################## filter
filters="
	compress
	wav
	amp
	fecdec
	wmadec
	prebuffer
	sync
"
filter_errlist_objs="
	filter_common
	wav_filter
	compress_filter
	filter
	string
	stdin
	stdout
	sched
	fd
	amp_filter
	ggo
	fecdec_filter
	fec
	version
	prebuffer_filter
	time
	bitstream
	imdct
	wma_common
	wmadec_filter
	buffer_tree
	net
	sync_filter
"
filter_cmdline_objs="
	filter
	compress_filter
	amp_filter
	prebuffer_filter
	sync_filter
"

if test "$have_vorbis" = "yes"; then
	filters="$filters oggdec"
	filter_errlist_objs="$filter_errlist_objs oggdec_filter"
fi
if test "$have_speex" = "yes"; then
	filters="$filters spxdec"
	filter_errlist_objs="$filter_errlist_objs spxdec_filter spx_common"
fi
if test "$have_opus" = "yes"; then
	filters="$filters opusdec"
	filter_errlist_objs="$filter_errlist_objs opusdec_filter opus_common"
fi
if test "$have_faad" = "yes"; then
	filter_errlist_objs="$filter_errlist_objs aacdec_filter aac_common"
	filters="$filters aacdec"
fi
if test "$have_mad" = "yes"; then
	filter_cmdline_objs="$filter_cmdline_objs mp3dec_filter"
	filter_errlist_objs="$filter_errlist_objs mp3dec_filter"
	filters="$filters mp3dec"
fi
if test "$have_flac" = "yes"; then
	filter_errlist_objs="$filter_errlist_objs flacdec_filter"
	filters="$filters flacdec"
fi
if test "$have_samplerate" = "yes"; then
	filter_errlist_objs="$filter_errlist_objs resample_filter check_wav"
	filter_cmdline_objs="$filter_cmdline_objs resample_filter"
	filters="$filters resample"
fi
filters="$(echo $filters)"
AC_SUBST(filters)
filter_objs="add_cmdline($filter_cmdline_objs) $filter_errlist_objs"

AC_SUBST(filter_objs, add_dot_o($filter_objs))
AC_DEFINE_UNQUOTED(INIT_FILTER_ERRLISTS,
	objlist_to_errlist($filter_errlist_objs), errors used by para_filter)

enum="$(for i in $filters; do printf "${i}_FILTER, " | tr '[a-z]' '[A-Z]'; done)"
AC_DEFINE_UNQUOTED(FILTER_ENUM, $enum NUM_SUPPORTED_FILTERS,
	enum of supported filters)
inits="$(for i in $filters; do printf 'extern void '$i'_filter_init(struct filter *f); '; done)"
AC_DEFINE_UNQUOTED(DECLARE_FILTER_INITS, $inits, init functions of the supported filters)
array="$(for i in $filters; do printf '{.name = "'$i'", .init = '$i'_filter_init},'; done)"
AC_DEFINE_UNQUOTED(FILTER_ARRAY, $array, array of supported filters)
########################################################################## recv
recv_cmdline_objs="
	recv
	http_recv
	dccp_recv
	udp_recv
	afh_recv
"

recv_errlist_objs="
	http_recv
	recv_common
	recv
	time
	string
	net
	dccp_recv
	fd
	sched
	stdout
	ggo
	udp_recv
	buffer_tree
	afh_recv
	afh_common
	wma_afh
	wma_common
	mp3_afh
	version
"
if test "$have_vorbis" = "yes" || \
		test "$have_speex" = "yes" || \
		test "$have_opus" = "yes"; then
	recv_errlist_objs="$recv_errlist_objs ogg_afh_common"
fi
if test "$have_vorbis" = "yes"; then
	recv_errlist_objs="$recv_errlist_objs ogg_afh"
fi
if test "$have_speex" = "yes"; then
	recv_errlist_objs="$recv_errlist_objs spx_afh spx_common"
fi
if test "$have_opus" = "yes"; then
	recv_errlist_objs="$recv_errlist_objs opus_afh opus_common"
fi
if test "$have_faad" = "yes"; then
	recv_errlist_objs="$recv_errlist_objs aac_afh aac_common"
fi
if test "$have_flac" = "yes"; then
	recv_errlist_objs="$recv_errlist_objs flac_afh"
fi
recv_objs="add_cmdline($recv_cmdline_objs) $recv_errlist_objs"
AC_SUBST(receivers, "http dccp udp afh")
AC_SUBST(recv_objs, add_dot_o($recv_objs))
AC_DEFINE_UNQUOTED(INIT_RECV_ERRLISTS, objlist_to_errlist($recv_errlist_objs),
	errors used by para_recv)
########################################################################### afh
audio_format_handlers="mp3 wma"
afh_cmdline_objs="afh"
afh_errlist_objs="
	afh
	string
	fd
	mp3_afh
	afh_common
	time
	wma_afh
	wma_common
	version
	ggo
"
if test "$have_vorbis" = "yes" || \
		test "$have_speex" = "yes" || \
		test "$have_opus" = "yes"; then
	afh_errlist_objs="$afh_errlist_objs ogg_afh_common"
fi
if test "$have_vorbis" = "yes"; then
	afh_errlist_objs="$afh_errlist_objs ogg_afh"
	audio_format_handlers="$audio_format_handlers ogg"
fi
if test "$have_speex" = "yes"; then
	afh_errlist_objs="$afh_errlist_objs spx_afh spx_common"
	audio_format_handlers="$audio_format_handlers spx"
fi
if test "$have_opus" = "yes"; then
	afh_errlist_objs="$afh_errlist_objs opus_afh opus_common"
	audio_format_handlers="$audio_format_handlers opus"
fi
if test "$have_faad" = "yes"; then
	afh_errlist_objs="$afh_errlist_objs aac_common aac_afh"
	audio_format_handlers="$audio_format_handlers aac"
fi
if test "$have_flac" = "yes"; then
	afh_errlist_objs="$afh_errlist_objs flac_afh"
	audio_format_handlers="$audio_format_handlers flac"
fi

afh_objs="add_cmdline($afh_cmdline_objs) $afh_errlist_objs"

AC_SUBST(afh_objs, add_dot_o($afh_objs))
AC_DEFINE_UNQUOTED(INIT_AFH_ERRLISTS,
	objlist_to_errlist($afh_errlist_objs), errors used by para_afh)
########################################################################## play
play_errlist_objs="
	play
	fd
	sched
	ggo
	buffer_tree
	time
	string
	net
	afh_recv
	afh_common
	wma_afh
	wma_common
	mp3_afh
	recv_common
	udp_recv
	http_recv
	dccp_recv
	filter_common
	fec
	bitstream
	imdct
	wav_filter
	compress_filter
	amp_filter
	prebuffer_filter
	fecdec_filter
	wmadec_filter
	write_common
	file_write
	version
	sync_filter
"
play_cmdline_objs="
	http_recv
	dccp_recv
	udp_recv
	afh_recv
	compress_filter
	amp_filter
	prebuffer_filter
	file_write
	play
	sync_filter
"
if test "$have_core_audio" = "yes"; then
	play_errlist_objs="$play_errlist_objs osx_write ipc"
	play_cmdline_objs="$play_cmdline_objs osx_write"
fi
if test "$have_vorbis" = "yes" || \
		test "$have_speex" = "yes" || \
		test "$have_opus" = "yes"; then
	play_errlist_objs="$play_errlist_objs ogg_afh_common"
fi
if test "$have_vorbis" = "yes"; then
	play_errlist_objs="$play_errlist_objs oggdec_filter ogg_afh"
fi
if test "$have_speex" = "yes"; then
	play_errlist_objs="$play_errlist_objs spxdec_filter spx_afh spx_common"
fi
if test "$have_opus" = "yes"; then
	play_errlist_objs="$play_errlist_objs opusdec_filter opus_afh opus_common"
fi
if test "$have_faad" = "yes"; then
	play_errlist_objs="$play_errlist_objs aacdec_filter aac_afh aac_common"
fi
if test "$have_mad" = "yes"; then
	play_cmdline_objs="$play_cmdline_objs mp3dec_filter"
	play_errlist_objs="$play_errlist_objs mp3dec_filter"
fi
if test "$have_flac" = "yes"; then
	play_errlist_objs="$play_errlist_objs flacdec_filter flac_afh"
fi
if test "$have_oss" = "yes"; then
	play_errlist_objs="$play_errlist_objs oss_write"
	play_cmdline_objs="$play_cmdline_objs oss_write"
fi
if test "$have_alsa" = "yes"; then
	play_errlist_objs="$play_errlist_objs alsa_write"
	play_cmdline_objs="$play_cmdline_objs alsa_write"
fi
if test "$have_ao" = "yes"; then
	play_errlist_objs="$play_errlist_objs ao_write"
	play_cmdline_objs="$play_cmdline_objs ao_write"
fi
if test "$have_readline" = "yes"; then
	play_errlist_objs="$play_errlist_objs interactive"
fi
if test "$have_samplerate" = "yes"; then
	play_errlist_objs="$play_errlist_objs resample_filter check_wav"
	play_cmdline_objs="$play_cmdline_objs resample_filter"
fi

play_objs="add_cmdline($play_cmdline_objs) $play_errlist_objs"
AC_SUBST(play_objs, add_dot_o($play_objs))
AC_DEFINE_UNQUOTED(INIT_PLAY_ERRLISTS,
	objlist_to_errlist($play_errlist_objs), errors used by para_play)
######################################################################### write
write_cmdline_objs="
	write
	file_write
"
write_errlist_objs="
	write
	write_common
	file_write
	time
	fd
	string
	sched
	stdin
	buffer_tree
	ggo
	check_wav
	version
"
writers="file"
default_writer="FILE_WRITE"

if test "$have_core_audio" = "yes"; then
	write_errlist_objs="$write_errlist_objs osx_write ipc"
	write_cmdline_objs="$write_cmdline_objs osx_write"
	writers="$writers osx"
	default_writer="OSX_WRITE"
fi
if test "$have_ao" = "yes"; then
	write_errlist_objs="$write_errlist_objs ao_write"
	write_cmdline_objs="$write_cmdline_objs ao_write"
	writers="$writers ao"
	default_writer="AO_WRITE"
fi
if test "$have_oss" = "yes"; then
	write_errlist_objs="$write_errlist_objs oss_write"
	write_cmdline_objs="$write_cmdline_objs oss_write"
	writers="$writers oss"
	default_writer="OSS_WRITE"
fi
if test "$have_alsa" = "yes"; then
	write_errlist_objs="$write_errlist_objs alsa_write"
	write_cmdline_objs="$write_cmdline_objs alsa_write"
	writers="$writers alsa"
	default_writer="ALSA_WRITE"
fi
AC_SUBST(writers)
write_objs="add_cmdline($write_cmdline_objs) $write_errlist_objs"
AC_SUBST(write_objs, add_dot_o($write_objs))
AC_DEFINE_UNQUOTED(INIT_WRITE_ERRLISTS,
	objlist_to_errlist($write_errlist_objs), errors used by para_write)
enum="$(for i in $writers; do printf "${i}_WRITE, " | tr '[a-z]' '[A-Z]'; done)"
AC_DEFINE_UNQUOTED(WRITER_ENUM, $enum NUM_SUPPORTED_WRITERS,
	enum of supported writers)
AC_DEFINE_UNQUOTED(DEFAULT_WRITER, $default_writer, use this writer if none was specified)
names="$(for i in $writers; do printf \"$i\",' ' ; done)"
AC_DEFINE_UNQUOTED(WRITER_NAMES, $names, supported writer names)
inits="$(for i in $writers; do printf 'extern void '$i'_write_init(struct writer *); '; done)"
AC_DEFINE_UNQUOTED(DECLARE_WRITER_INITS, $inits, init functions of the supported writers)
array="$(for i in $writers; do printf '{.init = '$i'_write_init},'; done)"
AC_DEFINE_UNQUOTED(WRITER_ARRAY, $array, array of supported writers)
######################################################################## audioc
audioc_cmdline_objs="audioc"
audioc_errlist_objs="
	audioc
	string
	net
	fd
	version
	ggo
"
if test "$have_readline" = "yes"; then
	audioc_errlist_objs="$audioc_errlist_objs
		buffer_tree
		interactive
		sched
		time
	"
fi
audioc_objs="add_cmdline($audioc_cmdline_objs) $audioc_errlist_objs"
AC_SUBST(audioc_objs, add_dot_o($audioc_objs))
AC_DEFINE_UNQUOTED(INIT_AUDIOC_ERRLISTS,
	objlist_to_errlist($audioc_errlist_objs), errors used by para_audioc)
############################################################# error2.h
# these are always built
all_errlist_objs="
	$recv_errlist_objs
	$filter_errlist_objs
	$audioc_errlist_objs
	$write_errlist_objs
	$afh_errlist_objs
	$play_errlist_objs
"

# optional executables
if test "$build_server" = "yes"; then
	all_errlist_objs="$all_errlist_objs $server_errlist_objs"
fi
if test "$build_gui" = "yes"; then
	all_errlist_objs="$all_errlist_objs $gui_errlist_objs"
fi
if test "$build_fade" = "yes"; then
	all_errlist_objs="$all_errlist_objs $fade_errlist_objs"
fi
if test "$build_client" = "yes"; then
	all_errlist_objs="$all_errlist_objs $client_errlist_objs"
fi
if test "$build_audiod" = "yes"; then
	all_errlist_objs="$all_errlist_objs $audiod_errlist_objs"
fi

all_errlist_objs="$(echo $all_errlist_objs | tr ' ' '\n' | sort | uniq)"

object_executable_matrix=
for i in $executables; do
	eval objs=\$${i}_errlist_objs
	object_executable_matrix="$object_executable_matrix $i: $objs"
done
# use echo to replace newlines by space
AC_SUBST(object_executable_matrix, $(echo $object_executable_matrix))

SS=$(for obj in $all_errlist_objs; do
	printf '%s' " SS_$obj,"; done | tr 'a-z' 'A-Z')
AC_DEFINE_UNQUOTED(DEFINE_ERRLIST_OBJECT_ENUM,
	[enum {$SS NUM_SS}],
	[list of all objects that use the paraslash error facility]
)
################################################################## status items

status_items="basename status num_played mtime bitrate frequency file_size
status_flags format score techinfo afs_mode
attributes_txt decoder_flags audiod_status play_time attributes_bitmap
offset seconds_total stream_start current_time audiod_uptime image_id
lyrics_id duration directory lyrics_name image_name path hash channels
last_played num_chunks chunk_time amplification artist title year album
comment"

result=
for i in $status_items; do
	result="$result SI_$(echo $i | tr 'a-z' 'A-Z'), "
done
AC_DEFINE_UNQUOTED(STATUS_ITEM_ENUM, [$result],
	[enum of all status items])

result=
for i in $status_items; do
	result="$result \"$i\", "
done
AC_DEFINE_UNQUOTED(STATUS_ITEM_ARRAY, [$result],
	[char * array of all status items])

AC_DEFINE_UNQUOTED(AUDIO_FORMAT_HANDLERS, "$audio_format_handlers",
	[formats supported by para_server and para_afh])

AC_SUBST(executables)

AC_OUTPUT
AC_MSG_NOTICE([
paraslash configuration:
~~~~~~~~~~~~~~~~~~~~~~~~
unix socket credentials: $have_ucred
readline (interactive CLIs): $have_readline
audio formats handlers: $audio_format_handlers
id3 version2 support: $have_libid3tag
filters: $filters
writers: $writers

para_fade: $build_fade
para_server: $build_server
para_gui: $build_gui
para_fade: $build_fade
para_client: $build_client
para_audiod: $build_audiod
])