configure.ac

    VLC_ADD_LDFLAGS([skins2],[-L${x_libraries} -lXext -lX11])
  fi fi
fi


dnl dnl
dnl dnl  Gtk+ module
dnl dnl
dnl AC_ARG_ENABLE(gtk,
dnl   [  --enable-gtk            Gtk+ support (default enabled)])
dnl if test "${enable_gtk}" != "no"
dnl then
dnl   GTK_PATH="${PATH}"
dnl   AC_ARG_WITH(gtk-config-path,
dnl     [    --with-gtk-config-path=PATH gtk-config path (default search in \$PATH)],
dnl     [ if test "${with_gtk_config_path}" != "no"
dnl       then
dnl         GTK_PATH="${with_gtk_config_path}:${PATH}"
dnl       fi ])
dnl   # look for gtk-config
dnl   AC_PATH_PROG(GTK12_CONFIG, gtk12-config, no, ${GTK_PATH})
dnl   GTK_CONFIG=${GTK12_CONFIG}
dnl   if test "${GTK_CONFIG}" = "no"
dnl   then
dnl     AC_PATH_PROG(GTK_CONFIG, gtk-config, no, ${GTK_PATH})
dnl   fi
dnl   if test "${GTK_CONFIG}" != "no"
dnl   then
dnl     if expr 1.2.0 \> `${GTK_CONFIG} --version` >/dev/null
dnl     then
dnl       AC_MSG_ERROR([Your development package for Gtk+ is too old, you need at least version 1.2.0. Please upgrade and try again. Alternatively you can also configure with --disable-gtk.])
dnl     fi
dnl     if test "${SYS}" != "mingw32"; then
dnl       VLC_ADD_CFLAGS([gtk],[`${GTK_CONFIG} --cflags gtk gthread`])
dnl       VLC_ADD_LDFLAGS([gtk],[`${GTK_CONFIG} --libs gtk gthread | sed 's,-rdynamic,,'`])
dnl     else
dnl       VLC_ADD_CFLAGS([gtk],[`${GTK_CONFIG} --cflags gtk`])
dnl       VLC_ADD_LDFLAGS([gtk],[`${GTK_CONFIG} --libs gtk | sed 's,-rdynamic,,'`])
dnl     fi
dnl     # now look for the gtk.h header
dnl     CPPFLAGS="${CPPFLAGS_save} ${CFLAGS_gtk}"
dnl     ac_cv_gtk_headers=yes
dnl     AC_CHECK_HEADERS(gtk/gtk.h glib.h gdk/gdk.h, , [
dnl       ac_cv_gtk_headers=no
dnl       echo "Cannot find gtk development headers."
dnl     ])
dnl     if test "${ac_cv_gtk_headers}" = "yes"
dnl     then
dnl       VLC_ADD_PLUGINS([gtk])
dnl       if test "${SYS}" != "mingw32"; then
dnl         NEED_GTK_MAIN=yes
dnl       fi
dnl       ALIASES="${ALIASES} gvlc"
dnl     fi
dnl     CPPFLAGS="${CPPFLAGS_save}"
dnl   fi
dnl fi
dnl 
dnl
dnl  Gtk+2 module ! Disabled for now as it is unusable and confuses users
dnl
dnl AC_ARG_ENABLE(gtk2,
dnl   [  --enable-gtk2           Gtk2 support (default disabled)])
dnl if test "${enable_gtk2}" = "yes"
dnl then
dnl   PKG_CHECK_MODULES(GTK2, [gtk+-2.0 >= 2.0.0, gthread-2.0])
dnl   VLC_ADD_CFLAGS([gtk2],[${GTK2_CFLAGS}])
dnl   VLC_ADD_LDFLAGS([gtk2],[${GTK2_LIBS}])
dnl   VLC_ADD_PLUGINS([gtk2])
dnl   if test "${SYS}" != "mingw32"; then
dnl     NEED_GTK2_MAIN=yes
dnl   fi
dnl fi

dnl
dnl  PDA Gtk+2 module
dnl
AC_ARG_ENABLE(pda,
  [  --enable-pda            PDA interface needs Gtk2 support (default disabled)])
