path: root/amarok/configure.in.in

###############################################################################
# BEGIN PKG-CONFIG CHECK
###############################################################################

AC_ARG_VAR(PKGCONFIGFOUND, [Path to pkg-config])
AC_CHECK_PROG(PKGCONFIGFOUND, pkg-config,[yes])

###############################################################################
# END PKG-CONFIG CHECK
###############################################################################



###############################################################################
# BEGIN TAGLIB CHECK
###############################################################################

PKG_CHECK_MODULES([TAGLIB], [taglib >= 1.5], [taglib_15_found=yes], [PKG_CHECK_MODULES([TAGLIB], [taglib >= 1.4])])

AM_CONDITIONAL([TAGLIB_15_FOUND], [test "x$taglib_15_found" = "xyes"])
AC_SUBST(TAGLIB_CFLAGS)
AC_SUBST(TAGLIB_LIBS)

if test "x$taglib_15_found" = "xyes"; then
	AC_DEFINE([TAGLIB_15], 1, [Taglib 1.5 or later found, disabling duplicate metadata plugins])
fi

###############################################################################
# END TAGLIB CHECK
###############################################################################



###############################################################################
# BEGIN GSTREAMER-0.10 CHECK
###############################################################################

#AC_ARG_WITH(gstreamer10,
#    AC_HELP_STRING([--with-gstreamer10],[build Amarok with GStreamer 0.10-engine]),
#    [build_gstreamer10=$withval],
#    [build_gstreamer10=no]
#)
#
#if test "$build_gstreamer10" != "no"; then
#    if test "$PKGCONFIGFOUND" = "yes" ; then
#        # check for GStreamer
#        dnl Now we're ready to ask for gstreamer libs and cflags
#        dnl And we can also ask for the right version of gstreamer
#        have_gst10=no
#
#        GST10_MAJORMINOR=0.10
#        GST10_REQ=0.10.0
#
#        PKG_CHECK_MODULES(GST10, gstreamer-$GST10_MAJORMINOR >= $GST10_REQ gstreamer-base-$GST10_MAJORMINOR,
#            have_gst10=yes,have_gst10=no)
#
#        dnl Give error if we don't have gstreamer
#        if test "x$have_gst10" = "xno"; then
#            LIB_GST10=""
#            CFLAGS_GST10=""
#        else
#            LIB_GST10=$GST10_LIBS
#            CFLAGS_GST10=$GST10_CFLAGS
#            AC_SUBST(LIB_GST10)
#            AC_SUBST(CFLAGS_GST10)
#            AC_SUBST(GST10_MAJORMINOR)
#            AC_DEFINE(HAVE_GSTREAMER10, 1, [have GStreamer10])
#        fi
#    fi
#fi
#
#AM_CONDITIONAL(with_gst10, [test x$have_gst10 = xyes])

###############################################################################
# END GSTREAMER-0.10 CHECK
###############################################################################



###############################################################################
# BEGIN XINE CHECK
###############################################################################

AC_ARG_WITH(xine,
    AC_HELP_STRING([--without-xine],[build Amarok without xine-engine]),
    [build_xine=$withval],
    [build_xine=yes]
)

if test "$build_xine" != "no"; then
    PKG_CHECK_MODULES([XINE], [libxine >= 1.0.2], , [build_xine=no])
fi

AM_CONDITIONAL(with_xine, test x$build_xine = xyes)
AC_SUBST(XINE_CFLAGS)
AC_SUBST(XINE_LIBS)

###############################################################################
# END XINE CHECK
###############################################################################



###############################################################################
# BEGIN AKODE CHECK
###############################################################################

#AC_ARG_WITH(akode,
#    AC_HELP_STRING([--without-akode],[build Amarok without akode-engine]),
#    [build_akode=$withval],
#    [build_akode=yes]
#)
#
#if test "$build_akode" != "no"; then
#
#    AC_CHECK_PROG(AKODE_CONFIG, akode-config, yes)
#
#    if test x$AKODE_CONFIG = xyes ; then
#        AC_DEFINE(HAVE_AKODE, 1, [have aKode])
#        CFLAGS_AKODE=[`akode-config --cflags`]
#        LIBS_AKODE=[`akode-config --libs`]
#
#        akode_version=`akode-config --version`
#        akode_version=VERSION_TO_NUMBER(echo $akode_version)
#        akode_version_min="2.0.0"
#        akode_version_min=VERSION_TO_NUMBER(echo $akode_version_min)
#
#        AC_MSG_CHECKING([for akode-lib version >= 2.0])
#
#        if test $akode_version -eq $akode_version_min \
#             -o $akode_version -gt $akode_version_min; then
#
#            echo "yes"
#
#        else
#            echo "no"
#
#            build_akode=no
#        fi
#    else
#        build_akode=no
#    fi
#fi
#
#AM_CONDITIONAL(with_akode, test x$build_akode = xyes)
#AC_SUBST(CFLAGS_AKODE)
#AC_SUBST(LIBS_AKODE)

###############################################################################
# END AKODE CHECK
###############################################################################



###############################################################################
# BEGIN NMM CHECK
###############################################################################

AC_ARG_WITH(nmm,
    AC_HELP_STRING([--with-nmm],[build Amarok with NMM-engine]),
    [build_nmm=$withval],
    [build_nmm=no]
)

