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

AC_PREREQ(2.60)


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

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_PROG_CC
AC_PROG_CPP
AC_PROG_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_TYPE_SIGNAL
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])])

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


all_errlist_objs="server mp3_afh afh_common vss command net string signal time
daemon stat http_send close_on_fork ipc acl afh fade amp_filter
dccp_send fd user_list chunk_queue afs aft mood score attribute blob ringbuffer
playlist 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 udp_send color fec fecdec_filter prebuffer_filter mm
server_command_list afs_command_list audiod_command_list bitstream imdct wma_afh
wma_common wmadec_filter buffer_tree crypt_common
"

executables="recv filter audioc write client afh audiod"

recv_cmdline_objs="add_cmdline(recv http_recv dccp_recv udp_recv)"

recv_errlist_objs="http_recv recv_common recv time string net dccp_recv
	fd sched stdout ggo udp_recv fec buffer_tree"
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
	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 audiod_command_list
	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=""

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
	server_command_list afs_command_list wma_afh wma_common"
server_ldflags=""
server_audio_formats="mp3 wma"

write_cmdline_objs="add_cmdline(write file_write)"
write_errlist_objs="write write_common file_write time fd string sched stdin
	buffer_tree ggo"
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
	client_common buffer_tree crypt_common"
client_ldflags=""

gui_cmdline_objs="add_cmdline(gui)"
gui_errlist_objs="exec signal string stat ringbuffer fd"
gui_other_objs="gui gui_theme"
gui_objs="$gui_cmdline_objs $gui_errlist_objs $gui_other_objs"

fade_cmdline_objs="add_cmdline(fade)"
fade_errlist_objs="fade exec string fd"


########################################################################### 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_TRY_RUN(
[#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_TRY_RUN(
[#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()
########################################################################### osl
have_osl=yes
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LD_FLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"
AC_ARG_WITH(osl_headers, [AC_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, [AC_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"
	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, [AC_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, [AC_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, [AC_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, [AC_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_TRY_LINK([
	#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, [AC_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, [AC_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([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_TRY_LINK([
	#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_TRY_LINK([
	#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"
	audiod_errlist_objs="$audiod_errlist_objs osx_write"
	audiod_cmdline_objs="$audiod_cmdline_objs osx_write.cmdline"
	audiod_ldflags="$audiod_ldflags $f"

	write_errlist_objs="$write_errlist_objs osx_write"
	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, [AC_HELP_STRING(--with-ogg-headers=dir,
	[look for ogg headers also in dir])])
AC_ARG_WITH(ogg_libs, [AC_HELP_STRING(--with-ogg-libs=dir,
	[look for ogg libs also in dir])])
AC_ARG_WITH(vorbis_headers, [AC_HELP_STRING(--with-vorbis-headers=dir,
	[look for vorbis headers also in dir])])
AC_ARG_WITH(vorbis_libs, [AC_HELP_STRING(--with-vorbis-libs=dir,
	[look for vorbis libs also in dir])])
AC_ARG_WITH(speex_headers, [AC_HELP_STRING(--with-speex-headers=dir,
	[look for speex headers also in dir])])
AC_ARG_WITH(speex_libs, [AC_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
	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"
	afh_ldflags="$afh_ldflags $ogg_libs"
	all_errlist_objs="$all_errlist_objs ogg_afh_common"
	afh_errlist_objs="$afh_errlist_objs ogg_afh_common"
	server_errlist_objs="$server_errlist_objs ogg_afh_common"
else
	AC_MSG_WARN([vorbis/speex require ogg])
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"
	afh_ldflags="$afh_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"
	afh_errlist_objs="$afh_errlist_objs ogg_afh"

	audiod_audio_formats="$audiod_audio_formats ogg"
	server_audio_formats="$server_audio_formats 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"
	afh_ldflags="$afh_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"
	afh_errlist_objs="$afh_errlist_objs spx_afh spx_common"

	audiod_audio_formats="$audiod_audio_formats spx"
	server_audio_formats="$server_audio_formats 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, [AC_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, [AC_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"
	server_errlist_objs="$server_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"
	afh_ldflags="$afh_ldflags $faad_libs -lfaad"
	audiod_audio_formats="$audiod_audio_formats aac"
	server_audio_formats="$server_audio_formats 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, [AC_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, [AC_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)"
	all_errlist_objs="$all_errlist_objs mp3dec_filter"
	filter_errlist_objs="$filter_errlist_objs mp3dec_filter"
	audiod_errlist_objs="$audiod_errlist_objs mp3dec_filter"
	filter_ldflags="$filter_ldflags $mad_libs -lmad"
	audiod_ldflags="$audiod_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
AC_MSG_CHECKING(for libid3tag)
AC_TRY_LINK([
	#include <id3tag.h>
],[
	struct id3_tag t = {.flags = 0};
],[have_libid3tag=yes],[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 -lid3tag"
	afh_ldflags="$afh_ldflags -lid3tag"
else
	AC_MSG_WARN([no support for id3v2 tags])
fi
########################################################################### oss
OLD_CPPFLAGS="$CPPFLAGS"
OLD_LD_FLAGS="$LDFLAGS"
OLD_LIBS="$LIBS"

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

AC_CHECK_HEADER(sys/soundcard.h, [
	extras="$extras fade"
	executables="$executables fade"
	all_errlist_objs="$all_errlist_objs oss_write"
	audiod_errlist_objs="$audiod_errlist_objs oss_write"
	audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(oss_write)"

	write_errlist_objs="$write_errlist_objs oss_write"
	write_cmdline_objs="$write_cmdline_objs add_cmdline(oss_write)"
	writers="$writers oss"
	default_writer="OSS_WRITE"
	AC_CHECK_LIB(ossaudio, _oss_ioctl, [
			audiod_ldflags="$audiod_ldflags -lossaudio"
			write_ldflags="$write_ldflags -lossaudio"
			fade_ldflags="$write_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
	all_errlist_objs="$all_errlist_objs alsa_write"
	audiod_errlist_objs="$audiod_errlist_objs alsa_write"
	audiod_cmdline_objs="$audiod_cmdline_objs add_cmdline(alsa_write)"
	audiod_ldflags="$audiod_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"
	writers="$writers alsa"
	default_writer="ALSA_WRITE"
fi

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

have_ao="yes"
AC_ARG_WITH(ao_headers, [AC_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, [AC_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"

	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"



AC_SUBST(install_sh, [$INSTALL])
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) }])
############################################################# 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(SERVER_AUDIO_FORMATS, "$server_audio_formats",
	[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"
fade_objs="$fade_cmdline_objs $fade_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(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 $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
audio formats supported by para_server/para_afh: $server_audio_formats
id3 version2 support: $have_libid3tag
filters supported by para_audiod/para_filter: $filters
writers supported by para_audiod/para_write: $writers
optional executables: $extras
])