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

AC_PREREQ([2.61])


AC_INIT([paraslash],[git],[maan@systemlinux.org])
AC_CONFIG_HEADER([config.h])

AC_CONFIG_FILES([Makefile])
AC_DEFUN([add_dot_o],[$(for i in $@; do printf "$i.o "; done)])
AC_DEFUN([add_para],[$(for i in $@; do printf "para_$i "; done)])
AC_DEFUN([objlist_to_errlist],[$(for i in $@; do printf "DEFINE_ERRLIST($(echo $i| tr 'a-z' 'A-Z'));"; done) [const char **para_errlist[[]]] = {$(for i in $@; do printf "PARA_ERRLIST($(echo $i | tr 'a-z' 'A-Z')), "; done) }])
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_PROG_CC
AC_PROG_CPP
AC_PROG_INSTALL
AC_SUBST(install_sh, [$INSTALL])
AC_REPLACE_FNMATCH

AC_HEADER_DIRENT
AC_HEADER_STDC
AC_HEADER_SYS_WAIT
AC_HEADER_STDBOOL
AC_CHECK_HEADERS([arpa/inet.h ctype.h fcntl.h limits.h netdb.h netinet/in.h \
	stdlib.h string.h sys/socket.h sys/time.h sys/timeb.h sys/un.h \
	sys/ipc.h unistd.h utime.h stddef.h],
	[], [AC_MSG_ERROR([$ac_header not found])])

# Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST
AC_C_INLINE
AC_TYPE_OFF_T
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_HEADER_TIME
AC_STRUCT_TM
AC_TYPE_INT8_T
AC_TYPE_INT16_T
AC_TYPE_INT32_T
AC_TYPE_INT64_T
AC_TYPE_MODE_T
AC_TYPE_SSIZE_T
AC_TYPE_UID_T
AC_TYPE_UINT8_T
AC_TYPE_UINT16_T
AC_TYPE_UINT32_T
AC_TYPE_UINT64_T

# Checks for library functions.
AC_FUNC_FORK
AC_PROG_GCC_TRADITIONAL
AC_FUNC_MALLOC
AC_FUNC_MEMCMP
AC_FUNC_MKTIME
AC_FUNC_MMAP
AC_FUNC_REALLOC
AC_FUNC_SELECT_ARGTYPES
AC_FUNC_STAT
AC_FUNC_STRFTIME
AC_FUNC_VPRINTF
AC_FUNC_CLOSEDIR_VOID
AC_FUNC_LSTAT

AC_CHECK_FUNCS([atexit dup2 memchr memmove memset \
	regcomp select strchr strdup strerror strstr strtol uname \
	fchdir gettimeofday localtime_r munmap strcasecmp strcspn \
	strncasecmp strrchr strspn alarm mkdir inet_ntoa socket], [],
	[AC_MSG_ERROR([function not found, cannot live without it])])

AC_DEFUN([add_cmdline],[$(for i in $@; do printf "${i}.cmdline "; done)])


all_errlist_objs="mp3_afh afh_common net string signal time daemon
	stat afh amp_filter fd ringbuffer sched audiod
	grab_client filter_common wav_filter compress_filter http_recv
	dccp_recv recv_common write_common file_write audiod_command
	client_common recv stdout filter stdin audioc write client
	exec send_common ggo udp_recv color fec fecdec_filter
	prebuffer_filter bitstream imdct check_wav
	wma_afh wma_common wmadec_filter buffer_tree crypt_common
	gui gui_theme sideband afh_recv play"

executables="recv filter audioc write client afh audiod play"

recv_cmdline_objs="add_cmdline(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
"

recv_ldflags=""

filter_cmdline_objs="add_cmdline(filter compress_filter amp_filter prebuffer_filter)"
filter_errlist_objs="filter_common wav_filter compress_filter filter string
	stdin stdout sched fd amp_filter ggo fecdec_filter fec
	prebuffer_filter time bitstream imdct wma_common wmadec_filter buffer_tree"
filter_ldflags="-lm"
filters=" compress wav amp fecdec wmadec prebuffer"

