configure.ac

	fi
        CFLAGS_NOOPTIM="${CFLAGS_NOOPTIM} -O"
    fi
fi

dnl Check for -ffast-math
AC_CACHE_CHECK([if \$CC accepts -ffast-math],
    [ac_cv_c_fast_math],
    [CFLAGS="${CFLAGS_save} -ffast-math"
     AC_TRY_COMPILE([],,ac_cv_c_fast_math=yes, ac_cv_c_fast_math=no)])
if test "${ac_cv_c_fast_math}" != "no"; then
    CFLAGS_OPTIM="${CFLAGS_OPTIM} -ffast-math"
fi

dnl Check for -funroll-loops
dnl Disabled on BeOS because BeOS' gcc is buggy and may crash with it
if test "${SYS}" != "beos"
then
  AC_CACHE_CHECK([if \$CC accepts -funroll-loops],
      [ac_cv_c_unroll_loops],
      [CFLAGS="${CFLAGS_save} -funroll-loops"
       AC_TRY_COMPILE([],,ac_cv_c_unroll_loops=yes, ac_cv_c_unroll_loops=no)])
  if test "${ac_cv_c_unroll_loops}" != "no"; then
      CFLAGS_OPTIM="${CFLAGS_OPTIM} -funroll-loops"
  fi
fi

dnl Check for -fomit-frame-pointer
AC_CACHE_CHECK([if \$CC accepts -fomit-frame-pointer],
    [ac_cv_c_omit_frame_pointer],
    [CFLAGS="${CFLAGS_save} -fomit-frame-pointer"
     AC_TRY_COMPILE([],,ac_cv_c_omit_frame_pointer=yes, ac_cv_c_omit_frame_pointer=no)])
if test "${ac_cv_c_omit_frame_pointer}" != "no"; then
    CFLAGS_OPTIM_NODEBUG="${CFLAGS_OPTIM_NODEBUG} -fomit-frame-pointer"
    # this plugin does not compile without -fomit-frame-pointer, damn gcc!
    VLC_ADD_CFLAGS([i420_yuy2_mmx],[-fomit-frame-pointer])
fi

dnl Check for -mdynamic-no-pic
AC_CACHE_CHECK([if \$CC accepts -mdynamic-no-pic],
    [ac_cv_c_dynamic_no_pic],
    [CFLAGS="${CFLAGS_save} -mdynamic-no-pic"
     AC_TRY_COMPILE([],,ac_cv_c_dynamic_no_pic=yes, ac_cv_c_dynamic_no_pic=no)])
AS_IF([test "${enable_libtool}" = "no" && test "${ac_cv_c_dynamic_no_pic}" != "no"], [
    VLC_ADD_CFLAGS([builtin],[-mdynamic-no-pic])
    VLC_ADD_CFLAGS([libvlc],[-mdynamic-no-pic])
])

dnl Check for Darwin plugin linking flags
AC_CACHE_CHECK([if \$CC accepts -bundle -undefined error],
    [ac_cv_ld_darwin],
    [CFLAGS="${CFLAGS_save} -bundle -undefined error"
     AC_TRY_COMPILE([],,ac_cv_ld_darwin=yes, ac_cv_ld_darwin=no)])
if test "${ac_cv_ld_darwin}" != "no"; then
    VLC_ADD_LDFLAGS([plugin],[-bundle -undefined error])
fi

dnl Check for standard plugin linking flags
dnl BeOS' gcc needs -nostart instead of -shared, even if -shared isn't harmful (just a warning)
if test "${SYS}" = "beos"; then
  VLC_ADD_LDFLAGS([plugin mozilla],[-nostart])
else
  AC_CACHE_CHECK([if \$CC accepts -shared],
      [ac_cv_ld_plugins],
      [CFLAGS="${CFLAGS_save} -shared"
       AC_TRY_COMPILE([],, ac_cv_ld_plugins=yes, ac_cv_ld_plugins=no)])
  if test "${ac_cv_ld_plugins}" != "no"; then
    VLC_ADD_LDFLAGS([plugin mozilla],[-shared])
  fi
fi

dnl Check for variadic macros
AC_CACHE_CHECK([for variadic cpp macros],
    [ac_cv_cpp_variadic_macros],
    [CFLAGS="${CFLAGS_save}"
     AC_TRY_COMPILE(
         [#include <stdio.h>
          #define a(b,c...) printf(b,##c)],
         [a("foo");a("%s","bar");a("%s%s","baz","quux");],
         ac_cv_cpp_variadic_macros=yes,
         ac_cv_cpp_variadic_macros=no)])
if test "${ac_cv_cpp_variadic_macros}" != "no"; then
    AC_DEFINE(HAVE_VARIADIC_MACROS, 1, Support for variadic macros)
fi

dnl Checks for __attribute__(aligned()) directive
AC_CACHE_CHECK([__attribute__ ((aligned ())) support],
    [ac_cv_c_attribute_aligned],
    [ac_cv_c_attribute_aligned=0
        CFLAGS="${CFLAGS_save} -Werror"
    for ac_cv_c_attr_align_try in 2 4 8 16 32 64; do
        AC_TRY_COMPILE([],
        [static char c __attribute__ ((aligned(${ac_cv_c_attr_align_try}))) = 0; return c;],
        [ac_cv_c_attribute_aligned="${ac_cv_c_attr_align_try}"])
    done
        CFLAGS="${CFLAGS_save}"])
if test "${ac_cv_c_attribute_aligned}" != "0"; then
    AC_DEFINE_UNQUOTED([ATTRIBUTE_ALIGNED_MAX],
        [${ac_cv_c_attribute_aligned}],[Maximum supported data alignment])
fi

dnl Checks for __attribute__(format()) directive
AC_CACHE_CHECK([__attribute__ ((format ())) support with function pointers],
    [ac_cv_c_attribute_format],
    [ac_cv_c_attribute_format=no
        CFLAGS="${CFLAGS_save} -Werror"
        AC_TRY_COMPILE([],
        [static void (*pf_printf)(const char *, ...) __attribute__ ((format(printf,1,2)));(void)pf_printf;],
        [ac_cv_c_attribute_format=yes])
        CFLAGS="${CFLAGS_save}"])
if test "${ac_cv_c_attribute_format}" != "no"; then
    AC_DEFINE(HAVE_ATTRIBUTE_FORMAT, 1, Support for __attribute__((format())) with function pointers)
fi

dnl Check for __attribute__(())
AC_CACHE_CHECK([for __attribute__((packed))],
  [ac_cv_c_attribute_packed],
  [ac_cv_c_attribute_packed=no
   AC_TRY_COMPILE(, [struct __attribute__((__packed__)) foo { int a; } b;],
                    [ac_cv_c_attribute_packed=yes])])
if test "${ac_cv_c_attribute_packed}" != "no"; then
  AC_DEFINE(HAVE_ATTRIBUTE_PACKED, 1, Support for __attribute__((packed)) for structs)
fi

dnl
dnl  Check the CPU
dnl
case "${target_cpu}" in
  "")
    ARCH=unknown
    ;;
  *)
    ARCH="${target_cpu}"
    ;;