AC_ARG_WITH(nmm-dir,
    AC_HELP_STRING([--with-nmm-dir],[path to the NMM [default=/usr/local]]),
    [nmm_dir="$withval"],
    [nmm_dir=/usr/local]
)

if test "$build_nmm" != "no"; then

    CFLAGS_NMM="-I$nmm_dir/include"
    LDFLAGS_NMM="-L$nmm_dir/lib"
    AC_DEFINE(HAVE_NMM, 1, [have NMM])
fi

AM_CONDITIONAL(with_nmm, test x$build_nmm = xyes)
AC_SUBST(CFLAGS_NMM)
AC_SUBST(LDFLAGS_NMM)

###############################################################################
# END NMM CHECK
###############################################################################



###############################################################################
# BEGIN MAS CHECK
###############################################################################

#AC_ARG_WITH(mas,
#    AC_HELP_STRING([--with-mas],[build Amarok with MAS-engine]),
#    [build_mas=$withval],
#    [build_mas=no]
#)
#
#
#if test "$build_mas" != "no"; then
#
#    AC_PATH_PROG(MAS_CONFIG, mas-config, no)
#
#    if test $MAS_CONFIG = "no"
#    then
#        amarok_warning_mas_notfound=yes
#    echo "amarok_warning_mas_notfound: $amarok_warning_mas_notfound"
#        build_mas=no
#    else
#        AC_DEFINE(HAVE_MAS, 1, [have MAS])
#
#        CFLAGS_MAS=[`$MAS_CONFIG --cflags`]
#        LIBS_MAS=[`$MAS_CONFIG --libs`]
#
#        build_mas=yes
#    fi
#fi
#
#AM_CONDITIONAL(with_mas, test x$build_mas = xyes)
#AC_SUBST(CFLAGS_MAS)
#AC_SUBST(LIBS_MAS)

###############################################################################
# END MAS CHECK
###############################################################################



###############################################################################
# BEGIN HELIX CHECK
###############################################################################

AC_ARG_WITH(helix,
    AC_HELP_STRING([--with-helix],[build Amarok with Helix-engine]),
    [build_helix=$withval],
    [build_helix=no]
)

if test "$build_helix" != "no"; then
    AC_MSG_CHECKING([for RealPlayer or HelixPlayer])

    if test "$build_helix" = "yes"; then
        HXPLAY=`type -p hxplay`
    RPLAY=`type -p realplay`
    if test "$RPLAY" != "" -a -x "$RPLAY"; then
        HELIX_LINK=`readlink -f $RPLAY`
        HELIX_LINK=`dirname $HELIX_LINK`
        HELIX_LIBS=`unset CDPATH; cd $HELIX_LINK && pwd`
        if test -e "$HELIX_LIBS/common/clntcore.so"; then
        AC_MSG_RESULT([found RealPlayer in $HELIX_LIBS])
        build_helix=$HELIX_LIBS
        fi
    elif test "$HXPLAY" != "" -a -x "$HXPLAY"; then
        HELIX_LINK=`readlink -f $HXPLAY`
        HELIX_LINK=`dirname $HELIX_LINK`
        HELIX_LIBS=`unset CDPATH; cd $HELIX_LINK && pwd`
        if test -e "$HELIX_LIBS/common/clntcore.so"; then
        AC_MSG_RESULT([found HelixPlayer in $HELIX_LIBS])
        build_helix=$HELIX_LIBS
        fi
    fi
    else
        if test -n "$build_helix" -a -d "$build_helix"; then
          HELIX_LIBS=`unset CDPATH; cd $build_helix && pwd`
        else
          HELIX_LIBS="$build_helix"
        fi
    build_helix=$HELIX_LIBS
        AC_MSG_RESULT([using $HELIX_LIBS])
    fi

    AC_DEFINE(HAVE_HELIX, 1, [have HELIX])
    if test "$build_helix" = "yes"; then
        HELIX_LIBS="/usr/local/RealPlayer"
        AC_MSG_RESULT(["not found, using default dir"])
    fi
    AC_DEFINE_UNQUOTED(HELIX_LIBS, "${HELIX_LIBS}", [location of helix libs])
    if test "$PKGCONFIGFOUND" = "yes" ; then
    PKG_CHECK_MODULES([ALSALIB], alsa, have_alsa=yes,have_alsa=no)
    if test "$have_alsa" = "yes" ; then
        AC_DEFINE(USE_HELIX_ALSA, 1, [support ALSA in the helix-engine])
    fi
    fi
fi

AM_CONDITIONAL(with_helix, test x$build_helix != xno)

###############################################################################
# END HELIX CHECK
###############################################################################

###############################################################################
# BEGIN yauap CHECK
###############################################################################

AC_ARG_WITH(yauap,
    AC_HELP_STRING([--with-yauap],[build Amarok with yauap-engine]),
    [build_yauap=$withval],
    [build_yauap=no]
)

if test "$build_yauap" != "no"; then
    if test "$PKGCONFIGFOUND" = "yes" ; then
        # check for dbus-glib
        have_yauap=no

        PKG_CHECK_MODULES(DBUS, dbus-1,
            have_yauap=yes,have_yauap=no)


        dnl Give error if we don't have gstreamer
        if test "x$have_yauap" = "xno"; then
            LIB_YAUAP=""
            CFLAGS_YAUAP=""
        else
            LIB_YAUAP="$DBUS_LIBS -ldbus-tqt-1"
            CFLAGS_YAUAP="$DBUS_CFLAGS"
            AC_SUBST(LIB_YAUAP)
            AC_SUBST(CFLAGS_YAUAP)
            AC_DEFINE(HAVE_YAUAP, 1, [have yauap])
        fi
    fi