audioc_cmdline_objs="add_cmdline(audioc)"
audioc_errlist_objs="audioc string net fd"
audioc_ldflags=""

audiod_cmdline_objs="add_cmdline(audiod compress_filter http_recv dccp_recv file_write client amp_filter udp_recv prebuffer_filter)"
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
	bitstream imdct wma_common wmadec_filter buffer_tree"
audiod_ldflags="-lm"
audiod_audio_formats="wma"

afh_cmdline_objs="add_cmdline(afh)"
afh_errlist_objs="afh string fd mp3_afh afh_common time wma_afh wma_common"
afh_ldflags=""

write_cmdline_objs="add_cmdline(write file_write)"
write_errlist_objs="write write_common file_write time fd string sched stdin
	buffer_tree ggo check_wav"
write_ldflags=""
writers=" file"
default_writer="FILE_WRITE"

client_cmdline_objs="add_cmdline(client)"
client_errlist_objs="client net string fd sched stdin stdout time sideband
	client_common buffer_tree crypt_common"
client_ldflags=""

gui_cmdline_objs="add_cmdline(gui)"
gui_errlist_objs="exec signal string stat ringbuffer fd gui gui_theme"
gui_objs="$gui_cmdline_objs $gui_errlist_objs"
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
"
play_cmdline_objs="add_cmdline(http_recv dccp_recv udp_recv afh_recv compress_filter amp_filter prebuffer_filter file_write play)"
play_ldflags="-lm"
########################################################################### snprintf
# ===========================================================================
#        http://www.nongnu.org/autoconf-archive/ax_func_snprintf.html
# ===========================================================================
#
# SYNOPSIS
#
#   AX_FUNC_SNPRINTF
#
# DESCRIPTION
#
#   Checks for a fully C99 compliant snprintf, in particular checks whether
#   it does bounds checking and returns the correct string length; does the
#   same check for vsnprintf. If no working snprintf or vsnprintf is found,
#   it prints an error message and aborts.
#
# LICENSE
#
#   Copyright (c) 2008 Ruediger Kuhlmann <info@ruediger-kuhlmann.de>
#
#   Copying and distribution of this file, with or without modification, are
#   permitted in any medium without royalty provided the copyright notice
#   and this notice are preserved.

AU_ALIAS([AC_FUNC_SNPRINTF], [AX_FUNC_SNPRINTF])
AC_DEFUN([AX_FUNC_SNPRINTF],
[AC_CHECK_FUNCS(snprintf vsnprintf)
AC_MSG_CHECKING(for working snprintf)
AC_CACHE_VAL(ac_cv_have_working_snprintf,
[AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <stdio.h>

int main(void)
{
    char bufs[5] = { 'x', 'x', 'x', '\0', '\0' };
    char bufd[5] = { 'x', 'x', 'x', '\0', '\0' };
    int i;
    i = snprintf (bufs, 2, "%s", "111");
    if (strcmp (bufs, "1")) exit (1);
    if (i != 3) exit (1);
    i = snprintf (bufd, 2, "%d", 111);
    if (strcmp (bufd, "1")) exit (1);
    if (i != 3) exit (1);
    exit(0);
}]])],[ac_cv_have_working_snprintf=yes],
[ac_cv_have_working_snprintf=no],[ac_cv_have_working_snprintf=cross])])
AC_MSG_RESULT([$ac_cv_have_working_snprintf])
AC_MSG_CHECKING(for working vsnprintf)
AC_CACHE_VAL(ac_cv_have_working_vsnprintf,
[AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdio.h>
#include <stdarg.h>

int my_vsnprintf (char *buf, const char *tmpl, ...)
{
    int i;
    va_list args;
    va_start (args, tmpl);
    i = vsnprintf (buf, 2, tmpl, args);
    va_end (args);
    return i;
}

int main(void)
{
    char bufs[5] = { 'x', 'x', 'x', '\0', '\0' };
    char bufd[5] = { 'x', 'x', 'x', '\0', '\0' };
    int i;
    i = my_vsnprintf (bufs, "%s", "111");
    if (strcmp (bufs, "1")) exit (1);
    if (i != 3) exit (1);
    i = my_vsnprintf (bufd, "%d", 111);
    if (strcmp (bufd, "1")) exit (1);
    if (i != 3) exit (1);
    exit(0);
}]])],[ac_cv_have_working_vsnprintf=yes],
[ac_cv_have_working_vsnprintf=no],[ac_cv_have_working_vsnprintf=cross])])
AC_MSG_RESULT([$ac_cv_have_working_vsnprintf])
if test x$ac_cv_have_working_snprintf$ac_cv_have_working_vsnprintf != "xyesyes"; then
AC_MSG_ERROR([fatal: buggy snprintf() detected])
fi])
AX_FUNC_SNPRINTF()
################################################################## 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_LD_FLAGS="$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" = "no"; then
	AC_MSG_WARN([libosl not found, can not build para_server.
Download libosl at
	http://systemlinux.org/~maan/osl
or execute
	git clone git://git.tuebingen.mpg.de/osl
	])