esac

dnl
dnl  Enable profiling
dnl
AC_ARG_ENABLE(gprof,
[  --enable-gprof          gprof profiling (default disabled)])
AC_ARG_ENABLE(cprof,
[  --enable-cprof          cprof profiling (default disabled)])
test "${enable_gprof}" != "yes" && enable_gprof="no"
test "${enable_cprof}" != "yes" && enable_cprof="no"

dnl
dnl  default modules
dnl
VLC_ADD_PLUGINS([dummy logger memcpy])
VLC_ADD_PLUGINS([mpgv mpga m4v m4a h264 ps pva avi asf mp4 rawdv nsv real aiff mjpeg demuxdump flac])
VLC_ADD_PLUGINS([cvdsub svcdsub spudec subsdec dvbsub mpeg_audio lpcm a52 dts cinepak flacdec])
VLC_ADD_PLUGINS([deinterlace invert adjust transform wave ripple psychedelic gradient motionblur rv32])
VLC_ADD_PLUGINS([fixed32tos16 s16tofixed32 u8tofixed32 mono])
VLC_ADD_PLUGINS([trivial_resampler ugly_resampler])
VLC_ADD_PLUGINS([trivial_channel_mixer trivial_mixer])
VLC_ADD_PLUGINS([playlist export sgimb nsc xtag])
VLC_ADD_PLUGINS([i420_rgb rawvideo blend scale image logo magnify])
VLC_ADD_PLUGINS([wav araw subtitle vobsub adpcm a52sys dtssys au ty voc xa nuv])
VLC_ADD_PLUGINS([access_directory access_file access_udp access_tcp])
VLC_ADD_PLUGINS([access_http access_mms access_ftp ipv4])
VLC_ADD_PLUGINS([packetizer_mpegvideo packetizer_h264])
VLC_ADD_PLUGINS([packetizer_mpeg4video packetizer_mpeg4audio])


if test "${SYS}" != "mingwce"; then
dnl  VLC_ADD_PLUGINS([externrun])
  VLC_ADD_PLUGINS([access_fake access_filter_timeshift access_filter_record])
  VLC_ADD_PLUGINS([gestures rc telnet hotkeys netsync showintf time marq podcast shout sap fake folder])
  VLC_ADD_PLUGINS([rss mosaic wall motiondetect clone crop])
  VLC_ADD_PLUGINS([i420_yuy2 i422_yuy2 i420_ymga])
  VLC_ADD_PLUGINS([aout_file linear_resampler bandlimited_resampler])
  VLC_ADD_PLUGINS([float32_mixer spdif_mixer simple_channel_mixer])
  VLC_ADD_PLUGINS([dolby_surround_decoder headphone_channel_mixer normvol equalizer param_eq])
  VLC_ADD_PLUGINS([fixed32tofloat32 float32tos16 float32tos8 float32tou16 float32tou8 a52tospdif dtstospdif s16tofloat32 s16tofloat32swab s8tofloat32 u8tofloat32 audio_format])
fi

dnl
dnl  Switch to enable a version of VLC where most modules will be builtin
dnl
AC_ARG_ENABLE(mostly-builtin,
[  --enable-mostly-builtin most modules will be built-in (default disabled)])
if test "${enable_mostly_builtin}" = "yes"; then
  VLC_ADD_BUILTINS([${PLUGINS}])
  PLUGINS=""
fi

dnl
dnl Some plugins aren't useful on some platforms
dnl
if test "${SYS}" != "mingw32" -a "${SYS}" != "mingwce"; then
    VLC_ADD_PLUGINS([screensaver motion])
elif test "${SYS}" != "mingwce"; then
    VLC_ADD_PLUGINS([ntservice access_smb dmo msn])
    VLC_ADD_LDFLAGS([dmo],[-lole32])
else
    VLC_ADD_PLUGINS([win32text])
fi

dnl
dnl  Accelerated modules
dnl
MMX_MODULES="memcpymmx i420_rgb_mmx i422_yuy2_mmx i420_ymga_mmx"
#MMX_MODULES="${MMX_MODULES} idctmmx motionmmx"
MMXEXT_MODULES="memcpymmxext"
#MMXEXT_MODULES="${MMXEXT_MODULES} idctmmxext motionmmxext"
THREEDNOW_MODULES="memcpy3dn"
SSE_MODULES=""
ALTIVEC_MODULES="memcpyaltivec i420_yuy2_altivec"
#ALTIVEC_MODULES="${ALTIVEC_MODULES} idctaltivec motionaltivec"

if test "${enable_gprof}" != "yes"
then
  MMX_MODULES="${MMX_MODULES} i420_yuy2_mmx"
fi

AC_CACHE_CHECK([if \$CC groks MMX inline assembly],
    [ac_cv_mmx_inline],
    [CFLAGS="${CFLAGS_save}"
     AC_TRY_COMPILE(,[void *p;asm volatile("packuswb %%mm1,%%mm2"::"r"(p));],
                    ac_cv_mmx_inline=yes, ac_cv_mmx_inline=no)])
if test "${ac_cv_mmx_inline}" != "no"; then
  AC_DEFINE(CAN_COMPILE_MMX, 1, Define if \$CC groks MMX inline assembly.)
  ACCEL_MODULES="${ACCEL_MODULES} ${MMX_MODULES}"
fi

