configure.ac

    AC_MSG_ERROR([The skins2 module depends on the Qt interface. Without it you will not be able to open any dialog box from the interface, which makes the skins2 interface rather useless. Install the Qt development package or alternatively you can also configure with: --disable-qt --disable-skins2.])
  ], [
    enable_skins2="no"
    AC_MSG_WARN([The skins2 module depends on the Qt interface, Qt is not built so skins2 is disabled.])
  ])
])

dnl
dnl Skins2 module
dnl
AC_ARG_ENABLE([skins2],
  AS_HELP_STRING([--enable-skins2], [skins interface module (default auto)]))
AS_IF([test "${enable_skins2}" != "no"], [
  have_skins_deps="yes"

  dnl Win32
  AS_IF([test "${SYS}" = "mingw32"], [
    VLC_ADD_CPPFLAGS([skins2],[-U_OFF_T_ -U_off_t -DWIN32_SKINS])
    VLC_ADD_LIBS([skins2],[-lgdi32 -lole32 -luuid -lmsimg32])
  dnl OS/2
  ], [test "${SYS}" = "os2"], [
    VLC_ADD_CPPFLAGS([skins2],[ -DOS2_SKINS])
  dnl Linux/Unix
  ], [
    PKG_CHECK_MODULES([XPM], [xpm],, [have_skins_deps="no"])
    PKG_CHECK_MODULES([XINERAMA], [xinerama],, [have_skins_deps="no"])
    PKG_CHECK_MODULES([XCURSOR], [xcursor],, [have_skins_deps="no"])
    PKG_CHECK_MODULES([XEXT], [xext],, [have_skins_deps="no"])
    VLC_ADD_CPPFLAGS([skins2],[${X_CFLAGS} ${XEXT_CFLAGS} ${XPM_CFLAGS} -DX11_SKINS])
    VLC_ADD_LIBS([skins2],[${X_LIBS} ${X_PRE_LIBS} ${XEXT_LIBS} ${XPM_LIBS} ${XINERAMA_LIBS} ${XCURSOR_LIBS} -lX11])
  ])

  dnl we need freetype
  AS_IF([test "${have_freetype}" != "yes"], [
    have_skins_deps="no"
  ])

  AS_IF([test "${have_skins_deps}" = "no"], [
    AS_IF([test "x${enable_skins2}" = "x"], [
      AC_MSG_WARN([Skins2 interface disabled due to missing dependencies.])
    ], [
      AC_MSG_ERROR([Skins2 interface requires FreeType, libxcursor, libxpm, libxext and libxinerama])
    ])
    enable_skins2="no"
  ], [
    ALIASES="${ALIASES} svlc"
    enable_skins2="yes"
  ])
])
AM_CONDITIONAL([BUILD_SKINS], [test "${enable_skins2}" = "yes"])

AC_ARG_ENABLE([libtar],
  AS_HELP_STRING([--enable-libtar], [libtar support for skins2 (default auto)]))
AS_IF([test "${enable_skins2}" = "yes" && test "${enable_libtar}" != "no"], [
  AC_CHECK_HEADERS([libtar.h], [
    VLC_ADD_LIBS([skins2],[-ltar])
  ])
])

dnl
dnl  MacOS X gui module
dnl
AC_ARG_ENABLE([macosx],
  AS_HELP_STRING([--enable-macosx], [Mac OS X gui support (default enabled on Mac OS X)]))
if test "x${enable_macosx}" != "xno" -a "${SYS}" = "darwin"
then

  dnl
  dnl If possible, use xcrun to find the right ibtool
  dnl

  AC_PATH_PROG([XCRUN], [xcrun], [no])
  AS_IF([test ! "x${XCRUN}" = "xno"], [
    AC_MSG_CHECKING([for ibtool (using xcrun)])
    XIB="$(eval $XCRUN -f ibtool 2>/dev/null || echo no)"
    AC_MSG_RESULT([${XIB}])
  ], [
    AC_MSG_WARN([Looking for tools without using xcrun])
  ])

  AS_IF([test "x${XIB}" = "xno"], [
    AC_PATH_PROG(XIB, [ibtool], [no])
    AS_IF([test "x${XIB}" = "xno"], [
      AC_MSG_ERROR([ibtool was not found, but is required for --enable-macosx])
    ])
  ])
