configure.ac.in

  [if test "x${enable_opie}" = "xyes"; then
     AC_ARG_WITH(qte,
     [    --with-qte=PATH    Qt Embedded headers and libraries])
     if test "x${with_qte}" = "x"
     then
       LDFLAGS_test="-L${QTDIR}/lib"
       CPPFLAGS_test="-I${QTDIR}/include"
     else
       LDFLAGS_test="-L${with_qte}/lib"
       CPPFLAGS_test="-I${with_qte}/include"
     fi

     PLUGINS="${PLUGINS} opie"
     LDFLAGS_opie="${LDFLAGS_opie} ${LDFLAGS_test} -lqte"
     CPPFLAGS_opie="${CPPFLAGS_opie} ${CPPFLAGS_test}"
     if test -x ${QTEDIR}/bin/moc
     then
       MOC=${QTEDIR}/bin/moc
     else
       MOC=moc
     fi
   fi])

dnl
dnl  MacOS X module
dnl
AC_ARG_ENABLE(macosx,
  [  --enable-macosx         MacOS X support (default enabled on MacOS X)],
  [if test "x${enable_macosx}" = "xyes"
   then
     BUILTINS="${BUILTINS} macosx"
     LDFLAGS_macosx="${LDFLAGS_macosx} -framework CoreAudio -framework AudioToolbox -framework IOKit -framework Cocoa -framework Carbon -framework AGL -framework QuickTime -lobjc -ObjC"
   fi],
  [AC_CHECK_HEADERS(Cocoa/Cocoa.h,
     BUILTINS="${BUILTINS} macosx"
     LDFLAGS_macosx="${LDFLAGS_macosx} -framework CoreAudio -framework AudioToolbox -framework IOKit -framework Cocoa -framework Carbon -framework AGL -framework QuickTime -lobjc -ObjC"
   )])

dnl
dnl  QNX RTOS module
dnl
AC_ARG_ENABLE(qnx,
  [  --enable-qnx            QNX RTOS support (default enabled on QNX RTOS)])
    if test "x${enable_qnx}" != "xno"
    then
      AC_CHECK_HEADERS(Ph.h, [
        PLUGINS="${PLUGINS} qnx"
        LDFLAGS_qnx="${LDFLAGS_qnx} -lasound -lph"
      ])
    fi

dnl
dnl  Windows native interface module, built with Borland C++ Builder
dnl
AC_ARG_ENABLE(intfwin,
[  --enable-intfwin        Win32 interface support (default disabled)],
[ if test "x${enable_intfwin}" != "xno"
  then
    AC_ARG_WITH(bcbuilder,
    [    --with-bcbuilder=PATH Borland C++ Builder installation path])
    if test "x${with_bcbuilder}" != "x"
    then
      BCBUILDER="${with_bcbuilder}"
    fi
    PLUGINS="${PLUGINS} win32"
  fi ])

dnl
dnl  ncurses module
dnl
AC_ARG_ENABLE(ncurses,
  [  --enable-ncurses        ncurses interface support (default disabled)],
  [if test "x${enable_ncurses}" = "xyes"; then
     PLUGINS="${PLUGINS} ncurses"
     LDFLAGS_ncurses="${LDFLAGS_ncurses} -lncurses"
   fi])

dnl
dnl  XOSD plugin
dnl
AC_ARG_ENABLE(xosd,
  [  --enable-xosd           xosd interface support (default disabled)])