dnl  Check for fully workin MMX intrinsics
dnl  We need support for -mmmx, we need <mmintrin.h>, and we also need a
dnl  working compiler (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23963)
AC_CACHE_CHECK([if \$CC groks MMX intrinsics],
    [ac_cv_c_mmx_intrinsics],
    [CFLAGS="${CFLAGS_save} -O -mmmx"
     AC_TRY_COMPILE([#include <mmintrin.h>
                     #include <stdint.h>
                     uint64_t frobzor;],
                    [__m64 a, b, c;
                     a = b = c = (__m64)frobzor;
                     a = _mm_slli_pi16(a, 3);
                     a = _mm_adds_pi16(a, b);
                     c = _mm_srli_pi16(c, 8);
                     c = _mm_slli_pi16(c, 3);
                     b = _mm_adds_pi16(b, c);
                     a = _mm_unpacklo_pi8(a, b);
                     frobzor = (uint64_t)a;],
                    [ac_cv_c_mmx_intrinsics=yes],
                    [ac_cv_c_mmx_intrinsics=no])])
if test "${ac_cv_c_mmx_intrinsics}" != "no"; then
  AC_DEFINE(HAVE_MMX_INTRINSICS, 1, Define if MMX intrinsics are available.)
  VLC_ADD_CFLAGS([i420_rgb_mmx],[-mmmx])
fi

AC_CACHE_CHECK([if \$CC groks MMX EXT inline assembly],
    [ac_cv_mmxext_inline],
    [CFLAGS="${CFLAGS_save}"
     AC_TRY_COMPILE(,[void *p;asm volatile("maskmovq %%mm1,%%mm2"::"r"(p));],
                    ac_cv_mmxext_inline=yes, ac_cv_mmxext_inline=no)])
if test "${ac_cv_mmxext_inline}" != "no"; then
  AC_DEFINE(CAN_COMPILE_MMXEXT, 1, Define if \$CC groks MMX EXT inline assembly.)
  ACCEL_MODULES="${ACCEL_MODULES} ${MMXEXT_MODULES}"
fi

AC_CACHE_CHECK([if \$CC groks 3D Now! inline assembly],
    [ac_cv_3dnow_inline],
    [CFLAGS="${CFLAGS_save}"
     AC_TRY_COMPILE(,[void *p;asm volatile("pfadd %%mm1,%%mm2"::"r"(p));],
                    ac_cv_3dnow_inline=yes, ac_cv_3dnow_inline=no)])
if test "${ac_cv_3dnow_inline}" != "no"; then
  AC_DEFINE(CAN_COMPILE_3DNOW, 1, Define if \$CC groks 3D Now! inline assembly.)
  ACCEL_MODULES="${ACCEL_MODULES} ${THREEDNOW_MODULES}"
fi

AC_CACHE_CHECK([if \$CC groks SSE inline assembly],
    [ac_cv_sse_inline],
    [CFLAGS="${CFLAGS_save}"
     AC_TRY_COMPILE(,[void *p;asm volatile("xorps %%xmm1,%%xmm2"::"r"(p));],
                    ac_cv_sse_inline=yes, ac_cv_sse_inline=no)])
if test "${ac_cv_sse_inline}" != "no" -a "${SYS}" != "solaris"; then
  AC_DEFINE(CAN_COMPILE_SSE, 1, Define if \$CC groks SSE inline assembly.)
  ACCEL_MODULES="${ACCEL_MODULES} ${SSE_MODULES}"
fi

if test "${SYS}" != "mingw32" -a "${SYS}" != "mingwce"; then
AC_CACHE_CHECK([if \$CC groks AltiVec inline assembly],
    [ac_cv_altivec_inline],
    [CFLAGS="${CFLAGS_save}"
     AC_TRY_COMPILE(,[asm volatile("vperm 0,1,2,3");],
         ac_cv_altivec_inline=yes,
         [CFLAGS="${CFLAGS_save} -Wa,-m7400"
          AC_TRY_COMPILE(,[asm volatile("vperm 0,1,2,3");],
            [ac_cv_altivec_inline="-Wa,-m7400"],
            ac_cv_altivec_inline=no)
         ])])
if test "${ac_cv_altivec_inline}" != "no"; then
  AC_DEFINE(CAN_COMPILE_ALTIVEC, 1, Define if \$CC groks AltiVec inline assembly.)
  if test "${ac_cv_altivec_inline}" != "yes"; then
    VLC_ADD_CFLAGS([idctaltivec],[${ac_cv_altivec_inline}])
    VLC_ADD_CFLAGS([motionaltivec],[${ac_cv_altivec_inline}])
    VLC_ADD_CFLAGS([memcpyaltivec],[${ac_cv_altivec_inline}])
    VLC_ADD_CFLAGS([i420_yuy2_altivec],[${ac_cv_altivec_inline}])
    VLC_ADD_CFLAGS([vlc],[${ac_cv_altivec_inline}])
  fi
  ACCEL_MODULES="${ACCEL_MODULES} ${ALTIVEC_MODULES}"
fi