fi
AM_CONDITIONAL([ENABLE_MACOSX_UI], [test "$enable_macosx" != "no" -a "${SYS}" = "darwin"])

dnl
dnl  MacOS X sparkle update support
dnl
AC_ARG_ENABLE([sparkle],
  AS_HELP_STRING([--enable-sparkle], [Sparkle update support for OS X (default enabled on Mac OS X)]))
if test "x${enable_sparkle}" != "xno" -a "${HAVE_OSX}" = "1"
then
  if test ! -d ${CONTRIB_DIR}/Sparkle.framework -a ! -d ${CONTRIB_DIR}/Frameworks/Sparkle.framework
  then
    AC_MSG_ERROR([Sparkle framework is required and was not found in ${CONTRIB_DIR}])
  fi

  AC_DEFINE([HAVE_SPARKLE], [1], [Define to 1 if sparkle is enabled.])
fi
AM_CONDITIONAL([HAVE_SPARKLE], [test "$enable_sparkle" != "no"])

dnl
dnl  MacOS X breakpad creash reporter support
dnl
AC_ARG_WITH([breakpad],
  AS_HELP_STRING([--with-breakpad=URL], [Enable Breakpad reporter using given URL]), [], [with_breakpad=no])

AS_IF([test "$with_breakpad" != "no"], [

  AS_IF([test "$with_breakpad" = "yes"], [
    AC_MSG_ERROR([You need to supply the CrashDragon Server URL as value for --with-breakpad])
  ])

  AS_IF([test "$HAVE_OSX" = "1"], [
    AC_MSG_CHECKING([for Breakpad framework])
    AS_IF([test ! -d ${CONTRIB_DIR}/Breakpad.framework -a \
                ! -d ${CONTRIB_DIR}/Frameworks/Breakpad.framework], [
      AC_MSG_RESULT([no])
      with_breakpad="no"
      AC_MSG_ERROR([Breakpad framework is required and was not found in ${CONTRIB_DIR}])
    ], [
      AC_MSG_RESULT([yes])
    ])
  ],[
    PKG_CHECK_MODULES([BREAKPAD], [breakpad-client], [
      LDFLAGS="${LDFLAGS} -Wl,--build-id"
    ], [
      AC_MSG_ERROR(["breakpad not found"])
    ])
  ])
])

AM_CONDITIONAL([HAVE_BREAKPAD], [test "$with_breakpad" != "no"])
AS_IF([test "$with_breakpad" != "no"], [
  AC_SUBST([BREAKPAD_URL], ["${with_breakpad}"])
])

dnl
dnl  Minimal Mac OS X module
dnl
AC_ARG_ENABLE([minimal-macosx],
  AS_HELP_STRING([--enable-minimal-macosx], [Minimal Mac OS X support (default disabled)]))
if test "${enable_minimal_macosx}" = "yes" -a "${SYS}" = "darwin"
then
  VLC_ADD_PLUGIN([minimal_macosx])
fi

dnl
dnl Mac OS X fancy dmg build tool
dnl
if test "${HAVE_OSX}" = "1"
then
  AC_PATH_PROG(DMGBUILD, dmgbuild, no)
  AS_IF([test "x${DMGBUILD}" = "xno"], [
    AC_MSG_WARN([dmgbuild not found -- unable to build fancy DMGs])
  ])
fi
AM_CONDITIONAL([HAVE_DMGBUILD], [test "x$DMGBUILD" != "xno" -a "${HAVE_OSX}" = "1"])

dnl
dnl  VideoToolbox plugins
AC_CHECK_HEADERS([VideoToolbox/VideoToolbox.h], [
    VLC_ADD_PLUGIN([videotoolbox])
    VLC_ADD_PLUGIN([cvpx])
  ])