if test "${enable_pda}" = "yes"
then
  PKG_CHECK_MODULES(GTK2, [gtk+-2.0 >= 2.0.0, gthread-2.0])
  VLC_ADD_CFLAGS([gtk2],[${GTK2_CFLAGS}])
  VLC_ADD_LDFLAGS([gtk2],[${GTK2_LIBS}])
  VLC_ADD_CFLAGS([pda],[${GTK2_CFLAGS} ${CFLAGS_pda}])
  VLC_ADD_LDFLAGS([pda],[${GTK2_LIBS} ${LDFLAGS_pda}])
  VLC_ADD_PLUGINS([pda])
  if test "${SYS}" != "mingw32"; then
    NEED_GTK2_MAIN=yes
  fi
fi

dnl dnl
dnl dnl  Gnome module
dnl dnl
dnl AC_ARG_ENABLE(gnome,
dnl   [  --enable-gnome          Gnome interface support (default disabled)],
dnl   [if test "${enable_gnome}" = "yes"; then
dnl     # look for gnome-config
dnl     AC_PATH_PROG(GNOME_CONFIG, gnome-config, no)
dnl     if test -x ${GNOME_CONFIG}
dnl     then
dnl        VLC_ADD_CFLAGS([gnome],[`${GNOME_CONFIG} --cflags gtk gnomeui`])
dnl        VLC_ADD_LDFLAGS([gnome],[`${GNOME_CONFIG} --libs gnomeui | sed 's,-rdynamic,,'`])
dnl     fi
dnl     # now look for the gnome.h header
dnl     CPPFLAGS="${CPPFLAGS_save} ${CFLAGS_gnome}"
dnl     AC_CHECK_HEADERS(gnome.h, [
dnl       VLC_ADD_PLUGINS([gnome])
dnl       NEED_GTK_MAIN=yes
dnl       NEED_GNOME_MAIN=yes
dnl       ALIASES="${ALIASES} gnome-vlc"
dnl       dnl We need this because of some moronic gnomesupport.h flavours
dnl       AC_MSG_CHECKING(for strndup in gnome.h)
dnl       AC_EGREP_HEADER(strndup,gnome.h,[
dnl         AC_MSG_RESULT(yes)
dnl         AC_DEFINE(STRNDUP_IN_GNOME_H, 1,
dnl                   Define if <gnome.h> defines strndup.)],[
dnl         AC_MSG_RESULT(no)])
dnl      ],[
dnl       AC_MSG_ERROR([Can't find gnome headers. Please install the gnome
dnl developement tools or remove the --enable-gnome option])
dnl      ])
dnl     CPPFLAGS="${CPPFLAGS_save}"
dnl   fi])

dnl
dnl  Gnome2 module ! Disabled for know as it is unuseable and confuses users
dnl
dnl AC_ARG_ENABLE(gnome2,
dnl   [  --enable-gnome2         Gnome2 support (default disabled)])
dnl if test "${enable_gnome2}" = "yes"
dnl then
dnl   PKG_CHECK_MODULES(GNOME2, [libgnomeui-2.0])
dnl   VLC_ADD_CFLAGS([gnome2],[${GNOME2_CFLAGS}])
dnl   VLC_ADD_LDFLAGS([gnome2],[${GNOME2_LIBS}])
dnl   VLC_ADD_PLUGINS([gnome2])
dnl   if test "${SYS}" != "mingw32"; then
dnl     NEED_GNOME2_MAIN=yes
dnl   fi
dnl fi

dnl
dnl  wxWindows module
dnl
AC_ARG_ENABLE(wxwindows,
  [  --enable-wxwindows      wxWindows support (default enabled)])
if test "${enable_wxwindows}" != "no"
then
  WXWINDOWS_PATH="${PATH}"
  AC_ARG_WITH(wx-config-path,
    [    --with-wx-config-path=PATH wx-config path (default search in \$PATH)],
    [ if test "${with_wx_config_path}" != "no"
      then
        WXWINDOWS_PATH="${with_wx_config_path}:${PATH}"
      fi ])
  # look for wx-config
  AC_PATH_PROG(WX_CONFIG, wx-config, no, ${WXWINDOWS_PATH})
  if test "${WX_CONFIG}" != "no"
  then
    if expr 2.3.0 \> `${WX_CONFIG} --version` >/dev/null
    then
      AC_MSG_ERROR([Your development package for wxWindows is too old, you need at least version 2.3.0. Please upgrade and try again. Alternatively you can also configure with --disable-wxwindows.])
    fi
    AC_LANG_PUSH(C++)
    VLC_ADD_CXXFLAGS([wxwindows],[`${WX_CONFIG} --cxxflags`])
    VLC_ADD_LDFLAGS([wxwindows],[`${WX_CONFIG} --libs`])
    # now look for the wxprec.h header
    CPPFLAGS="${CPPFLAGS_save} ${CXXFLAGS_wxwindows}"
    ac_cv_wx_headers=yes
    AC_CHECK_HEADERS(wx/wxprec.h, , [
      ac_cv_wx_headers=no
      echo "Cannot find wxWindows development headers."
    ])
    if test "${ac_cv_wx_headers}" = "yes"
    then
      VLC_ADD_PLUGINS([wxwindows])
      ALIASES="${ALIASES} wxvlc"
    fi
    CPPFLAGS="${CPPFLAGS_save}"
    AC_LANG_POP(C++)
  fi