dnl The AltiVec C extensions
dnl
dnl There are several possible cases:
dnl - OS X PPC, gcc 4.x: use -mpim-altivec -force_cpusubtype_ALL, don't
dnl                      need <altivec.h>
dnl - OS X PPC, gcc 3.x: need -faltivec, don't need <altivec.h>
dnl - Linux PPC, gcc 3.4, 4.x: need <altivec.h> which requires -maltivec
dnl - Linux PPC, gcc 3.3: need <altivec.h> and -maltivec -mabi=altivec
dnl - Linux PPC, gcc 3.x: need <altivec.h> and -fvec
dnl - Others: test should fail
AC_CACHE_CHECK([if \$CC groks AltiVec C extensions],
  [ac_cv_c_altivec],
  [# OS X/PPC test (gcc 4.x)
   CFLAGS="${CFLAGS_save} -mpim-altivec -force_cpusubtype_ALL"
   AC_TRY_COMPILE([],
     [vec_ld(0, (unsigned char *)0);],
     [ac_cv_c_altivec="-mpim-altivec -force_cpusubtype_ALL"],
     [# OS X/PPC test (gcc 3.x)
      CFLAGS="${CFLAGS_save} -faltivec"
      AC_TRY_COMPILE([],
        [vec_ld(1 * sizeof(vector float), (unsigned char *)0);],
        [ac_cv_c_altivec="-faltivec"],
        dnl Below this are the Linux tests
        [# Linux/PPC test (gcc 4.x)
         CFLAGS="${CFLAGS_save} -maltivec"
         AC_TRY_COMPILE([#include <altivec.h>],
           [vec_ld(0, (unsigned char *)0);],
           [ac_cv_c_altivec="-maltivec"],
           [# Linux/PPC test (gcc 3.3)
            CFLAGS="${CFLAGS_save} -maltivec -mabi=altivec"
            AC_TRY_COMPILE([#include <altivec.h>],
              [vec_ld(0, (unsigned char *)0);],
              [ac_cv_c_altivec=""
               ac_cv_c_altivec_abi="-maltivec -mabi=altivec"],
              [# Linux/PPC test (gcc 3.3)
               CFLAGS="${CFLAGS_save} -fvec"
               AC_TRY_COMPILE([#include <altivec.h>],
                 [vec_ld(0, (unsigned char *)0);],
                 [ac_cv_c_altivec="-fvec"],
                 [ac_cv_c_altivec=no])
              ])
           ])
        ])
     ])
   CFLAGS="${CFLAGS_save}"
  ])

if test "${ac_cv_c_altivec}" != "no"; then
  CPPFLAGS="${CPPFLAGS_save} ${ac_cv_c_altivec}"
fi
AC_CHECK_HEADERS(altivec.h)
CPPFLAGS="${CPPFLAGS_save}"

if test "${ac_cv_c_altivec}" != "no"; then
  AC_DEFINE(CAN_COMPILE_C_ALTIVEC, 1, Define if your compiler groks C AltiVec extensions.)
  VLC_ADD_CFLAGS([vlc],[${ac_cv_c_altivec}])
  VLC_ADD_CFLAGS([idctaltivec motionaltivec],[${ac_cv_c_altivec}])
  VLC_ADD_CFLAGS([i420_yuy2_altivec memcpyaltivec deinterlace],[${ac_cv_c_altivec} ${ac_cv_c_altivec_abi}])
  if test "${ac_cv_altivec_inline}" = "no"; then
    ACCEL_MODULES="${ACCEL_MODULES} ${ALTIVEC_MODULES}"
  fi
fi

AC_CACHE_CHECK([if linker needs -framework vecLib],
    [ac_cv_ld_altivec],
    [LDFLAGS="${LDFLAGS_vlc} -framework vecLib"
     AC_TRY_LINK([],,ac_cv_ld_altivec=yes,ac_cv_ld_altivec=no)
     LDFLAGS="${LDFLAGS_save}"
    ])
if test "${ac_cv_ld_altivec}" != "no"; then
  VLC_ADD_LDFLAGS([vlc idctaltivec motionaltivec memcpyaltivec],[-framework vecLib])
fi
fi # end "${SYS}" != "mingw32" -a "${SYS}" != "mingwce"

AC_ARG_WITH(,[])
AC_ARG_WITH(,[Optimization options:])

dnl
dnl  Special arch tuning
dnl
AC_ARG_WITH(tuning,
[  --with-tuning=ARCH      enable special tuning for an architecture
                          (default Pentium 2 on IA-32 and G4 on PPC)])
if test -n "${with_tuning}"; then
    if test "${with_tuning}" != "no"; then
        CFLAGS_TUNING="-mtune=${with_tuning}"
    fi
else
    if test "${target_cpu}" = "i686" -o "${target_cpu}" = "i586" -o "${target_cpu}" = "i486" -o "${target_cpu}" = "i386"; then
        CFLAGS_TUNING="-mtune=pentium2"
    elif test "${target_cpu}" = "x86_64"; then
        CFLAGS_TUNING="-mtune=athlon64"
    elif test "${target_cpu}" = "powerpc"; then
        CFLAGS_TUNING="-mtune=G4";
    fi
fi

dnl NOTE: this can't be cached cleanly
AS_IF([test "${CFLAGS_TUNING}"],
   [CFLAGS_save="${CFLAGS}"
    CFLAGS="${CFLAGS} ${CFLAGS_TUNING}"

    AC_MSG_CHECKING([whether $CC accepts ${CFLAGS_TUNING}])
    AC_COMPILE_IFELSE([ ],
                      [tuning="yes"],
                      [CFLAGS_TUNING=""; tuning="no"
                       AS_IF([test "${with_tuning}"],
                             [AC_MSG_ERROR([requested tuning not supported])])])

    AC_MSG_RESULT([$tuning])
    CFLAGS="${CFLAGS_save}"
])

dnl
dnl  x86 accelerations
dnl
if test "${target_cpu}" = "i686" -o "${target_cpu}" = "i586" -o "${target_cpu}" = "x86" -o "${target_cpu}" = "i386" -o "${target_cpu}" = "x86_64"
then
    ARCH="${ARCH} mmx"
    VLC_ADD_BUILTINS([${ACCEL_MODULES}])
fi

dnl
dnl  Memory usage
dnl
AC_ARG_ENABLE(optimize-memory,
[  --enable-optimize-memory      optimize memory usage over performance])
if test "${enable_optimize_memory}" = "yes"; then
  AC_DEFINE(OPTIMIZE_MEMORY, 1, Define if you want to optimize memory usage over performance)
fi

dnl
dnl  Enable/disable optimizations
dnl
AC_ARG_ENABLE(optimizations,
[  --disable-optimizations disable compiler optimizations (default enabled)])
test "${enable_optimizations}" != "no" && enable_optimizations="yes"

dnl
dnl  AltiVec acceleration
dnl
AC_ARG_ENABLE(altivec,
[  --disable-altivec       disable AltiVec optimizations (default enabled on PPC)],
[ if test "${enable_altivec}" = "yes"; then ARCH="${ARCH} altivec";
    VLC_ADD_BUILTINS([${ACCEL_MODULES}]) fi ],
[ if test "${target_cpu}" = "powerpc"; then ARCH="${ARCH} altivec";
    VLC_ADD_BUILTINS([${ACCEL_MODULES}]) fi ])

dnl
dnl  Debugging mode
dnl
AC_ARG_ENABLE(debug,
[  --enable-debug          debug mode (default disabled)])
test "${enable_debug}" != "yes" && enable_debug="no"
AH_TEMPLATE(NDEBUG,
            [Define to 1 if debug code should NOT be compiled])
AS_IF([test "x${enable_debug}" = "xno"], [AC_DEFINE(NDEBUG)])

dnl
dnl  Enable release-specific flags
dnl
AC_ARG_ENABLE(release,
[  --enable-release        activate extra optimizations (default disabled)])
test "${enable_release}" != "yes" && enable_release="no"

dnl
dnl  Is the shared libvlc forced ?
dnl
AC_ARG_ENABLE(shared-libvlc,
  [  --enable-shared-libvlc  Win32 libvlc.dll build (default disabled)])
AS_IF([test "${enable_libtool}" != "no" && test "${enable_shared_libvlc}"], [
  AC_MSG_ERROR([--enable-shared-libvlc and --enable-libtool are mutually exclusive])
])

dnl
dnl Stream output
dnl
AC_ARG_ENABLE(sout,
  [  --enable-sout           Stream output modules (default enabled)])
if test "${enable_sout}" != "no"
then
  VLC_ADD_PLUGINS([access_output_dummy access_output_udp access_output_file access_output_http])
  VLC_ADD_PLUGINS([mux_ps mux_avi mux_mp4 mux_asf mux_dummy mux_wav mux_mpjpeg])
  VLC_ADD_PLUGINS([packetizer_copy])

  VLC_ADD_PLUGINS([stream_out_dummy stream_out_standard stream_out_es stream_out_rtp stream_out_description vod_rtsp])
  VLC_ADD_PLUGINS([stream_out_duplicate stream_out_gather stream_out_display stream_out_transcode stream_out_bridge stream_out_mosaic_bridge])
#  VLC_ADD_PLUGINS([stream_out_transrate])
  VLC_ADD_PLUGINS([profile_parser])

  AC_DEFINE(ENABLE_SOUT, 1, Define if you want the stream output support)
fi

AC_ARG_ENABLE(switcher,
  [  --enable-switcher       Stream-out switcher plugin (default disabled)])    

dnl Check for libshout
AC_ARG_ENABLE(shout,
  [  --enable-shout          libshout output plugin (default disabled)])
if test "${enable_shout}" = "yes"; then
  PKG_CHECK_MODULES(SHOUT, shout >= 2.1,
    [AC_DEFINE(HAVE_SHOUT, [], [Define if you have the libshout library])
     VLC_ADD_PLUGINS([access_output_shout])
     VLC_ADD_LDFLAGS([access_output_shout],[$SHOUT_LIBS])
     VLC_ADD_CFLAGS([access_output_shout],[$SHOUT_CFLAGS])],
    [AC_MSG_WARN(libshout library not found)])
fi

dnl
dnl HTTP daemon
dnl
AC_ARG_ENABLE(httpd,
  [  --enable-httpd          HTTP daemon (default enabled)])
if test "${enable_httpd}" != "no"
then
  VLC_ADD_PLUGINS([http])
  AC_DEFINE(ENABLE_HTTPD, 1, Define if you want the HTTP dameon support)
fi

dnl
dnl VideoLAN manager
dnl
AC_ARG_ENABLE(vlm,
  [  --enable-vlm            VideoLAN manager (default enabled)])
if test "${enable_vlm}" != "no"
then
  AC_DEFINE(ENABLE_VLM, 1, Define if you want the VideoLAN manager support)
fi

dnl
dnl Growl notification plugin
dnl
AC_ARG_ENABLE(growl,
  [  --enable-growl          growl notification plugin (default enabled)])
AS_IF([test "${enable_growl}" != "no"], [
    VLC_ADD_PLUGINS([growl])
  ]
)

dnl
dnl Libnotify notification plugin
dnl

AC_ARG_ENABLE(notify,
  [  --enable-notify         libnotify notification plugin (default enabled)])
AS_IF([test "${enable_notify}" != "no"], [
    PKG_CHECK_MODULES(NOTIFY, libnotify,
      [
        VLC_ADD_PLUGINS([notify])
        VLC_ADD_CFLAGS(notify, [$NOTIFY_CFLAGS])
	VLC_ADD_LDFLAGS(notify, [$NOTIFY_LIBS])
      ],[
	AS_IF([test "${enable_notify}" = "yes"],[
	       AC_MSG_WARN( libnotify not found) ])
      ])
  ])

dnl
dnl Audioscrobbler plugin
dnl

AC_ARG_ENABLE(audioscrobbler,
  [  --enable-audioscrobbler Last.fm submission plugin (default enabled)])
AS_IF([test "${enable_audioscrobbler}" != "no"], [
        VLC_ADD_PLUGINS([audioscrobbler])
  ])

dnl
dnl Musicbrainz plugin
dnl
AC_ARG_ENABLE(musicbrainz,
  [  --enable-musicbrainz    MusicBrainz support (default disabled) ])
  AS_IF([test "${enable_musicbrainz}" = "yes"],[
      PKG_CHECK_MODULES(MUSICBRAINZ, libmusicbrainz,
  	[ VLC_ADD_PLUGINS([musicbrainz])
	  VLC_ADD_LDFLAGS([musicbrainz],[$MUSICBRAINZ_LIBS]) 
	  VLC_ADD_CFLAGS([musicbrainz],[$MUSICBRAINZ_CFLAGS])  ],
       [AC_MSG_WARN(MusicBrainz library not found)])
   ])


dnl
dnl Taglibplugin
dnl
AC_ARG_ENABLE(taglib,
  [  --enable-taglib Taglib support (default disabled) ])
  AS_IF([test "${enable_taglib}" = "yes"],[
    PKG_CHECK_MODULES(TAGLIB, taglib,
      [ VLC_ADD_PLUGINS([taglib])
        VLC_ADD_LDFLAGS([taglib],[$TAGLIB_LIBS])
       VLC_ADD_CXXFLAGS([taglib],[$TAGLIB_CFLAGS]) ],
      [AC_MSG_WARN(TagLib library not found)])
  ])


dnl
dnl  Input plugins
dnl

AC_ARG_WITH(,[Input plugins:])

dnl  live555 input
dnl
if test "${enable_livedotcom}" 
then
  AC_MSG_WARN(--{en|dis}able-livedotcom is deprecated. Use --{en|dis}able-live555 instead.)
fi

if test "${enable_livedotcom}" = "no"
then
  enable_live555="no"
fi
AC_ARG_ENABLE(live555,
[  --enable-live555        live555 RTSP input plugin (default enabled)])
if test "${enable_live555}" != "no"; then
  AC_ARG_WITH(live555-tree,
    [    --with-live555-tree=PATH live.com tree for static linking])

  dnl
  dnl test for --with-live555-tree
  dnl
  if test "${with_livedotcom_tree}" 
  then
    AC_MSG_WARN(--with-livedotcom-tree is deprecated. Use --with-live555-tree instead.)
  with_live555_tree="${with_livedotcom_tree}"
  fi
  
  if test -z "${with_live555_tree}" -a "${CXX}" != ""; then
    AC_LANG_PUSH(C++)
    CPPFLAGS_save="${CPPFLAGS}"
    CPPFLAGS_live555="-I/usr/include/liveMedia -I/usr/include/groupsock -I/usr/include/BasicUsageEnvironment -I/usr/include/UsageEnvironment"
    if test "${SYS}" = "solaris"; then
      CPPFLAGS_live555="${CPPFLAGS_live555} -DSOLARIS"
    fi
    CPPFLAGS="${CPPFLAGS} ${CPPFLAGS_live555}"
    AC_CHECK_HEADERS(liveMedia.hh, [
      VLC_ADD_CXXFLAGS([live555], [${CPPFLAGS_live555}])
      AC_CHECK_LIB(liveMedia_pic, main, [
        # We have -lliveMedia_pic, build plugins
        VLC_ADD_PLUGINS([live555])
        VLC_ADD_LDFLAGS([live555], [-lliveMedia_pic -lgroupsock_pic -lBasicUsageEnvironment_pic -lUsageEnvironment_pic])
      ], [
        AC_CHECK_LIB(liveMedia, main, [
          # We only have -lliveMedia, do builtins
          VLC_ADD_BUILTINS([live555])
          VLC_ADD_LDFLAGS([live555], [-lliveMedia -lgroupsock -lBasicUsageEnvironment -lUsageEnvironment])
        ])
      ])
      if test "${SYS}" = "mingw32"; then
        # add ws2_32 for closesocket, select, recv
        VLC_ADD_LDFLAGS([live555],[-lws2_32])
      fi
    ])
    CPPFLAGS="${CPPFLAGS_save}"
    AC_LANG_POP(C++)
  else
    AC_MSG_CHECKING(for liveMedia/libliveMedia.a in ${with_live555_tree})
    real_live555_tree="`cd ${with_live555_tree} 2>/dev/null && pwd`"
    if test -z "${real_live555_tree}"; then
      dnl  The given directory can't be found
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot cd to ${with_live555_tree}])
    fi
    if test -f "${real_live555_tree}/liveMedia/libliveMedia.a"; then
      AC_MSG_RESULT(${real_live555_tree}/liveMedia/libliveMedia.a)

      VLC_ADD_BUILTINS([live555])

      if test "${SYS}" = "mingw32"; then
        # add ws2_32 for closesocket, select, recv
        VLC_ADD_LDFLAGS([live555],[-lws2_32])
      fi

      VLC_ADD_LDFLAGS([live555],[-L${real_live555_tree}/liveMedia -lliveMedia])
      VLC_ADD_LDFLAGS([live555],[-L${real_live555_tree}/BasicUsageEnvironment -lBasicUsageEnvironment])
      VLC_ADD_LDFLAGS([live555],[-L${real_live555_tree}/groupsock -lgroupsock])
      VLC_ADD_LDFLAGS([live555],[-L${real_live555_tree}/UsageEnvironment -lUsageEnvironment])

      VLC_ADD_CXXFLAGS([live555],[-I${real_live555_tree}/BasicUsageEnvironment/include])
      VLC_ADD_CXXFLAGS([live555],[-I${real_live555_tree}/groupsock/include])
      VLC_ADD_CXXFLAGS([live555],[-I${real_live555_tree}/liveMedia/include])
      VLC_ADD_CXXFLAGS([live555],[-I${real_live555_tree}/UsageEnvironment/include ])
      if test "${SYS}" = "solaris"; then
        VLC_ADD_CXXFLAGS([live555],[-DSOLARIS])
      fi
    else
      dnl  The given live555 wasn't built
        AC_MSG_RESULT(no)
      if test "${enable_live555}" = "yes"; then
        AC_MSG_ERROR([cannot find ${real_live555_tree}/liveMedia/libliveMedia.a, make sure you compiled live555 in ${with_live555_tree}])
      fi	
    fi
  fi
fi

dnl
dnl dv module: digital video module check for libraw1394
dnl
AC_ARG_ENABLE(dv,
[  --enable-dv             dv input module (default disabled)])
if test "${enable_dv}" = "yes"
then
  AC_ARG_WITH(dv-raw1394,
  [    --with-dv-raw1394=PATH   libraw1394 headers and libraries])
  AC_ARG_WITH(dv-raw1394-tree,
  [    --with-dv-raw1394=PATH   libraw1394 tree for static linking])

  if test -z "${with_dv_raw1394}" -a "${with_dv_raw1394}" != ""
  then
    AC_MSG_CHECKING(for raw1394 headers in ${with_dv_raw1394})
    if test -f ${with_dv_raw1394}/include/libraw1394/raw1394.h
    then
      dnl  Use ${with_dv_raw1394}/include/libraw1394/raw1394.h
      AC_MSG_RESULT(yes)
      VLC_ADD_PLUGINS([access_dv])
      VLC_ADD_LDFLAGS([access_dv],[-L${with_dv_raw1394}/lib -lraw1394 -lpthread])
      VLC_ADD_CPPFLAGS([access_dv],[-I${with_dv_raw1394}/include])
    else
      dnl  No libraw1394 could be found, sorry
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot find ${with_dv_raw1394}/include/libraw1394/raw1394.h])
    fi
  else
    AC_CHECK_HEADERS(libraw1394/raw1394.h,
    [ VLC_ADD_PLUGINS([access_dv])
        VLC_ADD_LDFLAGS([access_dv],[-lraw1394 -lavc1394])
    ],[
        if test -n "${enable_dv}"
        then
          AC_MSG_ERROR([cannot find libraw1394 headers])
        fi
    ])
  fi

  dnl Check for static linking of libraw1394
  if test -z "${with_dv_raw1394_tree}" -a "${with_dv_raw1394_tree}" != ""
  then
    AC_MSG_CHECKING(for libraw1394.a in ${with_dv_raw1394_tree})
    real_dv_raw1394_tree="`cd ${with_dv_raw1394_tree} 2>/dev/null && pwd`"
    if test -z "${real_dv_raw1394_tree}"
    then
      dnl  The given directory can't be found
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot cd to ${real_dv_raw1394_tree}])
    fi
    if test -f "${real_dv_raw1394_tree}/src/.libs/libraw1394.a"
    then
      dnl  Use a custom libraw1394
      AC_MSG_RESULT(${real_dv_raw1394_tree}/src/.libs/libraw1394.a)
      VLC_ADD_BUILTINS([access_dv])
      VLC_ADD_LDFLAGS([access_dv],[-L${real_dv_raw1394_tree}/src/.libs -lraw1394])
      VLC_ADD_CPPFLAGS([access_dv],[-I${real_dv_raw1394_tree}])
    else
      dnl  The given libraw1394 wasn't built
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot find ${real_dv_raw1394_tree}/src/.libs/libraw1394.a, make sure you compiled libraw1394 in ${with_dv_raw1394_tree}])
    fi
  fi

  dnl
  dnl Check for libavc1394
  dnl

  AC_ARG_WITH(dv-avc1394,
  [    --with-dv-avc1394=PATH   libavc1394 headers and libraries])
  AC_ARG_WITH(dv-avc1394-tree,
  [    --with-dv-avc1394=PATH   libavc1394 tree for static linking])

  if test -z "${with_dv_avc1394}" -a "${with_dv_avc1394}" != ""
  then
    AC_MSG_CHECKING(for avc1394 headers in ${with_dv_avc1394})
    if test -f ${with_dv_avc1394}/include/libavc1394/avc1394.h
    then
      dnl  Use ${with_dv_avc1394}/include/libavc1394/avc1394.h
      AC_MSG_RESULT(yes)
      VLC_ADD_LDFLAGS([access_dv],[-L${with_dv_avc1394}/lib -lavc1394 -lrom1394 -lpthread])
      VLC_ADD_CPPFLAGS([access_dv],[-I${with_avc1394}/include])
    else
      dnl  No libavc1394 could be found, sorry
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot find ${with_dv_avc1394}/include/libavc1394/avc1394.h])
    fi
  else
    AC_CHECK_HEADERS(libavc1394/avc1394.h,
    [ VLC_ADD_LDFLAGS([access_dv],[-lavc1394 -lrom1394 -lpthread])
    ],[
        if test -n "${enable_dv}"
        then
          AC_MSG_ERROR([cannot find libavc1394 headers])
        fi
    ])
  fi

  dnl Check for static linking of libavc1394
  if test -z "${with_dv_avc1394_tree}" -a "${with_dv_avc1394_tree}" != ""
  then
    AC_MSG_CHECKING(for libavc1394.a in ${with_dv_avc1394_tree})
    real_dv_avc1394_tree="`cd ${with_dv_avc1394_tree} 2>/dev/null && pwd`"
    if test -z "${real_dv_avc1394_tree}"
    then
      dnl  The given directory can't be found
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot cd to ${real_dv_avc1394_tree}])
    fi
    if test -f "${real_dv_avc1394_tree}/src/.libs/libavc1394.a"
    then
      dnl  Use a custom libavc1394
      AC_MSG_RESULT(${real_dv_avc1394_tree}/src/.libs/libavc1394.a)
      VLC_ADD_LDFLAGS([access_dv],[-L${real_dv_avc1394_tree}/src/.libs -lavc1394 -lrom1394 -lpthread])
      VLC_ADD_CPPFLAGS([access_dv],[-I${real_dv_avc1394_tree}])
    else
      dnl  The given libavc1394 wasn't built
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot find ${real_dv_avc1394_tree}/src/.libs/libavc1394.a, make sure you compiled libavc1394 in ${with_dv_avc1394_tree}])
    fi
  fi