else
	extras="$extras server"
	executables="$executables server"
	server_cmdline_objs="add_cmdline(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"
	all_errlist_objs="$all_errlist_objs server vss command
		http_send close_on_fork mm ipc dccp_send user_list
		chunk_queue afs aft mood score attribute blob playlist
		acl udp_send"

	server_ldflags=""
	audio_format_handlers="mp3 wma"
	AC_SUBST(osl_cppflags)
	server_ldflags="$server_ldflags $osl_libs -losl"
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_LD_FLAGS="$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_libs="$openssl_libs -lssl -lcrypto"
		server_ldflags="$server_ldflags $openssl_libs"
		client_ldflags="$client_ldflags $openssl_libs"
		audiod_ldflags="$audiod_ldflags $openssl_libs"

		all_errlist_objs="$all_errlist_objs crypt"
		server_errlist_objs="$server_errlist_objs crypt"
		client_errlist_objs="$client_errlist_objs crypt"
		audiod_errlist_objs="$audiod_errlist_objs crypt"

		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_LD_FLAGS="$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_libs="$gcrypt_libs -lgcrypt"
		server_ldflags="$server_ldflags $gcrypt_libs"
		client_ldflags="$client_ldflags $gcrypt_libs"
		audiod_ldflags="$audiod_ldflags $gcrypt_libs"

		all_errlist_objs="$all_errlist_objs gcrypt"
		server_errlist_objs="$server_errlist_objs gcrypt"
		client_errlist_objs="$client_errlist_objs gcrypt"
		audiod_errlist_objs="$audiod_errlist_objs gcrypt"
	else
		AC_MSG_WARN([gcrypt library not found])
	fi
	CPPFLAGS="$OLD_CPPFLAGS"
	LDFLAGS="$OLD_LDFLAGS"
	LIBS="$OLD_LIBS"
else
	have_gcrypt="no"
fi
###########################################################################
if test "$have_openssl" = "no" -a "$have_gcrypt" = "no"; then
	AC_MSG_ERROR([neither openssl nor gcrypt usable])
fi
########################################################################### libsocket
AC_CHECK_LIB([c], [socket],
	[socket_lib=],
	[socket_lib="-lsocket"]
)
server_ldflags="$server_ldflags $socket_lib"
client_ldflags="$client_ldflags $socket_lib"
audioc_ldflags="$audioc_ldflags $socket_lib"
audiod_ldflags="$audiod_ldflags $socket_lib"
recv_ldflags="$recv_ldflags $socket_lib"
AC_SEARCH_LIBS([connect],[socket],[],[
	AC_MSG_ERROR([Fatal: Did not find connect().])
],[])
########################################################################### libnsl
AC_CHECK_LIB([c], [gethostbyname],
	[nsl_lib=],
	[nsl_lib="-lnsl"]
)
server_ldflags="$server_ldflags $nsl_lib"
client_ldflags="$client_ldflags $nsl_lib"
audioc_ldflags="$audioc_ldflags $nsl_lib"
recv_ldflags="$recv_ldflags $nsl_lib"
AC_SEARCH_LIBS([inet_ntoa],[nsl],[],[
	AC_MSG_ERROR([Fatal: Did not find inet_ntoa().])
],[])
########################################################################### 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

