# Process this file with autoconf to produce a configure script.

AC_INIT(transcode,1.0.2)
AC_CONFIG_AUX_DIR(autotools)
AC_CONFIG_SRCDIR(src/transcode.c)

dnl Detect the canonical host and target build environment
AC_CANONICAL_SYSTEM

AM_INIT_AUTOMAKE(transcode,1.0.2)
AM_CONFIG_HEADER(config.h)
  
AM_MAINTAINER_MODE

# Checks for programs.
AC_PROG_CC
AC_PROG_GCC_TRADITIONAL
AC_PROG_CXX
AC_PROG_AWK
AC_PROG_CPP
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET

# dnl added 2002-04-26
AM_PROG_AS
AS=$CC
CCAS='$(CC)'
AC_SUBST(CCAS)
AC_PROG_CC
AC_SUBST(CCASFLAGS)
ASFLAGS="$CCASFLAGS"
AC_SUBST(ASFLAGS)

dnl we got $AWK already, but not it's full path
AC_PATH_PROG(PATH_TO_AWK, $AWK)

deflib="/lib"

is_osx=false
case "x${target_os}" in
  xdarwin*)
    is_osx=true
    CFLAGS="${CFLAGS} -no-cpp-precomp -D_INTL_REDIRECT_MACROS"
    CXXFLAGS="${CXXFLAGS} -no-cpp-precomp -D_INTL_REDIRECT_MACROS"
    OBJCFLAGS="${OBJCFLAGS} -no-cpp-precomp -D_INTL_REDIRECT_MACROS"
    #LDFLAGS="${LDFLAGS} -all_load"

    AC_DEFINE([SYSTEM_DARWIN], 1, [Define if this is Darwin / MacOSX OS])
    AC_DEFINE([BROKEN_PTHREADS], 1, [Define if you have weird pthreads])

    # Include Fink in compile and link if present
    if test -d /sw; then
      CPPFLAGS="${CPPFLAGS} -I/sw/include"
      LDFLAGS="${LDFLAGS} -L/sw/lib"
    fi
    ;;
esac


AM_CONDITIONAL([SYSTEM_DARWIN], test x"$is_osx" = x"true")

# Checks for libraries.
AC_CHECK_LIB(dl, dlopen)
AC_CHECK_FUNCS([dlopen])
if test x"$is_osx" = x"true" ; then
  AC_CHECK_FUNCS(dlsym_prepend_underscore,
    [CFLAGS="${CFLAGS} -Ddlsym=dlsym_prepend_underscore"],
    AC_MSG_WARN([Function 'dlsym_prepend_underscore' not found.])
    AC_MSG_WARN([Using function 'dlsym' directly instead.])
    AC_MSG_WARN([This can be a problem if the installed dlsym])
    AC_MSG_WARN([does not automatically prepend an underscore])
    AC_MSG_WARN([to symbols.]))
fi
AC_DISABLE_STATIC

if test x"$ac_cv_lib_dl_dlopen" = x"no" ; then
  case x${target_os} in
    xdarwin*)
      DLDARWINOBJECTS="$DLDARWINOBJECTS dlfcn_simple.o"
      DLDARWINLIB="\$(top_builddir)/libdldarwin/libdldarwin.a"
      DLDARWININCL="-I\$(top_srcdir)/libdldarwin/"
      ;;
  esac
fi
DLDARWINOBJECTS="$DLDARWINOBJECTS dummy.o"
AC_SUBST(DLDARWINOBJECTS)
AC_SUBST(DLDARWINLIB)
AC_SUBST(DLDARWININCL)


# Checks for header files.
AC_HEADER_STDC
AC_HEADER_DIRENT
AC_CHECK_HEADERS([errno.h fcntl.h sys/time.h unistd.h limits.h])
AC_CHECK_HEADERS([inttypes.h malloc.h alloca.h])

# Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST
AC_HEADER_TIME
AC_C_INLINE
AC_TYPE_SIZE_T 
AC_C_BIGENDIAN([words_bigendian=true
  AC_DEFINE([WORDS_BIGENDIAN], 1, [Define if your CPU is big endian])],
  words_bigendian=false)
AM_CONDITIONAL(WORDS_BIGENDIAN, test x"$words_bigendian" = x"true")
AC_TYPE_OFF_T
AC_C_ATTRIBUTE_ALIGNED

# Checks for library functions.
AC_FUNC_MALLOC
AC_FUNC_ALLOCA
AC_FUNC_VPRINTF
AC_FUNC_STAT
AC_FUNC_STRCOLL
AC_TYPE_SIGNAL
AC_CHECK_FUNCS([strtol memalign ftruncate gettimeofday memset strerror])
AC_CHECK_FUNCS([strncasecmp stat floor atexit getpagesize memmove mkfifo])
AC_CHECK_FUNCS([vsscanf strptime alloca strlcat strlcpy])

AC_CHECK_LIB(m, lrint,
  AC_DEFINE([HAVE_LIBM_LRINT], 1,
    [Define if the lrint() function is in libm on your system]))

# Checks if support lib is needed
enable_supportlib="no"
AC_CHECK_FUNCS(getopt_long_only, [], [enable_supportlib="yes"
    SUPPORT_OBJECTS="$SUPPORT_OBJECTS getopt.o getopt1.o"])
SUPPORT_OBJECTS="$SUPPORT_OBJECTS dummy.o"
AC_MSG_CHECKING([whether support lib is needed])
AC_MSG_RESULT($enable_supportlib)
if test x"$enable_supportlib" = x"yes" ; then
  SUPPORT_LIBS="\$(top_builddir)/libsupport/libsupport.a" 
  SUPPORT_INCLUDES="-I\$(top_srcdir)/libsupport"
  AC_SUBST(SUPPORT_OBJECTS)
  AC_SUBST(SUPPORT_LIBS)
  AC_SUBST(SUPPORT_INCLUDES)
fi


case "$host_os" in
  freebsd*|openbsd*|netbsd*|bsdi*|darwin*|rhapsody*)
     AC_DEFINE([SYS_BSD], 1, [Define if your system is modern BSD])
     ;;
  *)
     ;;
esac


dnl check for pthreads
dnl
case "$host" in
  *-*-freebsd*)
    pthread_cflags="-pthread -D_REENTRANT -D_THREAD_SAFE"
    pthread_libs="-pthread"
    ;;
  *-*-openbsd*)
    pthread_cflags="-D_REENTRANT"
    pthread_libs="-pthread"
    ;;
  *-*-bsdi*)
    pthread_cflags="-D_REENTRANT -D_THREAD_SAFE"
    pthread_libs=""
    ;;
  *)
    pthread_cflags="-D_REENTRANT"
    pthread_libs="-lpthread"
    ;;
esac
# let user override
if test -n "$PTHREAD_LIBS" ; then
  pthread_libs="$PTHREAD_LIBS"
fi
if test -n "$PTHREAD_CFLAGS" ; then
  pthread_cflags="$PTHREAD_CFLAGS"
fi
save_LIBS="$LIBS"
LIBS="$LIBS $pthread_libs"
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $pthread_cflags"
AC_MSG_CHECKING(for pthreads in $pthread_libs)
AC_TRY_LINK([
#include <pthread.h>
],[
   pthread_attr_t type;
   pthread_attr_init(&type);
],
  [use_pthreads="yes"],
  [use_pthreads="no"]
);
LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS"
AC_MSG_RESULT($use_pthreads)
if test x"$use_pthreads" = x"yes" ; then
  PTHREAD_LIBS="$pthread_libs"
  PTHREAD_CFLAGS="$pthread_cflags"