fi

AM_CONDITIONAL(with_yauap, [test x$have_yauap = xyes])

###############################################################################
# END yauap CHECK
###############################################################################



###############################################################################
# BEGIN stdint.h CHECK
###############################################################################

AC_CHECK_HEADER(stdint.h)

###############################################################################
# END stdint.h CHECK
###############################################################################


###############################################################################
# BEGIN fabsf CHECK
###############################################################################

AC_CHECK_DECLS([fabsf],,,[#include <math.h>])
if test "$ac_cv_have_decl_fabsf" = "yes"; then
    AC_COMPILE_IFELSE(
        [AC_LANG_PROGRAM(
            [[#include <math.h>]],
            [[return (int)fabsf(1.f);]])],
        [AC_DEFINE(HAVE_FABSF, 1, [have fabsf])])
fi

###############################################################################
# END fabsf CHECK
###############################################################################





###############################################################################
# BEGIN INOTIFY CHECK
###############################################################################

AC_CHECK_HEADERS(linux/inotify.h)

if test x"$ac_cv_header_linux_inotify_h" = x"yes"; then
    AC_DEFINE(HAVE_INOTIFY, 1, [have inotify])
fi

###############################################################################
# END INOTIFY CHECK
###############################################################################



###############################################################################
# BEGIN QT OPENGL CHECK
###############################################################################

AC_ARG_WITH(opengl,
    AC_HELP_STRING([--without-opengl],[build Amarok without OpenGL support]),
    [build_opengl=$withval],
    [build_opengl=yes]
)

if test "$build_opengl" != "no"; then
    AC_MSG_CHECKING(for TQt with OpenGL support)
    AC_CACHE_VAL(ac_cv_kde_qt_has_opengl,
    [
    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS

    save_CXXFLAGS="$CXXFLAGS"
    save_LIBS="$LIBS"
    save_LDFLAGS="$LDFLAGS"

    CXXFLAGS="$CXXFLAGS -I$qt_incdir -I/usr/include/tqt $all_includes"
    LDFLAGS="$LDFLAGS -L$qt_libdir $all_libraries $USER_LDFLAGS $KDE_MT_LDFLAGS"
    LIBS="$LIBS $LIBQT $KDE_MT_LIBS"

    AC_TRY_LINK([
    #include <tqgl.h>
    ],
    [
    (void)new TQGLWidget((TQWidget*)0, "qgl");
    ],
    ac_cv_kde_qt_has_opengl=yes,
    ac_cv_kde_qt_has_opengl=no)

    CXXFLAGS="$save_CXXFLAGS"
    LIBS="$save_LIBS"
    LDFLAGS="$save_LDFLAGS"
    AC_LANG_RESTORE
    ])
    AC_MSG_RESULT($ac_cv_kde_qt_has_opengl)

    if test x$ac_cv_kde_qt_has_opengl = xyes; then
    AC_DEFINE(HAVE_TQGLWIDGET, 1, [have TQt with OpenGL support])
    gl_libs="-lGL"
    else
    gl_libs=""
    fi

    AC_SUBST(gl_libs)
fi

###############################################################################
# END QT OPENGL CHECK
###############################################################################



###############################################################################
# BEGIN SQLITE CHECK
###############################################################################

LIB_SQLITE=""

AC_ARG_WITH(included-sqlite,
    AC_HELP_STRING([--without-included-sqlite],[build Amarok using system sqlite library]),
    [included_sqlite=$withval],
    [included_sqlite=yes]
)

if test x$included_sqlite = xno; then
    if test x$PKGCONFIGFOUND = xyes; then
        PKG_CHECK_MODULES(SQLITE, sqlite3 >= 3.0, have_sqlite=yes,have_sqlite=no)

        if test x$have_sqlite = xyes; then
            ## AC_DEFINE(HAVE_SQLITE, 1, [have SQLite database library])
            LIB_SQLITE=`pkg-config --libs sqlite3`
        else
            # We don't support not having sqlite anymore
            DO_NOT_COMPILE="$DO_NOT_COMPILE amarok"
            no_amarok=yes
        fi
    fi
fi

AC_SUBST(LIB_SQLITE)
AM_CONDITIONAL(with_included_sqlite, [test x$included_sqlite = xyes])


# Determine pointer size for sqlite

KDE_CHECK_TYPES
AC_DEFINE(SQLITE_PTR_SZ, SIZEOF_CHAR_P, [Determine pointer size for SQLite])

###############################################################################
# END SQLITE CHECK
###############################################################################



###############################################################################
# BEGIN MYSQL CHECK
###############################################################################

AC_ARG_ENABLE(mysql,
    AC_HELP_STRING([--enable-mysql],[build Amarok with MySQL support]),
    [enable_mysql=$enableval],
    [enable_mysql=no]
)

if test "$enable_mysql" = "yes"; then

    AC_CHECK_PROG(MYSQL_CONFIG, mysql_config, yes)

    if test x$MYSQL_CONFIG = xyes; then
        AC_DEFINE(USE_MYSQL, 1, [MySql database support enabled])

        mysql_includes=`mysql_config --cflags`
        mysql_libs=`mysql_config --libs`

        AC_LANG_SAVE
        AC_LANG_CPLUSPLUS
        save_CXXFLAGS="$CXXFLAGS"
        CXXFLAGS="$CXXFLAGS $mysql_includes"

        AC_MSG_CHECKING([if mysql has st_mysql struct])
        AC_TRY_COMPILE(
            [
            #include <mysql.h>
            typedef struct st_mysql MYSQL;
            ],
            [],
            AC_MSG_RESULT( yes )
            mysql_struct=st_mysql,
            AC_MSG_RESULT( no )
            [
                AC_MSG_CHECKING([if mysql has MYSQL struct])
                AC_TRY_COMPILE(
                    [
                    #include <mysql.h>
                    typedef struct MYSQL MYSQL;
                    ],
                    [],
                    AC_MSG_RESULT( yes )
                    mysql_struct=MYSQL,
                    AC_MSG_RESULT( no )
                    enable_mysql=no
                )
            ]
        )

        CXXFLAGS="$save_CXXFLAGS"
        AC_LANG_RESTORE
    else
        amarok_warning_mysql_notfound=yes
        enable_mysql=no
    fi

fi

AM_CONDITIONAL(enable_mysql, test x$enable_mysql = xyes)
AC_DEFINE_UNQUOTED(MYSQL_STRUCT, $mysql_struct, [struct type name for MySql])
AC_SUBST(mysql_includes)
AC_SUBST(mysql_libs)

###############################################################################
# END MYSQL CHECK
###############################################################################



###############################################################################
# BEGIN POSTGRESQL CHECK
###############################################################################

AC_ARG_ENABLE(postgresql,
    AC_HELP_STRING([--enable-postgresql],[build Amarok with PostgreSQL support]),
    [enable_postgresql=$enableval],
    [enable_postgresql=no]
)

if test "$enable_postgresql" = "yes"; then

    AC_CHECK_PROG(POSTGRESQL_CONFIG, pg_config, yes)

    if test x$POSTGRESQL_CONFIG = xyes; then
        AC_DEFINE(USE_POSTGRESQL, 1, [Postgresql database support enabled])

        postgresql_includes=-I`pg_config --includedir`
        postgresql_libs="-L`pg_config --libdir` -lpq"
    else
        amarok_warning_postgresql_notfound=yes
        enable_postgresql=no
    fi

fi

AM_CONDITIONAL(enable_postgresql, test x$enable_postgresql = xyes)
AC_SUBST(postgresql_includes)
AC_SUBST(postgresql_libs)

###############################################################################
# END POSTGRESQL CHECK
###############################################################################



###############################################################################
# BEGIN LIBVISUAL CHECK
###############################################################################

AC_ARG_WITH(libvisual,
    AC_HELP_STRING([--without-libvisual],[build Amarok without libvisual support]),
    [with_libvisual=$withval],
    [with_libvisual=yes]
)

if test "$with_libvisual" = "yes"; then
    ## libvisual plugin depends on sdl
    AC_CHECK_PROG(SDL_CONFIG, sdl-config, yes)

    if test x$SDL_CONFIG = xyes; then
        sdl_cflags=`sdl-config --cflags`
        sdl_libs=`sdl-config --libs`
    fi

    AC_SUBST(sdl_cflags)
    AC_SUBST(sdl_libs)

    if test x$PKGCONFIGFOUND = xyes -a x$SDL_CONFIG = xyes; then

        PKG_CHECK_MODULES(LIBVISUAL, libvisual-0.4 >= 0.4.0, [
                   LIBVISUAL_LIBS=`echo $LIBVISUAL_LIBS | sed -e 's/-lpthread//' -e 's/-ldl//'`
                   build_libvisual="yes"
        ], [build_libvisual="no"])

        AC_SUBST(LIBVISUAL_LIBS)
        AC_SUBST(LIBVISUAL_CFLAGS)

        if test x$build_libvisual = xyes; then
            AC_DEFINE(HAVE_LIBVISUAL, 1, [have LIBVISUAL])
        fi
    fi
fi

AM_CONDITIONAL(with_libvisual, test x$build_libvisual = xyes)

###############################################################################
# END LIBVISUAL CHECK
###############################################################################



###############################################################################
# BEGIN TUNEPIMP CHECK
###############################################################################

AC_ARG_WITH(musicbrainz,
    AC_HELP_STRING([--without-musicbrainz],[build Amarok without MusicBrainz support]),
    [with_musicbrainz=$withval],
    [with_musicbrainz=yes]
)

if test "$with_musicbrainz" = "yes"; then
    AC_CHECK_HEADER(tunepimp-0.5/tp_c.h, [build_musicbrainz="yes"],
      [AC_CHECK_HEADER(tunepimp/tp_c.h, [build_musicbrainz="yes"],
        [build_musicbrainz="no"])])
fi

if test "$build_musicbrainz" = "yes"; then
    AC_CHECK_LIB(tunepimp, tr_GetPUID,
      AC_DEFINE(HAVE_TUNEPIMP, 5, [have MusicBrainz 0.5.x]),
        AC_CHECK_LIB(tunepimp, tp_SetFileNameEncoding,
        AC_DEFINE(HAVE_TUNEPIMP, 4, [have MusicBrainz 0.4.x]),
        AC_DEFINE(HAVE_TUNEPIMP, 1, [have MusicBrainz])))
    LIB_TUNEPIMP="-ltunepimp"
    have_tunepimp=yes
else
    AC_DEFINE(HAVE_TUNEPIMP, 0, [have TunePimp])
    LIB_TUNEPIMP=""
    have_tunepimp=no
fi

AC_SUBST(LIB_TUNEPIMP)

###############################################################################
# END TUNEPIMP CHECK
###############################################################################



###############################################################################
# BEGIN AMAZON CHECK
###############################################################################

AC_ARG_ENABLE(amazon,
    AC_HELP_STRING([--disable-amazon],[disable Amazon cover download support [default=enable]]),
    [enable_amazon=$enableval],
    [enable_amazon=yes]
)

if test "$enable_amazon" != "no"; then
    AC_DEFINE(AMAZON_SUPPORT, 1, [Amazon cover download support enabled])
fi

###############################################################################
# END AMAZON CHECK
###############################################################################



###############################################################################
# BEGIN SCHED_SETAFFINITY BUGGY GLIBC CHECK
###############################################################################

AC_MSG_CHECKING([if sched_setaffinity should be enabled])

AC_LANG_SAVE
AC_LANG_CPLUSPLUS

amarok_glibcsched_works=no

AC_TRY_COMPILE([
    #include <sched.h>
],
[
    cpu_set_t mask;
    CPU_ZERO( &mask );
    CPU_SET( 0, &mask );
    sched_setaffinity( 0, sizeof(mask), &mask );
],
    amarok_sched_3params=yes,
    amarok_sched_3params=no
)

if test "x$amarok_sched_3params" = "xyes"; then
    AC_DEFINE(SCHEDAFFINITY_SUPPORT, 1, [sched_setaffinity works correctly])
    AC_DEFINE(SCHEDAFFINITY_3PARAMS, 1, [sched_setaffinity takes three params])
    amarok_glibcsched_works=yes
fi

if test "x$amarok_sched_3params" = "xno"; then
    AC_TRY_COMPILE([
    #include <sched.h>
    ],
    [
        cpu_set_t mask;
        CPU_ZERO( &mask );
        CPU_SET( 0, &mask );
        sched_setaffinity( 0, &mask );
    ],
        amarok_sched_2params=yes,
        amarok_sched_2params=no
    )
    if test "x$amarok_sched_2params" = "xyes"; then
        AC_DEFINE(SCHEDAFFINITY_SUPPORT, 1, [sched_setaffinity works correctly])
        amarok_glibcsched_works=yes
    fi
fi

AC_LANG_RESTORE

AC_MSG_RESULT($amarok_glibcsched_works)

###############################################################################
# END SCHED_SETAFFINITY BUGGY GLIBC CHECK
###############################################################################



###############################################################################
# BEGIN KDEBASE CHECK
###############################################################################

KDE_CHECK_HEADER(konqsidebarplugin.h, have_konqsidebar=yes, have_konqsidebar=no)
KDE_CHECK_LIB(konqsidebarplugin, _init, have_konqsidebar=$have_konqsidebar, have_konqsidebar=no)

AM_CONDITIONAL(with_konqsidebar, [test x$have_konqsidebar = xyes])

###############################################################################
# END KDEBASE CHECK
###############################################################################



###############################################################################
# BEGIN NJB CHECK
###############################################################################
### mediabrowser.cpp can use libnjb if available

AC_ARG_WITH(libnjb,
    AC_HELP_STRING([--with-libnjb],[build Amarok with Nomad Jukebox support from libnjb]),
    [build_libnjb=$withval],
    [build_libnjb=yes]
)

if test "$build_libnjb" != "no"; then
    if test "$PKGCONFIGFOUND" = "yes" ; then

        # check for libnjb
        have_libnjb=no

        PKG_CHECK_MODULES(LIBNJB, libnjb, have_libnjb=yes,have_libnjb=no)
        if test "x$have_libnjb" != "xno"; then
            AC_DEFINE(HAVE_LIBNJB, 1, [have libnjb])
        fi
    fi
fi

AM_CONDITIONAL(with_libnjb, [test x$have_libnjb = xyes])

###############################################################################
# END NJB CHECK
###############################################################################



###############################################################################
# BEGIN MTP CHECK
###############################################################################
### mediabrowser.cpp can use libmtp if available

AC_ARG_WITH(libmtp,
    AC_HELP_STRING([--with-libmtp],[build Amarok with support for MTP devices]),
    [build_libmtp=$withval],
    [build_libmtp=yes]
)
if test "$build_libmtp" != "no"; then
    if test "$PKGCONFIGFOUND" = "yes" ; then
        PKG_CHECK_MODULES(LIBMTP, libmtp >= 0.1.1,
        [
            LIBMTP_LIBS=`echo ${LIBMTP_LIBS} | sed 's/-lusb//'`
            have_libmtp=yes
        ],
        [
            have_libmtp=no
        ])
    fi

    if test "x$have_libmtp" != "xno"; then
        AC_DEFINE(HAVE_LIBMTP, 1, [have libmtp])
    fi
fi

AM_CONDITIONAL(with_libmtp, [test x$have_libmtp = xyes])

###############################################################################
# END MTP CHECK
###############################################################################

###############################################################################
# BEGIN RIO KARMA CHECK
###############################################################################
### mediabrowser.cpp can use libkarma if available

AC_ARG_WITH(libkarma,
    AC_HELP_STRING([--with-libkarma],[build Amarok with Rio Karma support]),
    [build_libkarma=$withval],
    [build_libkarma=yes]
)

if test "$build_libkarma" != "no"; then
    AC_CHECK_HEADERS([libkarma/lkarma.h], [have_libkarma=yes], [], [])
    AC_CHECK_HEADERS([usb.h], [have_usb=yes], [], [])

    if test "$have_libkarma" = "yes"; then
        AC_DEFINE(HAVE_LIBKARMA, 1, [have libkarma])
    else
        AC_MSG_RESULT($have_libkarma)
        have_libkarma=no
    fi
fi

AM_CONDITIONAL(with_libkarma, [test x$have_libkarma = xyes])

###############################################################################
# END RIO KARMA CHECK
###############################################################################

###############################################################################
# BEGIN IFP CHECK
###############################################################################
### mediabrowser.cpp can use libifp if available

AC_ARG_WITH(ifp,
    AC_HELP_STRING([--with-ifp],[build Amarok with ifp support]),
    [build_ifp=$withval],
    [build_ifp=yes]
)

if test "$build_ifp" != "no"; then

    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS

    save_CXXFLAGS="$CXXFLAGS"
    save_LIBS="$LIBS"
    save_LDFLAGS="$LDFLAGS"

    AC_CHECK_HEADERS([ifp.h], [have_ifp=yes], [], [])

    CXXFLAGS="$save_CXXFLAGS"
    LIBS="$save_LIBS"
    LDFLAGS="$save_LDFLAGS"
    AC_LANG_RESTORE

#    AC_CHECK_HEADERS([ifp.h], [have_ifp=yes], [], [])
    AC_CHECK_HEADERS([usb.h], [have_usb=yes], [], [])

    if test "$have_ifp" = "yes"; then
        AC_DEFINE(HAVE_IFP, 1, [have ifp])
        IFP_LIBS="-lifp -lusb"
    else
        AC_MSG_RESULT($have_ifp)
        have_ifp=no
    fi

fi

AC_SUBST(IFP_INCLUDES)
AC_SUBST(IFP_LIBS)

AM_CONDITIONAL(with_ifp, [test x$have_ifp = xyes])

###############################################################################
# END IFP CHECK
###############################################################################



###############################################################################
# BEGIN LIBGPOD CHECK
###############################################################################

AC_ARG_WITH(libgpod,
    AC_HELP_STRING([--with-libgpod],[build Amarok with iPod support from libgpod]),
    [build_libgpod=$withval],
    [build_libgpod=yes]
)

if test "$build_libgpod" != "no"; then
    if test "$PKGCONFIGFOUND" = "yes" ; then

        # check for libgpod
        have_libgpod=no

        PKG_CHECK_MODULES(LIBGPOD, libgpod-1.0, have_libgpod=yes,have_libgpod=no)

        if test "x$have_libgpod" = "xyes"; then
            ac_cppflags_save=$CPPFLAGS
            ac_cflags_save=$CFLAGS
            ac_libs_save=$LIBS
            CPPFLAGS="$CPPFLAGS $LIBGPOD_INCLUDES"
            CFLAGS="$CFLAGS $LIBGPOD_CFLAGS"
            LIBS="$LIBS $LIBGPOD_LIBS"

            AC_CHECK_FUNCS(itdb_track_set_thumbnails, , have_libgpod_042=no)
            AC_CHECK_FUNCS(itdb_get_mountpoint, , have_libgpod_042=no)
            AC_CHECK_FUNCS(itdb_device_get_ipod_info, , have_libgpod_042=no)

            AC_CHECK_MEMBER(struct _Itdb_Track.movie_flag,
                  [AC_DEFINE(HAVE_ITDB_MOVIE_FLAG, 1, [have libgpod movie flag])],
                  have_libgpod_042=no,
                  [#include <gpod/itdb.h>])

            AC_CHECK_MEMBER(struct _Itdb_Track.skip_when_shuffling,
                  [AC_DEFINE(HAVE_ITDB_SKIP_SHUFFLE_FLAG, 1, [have libgpod skip when shuffling flag])],
                  have_libgpod_042=no,
                  [#include <gpod/itdb.h>])

            AC_CHECK_MEMBER(struct _Itdb_Track.mark_unplayed,
                  [AC_DEFINE(HAVE_ITDB_MARK_UNPLAYED, 1, [have libgpod mark played flag])],
                  have_libgpod_042=no,
                  [#include <gpod/itdb.h>])

            AC_CHECK_MEMBER(struct _Itdb_Track.mediatype,
                  [AC_DEFINE(HAVE_ITDB_MEDIATYPE, 1, [have libgpod mediatype flag])],
                  have_libgpod_042=no,
                  [#include <gpod/itdb.h>])

            AC_CHECK_DECL(ITDB_IPOD_MODEL_TOUCH_BLACK,
                  [AC_DEFINE(HAVE_LIBGPOD_060, 1, [have at least libgpod 0.6.0])],
                  have_libgpod_060=no,
                  [#include <gpod/itdb.h>])

            CPPFLAGS=$ac_cppflags_save
            CFLAGS=$ac_cflags_save
            LIBS=$ac_libs_save
        fi

        if test "x$have_libgpod_042" = "xno"; then
            have_libgpod=no
            AC_MSG_RESULT(Your libgpod version is too old: at least 0.4.2 is required)
        fi

        if test "x$have_libgpod" != "xno"; then
            AC_DEFINE(HAVE_LIBGPOD, 1, [have libgpod])
        fi
    fi
fi

AM_CONDITIONAL(with_libgpod, [test x$have_libgpod = xyes])

###############################################################################
# END LIBGPOD CHECK
###############################################################################



###############################################################################
# BEGIN statvfs(2) CHECK
###############################################################################

AC_CHECK_FUNCS(statvfs)

###############################################################################
# END statvfs(2) CHECK
###############################################################################



###############################################################################
# BEGIN MP4V2 CHECK
###############################################################################
# m4a/aac tag reading and writing needs libmp4v2 from faad2 or better mpeg4ip

AC_ARG_WITH(mp4v2,
    AC_HELP_STRING([--with-mp4v2],[build Amarok with M4A/AAC tag support from mp4v2/faad2]),
    [have_mp4v2=$withval],
    [have_mp4v2=no]
)

AC_ARG_WITH(mp4v2-dir,
    AC_HELP_STRING([--with-mp4v2-dir],[path to mp4v2  [default=/usr]]),
    [mp4v2_dir="$withval"],
    [mp4v2_dir=/usr]
)

if test "$have_mp4v2" != "no"; then
    AC_LANG_SAVE
    AC_LANG_CPLUSPLUS
    ac_cxxflags_save=$CXXFLAGS
    CXXFLAGS="$CXXFLAGS -I$mp4v2_dir/include"
    ac_ldflags_save=$LDFLAGS
    LDFLAGS="$LDFLAGS -L$mp4v2_dir/lib"

    # not even everyone using faad2 has <systems.h>
    if ! test -f config.h; then
        echo "#include \"confdefs.h\"" > config.h
    fi
    ac_cppflags_save=$CPPFLAGS
    CPPFLAGS="$CPPFLAGS -I."
    AC_CHECK_HEADERS(systems.h)
    AC_CHECK_HEADERS([mp4v2/mp4v2.h], [have_mp4v2_h=yes], [],
        [#ifdef HAVE_SYSTEMS_H
         # include <systems.h>
         #endif
        ])
    if test "$have_mp4v2_h" = "yes"; then
        AC_DEFINE(HAVE_MP4V2_H, 1, [have mp4v2 h])
    else
        AC_CHECK_HEADERS([mp4.h], [have_mp4_h=yes], [],
            [#ifdef HAVE_SYSTEMS_H
             # include <systems.h>
             #endif
            ])
        if test "$have_mp4_h" = "yes"; then
            AC_DEFINE(HAVE_MP4_H, 1, [have mp4 h])
        fi
    fi

    if test "$have_mp4v2_h" = "yes" -o "$have_mp4_h" = "yes"; then
        AC_CHECK_LIB( mp4v2, MP4Read, have_mp4v2=yes, have_mp4v2=no )
    fi

    if test "$have_mp4v2" = "yes"; then
        AC_DEFINE(HAVE_MP4V2, 1, [have mp4v2])
        MP4V2_INCLUDES="-I$mp4v2_dir/include"
        MP4V2_LIBS="-L$mp4v2_dir/lib -lmp4v2"
    else
        have_mp4v2=no
    fi

    CPPFLAGS=$ac_cppflags_save
    CXXFLAGS=$ac_cxxflags_save
    LDFLAGS=$ac_ldflags_save
    AC_LANG_RESTORE
fi

AC_SUBST(MP4V2_INCLUDES)
AC_SUBST(MP4V2_LIBS)

AM_CONDITIONAL(with_mp4v2, [test x$have_mp4v2 != xno ])

###############################################################################
# END MP4V2 CHECK
###############################################################################



###############################################################################
# BEGIN DAAP KDE 3.4 CHECK
###############################################################################

daapsave_CXXFLAGS="$CXXFLAGS"
CXXFLAGS="$CXXFLAGS $all_includes"
AC_LANG_SAVE
AC_LANG_CPLUSPLUS

AC_MSG_CHECKING([if KDE is at least 3.4 for DAAP support])
AC_COMPILE_IFELSE([
#include <tdeversion.h>
#if ! ( KDE_IS_VERSION( 3, 4, 0 ) )
#error KDE 3.4
#endif
],
    have_trinity4="yes"
    DNSSD_LIBS=$LIB_TDEDNSSD
#    echo "yes"
,
    have_trinity4="no"
    DNSSD_LIBS=""
#    echo "no"
)
CXXFLAGS="$daapsave_CXXFLAGS"
AC_LANG_RESTORE
AC_SUBST(DNSSD_LIBS)
AM_CONDITIONAL(atleast_trinity4, [test x$have_trinity4 != xno ])
AC_MSG_RESULT($have_trinity4)

###############################################################################
# END DAAP KDE 3.4 CHECK
###############################################################################



###############################################################################
# BEGIN OPTIONAL DAAP SUPPORT
###############################################################################

AC_ARG_WITH(daap,
    AC_HELP_STRING([--without-daap],[build Amarok without support for DAAP]),
    [have_daap=$withval],
    [have_daap=yes]
)

AM_CONDITIONAL(with_daap, [test x$have_daap = xyes])

###############################################################################
# END OPTIONAL DAAP SUPPORT
###############################################################################



###############################################################################
# BEGIN DAAP TYPE CHECKS
###############################################################################

AC_CHECK_TYPES([uint8_t, u_int8_t, uint16_t, u_int16_t, uint32_t, u_int32_t, uint64_t, u_int64_t])

###############################################################################
# END DAAP TYPE CHECKS
###############################################################################



###############################################################################
# BEGIN DAAP MONGREL RUBY VARIABLE
###############################################################################

AC_CHECK_PROG(RUBY_EXECUTABLE, ruby, ruby)

if test -n "RUBY_EXECUTABLE"; then
  RUBY_MAJOR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(MAJOR))"`
  RUBY_MINOR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(MINOR))"`

  RUBY_ARCHDIR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(archdir))"`
  RUBY_SITEARCHDIR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(sitearchdir))"`
  RUBY_SITEDIR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(sitelibdir))"`
  RUBY_LIBDIR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(libdir))"`
  RUBY_RUBYLIBDIR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(rubylibdir))"`
  RUBY_LIBRUBYARG=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(LIBRUBYARG_SHARED))"`

  RUBY_SERIES="$RUBY_MAJOR$RUBY_MINOR"
  if test "$RUBY_SERIES" -ge "19"; then
     AC_DEFINE_UNQUOTED(HAVE_RUBY_1_9, 1, [Defines if your system has Ruby 1.9.x])
  fi

  if test `${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.key?(%q(rubyhdrdir))"` = "true"; then
     RUBY_INCLUDEDIR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(rubyhdrdir))"`
     if test `${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.key?(%q(rubyarchhdrdir))"` = "true"; then
        RUBY_ARCHINCLUDEDIR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(rubyarchhdrdir))"`
     else
        RUBY_ARCH=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(arch))"`
        RUBY_ARCHINCLUDEDIR=${RUBY_INCLUDEDIR}/${RUBY_ARCH}
     fi
     RUBY_CFLAGS="-I${RUBY_INCLUDEDIR} -I${RUBY_ARCHINCLUDEDIR}"
  else
     RUBY_INCLUDEDIR=`${RUBY_EXECUTABLE} -r rbconfig -e "puts RbConfig::CONFIG.fetch(%q(archdir))"`
     RUBY_CFLAGS="-I${RUBY_INCLUDEDIR}"
  fi

  # Removes trailing slashes, if any, to avoid fail to install with recent libtool.
  RUBY_ARCHDIR=${RUBY_ARCHDIR%/}
  RUBY_SITEDIR=${RUBY_SITEDIR%/}
  RUBY_LIBDIR=${RUBY_LIBDIR%/}
  RUBY_RUBYLIBDIR=${RUBY_RUBYLIBDIR%/}

  AC_MSG_RESULT([\
                  archdir $RUBY_ARCHDIR,
                  sitearchdir $RUBY_SITEARCHDIR,
                  sitedir $RUBY_SITEDIR,
                  rubylibdir $RUBY_RUBYLIBDIR,
                  libdir $RUBY_LIBDIR,
                  includedir $RUBY_INCLUDEDIR,
                  librubyarg $RUBY_LIBRUBYARG,
                  cflags $RUBY_CFLAGS])
  AC_SUBST(RUBY_ARCHDIR)
  AC_SUBST(RUBY_SITEARCHDIR)
  AC_SUBST(RUBY_SITEDIR)
  AC_SUBST(RUBY_RUBYLIBDIR)
  AC_SUBST(RUBY_LIBDIR)
  AC_SUBST(RUBY_INCLUDEDIR)
  AC_SUBST(RUBY_LIBRUBYARG)
  AC_SUBST(RUBY_CFLAGS)

  OLDCFLAGS="$CFLAGS"
  CFLAGS="$RUBY_CFLAGS -Wall"
  OLDCPPFLAGS="$CPPFLAGS"
  CPPFLAGS="$RUBY_CFLAGS"
  AC_CHECK_HEADERS([ruby.h], [have_ruby_h=yes], [have_ruby_h=no]) #used in ruby check below
  CFLAGS="$OLDCFLAGS"
  CPPFLAGS="$OLDCPPFLAGS"
fi

###############################################################################
# END DAAP MONGREL RUBY VARIABLE
###############################################################################



###############################################################################
# BEGIN RUBY CHECK
###############################################################################
## TODO: Check version number >= 1.8

if test -z "$RUBY_EXECUTABLE" -o "x$have_ruby_h" = "xno"; then
    amarok_error_noruby=yes
    DO_NOT_COMPILE="$DO_NOT_COMPILE amarok"
    no_amarok=yes
fi

###############################################################################
# END RUBY CHECK
###############################################################################


###############################################################################
# BEGIN DO_NOT_COMPILE CHECK
###############################################################################

if test x$build_xine = xno -a x$build_helix = xno; then

    DO_NOT_COMPILE="$DO_NOT_COMPILE amarok"
    no_engine=yes

fi

###############################################################################
# END DO_NOT_COMPILE CHECK
###############################################################################