########################################################################### curses
have_curses="yes"
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LD_FLAGS="$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"
])
AC_CHECK_LIB([curses], [initscr], [], [
	have_curses="no"
])
if test "$have_curses" = "yes"; then
	AC_SUBST(curses_cppflags)
	AC_DEFINE(HAVE_NCURSES, 1, [define to 1 to turn on curses support])
	extras="$extras gui"
	executables="$executables gui"
else
	AC_MSG_WARN([no curses lib, cannot build para_gui])
fi
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"
	f="$f1 $f2 $f3 $f4"

	all_errlist_objs="$all_errlist_objs osx_write"
	# ipc is linked into para_server server and into the osx writer. If osl
	# was not found, para_server will not be built and ipc has not yet been
	# added to the list of all objects, so we must add it here.
	if test "$have_osl" = "no"; then
		all_errlist_objs="$all_errlist_objs ipc"
	fi
	audiod_errlist_objs="$audiod_errlist_objs osx_write ipc"
	audiod_cmdline_objs="$audiod_cmdline_objs osx_write.cmdline"
	audiod_ldflags="$audiod_ldflags $f"

	play_errlist_objs="$play_errlist_objs osx_write ipc"
	play_cmdline_objs="$play_cmdline_objs osx_write.cmdline"
	play_ldflags="$play_ldflags $f"

	write_errlist_objs="$write_errlist_objs osx_write ipc"
	write_cmdline_objs="$write_cmdline_objs osx_write.cmdline"
	write_ldflags="$write_ldflags $f"
	writers="$writers osx"
	default_writer="OSX_WRITE"
	AC_DEFINE(HAVE_CORE_AUDIO, 1, define to 1 on Mac Os X)
fi
########################################################### ogg/vorbis/speex
have_ogg="yes"
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LD_FLAGS="$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])])

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

have_vorbis="yes"
have_speex="yes"
if test "$have_ogg" = "yes"; then
	# 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" ])

	# speex
	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" ])
else
	AC_MSG_WARN([vorbis/speex depend on libogg, which was not detected])
	have_vorbis="no"
	have_speex="no"
fi

msg="support in para_server/para_filter/para_afh"
if test "$have_vorbis" = "yes" || test "$have_speex" = "yes"; then
	AC_SUBST(ogg_cppflags)
	ogg_libs="$ogg_libs -logg"
	if test "$OSTYPE" = "Darwin"; then
		ogg_libs="-Wl,-bind_at_load $ogg_libs"
	fi
	server_ldflags="$server_ldflags $ogg_libs"
	filter_ldflags="$filter_ldflags $ogg_libs"
	audiod_ldflags="$audiod_ldflags $ogg_libs"
	play_ldflags="$play_ldflags $ogg_libs"
	afh_ldflags="$afh_ldflags $ogg_libs"
	recv_ldflags="$recv_ldflags $ogg_libs"
	all_errlist_objs="$all_errlist_objs ogg_afh_common"
	afh_errlist_objs="$afh_errlist_objs ogg_afh_common"
	recv_errlist_objs="$recv_errlist_objs ogg_afh_common"
	server_errlist_objs="$server_errlist_objs ogg_afh_common"
	play_errlist_objs="$play_errlist_objs ogg_afh_common"
