#                                               -*- 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_DEFUN([LIB_ARG_WITH], [
	AC_ARG_WITH($1-headers, [AS_HELP_STRING(--with-$1-headers=dir,
		[look for $1 headers in dir])])
	AC_ARG_WITH($1-libs, [AS_HELP_STRING(--with-$1-libs=dir,
		[look for $1 libraries in dir])])
	if test -n "$with_$1_headers"; then
		$1_cppflags="-I$with_$1_headers"
		CPPFLAGS="$CPPFLAGS $$1_cppflags"
	fi
	if test -n "$with_$1_libs"; then
		$1_ldflags="-L$with_$1_libs $2"
	else
		$1_ldflags="$2"
	fi
	LDFLAGS="$LDFLAGS $$1_ldflags"
])

AC_DEFUN([STASH_FLAGS], [
	OLD_CPPFLAGS="$CPPFLAGS"
	OLD_LDFLAGS="$LDFLAGS"
	OLD_LIBS="$LIBS"
])

AC_DEFUN([UNSTASH_FLAGS], [
	CPPFLAGS="$OLD_CPPFLAGS"
	LDFLAGS="$OLD_LDFLAGS"
	LIBS="$OLD_LIBS"
])
AC_DEFUN([LIB_SUBST_FLAGS], [
	if test "$HAVE_[]m4_toupper([$1])" = 'yes'; then
		AC_DEFINE(HAVE_[]m4_toupper([$1]), 1,
			define to 1 to turn on $1 support)
	else
		$1_cppflags=
		$1_ldflags=
	fi
	AC_SUBST(HAVE_[]m4_toupper([$1]))
	AC_SUBST($1_cppflags)
	AC_SUBST($1_ldflags)
])

AC_USE_SYSTEM_EXTENSIONS
AC_C_BIGENDIAN()

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

AC_PATH_PROG([M4], [m4])
test -z "$M4" && AC_MSG_ERROR(
	[The m4 macro processor 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
STASH_FLAGS
LIB_ARG_WITH([osl], [-losl])
HAVE_OSL=yes
AC_CHECK_HEADER(osl.h, [], [HAVE_OSL=no])
AC_CHECK_LIB([osl], [osl_open_table], [], [HAVE_OSL=no])
LIB_SUBST_FLAGS(osl)
UNSTASH_FLAGS
######################################################################## openssl
STASH_FLAGS
HAVE_OPENSSL=yes
LIB_ARG_WITH([openssl], [-lssl -lcrypto])
AC_CHECK_HEADER(openssl/ssl.h, [], [HAVE_OPENSSL=no])
AC_CHECK_LIB([crypto], [RAND_bytes], [], [HAVE_OPENSSL=no])
LIB_SUBST_FLAGS(openssl)
if test $HAVE_OPENSSL = yes; then
	AC_CHECK_LIB([crypto], [RSA_set0_key],
		AC_DEFINE([HAVE_RSA_SET0_KEY], [1], [openssl-1.1]))
fi
UNSTASH_FLAGS
######################################################################### gcrypt
STASH_FLAGS
HAVE_GCRYPT=yes
LIB_ARG_WITH([gcrypt], [-lgcrypt])
AC_CHECK_HEADER(gcrypt.h, [], [HAVE_GCRYPT=no])
AC_CHECK_LIB([gcrypt], [gcry_randomize], [], [HAVE_GCRYPT=no])
LIB_SUBST_FLAGS(gcrypt)
UNSTASH_FLAGS
######################################################################### 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.])])

CRYPTOLIB="$enable_cryptolib"
case "$enable_cryptolib" in
"openssl")
	test $HAVE_OPENSSL = no && AC_MSG_ERROR(openssl not found)
	crypto_ldflags="$openssl_ldflags"
	;;
"gcrypt")
	test $HAVE_GCRYPT = no && AC_MSG_ERROR(gcrypt not found)
	crypto_ldflags="$gcrypt_ldflags"
	;;
"")
	crypto_ldflags=
	if test $HAVE_GCRYPT = yes; then
		CRYPTOLIB=gcrypt
		crypto_ldflags="$gcrypt_ldflags"
	fi
	if test $HAVE_OPENSSL = yes; then
		CRYPTOLIB=openssl
		crypto_ldflags="$openssl_ldflags"
	fi
	;;