fi

dnl dnl
dnl dnl  Qt module
dnl dnl
dnl AC_ARG_ENABLE(qt,
dnl   [  --enable-qt             Qt interface support (default disabled)],
dnl   [if test "${enable_qt}" = "yes"; then
dnl      VLC_ADD_PLUGINS([qt])
dnl      ALIASES="${ALIASES} qvlc"
dnl      VLC_ADD_LDFLAGS([qt],[-L${QTDIR}/lib])
dnl      LDFLAGS="${LDFLAGS_save} ${LDFLAGS_qt}"
dnl      AC_CHECK_LIB(qt-mt,main,[
dnl        VLC_ADD_LDFLAGS([qt],[-lqt-mt])
dnl      ],[
dnl        AC_CHECK_LIB(qt,main,[
dnl          VLC_ADD_LDFLAGS([qt],[-lqt])
dnl        ])
dnl      ])
dnl      LDFLAGS="${LDFLAGS_save}"
dnl      VLC_ADD_CXXFLAGS([qt],[-I/usr/include/qt3 -I/usr/include/qt -I${QTDIR}/include])
dnl      if test -x ${QTDIR}/bin/moc
dnl      then
dnl        MOC=${QTDIR}/bin/moc
dnl      else
dnl        MOC=moc
dnl      fi
dnl    fi])
dnl 
dnl dnl
dnl dnl  KDE module
dnl dnl
dnl AC_ARG_ENABLE(kde,
dnl   [  --enable-kde            KDE interface support (default disabled)],
dnl   [if test "${enable_kde}" = "yes"; then
dnl      VLC_ADD_PLUGINS([kde])
dnl      ALIASES="${ALIASES} kvlc"
dnl      VLC_ADD_LDFLAGS([kde],[-L${KDEDIR}/lib])
dnl      dnl Check for -lkfile (only in KDE 2) or -lkdeui -lkio (KDE 3)
dnl      LDFLAGS="${LDFLAGS_save} ${LDFLAGS_kde}"
dnl      AC_CHECK_LIB(kfile,main,[
dnl        VLC_ADD_LDFLAGS([kde],[-lkfile])
dnl      ])
dnl      LDFLAGS="${LDFLAGS_save} ${LDFLAGS_kde}"
dnl      AC_CHECK_LIB(kdeui,main,[
dnl        VLC_ADD_LDFLAGS([kde],[-lkdeui])
dnl      ])
dnl      LDFLAGS="${LDFLAGS_save} ${LDFLAGS_kde}"
dnl      AC_CHECK_LIB(kio,main,[
dnl        VLC_ADD_LDFLAGS([kde],[-lkio])
dnl      ])
dnl      LDFLAGS="${LDFLAGS_save}"
dnl      VLC_ADD_CXXFLAGS([kde],[-I/usr/include/kde -I/usr/include/qt3 -I/usr/include/qt])
dnl      VLC_ADD_CXXFLAGS([kde],[-I${KDEDIR}/include -I${QTDIR}/include])
dnl      if test -x ${QTDIR}/bin/moc
dnl      then
dnl        MOC=${QTDIR}/bin/moc
dnl      else
dnl        MOC=moc
dnl      fi
dnl    fi])