else
  PTHREAD_LIBS=""
  PTHREAD_CFLAGS=""
fi
AC_SUBST(PTHREAD_LIBS)
AC_SUBST(PTHREAD_CFLAGS)

dnl
dnl Architecture specific instructions
dnl

AC_MSG_CHECKING([for build architecture])
have_x86cpu=false
have_x86_64cpu=false
have_ppccpu=false
case x"$host_cpu" in
  xi?86*|xk6*)
    have_x86cpu=true
    AC_MSG_RESULT([Intel Pentium architecture (IA32)])
    AC_DEFINE([ARCH_X86], 1, [Define if your machine is x86 based])
    ;;
  xx86_64*|xamd64*)
    have_x86_64cpu=true
    AC_MSG_RESULT([AMD64 architecture (AMD64)])
    AC_DEFINE([ARCH_X86_64], 1, [Define if your machine is AMD64 based])
    ;;
  xpowerpc*)
    have_ppccpu=true
    AC_MSG_RESULT([Mac PPC architecture (PPC)])
    AC_DEFINE([ARCH_PPC], 1, [Define if your machine is PPC based])
    ;;
  *)
    ;;
esac
AM_CONDITIONAL(ARCH_X86, test x"$have_x86cpu" = x"true")
AM_CONDITIONAL(ARCH_X86_64, test x"$have_x86_64cpu" = x"true")
AM_CONDITIONAL(ARCH_PPC, test x"$have_ppccpu" = x"true")


dnl x86 & x86_64 architectures

dnl MMX support
dnl
AC_ARG_ENABLE(mmx,
  AC_HELP_STRING([--enable-mmx],
    [enable MMX code portions (yes)]),
  [case "${enableval}" in
    yes) use_mmx=yes ;;
    no)  use_mmx=no ;;
    *) AC_MSG_ERROR(bad value ${enableval} for --enable-mmx) ;;
  esac],
  [if test x"$have_x86cpu" = x"true" -o x"$have_x86_64cpu" = x"true" ; then
    use_mmx=yes
  else
    use_mmx=no
  fi])

AC_MSG_CHECKING([if \$CC groks MMX inline assembly])
have_asm_mmx="no"
if test x"$use_mmx" = x"yes" ; then
  AC_TRY_COMPILE([],
    [void *p;asm volatile("packuswb %%mm1,%%mm2"::"r"(p));],
    [have_asm_mmx="yes"])
  if test x"$have_asm_mmx" = x"yes" ; then
    AC_DEFINE([HAVE_ASM_MMX], 1,
      [Define if your CPU understands ASM MMX instructions])
    AC_DEFINE([HAVE_MMX], 1,
      [Define if your CPU understands MMX instructions])
  fi
fi
AC_MSG_RESULT($have_asm_mmx)
AM_CONDITIONAL(HAVE_MMX, test x"$have_asm_mmx" = x"yes")
if test x"$have_asm_mmx" = x"no" ; then
  AC_MSG_WARN(*** All of mmx dependent parts will be disabled ***)
fi

dnl 3DNow support
dnl
AC_ARG_ENABLE(3dnow,
  AC_HELP_STRING([--enable-3dnow],
    [enable 3DNow code portions (yes)]),
  [case "${enableval}" in
    yes) use_3dnow=yes ;;
    no)  use_3dnow=no ;;
    *) AC_MSG_ERROR(bad value ${enableval} for --enable-3dnow) ;;
  esac],
  [if test x"$have_x86cpu" = x"true" -o x"$have_x86_64cpu" = x"true" ; then
    use_3dnow=yes
  else
    use_3dnow=no
  fi])
AC_MSG_CHECKING([for support of 3DNow in assembly code])
have_asm_3dnow="no"
if test x"$use_3dnow" = x"yes" ; then
  cat > conftest.S <<EOF
    .text

    pfmul %mm3, %mm4
EOF
  if $CC -c conftest.S ; then
    rm -f conftest.*
    AC_DEFINE([HAVE_ASM_3DNOW], 1,
      [Define if your CPU understands ASM 3DNow instructions])
    AC_DEFINE([HAVE_3DNOW], 1,
      [Define if your CPU understands 3DNow instructions])
    have_asm_3dnow="yes"
  else
    echo "configure: failed program was:" >&AC_FD_CC
    cat conftest.S >&AC_FD_CC
    rm -f conftest.*
  fi
fi
AC_MSG_RESULT($have_asm_3dnow)
AM_CONDITIONAL(HAVE_3DNOW, test x"$have_asm_3dnow" = x"yes")
if test x"$have_asm_3dnow" = x"no" ; then
  AC_MSG_WARN(*** All of 3DNow dependent parts will be disabled ***)
fi


dnl SSE support
dnl
AC_ARG_ENABLE(sse,
  AC_HELP_STRING([--enable-sse],
    [enable SSE code portions (yes)]),
  [case "${enableval}" in
    yes) use_sse=yes ;;
    no)  use_sse=no ;;
    *) AC_MSG_ERROR(bad value ${enableval} for --enable-sse) ;;
  esac],
  [if test x"$have_x86cpu" = x"true" -o x"$have_x86_64cpu" = x"true" ; then
    use_sse=yes
  else
    use_sse=no
  fi])
AC_MSG_CHECKING([if \$CC groks SSE inline assembly])
have_asm_sse="no"
if test x"$use_sse" = x"yes" ; then
  AC_TRY_COMPILE([],
    [void *p; asm volatile("movntps  %%xmm0, 0"::"r"(p));],
    [have_asm_sse=yes])
  if test x"$have_asm_sse" = x"yes" ; then
    AC_DEFINE([HAVE_ASM_SSE], 1,
      [Define if your CPU understands ASM SSE instructions])
    AC_DEFINE([HAVE_SSE], 1,
      [Define if your CPU understands SSE instructions])
  fi
fi
AC_MSG_RESULT($have_asm_sse)
AM_CONDITIONAL(HAVE_SSE, test x"$have_asm_sse" = x"yes")
if test x"$have_asm_sse" = x"no" ; then
  AC_MSG_WARN(*** All of sse dependent parts will be disabled ***)
fi


dnl SSE2 support
dnl
AC_ARG_ENABLE(sse2,
  AC_HELP_STRING([--enable-sse2],
    [enable SSE2 code portions (yes)]),
  [case "${enableval}" in
    yes) use_sse2=yes ;;
    no)  use_sse2=no ;;
    *) AC_MSG_ERROR(bad value ${enableval} for --enable-sse2) ;;
  esac],
  [if test x"$have_x86cpu" = x"true" -o x"$have_x86_64cpu" = x"true" ; then
    use_sse2=yes
  else
    use_sse2=no
  fi])
AC_MSG_CHECKING([if \$CC can handle SSE2 inline asm])
have_asm_sse2="no"
if test x"$use_sse2" = x"yes" ; then
  AC_TRY_COMPILE([],
    [void *p; asm volatile("movdqa  %%xmm2, %%xmm3"::"r"(p));],
    [have_asm_sse2=yes])
  if test x"$have_asm_sse2" = x"yes" ; then
    AC_DEFINE([HAVE_ASM_SSE2], 1,
      [Define if your CPU understands ASM SSE2 instructions])
    AC_DEFINE([HAVE_SSE2], 1,
      [Define if your CPU understands SSE2 instructions])
  fi