if test "x${enable_xosd}" = "xyes"
then
  AC_CHECK_HEADER(xosd.h, have_xosd="true", have_xosd="false")
  AC_TRY_COMPILE([#include <xosd.h>],
     [void foo() { xosd_init("foo","bar",12,XOSD_top,2,12,42); }],,
      AC_DEFINE(HAVE_OLD_XOSD_H, 1, Define if <xosd.h> is pre-1.0.0))
  if test "x${have_xosd}" = "xtrue"
  then
    PLUGINS="${PLUGINS} xosd"
    LDFLAGS_xosd="${LDFLAGS_xosd} -lxosd"
  fi
fi

dnl
dnl  Lirc plugin
dnl
AC_ARG_ENABLE(lirc,
  [  --enable-lirc           lirc support (default disabled)])
if test "x${enable_lirc}" = "xyes"
then
  AC_CHECK_HEADER(lirc/lirc_client.h, AC_CHECK_LIB(lirc_client, lirc_init, have_lirc="true", have_lirc="false"),have_lirc="false")
  if test "x${have_lirc}" = "xtrue"
  then
    PLUGINS="${PLUGINS} lirc"
    LDFLAGS_lirc="${LDFLAGS_lirc} -llirc_client"
  fi
fi

AC_ARG_WITH(,[Misc options:])

dnl
dnl  Endianness check, AC_C_BIGENDIAN doesn't work if we are cross-compiling
dnl
dnl  We give the user the opportunity to specify
dnl  --with-words=big or --with-words=little ; otherwise, try to guess
dnl
AC_ARG_WITH(words,
  [  --with-words=endianness set endianness (big or little)])
  case "x${with_words}" in
    xbig)
      ac_cv_c_bigendian=yes
      ;;
    xlittle)
      ac_cv_c_bigendian=no
      ;;
    *)
      dnl  Try to guess endianness by matching patterns on a compiled
      dnl  binary, by looking for an ASCII or EBCDIC string
      AC_CACHE_CHECK([whether the byte order is big-endian],
        [ac_cv_c_bigendian],
        [ac_cv_c_bigendian="unknown"
        [cat >conftest.c <<EOF
        short am[] = { 0x4249, 0x4765, 0x6e44, 0x6961, 0x6e53, 0x7953, 0 };
        short ai[] = { 0x694c, 0x5454, 0x656c, 0x6e45, 0x6944, 0x6e61, 0 };
        void _a(void) { char*s = (char*)am; s = (char *)ai; }
        short ei[] = { 0x89D3, 0xe3e3, 0x8593, 0x95c5, 0x89c4, 0x9581, 0 };
        short em[] = { 0xc2c9, 0xc785, 0x95c4, 0x8981, 0x95e2, 0xa8e2, 0 };
        void _e(void) { char*s = (char*)em; s = (char*)ei; }
        int main(void) { _a(); _e(); return 0; }
EOF
        ]
        if test -f conftest.c
        then
          if ${CC-cc} -c conftest.c -o conftest.o >>config.log 2>&1 \
              && test -f conftest.o
          then
            if test "`strings conftest.o | grep BIGenDianSyS`"
            then
              ac_cv_c_bigendian="yes"
            fi
            if test "`strings conftest.o | grep LiTTleEnDian`"
            then
              ac_cv_c_bigendian="no"
            fi
          fi
        fi
      ])
      if test "x${ac_cv_c_bigendian}" = "xunknown"
      then
        AC_MSG_ERROR([Could not guess endianness, please use --with-words])
      fi
      ;;
  esac
dnl  Now we know what to use for endianness, just put it in the header
if test "${ac_cv_c_bigendian}" = "yes"
then
  AC_DEFINE(WORDS_BIGENDIAN, 1, big endian system)
fi

dnl
dnl  Profiling
dnl
AC_ARG_ENABLE(gprof,
[  --enable-gprof          gprof profiling (default disabled)])
AC_ARG_ENABLE(cprof,
[  --enable-cprof          cprof profiling (default disabled)])
AM_CONDITIONAL(GPROF, test "x${enable_gprof}" = "xyes")
AM_CONDITIONAL(CPROF, test "x${enable_gprof}" = "xyes")

dnl
dnl  GNU portable threads
dnl
AC_ARG_ENABLE(pth,
  [  --enable-pth            GNU Pth support (default disabled)],
  [ if test "x${enable_pth}" = "xyes"; then
    AC_CHECK_LIB(pth,pth_init)
    AC_EGREP_HEADER(pth_init,pth.h,[
      AC_DEFINE(PTH_INIT_IN_PTH_H, 1,
                Define if <pth.h> defines pth_init)
    THREAD_LIB="-lpth"
    fi])
])

dnl
dnl  State Threads
dnl
AC_ARG_ENABLE(st,
  [  --enable-st             State Threads (default disabled)],
  [ if test "x${enable_st}" = "xyes"; then
    AC_CHECK_LIB(st,st_init)
    AC_EGREP_HEADER(st_init,st.h,[
      AC_DEFINE(ST_INIT_IN_ST_H, 1,
                Define if <st.h> defines st_init)
    THREAD_LIB="-lst"
    fi])
])

if test "x${SYS}" != "xmingw32"; then
  LDFLAGS_vlc="${LDFLAGS_vlc} ${THREAD_LIB}"
  LDFLAGS_plugins="${LDFLAGS_plugins} ${THREAD_LIB}"
fi

dnl
dnl  Mozilla plugin
dnl
mozilla=false
AC_ARG_ENABLE(mozilla,
  [  --enable-mozilla        build a vlc-based Mozilla plugin (default disabled)])