dnl
dnl  Opie QT embedded module
dnl
AC_ARG_ENABLE(opie,
  [  --enable-opie           Qt embedded interface support (default disabled)],
  [if test "${enable_opie}" = "yes"; then
     AC_ARG_WITH(qte,
     [    --with-qte=PATH       Qt Embedded headers and libraries])
     if test "${with_qte}" != "no" -a -n "${with_qte}"
     then
       VLC_ADD_LDFLAGS([qte],[-L${with_qte}/lib `echo -L${with_qte}/lib | sed 's,opt/QtPalmtop,usr,'` -ljpeg -lqte])
       VLC_ADD_CXXFLAGS([qte],[-I${with_qte}/include `echo -I${with_qte}/include | sed 's,opt/QtPalmtop,usr,'` -DQT_QWS_IPAQ -DQWS -fno-exceptions -fno-rtti])
     else
       VLC_ADD_LDFLAGS([qte],[-L${QTDIR}/lib `echo -L${QTDIR}/lib | sed 's,opt/QtPalmtop,usr,'`])
       VLC_ADD_CXXFLAGS([qte],[-I${QTDIR}/include `echo -I${QTDIR}/include | sed 's,opt/QtPalmtop,usr,'`])
     fi
     CPPFLAGS="${CPPFLAGS_save} ${CXXFLAGS_qte}"
     AC_CHECK_HEADERS(qt.h jpeglib.h, ,[
       AC_MSG_ERROR([echo "Cannot find QT Embedded development headers."])
     ] )
     CPPFLAGS="${CPPFLAGS_save}"

     VLC_ADD_PLUGINS([opie])
     NEED_QTE_MAIN=yes
     VLC_ADD_LDFLAGS([opie],[-lqpe ${LDFLAGS_qte}])
     VLC_ADD_CXXFLAGS([opie],[${CXXFLAGS_qte}])
     if test "${with_qte}" != "no" -a -n "${with_qte}"
     then
       MOC=${with_qte}/bin/moc
     else
       MOC=${QTDIR}/bin/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 "${enable_macosx}" = "yes"
   then
     VLC_ADD_BUILTINS([macosx])
     VLC_ADD_LDFLAGS([macosx],[-framework IOKit -framework Cocoa -framework Carbon -framework QuickTime -lobjc -ObjC -framework OpenGL])
   fi],
  [AC_CHECK_HEADERS(Cocoa/Cocoa.h,
     VLC_ADD_BUILTINS([macosx])
     VLC_ADD_LDFLAGS([macosx],[-framework IOKit -framework Cocoa -framework Carbon -framework QuickTime -lobjc -ObjC -framework OpenGL])
   )])

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

dnl
dnl  ncurses module
dnl
AC_ARG_ENABLE(ncurses,
  [  --enable-ncurses        ncurses interface support (default disabled)],
  [if test "${enable_ncurses}" = "yes"; then
     VLC_ADD_PLUGINS([ncurses])
     VLC_ADD_LDFLAGS([ncurses],[-lncurses])
   fi])

dnl
dnl  XOSD plugin
dnl
AC_ARG_ENABLE(xosd,
  [  --enable-xosd           xosd interface support (default disabled)])