fi
AC_MSG_RESULT($have_asm_sse2)
AM_CONDITIONAL(HAVE_SSE2, test x"$have_asm_sse2" = x"yes")
if test x"$have_asm_sse2" = x"no" ; then
  AC_MSG_RESULT(*** All of sse2 dependent parts will be disabled ***)
fi



dnl ppc architectures


dnl
dnl Altivec support
dnl
AC_ARG_ENABLE(altivec,
  AC_HELP_STRING([--enable-altivec],
    [enable Altivec code portions (yes)]),
  [case "${enableval}" in
    yes) use_altivec=yes ;;
    no)  use_altivec=no ;;
    *) AC_MSG_ERROR(bad value ${enableval} for --enable-altivec) ;;
  esac],
  [if test x"$have_ppccpu" = x"true" ; then
    use_altivec=yes
  else
    use_altivec=no
  fi])
dnl if test x"$use_altivec" = x"no" ; then
dnl	AC_MSG_WARN(*** All of Altivec dependent parts will be disabled ***)
dnl fi


AC_MSG_CHECKING([if \$CC groks AltiVec inline assembly])
have_asm_altivec=no
if test x"$use_altivec" = x"yes" ; then
  AC_TRY_COMPILE([],
    [asm volatile("vperm 0,1,2,3");],
    [have_asm_altivec=yes],
    [save_CFLAGS="$CFLAGS"
      CFLAGS="$CFLAGS -Wa,-m7400"
      AC_TRY_COMPILE([],
        [asm volatile("vperm 0,1,2,3");],
        [have_asm_altivec=yes])
      CFLAGS="$save_CFLAGS"])
fi
AC_MSG_RESULT($have_asm_altivec)
if test x"$have_asm_altivec" = x"yes" ; then
  AC_DEFINE([HAVE_PPC_ALTIVEC], 1,
    [Define if \$CC groks AltiVec inline assembly].)
fi

AC_MSG_CHECKING([if \$CC groks AltiVec C extensions])
have_c_altivec=no
if test x"$use_altivec" = x"yes" ; then
  # Darwin test
  save_CFLAGS="$CFLAGS"
  CFLAGS="$CFLAGS -faltivec"
  AC_TRY_COMPILE([],
    [vec_mtvscr((vector unsigned int)(0));],
    [have_c_altivec=yes
      ALTIVEC_CFLAGS="-faltivec"],
    [# Linux/PPC test
      CFLAGS="${save_CFLAGS} -fvec"
      AC_TRY_COMPILE([],
        [vec_mtvscr((vector unsigned int)(0));],
        [have_c_altivec=yes
          ALTIVEC_CFLAGS="-fvec"])
    ])
  CFLAGS="$save_CFLAGS"
fi
AC_MSG_RESULT($have_c_altivec)
AM_CONDITIONAL(CAN_COMPILE_C_ALTIVEC, test x"$have_c_altivec" = x"yes")
if test x"$have_c_altivec" = x"yes" ; then
  AC_DEFINE([CAN_COMPILE_C_ALTIVEC], 1,
    [Define if your compiler groks C AltiVec extensions.])
  AC_SUBST(ALTIVEC_CFLAGS)
fi

AC_MSG_CHECKING([if linker needs -framework vecLib])
if test x"$use_altivec" = x"yes" ; then
  save_LDFLAGS="$LDFLAGS"
  LDFLAGS="$LDFLAGS -framework vecLib"
  ld_altivec=no
  AC_TRY_LINK([], [], [ld_altivec=yes])
  LDFLAGS="$save_LDFLAGS"
fi
AC_MSG_RESULT($ld_altivec)
if test x"$ld_altivec" = x"yes" ; then
  LDFLAGS="$LDFLAGS -framework vecLib"
fi


dnl
dnl gcc stuff
dnl
AM_CONDITIONAL(HAVE_GCC, test x"$GCC" = x"yes")

dnl XXX hack! filter/pp needs -fomit-frame-pointer with gcc
have_fomit_fp="no"
if test x"$GCC" = x"yes" ; then
  if echo "$CFLAGS" | grep -vq -- '-fomit-frame-pointer' ; then
    AC_TRY_CFLAGS([-fomit-frame-pointer], [have_fomit_fp="yes"])
  fi
fi
AM_CONDITIONAL(HAVE_FOMIT_FP, test x"$have_fomit_fp" = x"yes")

dnl Check for gcc2, which doesn't seem to handle asm templates
dnl And check for gcc4, which also has problems with filter_tomsmocomp
dnl
gcc2=no
gcc4=no
if test x"$GCC" = x"yes" ; then
  gcc_ver="`LANG=C $CC -dumpversion`"
  if test x"$gcc_ver" != x"" ; then
    if echo $gcc_ver | grep -q ^2 ; then
      gcc2=yes
    fi
    if echo $gcc_ver | grep -q ^4 ; then
      gcc4=yes
    fi
  fi
fi
AM_CONDITIONAL(HAVE_GCC2, test x"$gcc2" = x"yes")
AM_CONDITIONAL(HAVE_GCC4, test x"$gcc4" = x"yes")

AC_LIBTOOL_DLOPEN
AC_PROG_LIBTOOL

OPT_CFLAGS="-D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 $CFLAGS"
AC_TRY_CFLAGS([$OPT_CFLAGS],[CFLAGS=$OPT_CFLAGS])
AC_SUBST(CFLAGS)

OPT_CXXFLAGS="$CXXFLAGS -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64"
AC_TRY_CXXFLAGS([$OPT_CXXFLAGS],[CXXFLAGS=$OPT_CXXFLAGS])
AC_SUBST(CXXFLAGS)

dnl
dnl fast integers
dnl
AC_MSG_CHECKING(if fast integers are available)
AC_TRY_COMPILE([
#include <inttypes.h>
], [
volatile uint_fast64_t i=0x01234567;
return 0
], [
AC_MSG_RESULT([yes])
], [
AC_DEFINE([EMULATE_FAST_INT], 1, [Define if your system lacks uint_fast64_t])
AC_MSG_RESULT([no])
])


dnl
dnl pkgconfig
dnl
if test -z "$PKG_CONFIG" ; then
  AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
fi


dnl ---------------------------------------------------------------------
dnl X11 checks

AC_PATH_XTRA
if test x"${no_x}" = x"yes" ; then
  AC_MSG_WARN(can not find X11)
  USE_X11=no
else
  AC_DEFINE([HAVE_X11], 1, [Have X11 support])
  USE_X11=yes
fi

AC_SUBST(X_CFLAGS)
AC_SUBST(X_PRE_LIBS)
AC_SUBST(X_EXTRA_LIBS)
AC_SUBST(X_LIBS)
AC_SUBST(x_includes)
AC_SUBST(x_libraries)

dnl fi

AM_CONDITIONAL(HAVE_X11, test x"${USE_X11}" = x"yes")

AC_CHECK_LIB(Xv, XvQueryExtension,
  [have_xv=yes
    AC_DEFINE([HAVE_LIBXV], 1,
      [Have libxv support])],
  [have_xv=no],
  [$X_LIBS $X_PRE_LIBS -lXext -lX11 $X_EXTRA_LIBS])
AM_CONDITIONAL(HAVE_LIBXV, test x"$have_xv" = x"yes")

AC_CHECK_HEADERS([X11/Xaw/Simple.h], 
  [have_xaw_simple=yes
    AC_DEFINE([HAVE_XAW_SIMPLE], 1,
      [Have the Xaw Simple.h file support])],
  [have_xaw_simple=no])