fi
if test "$have_vorbis" = "yes"; then
	all_errlist_objs="$all_errlist_objs oggdec_filter ogg_afh"
	AC_DEFINE(HAVE_OGGVORBIS, 1, define to 1 to turn on ogg/vorbis support)
	filters="$filters oggdec"
	vorbis_libs="-lvorbis -lvorbisfile"
	server_ldflags="$server_ldflags $vorbis_libs"
	filter_ldflags="$filter_ldflags $vorbis_libs"
	audiod_ldflags="$audiod_ldflags $vorbis_libs"
	play_ldflags="$play_ldflags $vorbis_libs"
	afh_ldflags="$afh_ldflags $vorbis_libs"
	recv_ldflags="$recv_ldflags $vorbis_libs"

	server_errlist_objs="$server_errlist_objs ogg_afh"
	filter_errlist_objs="$filter_errlist_objs oggdec_filter"
	audiod_errlist_objs="$audiod_errlist_objs oggdec_filter"
	play_errlist_objs="$play_errlist_objs oggdec_filter ogg_afh"
	afh_errlist_objs="$afh_errlist_objs ogg_afh"
	recv_errlist_objs="$recv_errlist_objs ogg_afh"

	audiod_audio_formats="$audiod_audio_formats ogg"
	audio_format_handlers="$audio_format_handlers ogg"
else
	AC_MSG_WARN([no ogg/vorbis $msg])
fi
if test "$have_speex" = "yes"; then
	all_errlist_objs="$all_errlist_objs spxdec_filter spx_afh spx_common"
	AC_DEFINE(HAVE_SPEEX, 1, define to 1 to turn on ogg/speex support)
	filters="$filters spxdec"
	speex_libs="-lspeex"
	server_ldflags="$server_ldflags $speex_libs"
	filter_ldflags="$filter_ldflags $speex_libs"
	audiod_ldflags="$audiod_ldflags $speex_libs"
	play_ldflags="$play_ldflags $speex_libs"
	afh_ldflags="$afh_ldflags $speex_libs"
	recv_ldflags="$recv_ldflags $speex_libs"

	server_errlist_objs="$server_errlist_objs spx_afh spx_common"
	filter_errlist_objs="$filter_errlist_objs spxdec_filter spx_common"
	audiod_errlist_objs="$audiod_errlist_objs spxdec_filter spx_common"
	play_errlist_objs="$play_errlist_objs spxdec_filter spx_afh spx_common"
	afh_errlist_objs="$afh_errlist_objs spx_afh spx_common"
	recv_errlist_objs="$recv_errlist_objs spx_afh spx_common"

	audiod_audio_formats="$audiod_audio_formats spx"
	audio_format_handlers="$audio_format_handlers spx"
else
	AC_MSG_WARN([no ogg/speex $msg])
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### faad
have_faad=yes
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LD_FLAGS="$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)
	all_errlist_objs="$all_errlist_objs aac_common aacdec_filter aac_afh"
	filter_errlist_objs="$filter_errlist_objs aacdec_filter aac_common"
	afh_errlist_objs="$afh_errlist_objs aac_common aac_afh"
	audiod_errlist_objs="$audiod_errlist_objs aacdec_filter aac_common"
	play_errlist_objs="$play_errlist_objs aacdec_filter aac_afh aac_common"
	server_errlist_objs="$server_errlist_objs aac_afh aac_common"
	recv_errlist_objs="$recv_errlist_objs aac_afh aac_common"

	server_ldflags="$server_ldflags $faad_libs -lfaad"
	filter_ldflags="$filter_ldflags $faad_libs -lfaad"
	audiod_ldflags="$audiod_ldflags $faad_libs -lfaad"
	play_ldflags="$play_ldflags $faad_libs -lfaad"
	afh_ldflags="$afh_ldflags $faad_libs -lfaad"
	recv_ldflags="$afh_ldflags $faad_libs -lfaad"

	audiod_audio_formats="$audiod_audio_formats aac"
	audio_format_handlers="$audio_format_handlers aac"
	filters="$filters aacdec"
	AC_SUBST(faad_cppflags)