*)
	AC_MSG_ERROR([invalid value "$enable_cryptolib" for --enable-cryptolib])
	;;
esac
AC_SUBST(crypto_ldflags)
########################################################################## iconv
STASH_FLAGS
LIBS=
AC_SEARCH_LIBS([libiconv_open], [iconv],
	[iconv_ldflags="$LIBS"],
	[]
)
AC_SUBST(iconv_ldflags)
AC_MSG_CHECKING([whether iconv needs const char ** cast])
AC_COMPILE_IFELSE([
        AC_LANG_PROGRAM([
                #include <iconv.h>
        ],[
                size_t iconv(iconv_t cd, const char **inbuf,
                        size_t *inbytesleft, char **outbuf,
                        size_t *outbytesleft);
        ])
],
        [cast='(const char **)'; msg=yes],
        [cast=; msg=no]
)
AC_DEFINE_UNQUOTED(ICONV_CAST, $cast, [cast for second arg to iconv()])
AC_MSG_RESULT($msg)
UNSTASH_FLAGS
########################################################################### ucred
AC_MSG_CHECKING(for struct ucred)
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
	#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
STASH_FLAGS
LIB_ARG_WITH([curses], [])
HAVE_CURSES=yes
AC_CHECK_HEADER(curses.h, [], [HAVE_CURSES=no])
AC_SEARCH_LIBS([initscr], [ncursesw curses], [], [HAVE_CURSES=no])
curses_ldflags="$curses_ldflags $LIBS"
LIB_SUBST_FLAGS(curses)
UNSTASH_FLAGS
########################################################################### 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
STASH_FLAGS
LIB_ARG_WITH([ogg], [-logg])
HAVE_OGG=yes
AC_CHECK_HEADERS([ogg/ogg.h], [], [HAVE_OGG=no])
AC_CHECK_LIB([ogg], [ogg_stream_init], [], [HAVE_OGG=no])
AC_CHECK_LIB([ogg], [ogg_stream_flush_fill], [
	AC_DEFINE(HAVE_OGG_STREAM_FLUSH_FILL, 1, [libogg >= 1.3.0])])
LIB_SUBST_FLAGS(ogg)
UNSTASH_FLAGS
######################################################################### vorbis
STASH_FLAGS
LIB_ARG_WITH([vorbis], [-lvorbis -lvorbisfile])
HAVE_VORBIS=yes
AC_CHECK_HEADERS([vorbis/codec.h], [], [HAVE_VORBIS=no])
AC_CHECK_LIB([vorbis], [vorbis_info_init], [], [HAVE_VORBIS=no])
LIB_SUBST_FLAGS(vorbis)
UNSTASH_FLAGS
######################################################################### speex
STASH_FLAGS
LIB_ARG_WITH([speex], [-lspeex])
HAVE_SPEEX=yes
AC_CHECK_HEADERS([speex/speex.h], [], [HAVE_SPEEX=no])
AC_CHECK_LIB([speex], [speex_decoder_init], [], [HAVE_SPEEX=no])
LIB_SUBST_FLAGS(speex)
UNSTASH_FLAGS
######################################################################### opus
STASH_FLAGS
LIB_ARG_WITH([opus], [-lopus])
HAVE_OPUS=yes
AC_CHECK_HEADERS([opus/opus.h], [], [HAVE_OPUS=no])
AC_CHECK_LIB([opus], [opus_multistream_decode], [], [HAVE_OPUS=no])
LIB_SUBST_FLAGS(opus)
UNSTASH_FLAGS
########################################################################### flac
STASH_FLAGS
LIB_ARG_WITH([flac], [-lFLAC -lm])
HAVE_FLAC=yes
AC_CHECK_HEADER(FLAC/stream_decoder.h, [], HAVE_FLAC=no)
AC_CHECK_LIB([FLAC], [FLAC__stream_decoder_init_file], [], HAVE_FLAC=no)
LIB_SUBST_FLAGS(flac)
UNSTASH_FLAGS