if test "${enable_xosd}" = "yes"
then
  AC_CHECK_HEADER(xosd.h, have_xosd="true", have_xosd="false")
  AC_CHECK_LIB(xosd,xosd_set_offset,
      AC_DEFINE(HAVE_XOSD_VERSION_1, 1, Define if <xosd.h> is 1.0.x),
    AC_CHECK_LIB(xosd,xosd_set_horizontal_offset,
        AC_DEFINE(HAVE_XOSD_VERSION_2, 1, Define if <xosd.h> is 2.0.x),
      AC_TRY_COMPILE([#include <xosd.h>],
         [void foo() { xosd_init("foo","bar",12,XOSD_top,2,12,42); }],,
          AC_DEFINE(HAVE_XOSD_VERSION_0, 1, Define if <xosd.h> is pre-1.0.0))))
  if test "${have_xosd}" = "true"
  then
    VLC_ADD_PLUGINS([xosd])
    VLC_ADD_LDFLAGS([xosd],[-lxosd])
  fi
fi

dnl
dnl Visualisation plugin
dnl
AC_ARG_ENABLE(visual,
  [  --enable-visual          visualisation plugin (default enabled)])
if test "${enable_visual}" != "no"
then
    VLC_ADD_PLUGINS([visual])
fi

dnl
dnl  goom visualization plugin
dnl
AC_ARG_ENABLE(goom,
[  --enable-goom           goom visualisation plugin (default disabled)])
if test "${enable_goom}" = "yes"
then
  AC_ARG_WITH(goom-tree,
    [    --with-goom-tree=PATH goom tree for static linking (required)])

  dnl
  dnl test for --with-goom-tree
  dnl
  if test "${with_goom_tree}" != "no" -a -n "${with_goom_tree}"; then
    AC_MSG_CHECKING(for libgoom2.a in ${with_goom_tree})
    real_goom_tree="`cd ${with_goom_tree} 2>/dev/null && pwd`"
    if test -z "${real_goom_tree}"; then
      dnl  The given directory can't be found
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot cd to ${with_goom_tree}])
    fi
    if test -f "${real_goom_tree}/src/.libs/libgoom2.a"; then
      AC_MSG_RESULT(${real_goom_tree}/src/.libs/libgoom2.a)
      VLC_ADD_BUILTINS([goom])
      VLC_ADD_LDFLAGS([goom],[-L${real_goom_tree}/src/.libs -lgoom2])
      VLC_ADD_CPPFLAGS([goom],[-I${real_goom_tree}/src -DUSE_GOOM_TREE])
    else
      dnl  The given libgoom2 wasn't built, try to look for the old goom
      AC_MSG_RESULT(no)
      AC_MSG_CHECKING(for libgoom.a in ${with_goom_tree})
      if test -f "${real_goom_tree}/libgoom.a"; then
        AC_MSG_RESULT(${real_goom_tree}/libgoom.a)
        VLC_ADD_BUILTINS([goom])
        VLC_ADD_LDFLAGS([goom],[-L${real_goom_tree} -lgoom])
        VLC_ADD_CPPFLAGS([goom],[-I${real_goom_tree} -DUSE_GOOM_TREE -DOLD_GOOM])
      else
        dnl  The given libgoom wasn't built
        AC_MSG_RESULT(no)
        AC_MSG_ERROR([cannot find ${real_goom_tree}/src/.libs/libgoom2.a, make sure you compiled goom in ${with_goom_tree}])
      fi
    fi
  else
    AC_CHECK_HEADERS(goom/goom.h, [
      AC_CHECK_LIB(goom2, goom_init, [
        VLC_ADD_PLUGINS([goom])
        VLC_ADD_LDFLAGS([goom],[-lgoom2])
      ],[
        AC_MSG_ERROR([Could not find goom on your system: you may get it from http://www.ios-software.com/.])
      ])
    ])
  fi
fi

dnl
dnl  SLP access plugin
dnl
AC_ARG_ENABLE(slp,
  [  --enable-slp            SLP service discovery support (default disabled)])
if test "${enable_slp}" = "yes"
then
  AC_ARG_WITH(slp,
  [    --with-slp=PATH       libslp headers and libraries])
  if test -z "${with_slp}"
  then
    AC_CHECK_HEADERS(slp.h, have_slp="true", have_slp="false")
    if test "${have_slp}" = "true"
    then
      VLC_ADD_PLUGINS([slp])
      VLC_ADD_LDFLAGS([slp],[-lslp])
      VLC_ADD_LDFLAGS([stream_out_standard],[-lslp])
    fi
  else
    AC_MSG_CHECKING(for slp headers in ${with_slp})
    if test -f ${with_slp}/slp.h
    then
      dnl  Use ${with_slp}/libslp/slp.h
      AC_MSG_RESULT(yes)
      VLC_ADD_PLUGINS([slp])
      VLC_ADD_LDFLAGS([slp],[-L${with_slp} -lslp])
      VLC_ADD_LDFLAGS([stream_out_standard],[-L${with_slp} -lslp])
      VLC_ADD_CPPFLAGS([slp],[-I${with_slp}])
      AC_DEFINE(HAVE_SLP_H)
    else
      dnl  No libslp could be found, sorry
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot find ${with_slp}/slp.h])
    fi
  fi
fi

dnl
dnl  Lirc plugin
dnl
AC_ARG_ENABLE(lirc,
  [  --enable-lirc           lirc support (default disabled)])
if test "${enable_lirc}" = "yes"
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 "${have_lirc}" = "true"
  then
    VLC_ADD_PLUGINS([lirc])
    VLC_ADD_LDFLAGS([lirc],[-llirc_client])
  fi
fi

dnl 
dnl  Joystick plugin
dnl
AC_ARG_ENABLE(joystick,
  [  --enable-joystick       joystick control (default disabled)])
if test "${enable_joystick}" = "yes"
then
 AC_CHECK_HEADER( linux/joystick.h, 
		[VLC_ADD_PLUGINS([joystick])]
	        )
fi