dnl
dnl  AudioToolbox MIDI plugin
AC_CHECK_HEADERS([AudioToolbox/AudioToolbox.h], [
  VLC_ADD_PLUGIN([audiotoolboxmidi])
])

dnl
dnl  ncurses module
dnl
AC_ARG_ENABLE([ncurses],
AS_HELP_STRING([--disable-ncurses],[ncurses text-based interface (default auto)]))
have_ncurses="no"
AS_IF([test "${enable_ncurses}" != "no"] ,[
  PKG_CHECK_MODULES([NCURSES], [ncursesw], [
    have_ncurses="yes"
    ALIASES="${ALIASES} nvlc"
  ], [
    AS_IF([test -n "${enable_ncurses}"], [
      AC_MSG_ERROR([${NCURSES_PKG_ERRORS}.])
    ])
  ])
])
AM_CONDITIONAL([HAVE_NCURSES], [test "${have_ncurses}" = "yes"])

dnl
dnl  Lirc plugin
dnl
AC_ARG_ENABLE([lirc],
  AS_HELP_STRING([--enable-lirc], [lirc support (default disabled)]))
have_lirc="no"
AS_IF([test "${enable_lirc}" = "yes"], [
  AC_CHECK_HEADER(lirc/lirc_client.h, [
    AC_CHECK_LIB([lirc_client], [lirc_init], [
      have_lirc="yes"
    ])
  ])
])
AM_CONDITIONAL([HAVE_LIRC], [test "${have_lirc}" = "yes"])

dnl
dnl  Bitstream
dnl
PKG_CHECK_MODULES([BITSTREAM], [bitstream > 1.4],[have_bitstream="yes"], [have_bitstream="no"])
AM_CONDITIONAL([HAVE_BITSTREAM], [test "${have_bitstream}" = "yes"])

dnl
dnl  SRT plugin
dnl
PKG_ENABLE_MODULES_VLC([SRT], [access_srt access_output_srt], [srt >= 1.3.0], [SRT input/output plugin], [auto], [], [], [-DENABLE_SRT])

EXTEND_HELP_STRING([Visualisations and Video filter plugins:])
dnl
dnl  goom visualization plugin
dnl
PKG_ENABLE_MODULES_VLC([GOOM], [], [libgoom2], [goom visualization plugin], [auto])

dnl
dnl libprojectM visualization plugin
dnl
AC_ARG_ENABLE([projectm],
  AS_HELP_STRING([--enable-projectm], [projectM visualization plugin (default enabled)]))
AS_IF([test "${enable_projectm}" != "no"],
  [
    PKG_CHECK_MODULES(PROJECTM, libprojectM,
    [
      VLC_ADD_PLUGIN([projectm])
      PKG_CHECK_EXISTS([libprojectM >= 2.0.0],
        [ AC_DEFINE([HAVE_PROJECTM2], 1, [Define to 1 if using libprojectM 2.x]) ],
        [ AC_MSG_WARN( [Using libprojectM version 1] )
      ])
    ],[
      AC_MSG_WARN([${PROJECTM_PKG_ERRORS}.])
    ])
  ])

dnl
dnl Vovoid VSXu visualization plugin
dnl
AC_ARG_ENABLE([vsxu],
  AS_HELP_STRING([--enable-vsxu], [Vovoid VSXu visualization plugin (default auto)]))
AS_IF([test "${enable_vsxu}" != "no"],
  [
    PKG_CHECK_MODULES(VSXU, libvsxu,
    [
      VLC_ADD_PLUGIN([vsxu])
    ],[
      AC_MSG_WARN([${VSXU_PKG_ERRORS}.])
    ])
  ])

EXTEND_HELP_STRING([Service Discovery plugins:])
dnl
dnl  Avahi-Zeroconf services discovery
PKG_ENABLE_MODULES_VLC([AVAHI], [], [avahi-client >= 0.6], [Zeroconf services discovery], [auto])

dnl
dnl  libudev services discovery
PKG_ENABLE_MODULES_VLC([UDEV], [], [libudev >= 142], [Linux udev services discovery], [auto])