else
	AC_MSG_WARN([no aac support in para_audiod/para_filter])
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### mad
have_mad="yes"
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LD_FLAGS="$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)
	filter_cmdline_objs="$filter_cmdline_objs add_cmdline(mp3dec_filter)"
	audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(mp3dec_filter)"
	play_cmdline_objs="$play_cmdline_objs add_cmdline(mp3dec_filter)"
	all_errlist_objs="$all_errlist_objs mp3dec_filter"
	filter_errlist_objs="$filter_errlist_objs mp3dec_filter"
	audiod_errlist_objs="$audiod_errlist_objs mp3dec_filter"
	play_errlist_objs="$play_errlist_objs mp3dec_filter"
	filter_ldflags="$filter_ldflags $mad_libs -lmad"
	audiod_ldflags="$audiod_ldflags $mad_libs -lmad"
	play_ldflags="$play_ldflags $mad_libs -lmad"
	audiod_audio_formats="$audiod_audio_formats mp3"
	filters="$filters mp3dec"
	AC_SUBST(mad_cppflags)
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_LD_FLAGS="$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)
	server_ldflags="$server_ldflags $id3tag_libs -lid3tag -lz"
	afh_ldflags="$afh_ldflags $id3tag_libs -lid3tag -lz"
	play_ldflags="$play_ldflags -lz"
	recv_ldflags="$recv_ldflags $id3tag_libs -lid3tag"
	play_ldflags="$play_ldflags $id3tag_libs -lid3tag"
	AC_SUBST(id3tag_cppflags)
else
	AC_MSG_WARN([no support for id3v2 tags])
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### flac
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LD_FLAGS="$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], [], have_flac=no, -logg -lm)
if test "$have_flac" = "yes"; then
	AC_DEFINE(HAVE_FLAC, 1, define to 1 if you want to build the flacdec filter)
	all_errlist_objs="$all_errlist_objs flacdec_filter flac_afh"
	filter_errlist_objs="$filter_errlist_objs flacdec_filter"
	audiod_errlist_objs="$audiod_errlist_objs flacdec_filter"
	play_errlist_objs="$play_errlist_objs flacdec_filter flac_afh"
	afh_errlist_objs="$afh_errlist_objs flac_afh"
	server_errlist_objs="$server_errlist_objs flac_afh"
	recv_errlist_objs="$recv_errlist_objs flac_afh"
	filter_ldflags="$filter_ldflags $flac_libs -lFLAC"
	audiod_ldflags="$audiod_ldflags $flac_libs -lFLAC"
	play_ldflags="$play_ldflags $flac_libs -lFLAC"
	server_ldflags="$server_ldflags $flac_libs -lFLAC"
	afh_ldflags="$afh_ldflags $flac_libs -lFLAC"
	recv_ldflags="$afh_ldflags $flac_libs -lFLAC"
	filters="$filters flacdec"
	audio_format_handlers="$audio_format_handlers flac"
	audiod_audio_formats="$audiod_audio_formats flac"
	AC_SUBST(flac_cppflags)
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_LD_FLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

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