if test "x${enable_mozilla}" = "xyes"
then
  AC_PATH_PROG(MOZILLA_CONFIG, mozilla-config, no)
  if test "x${MOZILLA_CONFIG}" != "xno"
  then
    if test "x${SYS}" != "xmingw32"; then
      LDFLAGS="${LDFLAGS_save} -L${x_libraries}"
      AC_CHECK_LIB(Xt,XtStrings,[
        LDFLAGS_mozilla="${LDFLAGS_mozilla} -L${x_libraries} -lXt"
      ])
      LDFLAGS="${LDFLAGS_save}"
    fi
    mozilla=:
    dnl Workaround for http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=150490
    [CPPFLAGS_mozilla="${CPPFLAGS_mozilla} `${MOZILLA_CONFIG} --cflags plugin xpcom java | sed 's,-I\([^ ]*\)/mozilla/\([^ ]*\),-I\1/\2 -I\1/mozilla/\2,g' | xargs`"]
    #[CPPFLAGS_mozilla="${CPPFLAGS_mozilla} `${MOZILLA_CONFIG} --cflags plugin xpcom java --defines | sed 's,-I\([^ ]*\)/mozilla/\([^ ]*\),-I\1/\2 -I\1/mozilla/\2,g' | xargs`"]
    LDFLAGS_mozilla="${LDFLAGS_mozilla} `${MOZILLA_CONFIG} --libs plugin xpcom`"
    dnl Not necessarily in ${PATH}
    if test "x${XPIDL}" = "x" -o ! -x "${XPIDL}"
    then
      XPIDL="/usr/lib/mozilla/xpidl"
    fi
  fi
fi
AM_CONDITIONAL(BUILD_MOZILLA,${mozilla})

dnl
dnl  test plugins
dnl
AC_ARG_ENABLE(testsuite,
  [  --enable-testsuite      build test modules (default disabled)])
if test "x${enable_testsuite}" = "xyes"
then
  TESTS="test1 test2 test3 test4"

  dnl  we define those so that bootstrap sets the right linker
  CXXFLAGS_test2="${CXXFLAGS_test2}"
  OBJCFLAGS_test3="${OBJCFLAGS_test3}"
  dnl  this one is needed until automake knows what to do
  LDFLAGS_test3="${LDFLAGS_test3} -lobjc"

  PLUGINS="${PLUGINS} ${TESTS}"
  #BUILTINS="${BUILTINS} ${TESTS}"
fi

dnl
dnl  gtk_main plugin
dnl
if test "x${NEED_GTK_MAIN}" != "xno"
then
    PLUGINS="${PLUGINS} gtk_main"
    CFLAGS_gtk="${CFLAGS_gtk} -DNEED_GTK_MAIN"
    CFLAGS_gtk_main="${CFLAGS_gtk_main} ${CFLAGS_gtk} ${CFLAGS_familiar}"
    LDFLAGS_gtk_main="${LDFLAGS_gtk_main} ${LDFLAGS_gtk} ${LDFLAGS_familiar}"
fi

if test "x${NEED_GNOME_MAIN}" != "xno"
then
    PLUGINS="${PLUGINS} gnome_main"
    CFLAGS_gnome_main="${CFLAGS_gnome_main} ${CFLAGS_gtk} ${CFLAGS_familiar} ${CFLAGS_gnome}"
    LDFLAGS_gnome_main="${LDFLAGS_gnome_main} ${LDFLAGS_gtk} ${LDFLAGS_familiar} ${LDFLAGS_gnome}"
fi

dnl
dnl  Plugin and builtin checks
dnl
builtin_support=false
plugin_support=:

dnl Support for plugins - this must be AT THE END
AC_ARG_ENABLE(plugins,
  [  --disable-plugins       make all plugins built-in (default plugins enabled)],
  [if test "x${enable_plugins}" = "xno"
   then
     plugin_support=false
   fi])

dnl Automagically disable plugins if there is no system support for
dnl dynamically loadable files (.so, .dll, .dylib).
dnl don't forget vlc-win32 still can load .dll as plugins
if test "x${ac_cv_header_dlfcn_h}" = "xno" -a "x${ac_cv_header_image_h}" = "xno" -a "x${SYS}" != "xmingw32"
then
  echo "*** Your system doesn't have plugin support. All plugins will be built"
  echo "statically."
  plugin_support=false
fi

dnl Export automake variables
if ${plugin_support}
then
  for plugin in `echo ${PLUGINS}`
  do
    eval "${plugin}_plugin=yes"
  done
else
  BUILTINS="${BUILTINS} ${PLUGINS}"
  PLUGINS=
fi
AM_CONDITIONAL(HAVE_PLUGINS, ${plugin_support})

[if echo "${BUILTINS}" | grep '[^ ]' >/dev/null 2>&1
then
  builtin_support=:
  for builtin in `echo ${BUILTINS}`
  do
    eval "${builtin}_builtin=yes"
  done
fi]
AM_CONDITIONAL(HAVE_BUILTINS, ${builtin_support})