dnl
dnl MTP devices services discovery
PKG_ENABLE_MODULES_VLC([MTP], [mtp access_mtp], [libmtp >= 1.0.0], [MTP devices support], [auto])

dnl
dnl UPnP Plugin (Intel SDK)
dnl
PKG_ENABLE_MODULES_VLC([UPNP], [upnp], [libupnp], [Intel UPNP SDK],[auto])

dnl
dnl mDNS using libmicrodns
dnl
PKG_ENABLE_MODULES_VLC([MICRODNS], [], [microdns >= 0.1.2], [mDNS services discovery], [auto])


EXTEND_HELP_STRING([Misc options:])

dnl
dnl  libxml2 module
dnl
PKG_ENABLE_MODULES_VLC([LIBXML2], [xml], [libxml-2.0 >= 2.5], [libxml2 support],[auto])


dnl
dnl libgcrypt
dnl
AC_ARG_ENABLE([libgcrypt],
  AS_HELP_STRING([--disable-libgcrypt], [gcrypt support (default enabled)]))
AC_ARG_VAR([GCRYPT_CFLAGS], [C compiler flags for gcrypt])
AC_ARG_VAR([GCRYPT_LIBS], [linker flags flags for gcrypt])

# require libgcrypt >= 1.6.0
AS_IF([test "${enable_libgcrypt}" != "no"], [
  AC_CACHE_CHECK([for gcrypt 1.6.0 or later], [ac_cv_lib_gcrypt], [
    VLC_SAVE_FLAGS
    CFLAGS="${CFLAGS} ${GCRYPT_CFLAGS}"
    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
[#include <gcrypt.h>
#if GCRYPT_VERSION_NUMBER < 0x010600
#error
#endif]])], [
      ac_cv_lib_gcrypt=yes
    ], [
      ac_cv_lib_gcrypt=no
    ])
    VLC_RESTORE_FLAGS
  ])

  AS_IF([test "${ac_cv_lib_gcrypt}" = "yes"], [
    AC_DEFINE([HAVE_GCRYPT], 1, [Defined if having gcrypt])
  ], [
    AS_IF([test "${enable_libgcrypt}" = "yes"], [
      AC_MSG_ERROR([libgcrypt version 1.6.0 or higher not found. Install libgcrypt or pass --disable-libgcrypt.])
    ])
  ])
])

AS_IF([test -z "$GCRYPT_LIBS"], [
  GCRYPT_LIBS="-lgcrypt -lgpg-error"
])

AC_SUBST([GCRYPT_CFLAGS])
AC_SUBST([GCRYPT_LIBS])
AM_CONDITIONAL([HAVE_GCRYPT], [test "${ac_cv_lib_gcrypt}" = "yes"])

dnl
dnl TLS/SSL
dnl
AC_ARG_ENABLE([gnutls],
  AS_HELP_STRING([--enable-gnutls], [GNU TLS TLS/SSL support (default enabled)]))
AS_IF([test "${enable_gnutls}" != "no"], [
  PKG_CHECK_MODULES(GNUTLS, [gnutls >= 3.5.0], [
    VLC_ADD_PLUGIN([gnutls])
  ], [
    AS_IF([test -n "${enable_gnutls}"], [
      AC_MSG_ERROR([${GNUTLS_PKG_ERRORS}.)])
    ])
  ])
])


dnl
dnl Taglib plugin
dnl
AC_ARG_ENABLE([taglib],
  AS_HELP_STRING([--disable-taglib],
    [do not use TagLib (default enabled)]))
AS_IF([test "${enable_taglib}" != "no"], [
  PKG_CHECK_MODULES(TAGLIB, taglib >= 1.11, [
    VLC_ADD_PLUGIN([taglib])
  ], [
    AC_MSG_WARN([${TAGLIB_PKG_ERRORS}.])])
])

dnl
dnl  libsecret
dnl
PKG_ENABLE_MODULES_VLC([SECRET], [], [libsecret-1 >= 0.18], [use libsecret for keystore], [auto])