AM_CONDITIONAL(HAVE_XAW_SIMPLE, test x"$have_xaw_simple" = x"yes" )

AC_CHECK_LIB(Xpm, XpmFreeAttributes,
  [have_xpm=yes
    AC_DEFINE([HAVE_LIBXPM], 1,
      [Have libXpm support])],
  [have_xpm=no],
  [$X_LIBS $X_PRE_LIBS -lXext -lX11 $X_EXTRA_LIBS])
AM_CONDITIONAL(HAVE_LIBXPM, test x"$have_xpm" = x"yes")

dnl end X11 checks
dnl ---------------------------------------------------------------------

AC_CHECK_LIB(z, gzopen,
  [],
  [AC_MSG_ERROR([transcode depends on libz, but cannot links against libz])],
  [])

AC_CHECK_LIB(m, sin,
  [],
  [AC_MSG_ERROR([transcode depends on libm (>= 2.0), but cannot link against libm])],
  [-lc])

TC_PKG_INIT

dnl
dnl libavcodec
dnl
AC_ARG_ENABLE(libavcodec-static,
  AC_HELP_STRING([--enable-libavcodec-static],
    [link binaries and modules to static libavcodec WARNING: creates huge binaries WARNING: only tested on linux x86]),
  [case "${enableval}" in
    yes) ;;
    no)  ;;
    *) AC_MSG_ERROR(bad value ${enableval} for --enable-libavcodec-static) ;;
  esac],
  [enable_libavcodec_static=no])
LIBAVCODEC_EXTRA_LIBS="$LIBAVCODEC_EXTRA_LIBS -lm -lz $PTHREAD_LIBS"
TC_PKG_CHECK(libavcodec, required, LIBAVCODEC, no, [ffmpeg/avcodec.h],
 avcodec, avcodec_thread_init, FFMpeg, [http://www.ffmpeg.org/])
if test x"$have_libavcodec" = x"yes" ; then
  save_CPPFLAGS="$CPPFLAGS"
  CPPFLAGS="$CPPFLAGS $LIBAVCODEC_CFLAGS"
  AC_TRY_RUN([
#include <stdio.h>
#include <ffmpeg/avcodec.h>
int
main()
{
  if (LIBAVCODEC_BUILD < 4718)
  {
    printf("error: transcode needs at least libavcodec build 4718");
    printf("install ffmpeg 0.4.9-pre1 or newer, or a cvs version after 20040703");
    return(1);
  }
  printf("VER=%s\n", FFMPEG_VERSION);
  printf("BUILD=%d\n", LIBAVCODEC_BUILD);
  return(0);
}
],
    [LIBAVCODEC_VERSION="`./conftest$ac_exeext | sed -ne 's,VER=\(.*\),\1,p'`"
      LIBAVCODEC_BUILD="`./conftest$ac_exeext | sed -ne 's,BUILD=\(.*\),\1,p'`"],
    [TC_PKG_ERROR(libavcodec, ffmpeg/avcodec.h, required, FFmpeg, [http://www.ffmpeg.org],
      [cannot compile ffmpeg/avcodec.h])],
    [echo $ac_n "cross compiling; assumed OK... $ac_c"
      LIBAVCODEC_VERSION=""
      LIBAVCODEC_BUILD=""])
  if test x"$enable_libavcodec_static" = x"yes" ; then
    if test x"$deplibs_check_method" != x"pass_all" ; then
      AC_MSG_ERROR([linking static archives into shared objects not supported on this platform]) 
    fi
    save_LIBS="$LIBS"
    dnl $_w_libavcodec_l comes from TC_PKG_CHECK()
    LIBS="$LIBS $w_libavcodec_l${deflib}/libavcodec.a $LIBAVCODEC_EXTRA_LIBS"
    AC_TRY_LINK([
#include <ffmpeg/avcodec.h>
],[
AVCodecContext *ctx = (void *)0;
avcodec_thread_init(ctx, 0);
],
      [LIBAVCODEC_LIBS="$w_libavcodec_l${deflib}/libavcodec.a $LIBAVCODEC_EXTRA_LIBS"],
      [AC_MSG_ERROR([cannot link statically with libavcodec])])
    LIBS="$save_LIBS"
  fi
  CPPFLAGS="$save_CPPFLAGS"
fi
AC_SUBST(LIBAVCODEC_VERSION)
AC_SUBST(LIBAVCODEC_BUILD)
AC_SUBST(LIBAVCODEC_CFLAGS)
AC_SUBST(LIBAVCODEC_LIBS)

dnl
dnl libmpeg2
dnl
LIBMPEG2_EXTRA_LIBS="$LIBMPEG2_EXTRA_LIBS -lmpeg2convert"
TC_PKG_CHECK(libmpeg2, required, LIBMPEG2, no, mpeg2dec/mpeg2.h,
  mpeg2, mpeg2_init, mpeg2dec, [http://libmpeg2.sourceforge.net/])
TC_PKG_HAVE(libmpeg2, LIBMPEG2)


dnl
dnl build options
dnl

dnl
dnl static import frame buffer 
dnl
AC_MSG_CHECKING([for internal static framebuffer support])
AC_ARG_ENABLE(statbuffer,
  AC_HELP_STRING([--enable-statbuffer],
    [enable internal static framebuffer support (yes)]), 
  [case "${enableval}" in
    yes) ;;
    no)  ;;
    *) AC_MSG_ERROR(bad value ${enableval} for --enable-statbuffer) ;;
  esac],
  [enable_statbuffer=yes])
AC_MSG_RESULT($enable_statbuffer)
if test x"$enable_statbuffer" = x"yes" ; then
  AC_DEFINE([STATBUFFER], 1, [Use the static buffers])	
fi

dnl
dnl experimental network streaming support
dnl
AC_MSG_CHECKING(for network streaming support)
AC_ARG_ENABLE(netstream,
  AC_HELP_STRING([--enable-netstream],
    [enable network streaming support (no)]),
  [case "${enableval}" in
    yes) ;;
    no)  ;;
    *) AC_MSG_ERROR(bad value ${enableval} for --enable-netstream) ;;
  esac],
  [enable_netstream=no])
AC_MSG_RESULT($enable_netstream)
if test x"$enable_netstream" = x"yes" ; then
  AC_DEFINE([NET_STREAM], 1, [Enable network functionality])	
fi
AM_CONDITIONAL(NET_STREAM, test x"$enable_netstream" = x"yes")


dnl
dnl hardware/OS dependent modules
dnl

dnl
dnl v4l
dnl
TC_CHECK_V4L(AC_DEFINE([HAVE_V4L], 1, [Have video4linux(2)]))
AM_CONDITIONAL(HAVE_V4L, test x"$have_v4l" = x"yes")

dnl
dnl bktr
dnl
TC_CHECK_BKTR(AC_DEFINE([HAVE_BKTR], 1, [Have bktr(4)]))
AM_CONDITIONAL(HAVE_BKTR, test x"$have_bktr" = x"yes")

dnl
dnl sunau
dnl
TC_CHECK_SUNAU(AC_DEFINE([HAVE_SUNAU], 1, [Have Sun style audio(4)]))
AM_CONDITIONAL(HAVE_SUNAU, test x"$have_sunau" = x"yes")

dnl
dnl OSS
dnl
TC_CHECK_OSS(AC_DEFINE([HAVE_OSS], 1, [Have OSS audio]))
AM_CONDITIONAL(HAVE_OSS, test x"$have_oss" = x"yes")