fi

dnl
dnl dvdread module: check for libdvdread
dnl
AC_ARG_ENABLE(dvdread,
[  --enable-dvdread        dvdread input module (default disabled)])
if test "${enable_dvdread}" != "no"
then
  AC_ARG_WITH(dvdread,
  [    --with-dvdread=PATH   libdvdread headers and libraries])
  AC_ARG_WITH(dvdread-tree,
  [    --with-dvdread-tree=PATH libdvdread tree for static linking])

  dnl Temporary hack (yeah, sure ;)
  if test "${SYS}" = "mingw32" || test "${SYS}" = "darwin" || test "${SYS}" = "beos" ; then
      VLC_ADD_LDFLAGS([dvdread],[-ldvdcss])
  fi

  if test -z "${with_dvdread}"
  then
    if test -z "${with_dvdread_tree}"
    then
      AC_CHECK_HEADERS(dvdread/dvd_reader.h,
        [ VLC_ADD_PLUGINS([dvdread])
          VLC_ADD_LDFLAGS([dvdread],[-ldvdread ${LDFLAGS_dvdcss}])
        ],[
          if test -n "${enable_dvdread}"
          then
            AC_MSG_ERROR([cannot find libdvdread headers])
          fi
        ])
    else
      AC_MSG_CHECKING(for libdvdread.a in ${with_dvdread_tree})
      real_dvdread_tree="`cd ${with_dvdread_tree} 2>/dev/null && pwd`"
      if test -z "${real_dvdread_tree}"
      then
        dnl  The given directory can't be found
        AC_MSG_RESULT(no)
        AC_MSG_ERROR([cannot cd to ${with_dvdread_tree}])
      fi
      if test -f "${real_dvdread_tree}/dvdread/.libs/libdvdread.a"
      then
        dnl  Use a custom libdvdread
        AC_MSG_RESULT(${real_dvdread_tree}/dvdread/.libs/libdvdread.a)
        VLC_ADD_BUILTINS([dvdread])
        VLC_ADD_LDFLAGS([dvdread],[-L${real_dvdread_tree}/dvdread/.libs -ldvdread ${LDFLAGS_dvdcss}])
        VLC_ADD_CPPFLAGS([dvdread],[-I${real_dvdread_tree}])
      else
        dnl  The given libdvdread wasn't built
        AC_MSG_RESULT(no)
        AC_MSG_ERROR([cannot find ${real_dvdread_tree}/dvdread/.libs/libdvdread.a, make sure you compiled libdvdread in ${with_dvdread_tree}])
      fi
    fi
  else
    AC_MSG_CHECKING(for dvdread headers in ${with_dvdread})
    if test -f ${with_dvdread}/include/dvdread/dvd_reader.h
    then
      dnl  Use ${with_dvdread}/include/dvdread/dvd_reader.h
      AC_MSG_RESULT(yes)
      VLC_ADD_PLUGINS([dvdread])
      VLC_ADD_LDFLAGS([dvdread],[-L${with_dvdread}/lib -ldvdread ${LDFLAGS_dvdcss}])
      VLC_ADD_CPPFLAGS([dvdread],[-I${with_dvdread}/include])
    else
      dnl  No libdvdread could be found, sorry
      AC_MSG_RESULT(no)
      AC_MSG_ERROR([cannot find ${with_dvdread}/include/dvdread/dvd_reader.h])
    fi
  fi