# some helper functions for codecs which use the ogg container format
AC_DEFUN([NEED_OGG_OBJECTS], [{
	test "$HAVE_OGG" = 'yes' -a \( \
		 "$HAVE_VORBIS" = 'yes' \
		-o "$HAVE_SPEEX" = 'yes' \
		-o "$HAVE_OPUS" = 'yes' \
		-o "$HAVE_FLAC" = 'yes' \
	\)
}])
AC_DEFUN([NEED_VORBIS_OBJECTS], [{
	test "$HAVE_OGG" = 'yes' -a "$HAVE_VORBIS" = 'yes'
}])
AC_DEFUN([NEED_SPEEX_OBJECTS], [{
	test "$HAVE_OGG" = 'yes' -a "$HAVE_SPEEX" = 'yes'
}])
AC_DEFUN([NEED_OPUS_OBJECTS], [{
	test "$HAVE_OGG" = 'yes' -a "$HAVE_OPUS" = 'yes'
}])
AC_DEFUN([NEED_FLAC_OBJECTS], [{
	test "$HAVE_OGG" = 'yes' -a "$HAVE_FLAC" = 'yes'
}])
########################################################################### faad
STASH_FLAGS
LIB_ARG_WITH([faad], [-lfaad])
HAVE_FAAD=yes
AC_CHECK_HEADER(neaacdec.h, [], HAVE_FAAD=no)
AC_CHECK_LIB([faad], [NeAACDecOpen], [], HAVE_FAAD=no)
LIB_SUBST_FLAGS(faad)
UNSTASH_FLAGS
########################################################################### mad
STASH_FLAGS
LIB_ARG_WITH([mad], [-lmad])
HAVE_MAD=yes
AC_CHECK_HEADER(mad.h, [], HAVE_MAD=no)
AC_CHECK_LIB([mad], [mad_stream_init], [], HAVE_MAD=no)
LIB_SUBST_FLAGS(mad)
UNSTASH_FLAGS
###################################################################### libid3tag
STASH_FLAGS
LIB_ARG_WITH([id3tag], [-lid3tag -lz])
HAVE_ID3TAG=yes
AC_CHECK_HEADER(id3tag.h, [], HAVE_ID3TAG=no)
AC_CHECK_LIB([id3tag], [id3_file_fdopen], [], HAVE_ID3TAG=no)
LIB_SUBST_FLAGS(id3tag)
UNSTASH_FLAGS
########################################################################### oss
STASH_FLAGS
LIB_ARG_WITH([oss], [])
AC_CHECK_HEADER(sys/soundcard.h, [HAVE_OSS=yes], [HAVE_OSS=no])
AC_CHECK_LIB(ossaudio, _oss_ioctl, [oss_ldflags="$oss_ldflags -lossaudio"], [])
LIB_SUBST_FLAGS(oss)
UNSTASH_FLAGS
########################################################################### alsa
STASH_FLAGS
LIB_ARG_WITH([alsa], [-lasound])
HAVE_ALSA=yes
AC_CHECK_HEADER(alsa/asoundlib.h, [], HAVE_ALSA=no)
AC_CHECK_LIB([asound], [snd_pcm_open], [], HAVE_ALSA=no)
LIB_SUBST_FLAGS(alsa)
UNSTASH_FLAGS
######################################################################### pthread
STASH_FLAGS
LIB_ARG_WITH([pthread], [-lpthread])
HAVE_PTHREAD=yes
AC_CHECK_HEADER(pthread.h, [], HAVE_PTHREAD=no)
AC_CHECK_LIB([pthread], [pthread_create], [], HAVE_PTHREAD=no)
LIB_SUBST_FLAGS(pthread)
UNSTASH_FLAGS
########################################################################### libao
STASH_FLAGS
LIB_ARG_WITH([ao], [-lao])
HAVE_AO=yes
AC_CHECK_HEADER(ao/ao.h, [], HAVE_AO=no)
AC_CHECK_LIB([ao], [ao_initialize], [], HAVE_AO=no)
LIB_SUBST_FLAGS(ao)
UNSTASH_FLAGS
AC_DEFUN([NEED_AO_OBJECTS], [{ test $HAVE_AO = yes -a $HAVE_PTHREAD = yes; }])
######################################################################## readline
STASH_FLAGS
AC_SEARCH_LIBS([tgetent], [tinfo curses terminfo termcap])
LIB_ARG_WITH([readline], [-lreadline $LIBS])
HAVE_READLINE=yes
AC_CHECK_HEADER([readline/readline.h], [], [HAVE_READLINE=no])
AC_CHECK_LIB([readline], [rl_free_keymap], [], HAVE_READLINE=no)
AC_CHECK_DECL(
	[rl_free_keymap],
	[AC_DEFINE(RL_FREE_KEYMAP_DECLARED, 1, readline >= 6.3)],
	[],
	[
		#include <stdio.h>
		#include <readline/readline.h>
	]
)
LIB_SUBST_FLAGS(readline)
UNSTASH_FLAGS
############################################################# libsamplerate
STASH_FLAGS
LIB_ARG_WITH([samplerate], [-lsamplerate])
HAVE_SAMPLERATE=yes
AC_CHECK_HEADER(samplerate.h, [], HAVE_SAMPLERATE=no)
AC_CHECK_LIB([samplerate], [src_process], [], HAVE_SAMPLERATE=no)
LIB_SUBST_FLAGS(samplerate)
UNSTASH_FLAGS
########################################################################## mp4v2
STASH_FLAGS
LIB_ARG_WITH([mp4v2], [-lmp4v2])
HAVE_MP4V2=yes
AC_CHECK_HEADER([mp4v2/mp4v2.h], [], [HAVE_MP4V2=no])
AC_CHECK_LIB([mp4v2], [MP4Read], [], [HAVE_MP4V2=no])
LIB_SUBST_FLAGS(mp4v2)
UNSTASH_FLAGS
######################################################################### server
if test -n "$CRYPTOLIB" && test $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
		base64
		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 "$CRYPTOLIB" = openssl; then
		server_errlist_objs="$server_errlist_objs crypt"
	else
		server_errlist_objs="$server_errlist_objs gcrypt"
	fi
	NEED_OGG_OBJECTS() && server_errlist_objs="$server_errlist_objs ogg_afh_common"
	NEED_VORBIS_OBJECTS() && server_errlist_objs="$server_errlist_objs ogg_afh"
	NEED_SPEEX_OBJECTS() && server_errlist_objs="$server_errlist_objs spx_afh spx_common"
	NEED_OPUS_OBJECTS() && server_errlist_objs="$server_errlist_objs opus_afh opus_common"
	NEED_FLAC_OBJECTS && server_errlist_objs="$server_errlist_objs flac_afh"
	if test $HAVE_FAAD = yes && test $HAVE_MP4V2 = yes; then
		server_errlist_objs="$server_errlist_objs aac_afh aac_common"
	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 -n "$CRYPTOLIB"; 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
		base64
		version
		ggo
	"
	if test "$CRYPTOLIB" = openssl; then
		client_errlist_objs="$client_errlist_objs crypt"
	else
		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 -n "$CRYPTOLIB"; 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
		base64
		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 "$CRYPTOLIB" = openssl; then
		audiod_errlist_objs="$audiod_errlist_objs crypt"
	else
		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
	NEED_VORBIS_OBJECTS && {
		audiod_errlist_objs="$audiod_errlist_objs oggdec_filter"
		audiod_audio_formats="$audiod_audio_formats ogg"
	}
	NEED_SPEEX_OBJECTS && {
		audiod_errlist_objs="$audiod_errlist_objs spxdec_filter spx_common"
		audiod_audio_formats="$audiod_audio_formats spx"
	}
	NEED_OPUS_OBJECTS && {
		audiod_errlist_objs="$audiod_errlist_objs opusdec_filter opus_common"
		audiod_audio_formats="$audiod_audio_formats opus"
	}
	NEED_FLAC_OBJECTS && {
		audiod_errlist_objs="$audiod_errlist_objs flacdec_filter"
		audiod_audio_formats="$audiod_audio_formats flac"
	}
	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_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
	NEED_AO_OBJECTS && {
		audiod_errlist_objs="$audiod_errlist_objs ao_write"
		audiod_cmdline_objs="$audiod_cmdline_objs ao_write"
	}
	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