dnl
dnl corba (ORBit) plugin
dnl
dnl Default: do not enable corba
enablecorba=false
AC_ARG_ENABLE(corba,
  [  --enable-corba          corba interface support (default disabled)])
if test "${enable_corba}" = "yes"; then
      GLIB_VERSION=2.3.2
      PKG_CHECK_MODULES(CORBA, 
	ORBit-2.0 >= 2.8.0 \
	glib-2.0 >= $GLIB_VERSION \
	gobject-2.0 >= $GLIB_VERSION \
	gthread-2.0 >= $GLIB_VERSION,
	[
	  enablecorba=true
 	  VLC_ADD_LDFLAGS([corba],[$CORBA_LIBS])
      	  VLC_ADD_CFLAGS([corba],[$CORBA_CFLAGS])
          VLC_ADD_PLUGINS([corba snapshot]) ],
        [ enablecorba=false
	  AC_MSG_WARN(corba library not found) ])
fi
AM_CONDITIONAL(ENABLE_CORBA, test "$enablecorba" = "true")

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 "${with_words}" in
    big)
      ac_cv_c_bigendian=yes
      ;;
    little)
      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 "${ac_cv_c_bigendian}" = "unknown"
      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  Mozilla plugin
dnl
mozilla=false
AC_ARG_ENABLE(mozilla,
  [  --enable-mozilla        build a vlc-based Mozilla plugin (default disabled)])
if test "${enable_mozilla}" = "yes" -a "${SYS}" != "mingw32"
then
  AC_PATH_PROG(MOZILLA_CONFIG, mozilla-config, no)
  if test "${MOZILLA_CONFIG}" = "no"
  then
    AC_MSG_ERROR([Please install the Mozilla development tools, mozilla-config was not found.])
  else
    if test "${SYS}" != "mingw32"; then
      LDFLAGS="${LDFLAGS_save} -L${x_libraries}"
      AC_CHECK_LIB(Xt,XtStrings,[
        VLC_ADD_LDFLAGS([mozilla],[-L${x_libraries} -lXt])
      ])
      LDFLAGS="${LDFLAGS_save}"
    fi
    mozilla=:
    dnl Workaround for http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=150490
    VLC_ADD_CPPFLAGS([mozilla],[[`${MOZILLA_CONFIG} --cflags plugin xpcom java | sed 's,-I\([^ ]*\)/mozilla/\([^ ]*\),-I\1/\2 -I\1/mozilla/\2,g' | xargs`]])
    VLC_ADD_LDFLAGS([mozilla],[`${MOZILLA_CONFIG} --libs plugin xpcom`])
    CPPFLAGS="${CPPFLAGS_save} ${CPPFLAGS_mozilla}"
    AC_CHECK_HEADERS(mozilla-config.h)
    CPPFLAGS="${CPPFLAGS_save}"
  fi

dnl special case for mingw32
elif test "${enable_mozilla}" = "yes"
then
  AC_CHECK_TOOL(CYGPATH, cygpath, "")
  AC_ARG_WITH(mozilla-sdk-path,
    [    --with-mozilla-sdk-path=PATH path to win32 mozilla sdk], [
    real_mozilla_sdk="`cd ${with_mozilla_sdk_path} 2>/dev/null && pwd`"
    CPPFLAGS="${CPPFLAGS_save} ${real_mozilla_sdk}"
    AC_CHECK_HEADERS(mozilla-config.h, [
      mozilla=:
      VLC_ADD_CPPFLAGS([mozilla],[-DXPCOM_GLUE -I${real_mozilla_sdk} -I${real_mozilla_sdk}/embedstring/include -I${real_mozilla_sdk}/xpcom/include -I${real_mozilla_sdk}/nspr/include -I${real_mozilla_sdk}/string/include -I${real_mozilla_sdk}/plugin/include -I${real_mozilla_sdk}/java/include])
      VLC_ADD_LDFLAGS([mozilla],[-L${real_mozilla_sdk}/embedstring/bin -L${real_mozilla_sdk}/xpcom/bin -L${real_mozilla_sdk}/nspr/bin -L${real_mozilla_sdk}/string/bin -lnspr4 -lplds4 -lplc4 -lembedstring -lxpcomglue -Wl,--kill-at])
      XPIDL_INCL="-I${real_mozilla_sdk}/xpcom/idl"
      if test -n "${CYGPATH}"; then
        XPIDL="${real_mozilla_sdk}/xpcom/bin/xpidl"
        real_mozilla_sdk="`${CYGPATH} -w ${real_mozilla_sdk}`"
        XPIDL_INCL="${XPIDL_INCL} -I\"${real_mozilla_sdk}/xpcom/idl\""
      fi ])
    CPPFLAGS="${CPPFLAGS_save}"
  ])