dnl
dnl  kwallet
dnl
AC_ARG_ENABLE([kwallet],
  AS_HELP_STRING([--enable-kwallet],
    [use kwallet (via D-Bus) for keystore (default enabled)]))
AS_IF([test "${enable_kwallet}" != "no" -a "${have_dbus}" = "yes"], [
  VLC_ADD_PLUGIN([kwallet])
])

dnl
dnl update checking system
dnl
AC_ARG_ENABLE([update-check],
  AS_HELP_STRING([--enable-update-check], [update checking system (default disabled)]))
if test "${enable_update_check}" = "yes"
then
 AS_IF([test "${ac_cv_lib_gcrypt}" != "yes"],[
    AC_MSG_ERROR([libgcrypt is required for update checking system]) ])
fi
AM_CONDITIONAL([UPDATE_CHECK], [test "${enable_update_check}" = "yes"])

dnl
dnl OS X notification plugin
dnl
AC_ARG_ENABLE([osx_notifications],
  AS_HELP_STRING([--enable-osx-notifications],
    [macOS notification plugin (default disabled)]),,
  [enable_osx_notifications=no])
AS_IF([test "${enable_osx_notifications}" != "no"], [
  VLC_ADD_PLUGIN([osx_notifications])
])

dnl
dnl Libnotify notification plugin
dnl
PKG_ENABLE_MODULES_VLC([NOTIFY], [], [libnotify gtk+-3.0], [libnotify notification], [auto])

PKG_ENABLE_MODULES_VLC([MEDIALIBRARY], [medialibrary], [medialibrary >= 0.7.1], (medialibrary support), [auto])

dnl
dnl  Endianness check
dnl
AC_C_BIGENDIAN
AS_IF([test "${ac_cv_c_bigendian}" = "yes"], [
  DEFS_BIGENDIAN="-DWORDS_BIGENDIAN=1"
], [
  DEFS_BIGENDIAN=""
])
AC_SUBST([DEFS_BIGENDIAN])

dnl
dnl Where to install KDE solid .desktop
dnl
AC_ARG_WITH(kde-solid,
  AS_HELP_STRING([--with-kde-solid=PATH],
                 [KDE Solid actions directory (auto)]),, [

if test "${SYS}" != "mingw32" -a "${SYS}" != "darwin" -a "${HAVE_ANDROID}" != "1" ; then
  with_kde_solid="yes"
fi
])
soliddatadir=""
AS_IF([test "${with_kde_solid}" != "no"], [
  AS_IF([test "${with_kde_solid}" = "yes"], [
    kde4datadir="`${KDE4_CONFIG} --install data`"
    AS_IF([test "x$kde4datadir" = "x"], [kde4datadir='${datadir}/kde4/apps'])
    soliddatadir="${kde4datadir}/solid/actions"
  ], [
    soliddatadir="${with_kde_solid}"
  ])
])
AC_SUBST([soliddatadir])
AM_CONDITIONAL([KDE_SOLID], [test "x${soliddatadir}" != "x"])

dnl
dnl  Find tools for win32 packaging
dnl
AS_IF([test "${SYS}" = "mingw32"], [
    dnl
    dnl Find makensis required to build the NSIS installer
    dnl
    nsis_major_required="3"
    nsis_version_ok="no"
    AC_PATH_PROG([MAKENSIS], [makensis], [no])
    AS_IF([test "$MAKENSIS" != "no"], [
        # Check version
        AC_MSG_CHECKING([makensis version])
        nsis_version=$($MAKENSIS -VERSION)
        AC_MSG_RESULT([$nsis_version])
        nsis_version_major=$(echo "$nsis_version" | awk -F \. '{print $1}' | sed 's/v//')
        # Check if major version is a valid number
        AS_IF([test -n "$nsis_version_major" && \
               test "$nsis_version_major" -eq "$nsis_version_major" 2> /dev/null], [
            # Do the version check using major version
            AS_IF([test "$nsis_version_major" -lt "$nsis_major_required"], [
                AC_MSG_WARN([makensis too old, (needs ${nsis_major_required}.x, have ${nsis_version_major}.x)])
            ], [
                nsis_version_ok="yes"
            ])
        ], [
            AC_MSG_WARN([failed to check the makensis version])
        ])
    ])
    dnl
    dnl Find 7zip
    dnl
    AC_PATH_PROG([SEVENZIP], [7z], [7z])
])
AM_CONDITIONAL([HAVE_MAKENSIS], [test "x$MAKENSIS" != "xno" && test "$nsis_version_ok" = "yes"])