"
NEED_VORBIS_OBJECTS && {
	filters="$filters oggdec"
	filter_errlist_objs="$filter_errlist_objs oggdec_filter"
}
NEED_SPEEX_OBJECTS && {
	filters="$filters spxdec"
	filter_errlist_objs="$filter_errlist_objs spxdec_filter spx_common"
}
NEED_OPUS_OBJECTS && {
	filters="$filters opusdec"
	filter_errlist_objs="$filter_errlist_objs opusdec_filter opus_common"
}
NEED_FLAC_OBJECTS && {
	filter_errlist_objs="$filter_errlist_objs flacdec_filter"
	filters="$filters flacdec"
}
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_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
"
NEED_OGG_OBJECTS && recv_errlist_objs="$recv_errlist_objs ogg_afh_common"
NEED_VORBIS_OBJECTS && recv_errlist_objs="$recv_errlist_objs ogg_afh"
NEED_SPEEX_OBJECTS && recv_errlist_objs="$recv_errlist_objs spx_afh spx_common"
NEED_OPUS_OBJECTS && recv_errlist_objs="$recv_errlist_objs opus_afh opus_common"
NEED_FLAC_OBJECTS && recv_errlist_objs="$recv_errlist_objs flac_afh"

if test $HAVE_FAAD = yes -a $HAVE_MP4V2 = yes; then
	recv_errlist_objs="$recv_errlist_objs aac_afh aac_common"
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
"
NEED_OGG_OBJECTS && afh_errlist_objs="$afh_errlist_objs ogg_afh_common"
NEED_VORBIS_OBJECTS && {
	afh_errlist_objs="$afh_errlist_objs ogg_afh"
	audio_format_handlers="$audio_format_handlers ogg"
}
NEED_SPEEX_OBJECTS && {
	afh_errlist_objs="$afh_errlist_objs spx_afh spx_common"
	audio_format_handlers="$audio_format_handlers spx"
}
NEED_OPUS_OBJECTS && {
	afh_errlist_objs="$afh_errlist_objs opus_afh opus_common"
	audio_format_handlers="$audio_format_handlers opus"
}
NEED_FLAC_OBJECTS && {
	afh_errlist_objs="$afh_errlist_objs flac_afh"
	audio_format_handlers="$audio_format_handlers flac"
}
if test $HAVE_FAAD = yes -a $HAVE_MP4V2 = yes; then
	afh_errlist_objs="$afh_errlist_objs aac_afh aac_common"
	audio_format_handlers="$audio_format_handlers aac"
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
NEED_OGG_OBJECTS && play_errlist_objs="$play_errlist_objs ogg_afh_common"
NEED_VORBIS_OBJECTS && {
	play_errlist_objs="$play_errlist_objs oggdec_filter ogg_afh"
}
NEED_SPEEX_OBJECTS && {
	play_errlist_objs="$play_errlist_objs spxdec_filter spx_afh spx_common"
}
NEED_OPUS_OBJECTS &&
	play_errlist_objs="$play_errlist_objs
		opusdec_filter
		opus_afh
		opus_common
	"