dnl do not touch this line (bootstrap needs it)


dnl
dnl  Stuff used by the program
dnl
AC_DEFINE_UNQUOTED(VERSION_MESSAGE, "${VERSION} ${CODENAME}", [Simple version string])
AC_DEFINE_UNQUOTED(COPYRIGHT_MESSAGE, "VideoLAN Client - version ${VERSION} ${CODENAME} - (c) 1996-2002 VideoLAN", [Copyright string])
AC_DEFINE_UNQUOTED(CONFIGURE_LINE, "${CONFIGURE_LINE}", [The ./configure command line])

VLC_SYMBOL="`echo ${VERSION} | tr .- __`"
AC_DEFINE_UNQUOTED(MODULE_SUFFIX, "__${VLC_SYMBOL}", [String suffix for module functions])
AC_DEFINE_UNQUOTED(MODULE_SYMBOL, ${VLC_SYMBOL}, [Symbol suffix for module functions])
AC_DEFINE_UNQUOTED(LIBEXT, "${LIBEXT}", [Dynamic object extension])

DATA_PATH="${ac_tool_prefix}/share/videolan"
AC_SUBST(DATA_PATH)
PLUGIN_PATH="${ac_tool_prefix}/share/videolan"
AC_SUBST(PLUGIN_PATH)

dnl
dnl  Restore *FLAGS
dnl
CPPFLAGS="${CPPFLAGS_save}"
CFLAGS="${CFLAGS_save}"
CXXFLAGS="${CXXFLAGS_save}"
OBJCFLAGS="${OBJCFLAGS_save}"
LDFLAGS="${LDFLAGS_save}"

dnl
dnl  Fool automake (see Makefile.am)
dnl
AUTOMAKE_SUCKS="\$(L_builtin) \$(LDFLAGS_builtin)"
AC_SUBST(AUTOMAKE_SUCKS)

dnl
dnl  Create the vlc-config script
dnl
LDFLAGS_libvlc="${LDFLAGS_vlc} ${LDFLAGS_builtins}"
for i in `echo "${BUILTINS}" | sed -e 's@[^ ]*/@@g'` ; do LDFLAGS_libvlc="${LDFLAGS_libvlc} ${libdir}/vlc/${i}.a `eval echo '$'{LDFLAGS_${i}}`" ; done

dnl
dnl  Configuration is finished
dnl
AC_SUBST(SYS)
AC_SUBST(ARCH)
AC_SUBST(PLUGINS)
AC_SUBST(BUILTINS)
AC_SUBST(ALIASES)
AC_SUBST(ASM)
AC_SUBST(MOC)
AC_SUBST(WINDRES)
AC_SUBST(BCBUILDER)
AC_SUBST(XPIDL)
AC_SUBST(LIBEXT)
AC_SUBST(INCLUDES)

AC_SUBST(CFLAGS_TUNING)
AC_SUBST(CFLAGS_OPTIM)
AC_SUBST(CFLAGS_OPTIM_NODEBUG)
AC_SUBST(LDFLAGS)

AC_SUBST(CFLAGS_vlc)
AC_SUBST(CFLAGS_pics)
AC_SUBST(CFLAGS_plugins)
AC_SUBST(CFLAGS_builtins)
AC_SUBST(CPPFLAGS_mozilla)

AC_SUBST(LDFLAGS_vlc)
AC_SUBST(LDFLAGS_libvlc)
AC_SUBST(LDFLAGS_plugins)
AC_SUBST(LDFLAGS_builtins)
AC_SUBST(LDFLAGS_mozilla)

AC_OUTPUT([
  Makefile
  debian/Makefile
  doc/Makefile
  intl/Makefile
  ipkg/Makefile
  lib/Makefile
  m4/Makefile
  modules/Makefile
  po/Makefile.in
  share/Makefile
  src/Makefile
  vlc-config
],[
  chmod a+x vlc-config
])

printf "
vlc configuration
--------------------
vlc version           : ${VERSION}
system                : ${SYS}
architecture          : ${ARCH}
build flavour         : "
test "x${DEBUG_TRUE}" = "x" && printf "debug "
test "x${CPROF_TRUE}" = "x" && printf "cprof "
test "x${GPROF_TRUE}" = "x" && printf "gprof "
test "x${OPTIM_TRUE}" = "x" && printf "optim "
test "x${RELEASE_TRUE}" = "x" && printf "release " || printf "devel "
echo "
vlc aliases           :${ALIASES}

To build vlc and its plugins, type \`make'.
"