dnl
dnl Check wether we have the PROCESS_MITIGATION_IMAGE_LOAD_POLICY
dnl It should only be available when building for win10, but some SDKs define it unconditionnaly
dnl
if test "${SYS}" = "mingw32"; then
    AC_CHECK_TYPES([PROCESS_MITIGATION_IMAGE_LOAD_POLICY],,,[#include <windows.h>])
fi

EXTEND_HELP_STRING([Components:])

dnl
dnl  the VLC binary
dnl
AC_ARG_ENABLE([vlc],
  AS_HELP_STRING([--enable-vlc], [build the VLC media player (default enabled)]))
AM_CONDITIONAL([BUILD_VLC], [test "${enable_vlc}" != "no"])

dnl
dnl Fuzzer (at the end not to mess dependencies FLAGS)
dnl
AS_VAR_IF(with_libfuzzer, no, [], [
    LIBS="-lstdc++ ${LIBM}"
    AS_IF([test "${with_libfuzzer}" != "yes"], [
      LIBS="$LIBS -L${with_libfuzzer}"
    ])
    LIBS="$LIBS -lFuzzer"
    AX_CHECK_COMPILE_FLAG(-fsanitize-coverage=trace-pc-guard, [
        AX_APPEND_FLAG([-fsanitize-coverage=trace-pc-guard])
        AX_APPEND_FLAG([-fsanitize-coverage=trace-pc-guard], [CXXFLAGS])
        AX_APPEND_COMPILE_FLAGS([-fsanitize-coverage=trace-cmp])
        AX_APPEND_COMPILE_FLAGS([-fsanitize-coverage=trace-cmp], [CXXFLAGS])
    ], [
        AX_CHECK_COMPILE_FLAG(-fsanitize-coverage=trace-pc, [
            AX_APPEND_FLAG([-fsanitize-coverage=trace-pc])
            AX_APPEND_FLAG([-fsanitize-coverage=trace-pc], [CXXFLAGS])
        ], [
            AC_MSG_ERROR([Sanitizer coverage not supported by your compiler])
        ])
    ])
])

dnl
dnl  Stuff used by the program
dnl
VERSION_MESSAGE="${VERSION} ${CODENAME}"
COPYRIGHT_MESSAGE="Copyright © ${COPYRIGHT_YEARS} the VideoLAN team"
AC_DEFINE_UNQUOTED([VERSION_MESSAGE], "${VERSION_MESSAGE}", [Simple version string])
AC_DEFINE_UNQUOTED([COPYRIGHT_MESSAGE], "${COPYRIGHT_MESSAGE}", [Copyright string])
AC_DEFINE_UNQUOTED([COPYRIGHT_YEARS], "${COPYRIGHT_YEARS}", [The copyright years])
AC_DEFINE_UNQUOTED([CONFIGURE_LINE], "${CONFIGURE_LINE}", [The ./configure command line])
AC_DEFINE_UNQUOTED([PACKAGE_VERSION_MAJOR],${VERSION_MAJOR}, [version major number])
AC_DEFINE_UNQUOTED([PACKAGE_VERSION_MINOR],${VERSION_MINOR}, [version minor number])
AC_DEFINE_UNQUOTED([PACKAGE_VERSION_REVISION],${VERSION_REVISION}, [version revision number])
AC_DEFINE_UNQUOTED([PACKAGE_VERSION_EXTRA],${VERSION_EXTRA}, [version extra number])
AC_DEFINE_UNQUOTED([PACKAGE_VERSION_DEV],"${VERSION_DEV}", [version development string])
AC_SUBST([COPYRIGHT_MESSAGE])
AC_SUBST([VERSION_MESSAGE])
AC_SUBST([VERSION_MAJOR])
AC_SUBST([VERSION_MINOR])
AC_SUBST([VERSION_REVISION])
AC_SUBST([VERSION_EXTRA])
AC_SUBST([COPYRIGHT_YEARS])
AC_DEFINE_UNQUOTED([VLC_COMPILE_BY], "`whoami|sed -e 's/\\\/\\\\\\\/g'`", [user who ran configure])
AC_DEFINE_UNQUOTED([VLC_COMPILE_HOST], "`hostname -f 2>/dev/null || hostname`", [host which ran configure])
AC_DEFINE_UNQUOTED([VLC_COMPILER], "`$CC -v 2>&1 | tail -n 1 | sed -e 's/ *$//'`", [compiler])
dnl
dnl  Handle substvars that use $(top_srcdir)
dnl
CPPFLAGS="-I\$(top_srcdir)/include -I\$(top_builddir)/include ${CPPFLAGS}"

dnl
dnl  Configuration is finished
dnl
AC_SUBST([SYS])
AC_SUBST([ARCH])
AC_SUBST([ALIASES])
AC_SUBST([ASM])
AC_SUBST([MOC])
AC_SUBST([RCC])
AC_SUBST([UIC])
AC_SUBST([WINDRES])
AC_SUBST([WINE_SDK_PATH])
AC_SUBST([LIBEXT])
AC_SUBST([AM_CPPFLAGS])
AC_SUBST([MACOSX_DEPLOYMENT_TARGET])
AC_SUBST([FILE_LIBVLCCORE_DLL])
AC_SUBST([FILE_LIBVLC_DLL])

AC_CONFIG_FILES([
  Makefile
  doc/Makefile
  modules/Makefile
  m4/Makefile
  po/Makefile.in
  share/Makefile
  compat/Makefile
  src/Makefile
  lib/Makefile
  bin/Makefile
  test/Makefile
  modules/hw/mmal/Makefile
  share/vlc.appdata.xml.in
])

AM_COND_IF([HAVE_WIN32], [
  AC_CONFIG_FILES([
    extras/package/win32/NSIS/spad.nsi
    extras/package/win32/NSIS/vlc.win32.nsi
    extras/package/win32/msi/config.wxi
  ])
])

AM_COND_IF([HAVE_DARWIN], [
  AC_CONFIG_FILES([
    modules/gui/macosx/UI/InfoPlist.strings:modules/gui/macosx/Resources/InfoPlist.strings.in
    share/macosx/Info.plist:share/Info.plist.in
  ])
])

dnl Generate makefiles
AC_OUTPUT

dnl Do we have to use make or gmake ?
if make --version 2>&1|grep -q GNU
then
    # GNU make, all seems good
    MAKE=make
else
    # Known GNU make alias (on BSD)
    MAKE=gmake
fi
dnl Shortcut to nice compile message
if test -n $SHELL; then
  SHELL=${CONFIG_SHELL-/bin/sh}
fi
rm -f compile
compile_top_srcdir=`sed -ne "s/^top_srcdir *= *//p" < Makefile`
echo "#! $SHELL
rm -f .error\$\$
ERROR=0
export PATH=\"$PATH\" LANG=C
($MAKE V=1 \$@ 2>&1 || touch .error\$\$)| $compile_top_srcdir/extras/buildsystem/make.pl
test -f .error\$\$ && ERROR=1
rm -f .error\$\$
exit \$ERROR" >compile
chmod a+x compile

echo "
libvlc configuration
--------------------
version               : ${VERSION}
system                : ${SYS}
architecture          : ${ARCH}
optimizations         : ${enable_optimizations}"
if test "${enable_vlc}" != "no"; then
echo "vlc aliases           :${ALIASES}"
else
echo "build vlc executable  : no"
fi
echo "
To build vlc and its plugins, type \`$MAKE', or \`./compile' if you like nice colors."