dnl
dnl optional 3rd party package support
dnl

dnl
dnl Divx4linux
dnl
AC_CHECK_HEADERS([decore.h], 
  [have_divx_decore=yes
    AC_DEFINE([HAVE_DIVX_DECORE], 1,
      [Have the Divx4linux decore.h header file])],
  [have_divx_decore=no])
AM_CONDITIONAL(HAVE_DIVX_DECORE, test x"$have_divx_decore" = x"yes" )

AC_CHECK_HEADERS([encore2.h], 
  [have_divx_encore2=yes
    AC_DEFINE([HAVE_DIVX_ENCORE2], 1,
      [Have the Divx4linux encore2.h header file])],
  [have_divx_encore2=no])
AM_CONDITIONAL(HAVE_DIVX_ENCORE2, test x"$have_divx_encore2" = x"yes" )

dnl
dnl xvid
dnl
AC_MSG_CHECKING([for default xvid])
AC_ARG_WITH(default-xvid,
  AC_HELP_STRING([--with-default-xvid=xvid2/xvid3/xvid4],
    [Default xvid version (xvid4)]),
  [default_xvid=$withval],
  [default_xvid="xvid4"])
AC_MSG_RESULT($default_xvid)
XVID_DEFAULT="$default_xvid"
AC_SUBST(XVID_DEFAULT)

dnl
dnl ibp and lors
dnl
TC_PATH_IBP(AC_DEFINE([HAVE_IBP], 1, [ibp and lors support]))
AM_CONDITIONAL(HAVE_IBP, test x"$have_ibp" = x"yes")