fi

dnl
dnl  libdvdnav plugin
dnl
AC_ARG_ENABLE(dvdnav,
  [  --enable-dvdnav         dvdnav input module (default enabled)])
if test "${enable_dvdnav}" != "no"
then
  dnl Same hack than dvdread
  if test "${SYS}" = "mingw32" || test "${SYS}" = "darwin" || test "${SYS}" = "beos" ; then
      VLC_ADD_LDFLAGS([dvdnav],[-ldvdcss])
  fi

  DVDNAV_PATH="${PATH}"
  AC_ARG_WITH(dvdnav-config-path,
    [    --with-dvdnav-config-path=PATH dvdnav-config path (default search in \$PATH)],
    [ if test "${with_dvdnav_config_path}" != "no"
      then
        DVDNAV_PATH="${with_dvdnav_config_path}:${PATH}"
      fi ])
  AC_PATH_PROG(DVDNAV_CONFIG, dvdnav-config, no, ${DVDNAV_PATH})
  if test "${DVDNAV_CONFIG}" != "no"
  then
    VLC_ADD_PLUGINS([dvdnav])
    VLC_ADD_CFLAGS([dvdnav],[`${DVDNAV_CONFIG} --cflags`])
    VLC_ADD_LDFLAGS([dvdnav],[`${DVDNAV_CONFIG} --libs`])
  fi