AC_CHECK_HEADER(sys/soundcard.h, [
	audiod_errlist_objs="$audiod_errlist_objs oss_write"
	play_errlist_objs="$play_errlist_objs oss_write"
	audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(oss_write)"
	play_cmdline_objs="$play_cmdline_objs add_cmdline(oss_write)"

	write_errlist_objs="$write_errlist_objs oss_write"
	write_cmdline_objs="$write_cmdline_objs add_cmdline(oss_write)"
	fade_errlist_objs="$fade_errlist_objs oss_mix"
	all_errlist_objs="$all_errlist_objs oss_write oss_mix"

	writers="$writers oss"
	default_writer="OSS_WRITE"
	mixers="${mixers}oss "
	default_mixer="OSS_MIX"

	AC_CHECK_LIB(ossaudio, _oss_ioctl, [
			audiod_ldflags="$audiod_ldflags -lossaudio"
			play_ldflags="$play_ldflags -lossaudio"
			write_ldflags="$write_ldflags -lossaudio"
			fade_ldflags="$fade_ldflags -lossaudio"
		]
	)
	],
	[
		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_LD_FLAGS="$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
	audiod_errlist_objs="$audiod_errlist_objs alsa_write"
	audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(alsa_write)"
	audiod_ldflags="$audiod_ldflags -lasound"
	play_errlist_objs="$play_errlist_objs alsa_write"
	play_cmdline_objs="$play_cmdline_objs add_cmdline(alsa_write)"
	play_ldflags="$play_ldflags -lasound"

	write_errlist_objs="$write_errlist_objs alsa_write"
	write_cmdline_objs="$write_cmdline_objs add_cmdline(alsa_write)"
	write_ldflags="$write_ldflags -lasound"
	fade_errlist_objs="$fade_errlist_objs alsa_mix"
	fade_ldflags="$fade_ldflags -lasound"
	all_errlist_objs="$all_errlist_objs alsa_write alsa_mix"

	writers="$writers alsa"
	default_writer="ALSA_WRITE"
	mixers="${mixers}alsa "
	default_mixer="ALSA_MIX"
fi

CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
########################################################################### fade
if test -n "$mixers"; then
	extras="$extras fade"
	executables="$executables fade"
	all_errlist_objs="$all_errlist_objs fade"
	fade_errlist_objs="$fade_errlist_objs fade exec string fd"
	fade_cmdline_objs="add_cmdline(fade)"
	fade_objs="$fade_cmdline_objs $fade_errlist_objs"
	AC_SUBST(fade_objs, add_dot_o($fade_objs))
	AC_SUBST(fade_ldflags, $fade_ldflags)
	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)
	mixer_summary="supported mixers:: $mixers, default: $default_mixer"
else
	AC_MSG_WARN([no mixer support])
	mixer_summary="para_fade: no"
fi
########################################################################### libao
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LD_FLAGS="$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
	all_errlist_objs="$all_errlist_objs ao_write"
	audiod_errlist_objs="$audiod_errlist_objs ao_write"
	audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(ao_write)"
	audiod_ldflags="$audiod_ldflags -lao -lpthread"

	play_errlist_objs="$play_errlist_objs ao_write"
	play_cmdline_objs="$play_cmdline_objs add_cmdline(ao_write)"
	play_ldflags="$play_ldflags -lao -lpthread"

	write_errlist_objs="$write_errlist_objs ao_write"
	write_cmdline_objs="$write_cmdline_objs add_cmdline(ao_write)"
	write_ldflags="$write_ldflags $ao_libs -lao -lpthread"
	writers="$writers ao"
	AC_SUBST(ao_cppflags)
fi

CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
############################################################# readline
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LD_FLAGS="$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_curses" != "yes"; then
	have_readline="no"
	AC_MSG_WARN([interactive cli support depends on curses,])
	AC_MSG_WARN([but no curses lib was detected, $msg])
fi

if test "$have_readline" = "yes"; then
	readline_libs="$readline_libs -lreadline"
	AC_SEARCH_LIBS([rl_free_keymap], [readline], [], [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_libs="$readline_libs -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_libs="$readline_libs -ltermcap"
		], [], [-ltermcap])
	fi
fi

if test "$have_readline" = "yes"; then
	all_errlist_objs="$all_errlist_objs interactive"
	client_errlist_objs="$client_errlist_objs interactive"
	client_ldflags="$client_ldflags $readline_libs"
	audioc_errlist_objs="$audioc_errlist_objs buffer_tree interactive sched time"
	audioc_ldflags="$audioc_ldflags $readline_libs"
	play_errlist_objs="$play_errlist_objs interactive"
	play_ldflags="$play_ldflags $readline_libs"
	AC_SUBST(readline_cppflags)
	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_LD_FLAGS="$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
	all_errlist_objs="$all_errlist_objs resample_filter"
	filter_errlist_objs="$filter_errlist_objs resample_filter check_wav"
	filter_cmdline_objs="$filter_cmdline_objs add_cmdline(resample_filter)"
	audiod_errlist_objs="$audiod_errlist_objs resample_filter check_wav"
	audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(resample_filter)"
	play_errlist_objs="$play_errlist_objs resample_filter check_wav"
	play_cmdline_objs="$play_cmdline_objs add_cmdline(resample_filter)"
	filter_ldflags="$filter_ldflags $samplerate_libs -lsamplerate"
	audiod_ldflags="$audiod_ldflags $samplerate_libs -lsamplerate"
	play_ldflags="$play_ldflags $samplerate_libs -lsamplerate"
	filters="$filters resample"
	AC_SUBST(samplerate_cppflags)
else
	AC_MSG_WARN([no resample support in para_audiod/para_filter])
fi
CPPFLAGS="$OLD_CPPFLAGS"
LDFLAGS="$OLD_LDFLAGS"
LIBS="$OLD_LIBS"
############################################################# error2.h
AC_MSG_NOTICE(creating error2.h)
for i in $executables; do
	echo "$i: "
	eval echo \$${i}_errlist_objs
done | ./error2.pl > error2.h
for obj in $all_errlist_objs; do
	SS="$SS SS_$(echo $obj | tr 'a-z' 'A-Z'),"
done
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, add_para($executables))