dnl
dnl libpostproc
dnl
TC_PKG_CHECK(libpostproc, no, LIBPOSTPROC, no, postprocess.h,
  postproc, pp_postprocess, FFmpeg, [http://www.ffmpeg.org/])
TC_PKG_HAVE(libpostproc, LIBPOSTPROC)

dnl
dnl freetype2
dnl
TC_PKG_CHECK(freetype2, no, FREETYPE2, freetype-config, ft2build.h,
  freetype, FT_Init_FreeType, freetype, [http://www.freetype.org/])
TC_PKG_HAVE(freetype2, FREETYPE2)

dnl
dnl avifile
dnl
AVIFILE_EXTRA_LIBS="$AVIFILE_EXTRA_LIBS $X_LIBS $PTHREAD_LIBS"
AC_LANG_PUSH([C++])
TC_PKG_CHECK(avifile, no, AVIFILE, avifile-config, avifile.h, aviplay,
 GetAvifileVersion, avifile, [http://avifile.sourceforge.net/])
if test x"$have_avifile" = x"yes" ; then
  if echo "$AVIFILE_CFLAGS" | grep -q '/avifile-0\.7' ; then
    have_avifile_includes=7
  else
    have_avifile_includes=0
  fi
  AC_DEFINE_UNQUOTED([HAVE_AVIFILE_INCLUDES], $have_avifile_includes,
    [avifile includes directory version specific])
fi
AC_LANG_POP([C++])
TC_PKG_HAVE(avifile, AVIFILE)

dnl
dnl lame
dnl
TC_PKG_CHECK(lame, yes, LAME, no, none, mp3lame, lame_init, lame,
 [http://www.mp3dev.org/])
if test x"$have_lame" = x"yes" ; then
  lame_inc="no"
  save_CPPFLAGS="$CPPFLAGS"
  CPPFLAGS="$CPPFLAGS $lame_ii"
  AC_CHECK_HEADER([lame/lame.h],
    [AC_DEFINE([HAVE_LAME_INC], [1],
      [Have Lame includes in separate path]) lame_inc=yes])
  if test x"$lame_inc" = x"no" ; then
    AC_CHECK_HEADER([lame.h], lame_inc="yes")
  fi
  if test x"$lame_inc" = x"no" ; then
    have_lame="no"
    TC_PKG_ERROR(lame, lame.h, yes, lame, [http://www.mp3dev.org/],
      [cannot compile lame.h])
  else
    LAME_CFLAGS="$lame_ii"
  fi
  CPPFLAGS="$save_CPPFLAGS"

  AC_MSG_CHECKING([lame version])
  ac_save_CFLAGS="$CFLAGS"
  ac_save_LIBS="$LIBS"
  CFLAGS="$CFLAGS $LAME_CFLAGS"
  LIBS="$LIBS $LAME_LIBS"
  AC_TRY_RUN([
#include <stdio.h>

#ifdef HAVE_LAME_INC
#include <lame/lame.h>
#else
#include <lame.h>
#endif

int main () {
  lame_version_t lv;
  get_lame_version_numerical(&lv);
  if(lv.alpha || lv.beta) lv.minor--;
  printf("%d%d\n", lv.major, lv.minor);
  return 0;
}
],
    [lame_version="`./conftest$ac_exeext`"],
    [TC_PKG_ERROR(lame, lame.h, yes, lame, [http://www.mp3dev.org/],
      [cannot compile and run a test program])],,
    [echo $ac_n "cross compiling; assumed OK... $ac_c"])
  CFLAGS="$ac_save_CFLAGS"
  LIBS="$ac_save_LIBS"

  if test $lame_version -lt 389 ; then
    have_lame="no"
    TC_PKG_ERROR(lame, lame.h, yes, lame, [http://www.mp3dev.org/],
      [lame version < 3.89])
  fi
  if test x"$have_lame" = x"yes" ; then
    AC_DEFINE_UNQUOTED([TC_LAME_VERSION], $lame_version, [lame version])
  fi
fi
TC_PKG_HAVE(lame, LAME)

dnl
dnl ogg
dnl
TC_PKG_CHECK(ogg, no, OGG, no, [ogg/ogg.h], ogg, ogg_stream_init, ogg,
 [http://www.xiph.org/ogg/])
TC_PKG_HAVE(ogg, OGG)

dnl
dnl vorbis
dnl
VORBIS_EXTRA_LIBS="$VORBIS_EXTRA_LIBS $OGG_LIBS -lm"
TC_PKG_CHECK(vorbis, no, VORBIS, no, [vorbis/codec.h], vorbis,
 vorbis_info_init, vorbis, [http://www.xiph.org/ogg/vorbis/])
TC_PKG_HAVE(vorbis, VORBIS)

dnl
dnl theora
dnl
THEORA_EXTRA_LIBS="$THEORA_EXTRA_LIBS $OGG_LIBS -lm"
TC_PKG_CHECK(theora, no, THEORA, theora-config, [theora/theora.h], theora,
 theora_info_init, theora, [http://www.theora.org/])
TC_PKG_HAVE(theora, THEORA)

dnl
dnl libdvdread
dnl
LIBDVDREAD_EXTRA_LIBS="$LIBDVDREAD_EXTRA_LIBS -lm"
TC_PKG_CHECK(libdvdread, yes, LIBDVDREAD, no, none, dvdread, DVDOpen,
 libdvdread, [http://www.dtek.chalmers.se/groups/dvd/downloads.shtml])
if test x"$have_libdvdread" = x"yes" ; then
  libdvdread_inc="no"
  save_CPPFLAGS="$CPPFLAGS"
  CPPFLAGS="$CPPFLAGS $libdvdread_ii"
  AC_CHECK_HEADER([dvdread/dvd_reader.h],
    [AC_DEFINE([HAVE_LIBDVDREAD_INC], [1],
      [have libdvdread includes in separate path])
    libdvdread_inc="yes"])
  if test x"$libdvdread_inc" = x"no" ; then
    AC_CHECK_HEADER([dvd_reader.h],
      [libdvdread_inc="yes"])
  fi
  CPPFLAGS="$save_CPPFLAGS"
  if test x"$libdvdread_inc" = x"no" ; then
    have_libdvdread="no"
    TC_PKG_ERROR(libdvdread, dvd_reader.h, yes, libdvdread,
      [http://www.dtek.chalmers.se/groups/dvd/downloads.shtml],
      [cannot compile dvd_reader.h])
  else
    LIBDVDREAD_CFLAGS="$libdvdread_ii"
  fi
fi
TC_PKG_HAVE(libdvdread, LIBDVDREAD)

dnl
dnl PVM3
dnl
PVM3_EXTRA_LIBS="$PVM3_EXTRA_LIBS -lgpvm3"
TC_PKG_CHECK(pvm3, no, PVM3, no, pvm3.h, pvm3, pvm_initsend,
  pvm3, [])
if test x"$have_pvm3" = x"yes" ; then
  save_CPPFLAGS="$CPPFLAGS"
  CPPFLAGS="$CPPFLAGS $PVM3_CFLAGS"
  AC_TRY_RUN([
#include <stdio.h>
#include <pvm3.h>
int main () 
{
  if ((PVM_MAJOR_VERSION == 3) && (PVM_MINOR_VERSION < 4))
  {
	printf("You need to upgrade pvm3 to version > 3.4\n");
	return(1);
  }
  if (PVM_MAJOR_VERSION < 3)
  {
	printf("You need to upgrade pvm3 to version > 3.4\n");
	return(1);
  }
  return 0;
}
],
  [have_pvm3="yes"],
  [have_pvm3="no"],
  [echo $ac_n "cross compiling; assumed OK... $ac_c"
    have_pvm3="yes"])
  CPPFLAGS="$save_CPPFLAGS"
  # also include the in-tree pvm3 headers
  PVM3_CFLAGS="$PVM3_CFLAGS -I\$(top_srcdir)/pvm3"
  PVM3_PVMGS="$w_pvm3_l/pvmgs"
fi
AC_SUBST(PVM3_PVMGS)
TC_PKG_HAVE(pvm3, PVM3)

dnl
dnl libdv
dnl
LIBDV_EXTRA_LIBS="$LIBDV_EXTRA_LIBS $PTHREAD_LIBS -lm"
TC_PKG_CHECK(libdv, no, LIBDV, no, [libdv/dv.h], dv, dv_encoder_new,
 libdv, [http://libdv.sourceforge.net/])
if test x"$have_libdv" = x"yes" ; then
  save_LDFLAGS="$LDFLAGS"
  LDFLAGS="$LDFLAGS $LIBDV_LIBS"
  save_CPPFLAGS="$CPPFLAGS"
  CPPFLAGS="$CPPFLAGS $LIBDV_CFLAGS"
  dnl check for libdv version >= 0.99
  AC_CHECK_LIB(dv, dv_calculate_samples,
    [AC_DEFINE([LIBDV_099], [1], [Have libdv 0.99 or newer])],
    [], 
    [$LIBDV_EXTRA_LIBS])
  dnl check for libdv version >= 0.103
  AC_TRY_COMPILE([#include <libdv/dv_types.h>
      #include <stdio.h>],
    [printf("header_size = %d\n", header_size);],
    [],
    [AC_DEFINE([LIBDV_0103], [1], [Have libdv 0.103 or newer])])
  LDFLAGS="$save_LDFLAGS"
  CPPFLAGS="$save_CPPFLAGS"
fi
TC_PKG_HAVE(libdv, LIBDV)

dnl
dnl libquicktime
dnl
LIBQUICKTIME_EXTRA_LIBS="$LIBQUICKTIME_EXTRA_LIBS -lpng -lz $PTHREAD_LIBS -lm $LIBDV_LIBS"
TC_PKG_CHECK(libquicktime, no, LIBQUICKTIME, lqt-config, [quicktime.h],
 quicktime, quicktime_open, libquicktime,
 [http://libquicktime.sourceforge.net/])
if test x"$have_libquicktime" = x"yes" ; then
  AC_CHECK_LIB(quicktime, lqt_encode_video,
    [AC_DEFINE([LIBQUICKTIME_000904], [1], [Have libquicktime 0.9.4 or newer])],
    [], 
    [$LIBQUICKTIME_EXTRA_LIBS])
fi
TC_PKG_HAVE(libquicktime, LIBQUICKTIME)

dnl
dnl LZO
dnl
TC_PKG_CHECK(lzo, no, LZO, no, [lzo1x.h], lzo, lzo_version, lzo,
 [http://www.oberhumer.com/opensource/lzo/])
TC_PKG_HAVE(lzo, LZO)

dnl
dnl A52
dnl
A52_EXTRA_LIBS="$A52_EXTRA_LIBS -lm"
TC_PKG_CHECK(a52, no, A52, no, [a52dec/a52.h], a52, a52_init, a52dec,
 [http://liba52.sourceforge.net/])
if test x"$have_a52" = x"yes" ; then
  # whether to use liba52 as the default A52/AC3 decoder
  AC_MSG_CHECKING(for liba52 as default A52/AC3 decoder)
  AC_ARG_ENABLE(a52-default-decoder,
    AC_HELP_STRING([--enable-a52-default-decoder],
      [liba52 as default decoder (disabled)]),
    [case "${enableval}" in
      yes) ;;
      no)  ;;
      *) AC_MSG_ERROR(bad value ${enableval} for --enable-a52-default-decoder) ;;
    esac],
    [enable_a52_default_decoder="no"])
  AC_MSG_RESULT($enable_a52_default_decoder)
  if test x"${enable_a52_default_decoder}" = x"yes"; then
    AC_DEFINE([USE_LIBA52_DECODER], 1,
      [Use the liba52 A52/AC3 decoder as default])
  fi
else
  AC_MSG_CHECKING(use libac3 as default decoder)
  AC_MSG_RESULT(yes)
fi
TC_PKG_HAVE(a52, A52)

dnl
dnl libmpeg3
dnl
LIBMPEG3_EXTRA_LIBS="$LIBMPEG3_EXTRA_LIBS $A52_LIBS -lm $PTHREAD_LIBS"
TC_PKG_CHECK(libmpeg3, no, LIBMPEG3, no, none, mpeg3, mpeg3_open,
 libmpeg3, [http://heroinewarrior.com/libmpeg3/])
if test x"$have_libmpeg3" = x"yes" ; then
  libmpeg3_inc="no"
  save_CPPFLAGS="$CPPFLAGS"
  CPPFLAGS="$CPPFLAGS $libmpeg3_ii"
  AC_CHECK_HEADER([libmpeg3/libmpeg3.h],
    [LIBMPEG3_CFLAGS="$libmpeg3_ii/libmpeg3"
      libmpeg3_inc="yes"])
  if test x"$libmpeg3_inc" = x"no" ; then
    AC_CHECK_HEADER([mpeg3/libmpeg3.h],
      [LIBMPEG3_CFLAGS="$libmpeg3_ii/mpeg3"
        libmpeg3_inc="yes"])
  fi
  if test x"$libmpeg3_inc" = x"no" ; then
    AC_CHECK_HEADER([libmpeg3.h],
      [LIBMPEG3_CFLAGS="$libmpeg3_ii"
        libmpeg3_inc="yes"])
  fi
  CPPFLAGS="$save_CPPFLAGS"
  if test x"$libmpeg3_inc" = x"no" ; then
    have_libmpeg3="no"
    TC_PKG_ERROR(libmpeg3, libmpeg3.h, no, libmpeg3, [http://heroinewarrior.com/libmpeg3/],
      [cannot compile libmpeg3.h])
  fi
fi
TC_PKG_HAVE(libmpeg3, LIBMPEG3)

dnl
dnl libxml2
dnl
LIBXML2_EXTRA_LIBS="$LIBXML2_EXTRA_LIBS -lz -lm"
TC_PKG_CHECK(libxml2, no, LIBXML2, xml2-config, [libxml/parser.h],
 xml2, xmlStrcmp, libxml-2.0, [http://xmlsoft.org])
TC_PKG_HAVE(libxml2, LIBXML2)

dnl
dnl mjpegtools (actually only YUV4MPEG)
dnl
TC_PKG_CHECK(mjpegtools, no, MJPEGTOOLS, mjpegtools-config,
 [mjpegtools/yuv4mpeg.h], mjpegutils, y4m_si_get_height, mjpegtools,
 [http://mjpeg.sourceforge.net/])
if test x"$have_mjpegtools" = x"yes" ; then
  # check if mjpegtools version >= Mar 31 2004
  save_CFLAGS="$CFLAGS"
  save_LIBS="$LIBS"
  CFLAGS="$CFLAGS $MJPEGTOOLS_CFLAGS"
  LIBS="$LIBS $MJPEGTOOLS_LIBS"
  AC_TRY_LINK([
#if defined(HAVE_MJPEGTOOLS_INC)
#include "yuv4mpeg.h"
#include "mpegconsts.h"
#else
#include "mjpegtools/yuv4mpeg.h"
#include "mjpegtools/mpegconsts.h"
#endif
],
    [y4m_write_frame_header(1, NULL, NULL)],
    [AC_DEFINE([USE_NEW_MJPEGTOOLS_CODE], [1],
      [using mjpegtools post Mar 31 2004])])
  CFLAGS="$save_CFLAGS"
  LIBS="$save_LIBS"
fi
TC_PKG_HAVE(mjpegtools, MJPEGTOOLS)

dnl
dnl SDL
dnl
TC_PKG_CHECK(sdl, no, SDL, sdl-config, SDL.h, SDL, SDL_Init, SDL,
  [http://www.libsdl.org/])
if test x"$have_sdl" = x"yes" ; then
  sdl_major_version=1
  sdl_minor_version=1
  sdl_micro_version=6
  save_CPPFLAGS="$CPPFLAGS"
  CPPFLAGS="$CPPFLAGS $SDL_CFLAGS"
  AC_TRY_RUN([
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SDL.h"
int main (int argc, char *argv[])
{
   if ( (SDL_MAJOR_VERSION > $sdl_major_version) ||
        ((SDL_MAJOR_VERSION == $sdl_major_version) &&
		(SDL_MINOR_VERSION > $sdl_minor_version)) ||
        ((SDL_MAJOR_VERSION == $sdl_major_version) &&
		(SDL_MINOR_VERSION == $sdl_minor_version) &&
		(SDL_PATCHLEVEL >= $sdl_micro_version)) )
    {
      return 0;
    }
  else
    {
      fprintf(stderr, "SDL version %d.%d.%d is too old!\n",
			SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
      return 1;
    }
}
],
  [have_sdl="yes"],
  [have_sdl="no"],
  [echo $ac_n "cross compiling; assumed OK... $ac_c"
    have_sdl="yes"])
  CPPFLAGS="$save_CPPFLAGS"
fi
TC_PKG_HAVE(sdl, SDL)

dnl
dnl GTK
dnl
TC_PKG_CHECK(gtk, no, GTK, gtk-config, [gtk/gtk.h], gtk, gtk_init,
 gtk+, [http://www.gtk.org/])
TC_PKG_HAVE(gtk, GTK)

dnl
dnl libfame
dnl
TC_PKG_CHECK(libfame, no, LIBFAME, libfame-config, fame.h, fame, fame_init,
  libfame, [http://fame.sourceforge.net])
TC_PKG_HAVE(libfame, LIBFAME)

dnl
dnl ImageMagick
dnl
IMAGEMAGICK_EXTRA_LIBS="$IMAGEMAGICK_EXTRA_LIBS -lz -lm"
TC_PKG_CHECK(imagemagick, no, IMAGEMAGICK, Magick-config, [magick/api.h],
 Magick, InitializeMagick, ImageMagick, [http://www.imagemagick.org/])
TC_PKG_HAVE(imagemagick, IMAGEMAGICK)

dnl
dnl libjpegmmx or libjpeg
dnl
TC_PKG_CHECK(libjpegmmx, no, LIBJPEGMMX, no, jpeglib.h, jpeg-mmx,
  jpeg_CreateCompress, jpeg-mmx, [http://sourceforge.net/projects/mjpeg/])
if test x"$have_libjpegmmx" = x"no" ; then
  TC_PKG_CHECK(libjpeg, yes, LIBJPEG, no, jpeglib.h, jpeg,
    jpeg_CreateCompress, jpeg, [ftp://ftp.uu.net/graphics/jpeg/])
else
  have_libjpeg="yes"
  LIBJPEG_CFLAGS="$LIBJPEGMMX_CFLAGS"
  LIBJPEG_LIBS="$LIBJPEGMMX_LIBS"
fi
TC_PKG_HAVE(libjpeg, LIBJPEG)


dnl
dnl bsdav
dnl
TC_PKG_CHECK(bsdav, no, BSDAV, no, bsdav.h, bsdav,
  bsdav_read_stream_header, bsdav, [http://www.jakemsr.com/bsdav/])
TC_PKG_HAVE(bsdav, BSDAV)


dnl
dnl iconv
dnl
TC_PKG_CHECK(iconv, yes, ICONV, no, iconv.h, none, none, libiconv,
 [http://www.gnu.org/software/libiconv/])
if test x"$have_iconv" = x"yes" ; then
  save_LDFLAGS="$LDFLAGS"
  LDFLAGS="$LDFLAGS $iconv_ll"
  AC_CHECK_LIB(iconv, iconv_open,
    [],
    [have_iconv="no"],
    [$ICONV_EXTRA_LIBS])
  LDFLAGS="$save_LDFLAGS"
  if test x"$have_iconv" = x"no" ; then
    save_LDFLAGS="$LDFLAGS"
    LDFLAGS="$LDFLAGS $iconv_ll"
    AC_CHECK_LIB(iconv, libiconv_open,
      [have_iconv="yes"],
      [have_iconv="no"],
      [$ICONV_EXTRA_LIBS])
    LDFLAGS="$save_LDFLAGS"
  fi
  # see if iconv_open is in (g)libc
  have_libc_iconv="no"
  if test x"$have_iconv" = x"no" ; then
    save_LDFLAGS="$LDFLAGS"
    LDFLAGS="$LDFLAGS $iconv_ll"
    AC_CHECK_LIB(c, iconv_open,
      [have_iconv="yes" have_libc_iconv="yes"],
      [have_iconv="no"],
      [$ICONV_EXTRA_LIBS])
    LDFLAGS="$save_LDFLAGS"
  fi
  if test x"$have_iconv" = x"yes" ; then
    if test x"$have_libc_iconv" != x"yes" ; then
      ICONV_LIBS="$iconv_ll -liconv $ICONV_EXTRA_LIBS"
    fi
  else
    TC_PKG_ERROR(iconv, [iconv_open()], yes, libiconv,
      [http://www.gnu.org/software/libiconv/],
      [cannot find either iconv_open() or libiconv_open()])
  fi
fi
TC_PKG_HAVE(iconv, ICONV)


dnl
dnl The following come with transcode
dnl

dnl
dnl libtc
dnl
LIBTC_CFLAGS="-I\$(top_srcdir)/libtc"
LIBTC_LIBS="\$(top_builddir)/libtc/libtc.la"
AC_SUBST(LIBTC_CFLAGS)
AC_SUBST(LIBTC_LIBS)

dnl
dnl libxio
dnl
AC_MSG_CHECKING([whether internal libxio support is requested])
AC_ARG_ENABLE(xio,
  AC_HELP_STRING([--enable-xio],
    [link to the xio library (no)]),
  [case "${enableval}" in
    yes) libxio=yes ;;
    no)  libxio=no ;;
    *) AC_MSG_ERROR(bad value ${enableval} for --enable-xio) ;;
  esac],
  [libxio=no])
AC_MSG_RESULT($libxio)
if test x"$libxio" = x"yes" ; then
  if test x"$have_ibp" = x"yes" ; then
    XIO_CFLAGS="-DUSE_XIO -I\$(top_srcdir)/libxio"
    XIO_LIBS="\$(top_builddir)/libxio/libxio.la $IBP_LIBS $LIBXML2_LIBS"
  else
    XIO_CFLAGS="-DUSE_XIO -I\$(top_srcdir)/libxio"
    XIO_LIBS="\$(top_builddir)/libxio/libxio.la"
  fi
else 
  XIO_CFLAGS="-I\$(top_srcdir)/libxio"
  XIO_LIBS=""
fi
AC_SUBST(XIO_CFLAGS)
AC_SUBST(XIO_LIBS)

dnl
dnl avilib
dnl
AVILIB_CFLAGS="-I\$(top_srcdir)/avilib"
AVILIB_LIBS="\$(top_builddir)/avilib/libavi.la"
AC_SUBST(AVILIB_CFLAGS)
AC_SUBST(AVILIB_LIBS)

dnl
dnl libioaux
dnl
TCIOAUX_CFLAGS="-I\$(top_srcdir)/libioaux"
TCIOAUX_LIBS="\$(top_builddir)/libioaux/libtcioaux.la"
AC_SUBST(TCIOAUX_CFLAGS)
AC_SUBST(TCIOAUX_LIBS)

dnl
dnl libac3
dnl
AC3_CFLAGS="-I\$(top_srcdir)/libac3"
AC3_LIBS="\$(top_builddir)/libac3/libac3_tc.la"
AC_SUBST(AC3_CFLAGS)
AC_SUBST(AC3_LIBS)

dnl
dnl libvo
dnl
LIBVO_CFLAGS="-I\$(top_srcdir)/libvo"
LIBVO_LIBS="\$(top_builddir)/libvo/libvout.la"
AC_SUBST(LIBVO_CFLAGS)
AC_SUBST(LIBVO_LIBS)

dnl
dnl aclib
dnl
ACLIB_CFLAGS="-I\$(top_srcdir)/aclib"
ACLIB_LIBS="\$(top_builddir)/aclib/libac.la"
AC_SUBST(ACLIB_CFLAGS)
AC_SUBST(ACLIB_LIBS)



dnl
dnl warning flags; always add -Wall
dnl
if test x"$GCC" = x"yes" ; then
    OPT_CFLAGS="-Wall $CFLAGS"
    AC_TRY_CFLAGS([$OPT_CFLAGS],[CFLAGS=$OPT_CFLAGS])
fi
AC_ARG_ENABLE([warnings-as-errors],
    AC_HELP_STRING([--enable-warnings-as-errors], [treat warnings as errors]))
if test x"$enable_warnings-as-errors" = x"yes" -a x"$GCC" = x"yes" ; then
    dnl compiler warnings treated as erors
    OPT_CFLAGS="-Werror $CFLAGS"
    AC_TRY_CFLAGS([$OPT_CFLAGS],[CFLAGS=$OPT_CFLAGS])
fi
AC_SUBST(CFLAGS)

dnl import/export module path
dnl
MOD_PATH="\${libdir}/transcode"
AC_ARG_WITH(mod-path,
  AC_HELP_STRING([--with-mod-path],
    [where export/import modules are installed (${libdir}/transcode)]),
  MOD_PATH=$withval)
AC_SUBST(MOD_PATH)

X_CFLAGS=`echo $X_CFLAGS | sed -e 's/  */ /g'`
X_PRE_LIBS=`echo $X_PRE_LIBS | sed -e 's/  */ /g'`
X_LIBS=`echo $X_LIBS | sed -e 's/  */ /g'`
X_EXTRA_LIBS=`echo $X_EXTRA_LIBS | sed -e 's/  */ /g'`

CC=`echo $CC | sed -e 's/  */ /g'`
CFLAGS=`echo $CFLAGS | sed -e 's/  */ /g'`
CPPFLAGS=`echo $CPPFLAGS | sed -e 's/  */ /g'`
CXXFLAGS=`echo $CXXFLAGS | sed -e 's/  */ /g'`
LDFLAGS=`echo $LDFLAGS | sed -e 's/  */ /g'`

AC_SUBST(CFLAGS)
AC_SUBST(CC)
AC_SUBST(LDFLAGS)

AC_OUTPUT([
	Makefile
	aclib/Makefile
	avilib/Makefile
	contrib/Makefile
	contrib/pnmpvn/Makefile
	docs/Makefile
	docs/html/Makefile
	docs/man/Makefile
	docs/release-notes/Makefile
	export/Makefile
	filter/Makefile
	filter/divxkey/Makefile
	filter/extsub/Makefile
	filter/pp/Makefile
	filter/preview/Makefile
	filter/subtitler/Makefile
	filter/tomsmocomp/Makefile
	filter/yuvdenoise/Makefile
	import/Makefile
	import/nuv/Makefile
	import/v4l/Makefile
	libac3/Makefile
	libdldarwin/Makefile
	libioaux/Makefile
	libsupport/Makefile
	libtc/Makefile
	libvo/Makefile
	libxio/Makefile
	pvm3/Makefile
	src/Makefile
	testsuite/Makefile
	tools/Makefile
	transcode.spec
	filter/parse_csv.awk
	filter/filter_list.awk
])


AC_MSG_RESULT([
----------------------------------------
Summary for transcode $VERSION:
----------------------------------------

core options
----------------------------------------
static AV-frame buffering      $enable_statbuffer
network (sockets) streams      $enable_netstream
experimental xio               $libxio
Default xvid export            $XVID_DEFAULT
A52 default decoder            $enable_a52_default_decoder

libavcodec
----------------------------------------
headers                        $LIBAVCODEC_CFLAGS
libraries                      $LIBAVCODEC_LIBS
build                          $LIBAVCODEC_BUILD
version                        $LIBAVCODEC_VERSION
statically linked              $enable_libavcodec_static

hardware support
----------------------------------------
v4l/v4l2                       $have_v4l
OSS                            $have_oss
bktr                           $have_bktr
sunau                          $have_sunau

optional package support
----------------------------------------
IBP                            $have_ibp
X11                            $USE_X11])

TC_PKG_REPORT