fi

dnl
dnl  Windows DirectShow access module
dnl
AC_ARG_ENABLE(dshow,
  [  --enable-dshow          Win32 DirectShow support (default enabled on Win32)])
if test "${enable_dshow}" != "no"
then
  if test "${SYS}" = "mingw32" -o "${SYS}" = "cygwin"
  then
    AC_LANG_PUSH(C++)
      AC_CHECK_HEADERS(dshow.h,
      [ VLC_ADD_PLUGINS([dshow])
        VLC_ADD_CXXFLAGS([dshow],[])
        VLC_ADD_LDFLAGS([dshow],[-lole32 -loleaut32 -luuid]) ])
    AC_LANG_POP(C++)
  fi
fi


dnl
dnl  OpenCV wrapper and example filters
dnl
AC_ARG_ENABLE(opencv,
  [  --enable-opencv            OpenCV (computer vision) filter (default disabled)])
if test "${enable_opencv}" = "yes" -a "${CXX}" != "";
then
  AC_ARG_WITH(opencv-tree,
  [    --with-opencv-tree=PATH opencv tree for linking])
  if test -n "${with_opencv_tree}"
  then
    if test "${SYS}" = "mingw32" -o "${SYS}" = "cygwin"
    then
	  AC_MSG_CHECKING(for opencv in ${with_opencv_tree})
	  if test -f ${with_opencv_tree}/cv/include/cv.h -a -f ${with_opencv_tree}/cxcore/include/cxcore.h \
	    -a -f ${with_opencv_tree}/cvaux/include/cvaux.h -a -f ${with_opencv_tree}/otherlibs/highgui/highgui.h
      then
        AC_MSG_RESULT(yes)
        VLC_ADD_PLUGINS([opencv_wrapper])
        VLC_ADD_LDFLAGS([opencv_wrapper],[-L${with_opencv_tree}/lib -lcv -lcxcore -lcvaux -lhighgui])
        VLC_ADD_CFLAGS([opencv_wrapper],[-I${with_opencv_tree}/cv/include -I${with_opencv_tree}/cxcore/include -I${with_opencv_tree}/cvaux/include -I${with_opencv_tree}/otherlibs/highgui])
        AC_LANG_PUSH(C++)
        VLC_ADD_PLUGINS([opencv_example])
        VLC_ADD_LDFLAGS([opencv_example],[-L${with_opencv_tree}/lib -lcv -lcxcore -lcvaux -lhighgui])
        VLC_ADD_CXXFLAGS([opencv_example],[-I${with_opencv_tree}/cv/include -I${with_opencv_tree}/cxcore/include -I${with_opencv_tree}/cvaux/include -I${with_opencv_tree}/otherlibs/highgui])
        AC_LANG_POP(C++)        
	  else
        dnl  No opencv could be found, sorry
        AC_MSG_RESULT(no)
        AC_MSG_ERROR([cannot find opencv in ${with_opencv_tree}])
	  fi
    else
	  AC_MSG_WARN([--enable-opencv currently only works on windows])
    fi
  fi  
fi


dnl
dnl  libsmbclient plugin
dnl
AC_ARG_ENABLE(smb,
  [  --enable-smb            smb input module (default enabled)])
if test "${enable_smb}" != "no"; then
  AC_CHECK_HEADERS(libsmbclient.h,
    [ VLC_ADD_PLUGINS([access_smb])
      VLC_ADD_LDFLAGS([access_smb],[-lsmbclient]) ],
    [ if test -n "${enable_smb}"; then
        AC_MSG_ERROR([cannot find libsmbclient headers])
     fi ])
  AC_CHECK_MEMBER([struct _SMBCCTX.close_fn],
    AC_DEFINE([HAVE__SMBCCTX_CLOSE_FN], [1], [Define if samba has _SMBCCTX.close_fn]),,
    [#include <libsmbclient.h>])
fi

dnl
dnl  libdvbpsi ts demux/mux
dnl
AC_ARG_ENABLE(dvbpsi,
  [  --enable-dvbpsi         dvbpsi ts mux and demux module (default enabled)])
if test "${enable_dvbpsi}" != "no"
then