recv_objs="$recv_cmdline_objs $recv_errlist_objs"
filter_objs="$filter_cmdline_objs $filter_errlist_objs"
audiod_objs="$audiod_cmdline_objs $audiod_errlist_objs"
server_objs="$server_cmdline_objs $server_errlist_objs"
write_objs="$write_cmdline_objs $write_errlist_objs"
client_objs="$client_cmdline_objs $client_errlist_objs"
audioc_objs="$audioc_cmdline_objs $audioc_errlist_objs"
afh_objs="$afh_cmdline_objs $afh_errlist_objs"
play_objs="$play_cmdline_objs $play_errlist_objs"


AC_SUBST(recv_objs, add_dot_o($recv_objs))
AC_SUBST(recv_ldflags, $recv_ldflags)
AC_DEFINE_UNQUOTED(INIT_RECV_ERRLISTS, objlist_to_errlist($recv_errlist_objs),
	errors used by para_recv)

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

AC_SUBST(audiod_objs, add_dot_o($audiod_objs))
AC_SUBST(audiod_ldflags, $audiod_ldflags)
AC_DEFINE_UNQUOTED(INIT_AUDIOD_ERRLISTS, objlist_to_errlist($audiod_errlist_objs),
	errors used by para_audiod)

AC_SUBST(server_objs, add_dot_o($server_objs))
AC_SUBST(server_ldflags, $server_ldflags)
AC_DEFINE_UNQUOTED(INIT_SERVER_ERRLISTS,
	objlist_to_errlist($server_errlist_objs), errors used by para_server)

AC_SUBST(afh_objs, add_dot_o($afh_objs))
AC_SUBST(afh_ldflags, $afh_ldflags)
AC_DEFINE_UNQUOTED(INIT_AFH_ERRLISTS,
	objlist_to_errlist($afh_errlist_objs), errors used by para_afh)

AC_SUBST(write_objs, add_dot_o($write_objs))
AC_SUBST(write_ldflags, $write_ldflags)
AC_DEFINE_UNQUOTED(INIT_WRITE_ERRLISTS,
	objlist_to_errlist($write_errlist_objs), errors used by para_write)

AC_SUBST(client_objs, add_dot_o($client_objs))
AC_SUBST(client_ldflags, $client_ldflags)
AC_DEFINE_UNQUOTED(INIT_CLIENT_ERRLISTS,
	objlist_to_errlist($client_errlist_objs), errors used by para_client)

AC_SUBST(audioc_objs, add_dot_o($audioc_objs))
AC_SUBST(audioc_ldflags, $audioc_ldflags)
AC_DEFINE_UNQUOTED(INIT_AUDIOC_ERRLISTS,
	objlist_to_errlist($audioc_errlist_objs), errors used by para_audioc)

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)

AC_SUBST(play_objs, add_dot_o($play_objs))
AC_SUBST(play_ldflags, $play_ldflags)
AC_DEFINE_UNQUOTED(INIT_PLAY_ERRLISTS,
	objlist_to_errlist($play_errlist_objs), errors used by para_play)

AC_MSG_NOTICE(play objs: $play_objs)

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)

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)

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)

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
optional executables: $extras
$mixer_summary
])