fi

dnl Not necessarily in ${PATH}
if test -z "${XPIDL}" -o ! -x "${XPIDL}"; then
  XPIDL="/usr/lib/mozilla/xpidl"
fi
AM_CONDITIONAL(BUILD_MOZILLA,${mozilla})

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

  dnl  we define those so that bootstrap sets the right linker
  VLC_ADD_CXXFLAGS([test2],[])
  VLC_ADD_OBJCFLAGS([test3],[])
  dnl  this one is needed until automake knows what to do
  VLC_ADD_LDFLAGS([test3],[-lobjc])

  VLC_ADD_PLUGINS([${TESTS}])
  #VLC_ADD_BUILTINS([${TESTS}])
fi

dnl
dnl  gtk_main plugin
dnl
if test "${NEED_GTK_MAIN}" != "no"
then
    VLC_ADD_PLUGINS([gtk_main])
    VLC_ADD_CFLAGS([gtk_main],[${CFLAGS_gtk}])
    VLC_ADD_LDFLAGS([gtk_main],[${LDFLAGS_gtk}])
fi

if test "${NEED_GNOME_MAIN}" != "no"
then
    VLC_ADD_PLUGINS([gnome_main])
    VLC_ADD_CFLAGS([gnome_main],[${CFLAGS_gtk} ${CFLAGS_gnome}])
    VLC_ADD_LDFLAGS([gnome_main],[${LDFLAGS_gtk} ${LDFLAGS_gnome}])
fi

if test "${NEED_GTK2_MAIN}" != "no"
then
    VLC_ADD_PLUGINS([gtk2_main])
    VLC_ADD_CFLAGS([gtk2],[-DNEED_GTK2_MAIN])
    VLC_ADD_CFLAGS([pda],[-DNEED_GTK2_MAIN])
    VLC_ADD_CFLAGS([gtk2_main],[${CFLAGS_gtk2} ${CFLAGS_pda}])
    VLC_ADD_LDFLAGS([gtk2_main],[${LDFLAGS_gtk2} ${LDFLAGS_pda}])
fi

if test "${NEED_GNOME2_MAIN}" != "no"
then
    VLC_ADD_PLUGINS([gnome2_main])
    VLC_ADD_CFLAGS([gnome2_main],[${CFLAGS_gtk2} ${CFLAGS_gnome2}])
    VLC_ADD_LDFLAGS([gnome2_main],[${LDFLAGS_gtk2} ${LDFLAGS_gnome2}])
fi

dnl
dnl  qte_main plugin
dnl
if test "${NEED_QTE_MAIN}" != "no"
then
    VLC_ADD_PLUGINS([qte_main])
    VLC_ADD_CXXFLAGS([opie qte qt_video],[-DNEED_QTE_MAIN])
    VLC_ADD_CXXFLAGS([qte_main],[${CXXFLAGS_qte} ${CXXFLAGS_qt_video}])
    VLC_ADD_LDFLAGS([qte_main],[${LDFLAGS_qte} ${LDFLAGS_qt_video}])
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 "${enable_plugins}" = "no"
   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 "${ac_cv_have_plugins}" = "no"
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}_p=yes"
  done
else
  VLC_ADD_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}_b=yes"
  done
fi]
AM_CONDITIONAL(HAVE_BUILTINS, ${builtin_support})

dnl Import conditional variables generated by bootstrap
VLC_CONDITIONALS

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

VLC_SYMBOL="`echo ${VERSION} | sed -e 'y/.-+/___/'`"
AC_DEFINE_UNQUOTED(MODULE_SUFFIX, "__${VLC_SYMBOL}", [String suffix for module functions])
AC_DEFINE_UNQUOTED(MODULE_SYMBOL, ${VLC_SYMBOL}, [Symbol suffix for module functions])

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

dnl
dnl  Handle substvars that use $(top_srcdir)
dnl
VLC_CONFIG="top_builddir=\"\$(top_builddir)\" \$(top_builddir)/vlc-config"
AC_SUBST(VLC_CONFIG)
CPPFLAGS_save="${CPPFLAGS_save} -I\$(top_srcdir)/include"