NEED_FLAC_OBJECTS && {
	play_errlist_objs="$play_errlist_objs flacdec_filter flac_afh"
}
if test $HAVE_FAAD = yes; then
	play_errlist_objs="$play_errlist_objs aacdec_filter"
fi
if test $HAVE_MP4V2 = yes; then
	play_errlist_objs="$play_errlist_objs aac_afh"
fi
if test $HAVE_MP4V2 = yes || test $HAVE_FAAD = yes; then
	play_errlist_objs="$play_errlist_objs 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_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
NEED_AO_OBJECTS && {
	play_errlist_objs="$play_errlist_objs ao_write"
	play_cmdline_objs="$play_cmdline_objs ao_write"
}
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
NEED_AO_OBJECTS && {
	write_errlist_objs="$write_errlist_objs ao_write"
	write_cmdline_objs="$write_cmdline_objs ao_write"
	writers="$writers ao"
	default_writer="AO_WRITE"
}
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:
~~~~~~~~~~~~~~~~~~~~~~~~
crypto lib: ${CRYPTOLIB:-[none]}
unix socket credentials: $have_ucred
readline (interactive CLIs): $HAVE_READLINE
id3 version 2 support: $HAVE_ID3TAG
faad: $HAVE_FAAD
mp4v2: $HAVE_MP4V2

audio format handlers: $audio_format_handlers
filters: $(echo $filters)
writers: $writers

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