dnl
dnl  Restore *FLAGS
dnl
VLC_RESTORE_FLAGS

dnl
dnl  Create the vlc-config script
dnl
LDFLAGS_libvlc="${LDFLAGS_vlc} ${LDFLAGS_builtin}"
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(ALIASES)
AC_SUBST(ASM)
AC_SUBST(MOC)
AC_SUBST(WINDRES)
AC_SUBST(XPIDL)
AC_SUBST(XPIDL_INCL)
AC_SUBST(LIBEXT)
AC_SUBST(INCLUDES)
AC_SUBST(ALL_LINGUAS)

dnl Import substitutions generated by bootstrap
VLC_SUBSTS

dnl Create vlc-config.in
VLC_OUTPUT_VLC_CONFIG_IN

AC_CONFIG_FILES([
  Makefile
  autotools/Makefile
  debian/Makefile
  doc/Makefile
  intl/Makefile
  ipkg/Makefile
  lib/Makefile
  modules/Makefile
  mozilla/Makefile
  m4/Makefile
  po/Makefile.in
  share/Makefile
  src/Makefile
])

AC_CONFIG_FILES([
  modules/access/Makefile
  modules/access/dshow/Makefile
  modules/access/dvb/Makefile
  modules/access/mms/Makefile
  modules/access/pvr/Makefile
  modules/access/satellite/Makefile
  modules/access/v4l/Makefile
  modules/access/cdda/Makefile
  modules/access/vcd/Makefile
  modules/access/vcdx/Makefile
  modules/access_output/Makefile
  modules/audio_filter/Makefile
  modules/audio_filter/channel_mixer/Makefile
  modules/audio_filter/converter/Makefile
  modules/audio_filter/resampler/Makefile
  modules/audio_mixer/Makefile
  modules/audio_output/Makefile
  modules/codec/Makefile
  modules/codec/cmml/Makefile
  modules/codec/dmo/Makefile
  modules/codec/ffmpeg/Makefile
  modules/codec/ffmpeg/postprocessing/Makefile
  modules/codec/ogt/Makefile
  modules/codec/spudec/Makefile
  modules/control/Makefile
  modules/control/corba/Makefile
  modules/demux/Makefile
  modules/demux/asf/Makefile
  modules/demux/avi/Makefile
  modules/demux/mp4/Makefile
  modules/demux/mpeg/Makefile
  modules/demux/playlist/Makefile
  modules/demux/util/Makefile
  modules/gui/Makefile
  modules/gui/beos/Makefile
  modules/gui/pda/Makefile
  modules/gui/gtk/Makefile
  modules/gui/gtk2/Makefile
  modules/gui/kde/Makefile
  modules/gui/macosx/Makefile
  modules/gui/qnx/Makefile
  modules/gui/qt/Makefile
  modules/gui/skins/Makefile
  modules/gui/skins2/Makefile
  modules/gui/wxwindows/Makefile
  modules/misc/Makefile
  modules/misc/dummy/Makefile
  modules/misc/memcpy/Makefile
  modules/misc/network/Makefile
  modules/misc/testsuite/Makefile
  modules/misc/playlist/Makefile
  modules/mux/Makefile
  modules/mux/mpeg/Makefile
  modules/packetizer/Makefile
  modules/stream_out/Makefile
  modules/stream_out/transrate/Makefile
  modules/video_chroma/Makefile
  modules/video_filter/Makefile
  modules/video_output/Makefile
  modules/video_output/directx/Makefile
  modules/video_output/qte/Makefile
  modules/video_output/x11/Makefile
  modules/visualization/Makefile
  modules/visualization/visual/Makefile
])

AC_CONFIG_FILES([vlc-config], [chmod 0755 vlc-config])

dnl Generate makefiles
AC_OUTPUT

printf "
vlc configuration
--------------------
vlc version           : ${VERSION}
system                : ${SYS}
architecture          : ${ARCH}
build flavour         : "
test "${enable_debug}" = "yes" && printf "debug "
test "${enable_cprof}" = "yes" && printf "cprof "
test "${enable_gprof}" = "yes" && printf "gprof "
test "${enable_optimizations}" = "yes" && printf "optim "
test "${enable_release}" = "yes" && printf "release " || printf "devel "
echo "
vlc aliases           :${ALIASES}

You can tune the compiler flags in vlc-config.
To build vlc and its plugins, type \`make'.
"