#!/bin/sh
#
# libvalhalla configure script - (c) 2009 Mathieu Schroeter
#
#  Fully inspired from :
#     libdlna configure script - (c) 2007-2008 Benjamin Zores
#   libplayer configure script - (c) 2006 Benjamin Zores
#      FFmpeg configure script, thanks to Fabrice Bellard
#

# make sure we are running under a compatible shell
unset foo
(: ${foo%%bar}) 2>/dev/null && ! (: ${foo?}) 2>/dev/null
if test "$?" != 0; then
  if test "x$VALHALLA_CONFIGURE_EXEC" = x; then
    VALHALLA_CONFIGURE_EXEC=1
    export VALHALLA_CONFIGURE_EXEC
    exec bash "$0" "$@"
    exec ksh "$0" "$@"
    exec /usr/xpg4/bin/sh "$0" "$@"
  fi
  echo "No compatible shell script interpreter found."
  exit 1
fi

show_help(){
  echo "Usage: configure [options]"
  echo "Options: [defaults in brackets after descriptions]"
  echo
  echo "Standard options:"
  echo "  --help                       print this message"
  echo "  --log[=FILE|yes|no]          log tests and output to FILE [config.log]"
  echo "  --prefix=PREFIX              install in PREFIX [$PREFIX]"
  echo "  --bindir=DIR                 install bins in DIR [PREFIX/bin]"
  echo "  --libdir=DIR                 install libs in DIR [PREFIX/lib]"
  echo "  --includedir=DIR             install includes in DIR [PREFIX/include]"
  echo "  --docdir=DIR                 install docs in DIR [PREFIX/share/doc]"
  echo "  --mandir=DIR                 man documentation DIR [PREFIX/share/man]"
  echo "  --enable-static              build static libraries [default=yes]"
  echo "  --disable-static             do not build static libraries [default=no]"
  echo "  --enable-shared              build shared libraries [default=yes]"
  echo "  --disable-shared             do not build shared libraries [default=no]"
  echo ""
  echo "Grabbers options:"
  echo "  --enable-grabbers            build all grabbers (dummy excepted) [default=no]"
  echo "  --enable-grabber-dummy       build dummy grabber (for debugging) [default=no]"
  echo "  --enable-grabber-allocine    build Allocine grabber [default=yes]"
  echo "  --enable-grabber-amazon      build Amazon grabber [default=yes]"
  echo "  --enable-grabber-chartlyrics build ChartLyrics grabber [default=yes]"
  echo "  --enable-grabber-exif        build EXIF grabber [default=yes]"
  echo "  --enable-grabber-ffmpeg      build FFmpeg grabber [default=no]"
  echo "  --enable-grabber-imdb        build ImDB grabber [default=yes]"
  echo "  --enable-grabber-lastfm      build Last.fm grabber [default=yes]"
  echo "  --enable-grabber-local       build localfiles grabber [default=yes]"
  echo "  --enable-grabber-lyricwiki   build LyricWiki.org grabber [default=yes]"
  echo "  --enable-grabber-nfo         build NFO grabber [default=yes]"
  echo "  --enable-grabber-tvdb        build TheTVDB.com grabber [default=yes]"
  echo "  --enable-grabber-tmdb        build TheMovieDB.org grabber [default=yes]"
  echo "  --enable-grabber-tvrage      build TVRage.com grabber [default=yes]"
  echo ""
  echo "Search paths:"
  echo "  --with-lavf=PATH             specify prefix directory for libavformat package."
  echo "                               Equivalent to --with-lavf-inc=PATH/include"
  echo "                                        plus --with-lavf-lib=PATH/lib"
  echo "  --with-lavf-inc=PATH         specify directory for libavformat include files"
  echo "  --with-lavf-lib=PATH         specify directory for libavformat library"
  echo "  --with-lavc=PATH             specify prefix directory for libavcodec package."
  echo "                               Equivalent to --with-lavc-inc=PATH/include"
  echo "                                        plus --with-lavc-lib=PATH/lib"
  echo "  --with-lavc-inc=PATH         specify directory for libavcodec include files"
  echo "  --with-lavc-lib=PATH         specify directory for libavcodec library"
  echo "  --with-lavu=PATH             specify prefix directory for libavutil package."
  echo "                               Equivalent to --with-lavu-inc=PATH/include"
  echo "                                        plus --with-lavu-lib=PATH/lib"
  echo "  --with-lavu-inc=PATH         specify directory for libavutil include files"
  echo "  --with-lavu-lib=PATH         specify directory for libavutil library"
  echo "  --with-sqlite3-dir=DIR       check for SQLite installed in DIR"
  echo "  --with-curl-dir=DIR          check for libcurl installed in DIR"
  echo "  --with-xml2-dir=DIR          check for libxml-2.0 installed in DIR"
  echo "  --with-exif-dir=DIR          check for libexif installed in DIR"
  echo "  --with-nfo-dir=DIR           check for libnfo installed in DIR"
  echo ""
  echo "Advanced options (experts only):"
  echo "  --arch=ARCH                  force architecture"
  echo "  --cpu=CPU                    force CPU optimization"
  echo "  --disable-debug              disable debugging symbols"
  echo "  --enable-debug=LEVEL         set the debug level [$debuglevel]"
  echo "  --disable-strip              disable stripping of executables at installation"
  echo "  --disable-optimize           disable compiler optimization"
  echo "  --enable-small               optimize for size instead of speed"
  echo "  --cross-prefix=PREFIX        use PREFIX for compilation tools [$cross_prefix]"
  echo "  --cross-compile              assume a cross-compiler is used"
  echo "  --enable-pic                 build position-independent code"
  echo ""
  echo "Miscellaneous:"
  echo "  --disable-logcolor           disable colorful console output on terminals"
  echo "  --enable-doc                 build Doxygen and Lyx documentation"
  exit 1
}

log(){
  echo "$@" >>$logfile
}

log_file(){
  log BEGIN $1
  cat -n $1 >>$logfile
  log END $1
}

echolog(){
  log "$@"
  echo "$@"
}

echologn(){
  log "$@"
  echo -n "$@"
}

clean(){
  rm -f $TMPC $TMPO $TMPE $TMPS
}

die(){
  echolog "$@"
  if enabled logging; then
    echo "See file \"$logfile\" produced by configure for more details."
  else
    echo "Rerun configure with logging enabled (do not use --log=no) for more details."
  fi
  clean
  exit 1
}

set_all(){
  value=$1
  shift
  for var in $*; do
    eval $var=$value
  done
}

enable(){
  set_all yes $*
}

enabled(){
  eval test "x\$$1" = "xyes"
}

disabled(){
  eval test "x\$$1" = "xno"
}

flags_saved(){
  (: ${SAVE_CFLAGS?}) 2>/dev/null
}

save_flags(){
  flags_saved && return
  SAVE_CFLAGS="$CFLAGS"
  SAVE_CPPFLAGS="$CPPFLAGS"
  SAVE_HOST_CFLAGS="$HOST_CFLAGS"
  SAVE_LDFLAGS="$LDFLAGS"
  SAVE_extralibs="$extralibs"
}

restore_flags(){
  CFLAGS="$SAVE_CFLAGS"
  CPPFLAGS="$SAVE_CPPFLAGS"
  HOST_CFLAGS="$SAVE_HOST_CFLAGS"
  LDFLAGS="$SAVE_LDFLAGS"
  extralibs="$SAVE_extralibs"
  unset SAVE_CFLAGS
  unset SAVE_CPPFLAGS
  unset SAVE_HOST_CFLAGS
  unset SAVE_LDFLAGS
  unset SAVE_extralibs
}

temp_cflags(){
  temp_append CFLAGS "$@"
}

temp_cppflags(){
  temp_append CPPFLAGS "$@"
}

temp_host_cflags(){
  temp_append HOST_CFLAGS "$@"
}

temp_ldflags(){
  temp_append LDFLAGS "$@"
}

temp_extralibs(){
  temp_append extralibs "$@"
}

temp_append(){
  local var
  var=$1
  shift
  save_flags
  append_var "$var" "$@"
}

append_var(){
  local var f
  var=$1
  shift
  for f in $@; do
    if eval echo \$$var | grep -qv -e "$f"; then
      test -n "$(eval echo \$$var)" && eval "$var=\"\$$var $f\"" || eval "$var=\"$f\""
    fi
  done
}

append(){
  local var
  var=$1
  shift
  flags_saved && append_var "SAVE_$var" "$@"
  append_var "$var" "$@"
}

add_cflags(){
  append CFLAGS "$@"
}

add_cppflags(){
  append CPPFLAGS "$@"
}

add_ldflags(){
  append LDFLAGS "$@"
}

add_extralibs(){
  append extralibs "$@"
}

add_pkgconfig_requires(){
  append pkgconfig_requires "$@"
}

add_pkgconfig_libs(){
  append pkgconfig_libs "$@"
}

check_cmd(){
  log "$@"
  "$@" >>$logfile 2>&1
}

check_cc(){
  log check_cc "$@"
  cat >$TMPC
  log_file $TMPC
  check_cmd $cc $CPPFLAGS $CFLAGS "$@" -c -o $TMPO $TMPC
}

check_host_cc(){
  log check_host_cc "$@"
  cat >$TMPC
  log_file $TMPC
  check_cmd $host_cc $HOST_CFLAGS "$@" -c -o $TMPO $TMPC
}

check_cpp(){
  log check_cpp "$@"
  cat >$TMPC
  log_file $TMPC
  check_cmd $cc $CPPFLAGS $CFLAGS "$@" -E -o $TMPO $TMPC
}

check_ld(){
  log check_ld "$@"
  check_cc || return
  check_cmd $cc "$@" -o $TMPE $TMPO $extralibs $LDFLAGS
}

check_host_ld(){
  log check_host_ld "$@"
  check_host_cc || return
  check_cmd $host_cc $HOST_LDFLAGS "$@" -o $TMPE $TMPO
}

check_exec(){
  check_ld "$@" && { enabled cross_compile || $TMPE >>$logfile 2>&1; }
}

check_cppflags(){
  log check_cppflags "$@"
  check_cc "$@" <<EOF && append CPPFLAGS "$@"
int x;
EOF
}

check_cflags(){
  log check_cflags "$@"
  check_cc "$@" <<EOF && add_cflags "$@"
int x;
EOF
}

check_ldflags(){
  log check_ldflags "$@"
  check_ld "$@" <<EOF && add_ldflags "$@"
int main(){
  return 0;
}
EOF
}

check_header(){
  local header
  log check_header "$@"
  header=$1
  shift
  check_cpp "$@" <<EOF
#include <$header>
int x;
EOF
}

check_func(){
  local func
  log check_func "$@"
  func=$1
  shift
  check_ld "$@" <<EOF
extern int $func();
int main(){
  $func();
  return 0;
}
EOF
}

check_func_headers(){
  log check_func_headers "$@"
  headers=$1
  func=$2
  shift 2
  incs=""
  for hdr in $headers; do
    incs="$incs
#include <$hdr>"
  done
  check_ld "$@" <<EOF
$incs
int main(){
  return (long) $func;
}
EOF
}

check_lib(){
  local header func err
  log check_lib "$@"
  header="$1"
  func="$2"
  shift 2
  temp_extralibs "$@"
  check_header $header && check_func $func && add_extralibs "$@"
  err=$?
  restore_flags
  return $err
}

check_libconfig(){
  local config func ccflags clibs err
  log check_libconfig "$@"
  config="$1"
  func="$2"
  ccflags="${3:---cflags}"
  clibs="${4:---libs}"
  err=1
  if `which "$config" 1>/dev/null 2>&1`; then
    cflags=`$config $ccflags`
    [ -n "$cflags" ] && check_cflags "$cflags"
    libs=`$config $clibs`
    if [ -n "$libs" ]; then
      temp_extralibs "$libs"
      check_func $func && add_extralibs "$libs"
      err=$?
      restore_flags
    fi
  fi
  return $err
}

check_pkgconfig(){
  local pkg func ccflags clibs err
  log check_pkgconfig "$@"
  pkg="$1"
  func="$2"
  ccflags="${3:---cflags}"
  clibs="${4:---libs}"
  err=1
  if `which pkg-config 1>/dev/null 2>&1`; then
    cflags=`pkg-config $pkg $ccflags`
    [ -n "$cflags" ] && check_cflags "$cflags"
    libs=`pkg-config $pkg $clibs`
    if [ -n "$libs" ]; then
      temp_extralibs "$libs"
      check_func $func
      err=$?
      restore_flags
    fi
  fi
  return $err
}

check_lib_pkgcfg(){
  local pkg header func err
  log check_lib_pkgcfg "$@"
  pkg="$1"
  header="$2"
  func="$3"
  shift 3
  err=1
  check_pkgconfig $pkg $func && add_pkgconfig_requires $pkg && err=0
  [ "$err" != 0 ] && check_lib $header $func "$@" && add_pkgconfig_libs "$@" && err=0
  return $err
}

check_lib_libcfg(){
  local config header func err
  log check_lib_pkgcfg "$@"
  config="$1"
  header="$2"
  func="$3"
  shift 3
  err=1
  check_libconfig $config $func && add_pkgconfig_libs "$@" && err=0
  [ "$err" != 0 ] && check_lib $header $func "$@" && add_pkgconfig_libs "$@" && err=0
  return $err
}

check_lib_version(){
  local min_ver toobig_ver
  min_ver="$2"
  toobig_ver="$3"
  check_cmd pkg-config --print-errors --exists "$1 >= $min_ver $1 < $toobig_ver" 2>>$logfile
  err=$?
  return $err
}

append_config(){
  echo "$@" >> $CONFIGFILE
}

pkgconfig_generate(){
  name=$1
  shortname=${name#lib}
  comment=$2
  version=$3
  libs=$4
  requires=$5
  cflags=$6

  cat <<EOF >$name.pc
PREFIX=$PREFIX
libdir=$libdir
includedir=$includedir

Name: $name
Description: $comment
Version: $version
Requires: $(enabled shared || echo $requires)
Requires.private: $(enabled shared && echo $requires)
Conflicts:
Libs: -L\${libdir} -l${shortname} $(enabled shared || echo $libs)
Libs.private: $(enabled shared && echo $libs)
Cflags: -I\${includedir} $cflags
EOF
}

add_pkgconfig_deps(){
  if `which pkg-config 1>/dev/null 2>&1`; then
    add_cflags `pkg-config "$1" --cflags 2>>$logfile`
    add_extralibs `pkg-config "$1" --libs 2>>$logfile`
  fi
}

# set temporary file name
if test ! -z "$TMPDIR" ; then
  TMPDIR1="${TMPDIR}"
elif test ! -z "$TEMPDIR" ; then
  TMPDIR1="${TEMPDIR}"
else
  TMPDIR1="/tmp"
fi

TMPC="${TMPDIR1}/libvalhalla-${RANDOM}-$$-${RANDOM}.c"
TMPO="${TMPDIR1}/libvalhalla-${RANDOM}-$$-${RANDOM}.o"
TMPE="${TMPDIR1}/libvalhalla-${RANDOM}-$$-${RANDOM}"
TMPS="${TMPDIR1}/libvalhalla-${RANDOM}-$$-${RANDOM}.S"

CONFIGFILE="config.mak"

#################################################
#   set default parameters
#################################################
logging="yes"
logfile="config.log"
PREFIX="/usr/local"
bindir='${PREFIX}/bin'
libdir='${PREFIX}/lib'
includedir='${PREFIX}/include'
docdir='${PREFIX}/share/doc'
mandir='${PREFIX}/share/man'
static="yes"
shared="yes"
cc="gcc"
host_cc="gcc"
ar="ar"
ranlib="ranlib"
make="make"
strip="strip"
arch=`uname -m`
cpu="generic"
optimize="yes"
small="no"
debug="yes"
dostrip="yes"
extralibs=""
installstrip="-s"
cross_compile="no"
pic="no"
INSTALL="install"
VERSION=""
pkgconfig_requires=""
pkgconfig_libs=""
grabber_all="auto"
grabber_dummy="no"
grabber_allocine="auto"
grabber_amazon="auto"
grabber_chartlyrics="auto"
grabber_exif="auto"
grabber_ffmpeg="auto"
grabber_imdb="auto"
grabber_lastfm="auto"
grabber_local="auto"
grabber_lyricwiki="auto"
grabber_nfo="auto"
grabber_tmdb="auto"
grabber_tvdb="auto"
grabber_tvrage="auto"
logcolor="yes"
doc="no"
doxygen="no"
lyx="no"

#################################################
#   check options
#################################################
for opt do
  optval="${opt#*=}"
  case "$opt" in
  --log)
  ;;
  --log=*) logging="$optval"
  ;;
  --prefix=*) PREFIX="$optval"; force_prefix=yes
  ;;
  --bindir=*) bindir="$optval"
  ;;
  --libdir=*) libdir="$optval"; force_libdir=yes
  ;;
  --includedir=*) includedir="$optval"
  ;;
  --docdir=*) docdir="$optval"; force_docdir=yes
  ;;
  --mandir=*) mandir="$optval"
  ;;
  --enable-static) static="yes"
  ;;
  --disable-static) static="no"
  ;;
  --enable-shared) shared="yes"
  ;;
  --disable-shared) shared="no"
  ;;
  --enable-debug=*) debug="yes"; debuglevel="$optval"
  ;;
  --enable-debug) debug="yes"
  ;;
  --disable-debug) debug="no"
  ;;
  --enable-strip) dostrip="yes"
  ;;
  --disable-strip) dostrip="no"
  ;;
  --enable-optimize) optimize="yes"
  ;;
  --disable-optimize) optimize="no"
  ;;
  --enable-small) small="yes"
  ;;
  --disable-small) small="no"
  ;;
  --cross-prefix=*) cross_prefix="$optval"
  ;;
  --cross-compile) cross_compile="yes"
  ;;
  --with-lavf=*) lavfdir="$optval";
  ;;
  --with-lavf-inc=*) lavfincdir="$optval";
  ;;
  --with-lavf-lib=*) lavflibdir="$optval";
  ;;
  --with-lavc=*) lavcdir="$optval";
  ;;
  --with-lavc-inc=*) lavcincdir="$optval";
  ;;
  --with-lavc-lib=*) lavclibdir="$optval";
  ;;
  --with-lavu=*) lavudir="$optval";
  ;;
  --with-lavu-inc=*) lavuincdir="$optval";
  ;;
  --with-lavu-lib=*) lavulibdir="$optval";
  ;;
  --with-sqlite3-dir=*) sqlite3dir="$optval";
  ;;
  --with-curl-dir=*) curldir="$optval";
  ;;
  --with-xml2-dir=*) xml2dir="$optval";
  ;;
  --with-exif-dir=*) exifdir="$optval";
  ;;
  --with-nfo-dir=*) nfodir="$optval";
  ;;
  --enable-grabbers) grabber_all="yes";
  ;;
  --disable-grabbers) grabber_all="no";
  ;;
  --enable-grabber-dummy) grabber_dummy="yes";
  ;;
  --disable-grabber-dummy) grabber_dummy="no";
  ;;
  --enable-grabber-allocine) grabber_allocine="yes";
  ;;
  --disable-grabber-allocine) grabber_allocine="no";
  ;;
  --enable-grabber-amazon) grabber_amazon="yes";
  ;;
  --disable-grabber-amazon) grabber_amazon="no";
  ;;
  --enable-grabber-chartlyrics) grabber_chartlyrics="yes";
  ;;
  --disable-grabber-chartlyrics) grabber_chartlyrics="no";
  ;;
  --enable-grabber-exif) grabber_exif="yes";
  ;;
  --disable-grabber-exif) grabber_exif="no";
  ;;
  --enable-grabber-ffmpeg) grabber_ffmpeg="yes";
  ;;
  --disable-grabber-ffmpeg) grabber_ffmpeg="no";
  ;;
  --enable-grabber-imdb) grabber_imdb="yes";
  ;;
  --disable-grabber-imdb) grabber_imdb="no";
  ;;
  --enable-grabber-lastfm) grabber_lastfm="yes";
  ;;
  --disable-grabber-lastfm) grabber_lastfm="no";
  ;;
  --enable-grabber-local) grabber_local="yes";
  ;;
  --disable-grabber-local) grabber_local="no";
  ;;
  --enable-grabber-lyricwiki) grabber_lyricwiki="yes";
  ;;
  --disable-grabber-lyricwiki) grabber_lyricwiki="no";
  ;;
  --enable-grabber-nfo) grabber_nfo="yes";
  ;;
  --disable-grabber-nfo) grabber_nfo="no";
  ;;
  --enable-grabber-tmdb) grabber_tmdb="yes";
  ;;
  --disable-grabber-tmdb) grabber_tmdb="no";
  ;;
  --enable-grabber-tvdb) grabber_tvdb="yes";
  ;;
  --disable-grabber-tvdb) grabber_tvdb="no";
  ;;
  --enable-grabber-tvrage) grabber_tvrage="yes";
  ;;
  --disable-grabber-tvrage) grabber_tvrage="no";
  ;;
  --enable-pic) pic="yes";
  ;;
  --disable-pic) pic="no";
  ;;
  --enable-logcolor) logcolor="yes";
  ;;
  --disable-logcolor) logcolor="no";
  ;;
  --enable-doc) doc="yes";
  ;;
  --disable-doc) doc="no";
  ;;
  --help) show_help
  ;;
  *)
  echo "Unknown option \"$opt\"."
  echo "See $0 --help for available options."
  exit 1
  ;;
  esac
done

# Check for conflictual build options
if [ "$shared" = no -a "$static" = no ]; then
  echo "At least one library type must be built."
  echo "Specify --enable-static to build the static libraries or"
  echo "--enable-shared to build the shared libraries as well."
  exit 1
fi

if [ -n "$cross_prefix" ]; then
  cross_compile="yes"
  cc="${cross_prefix}${cc}"
  ar="${cross_prefix}${ar}"
  ranlib="${cross_prefix}${ranlib}"
  strip="${cross_prefix}${strip}"
else
  [ -n "$CC" ] && cc="$CC"
  [ -n "$AR" ] && ar="$AR"
  [ -n "$RANLIB" ] && ranlib="$RANLIB"
  [ -n "$STRIP" ] && strip="$STRIP"
fi
[ -n "$MAKE" ] && make="$MAKE"

[ -n "$HOST_CC" ] && HOST_CC="$HOST_CC"
[ -n "$HOST_CFLAGS" ] && HOST_CFLAGS="$HOST_CFLAGS"
[ -n "$HOST_LDFLAGS" ] && HOST_LDFLAGS="$HOST_LDFLAGS"

#################################################
#   set arch variable and specific cpu flags
#################################################
if enabled cross_compile; then
  arch="`$cc -dumpmachine | sed -e 's,\([^-]*\)-.*,\1,'`"
fi

case "$arch" in
  i386|i486|i586|i686|i86pc|BePC)
    arch="x86_32"
  ;;
  x86_64|amd64)
    arch="x86_32"
    canon_arch="`$cc -dumpmachine | sed -e 's,\([^-]*\)-.*,\1,'`"
    if [ x"$canon_arch" = x"x86_64" -o x"$canon_arch" = x"amd64" ]; then
      if [ -z "`echo $CFLAGS | grep -- -m32`"  ]; then
        arch="x86_64"
      fi
    fi
    spic=$shared
  ;;
# armv4l is a subset of armv5tel
  arm|armv4l|armv5tel)
    arch="armv4l"
  ;;
  alpha)
    arch="alpha"
    spic=$shared
  ;;
  "Power Macintosh"|ppc|ppc64|powerpc)
    arch="powerpc"
  ;;
  mips|mipsel|IP*)
    arch="mips"
    spic=$shared
  ;;
  mips64)
    arch="mips64"
    spic=$shared
  ;;
  sun4u|sparc64)
    arch="sparc64"
    spic=$shared
  ;;
  sparc)
    arch="sparc"
    spic=$shared
  ;;
  sh4)
    arch="sh4"
  ;;
  parisc|parisc64)
    arch="parisc"
    spic=$shared
  ;;
  s390|s390x)
    arch="s390"
  ;;
  m68k)
    arch="m68k"
  ;;
  ia64)
    arch="ia64"
    spic=$shared
  ;;
  bfin)
    arch="bfin"
  ;;
  *)
    arch="unknown"
  ;;
esac

# Add processor-specific flags
if test $cpu != "generic"; then
  case $cpu in
    601|ppc601|PowerPC601)
      add_cflags "-mcpu=601"
    ;;
    603*|ppc603*|PowerPC603*)
      add_cflags "-mcpu=603"
    ;;
    604*|ppc604*|PowerPC604*)
      add_cflags "-mcpu=604"
    ;;
    G3|g3|75*|ppc75*|PowerPC75*)
      add_cflags "-mcpu=750 -mpowerpc-gfxopt"
    ;;
    G4|g4|745*|ppc745*|PowerPC745*)
      add_cflags "-mcpu=7450 -mpowerpc-gfxopt"
    ;;
    74*|ppc74*|PowerPC74*)
      add_cflags "-mcpu=7400 -mpowerpc-gfxopt"
    ;;
    G5|g5|970|ppc970|PowerPC970|power4*|Power4*)
      add_cflags "-mcpu=970 -mpowerpc-gfxopt -mpowerpc64"
    ;;
    Cell|CELL|cell)
      add_cflags "-mcpu=cell"
    ;;
    i[3456]86|pentium|pentium-mmx|pentiumpro|pentium[23]|pentium-m|k6|k6-[23]|winchip-c6|winchip2|c3|athlon|athlon-tbird|athlon-4|athlon-[mx]p|athlon64|k8|opteron|athlon-fx|core2|pentium4|pentium4m|prescott|nocona)
      add_cflags "-march=$cpu"
    ;;
    sparc64)
      add_cflags "-mcpu=v9"
    ;;
    arm*|cortex*)
      add_cflags "-mcpu=$cpu"
    ;;
    *)
      die "WARNING: Unknown CPU \"$cpu\", ignored."
    ;;
  esac
fi

enable_pic(){
  enable pic
  add_cppflags -DPIC
  add_cflags   -fPIC
}

enabled spic && enable pic
enabled pic && enable_pic

#################################################
#   create logging file
#################################################
if test "$logging" != no; then
  enabled logging || logfile="$logging"
  echo "# $0 $@" >$logfile
  set >>$logfile
else
  logfile=/dev/null
fi

#################################################
#   compiler sanity check
#################################################
echolog "Checking for compiler available..."
check_exec <<EOF
int main(){
    return 0;
}
EOF
if test "$?" != 0; then
  echo "$cc is unable to create an executable file."
  if test -z "$cross_prefix" -a "$cross_compile" = no; then
    echo "If $cc is a cross-compiler, use the --cross-compile option."
  fi
  die "C compiler test failed."
fi

if test -n "`$cc -v 2>&1 | grep version | grep Apple`"; then
  dylib="yes"
else
  dylib="no"
fi

mingw32="no"
if test -n "`$cc -v 2>&1 | grep version | grep mingw`" \
     -o -n "`$cc -v 2>&1 | grep Target  | grep mingw`"; then
  mingw32="yes"
fi

#################################################
#   check for target specific flags
#################################################
# check for SIMD availability

# mmi only available on mips
if [ "$mmi" = "default" ]; then
  if [ "$arch" = "mips" ]; then
    mmi="yes"
  else
    mmi="no"
  fi
fi

# check if our compiler supports mmi
enabled mmi && check_cc <<EOF || mmi="no"
int main(void) {
  __asm__ ("lq \$2, 0(\$2)");
  return 0;
}
EOF

# test gcc version to see if vector builtins can be used
# currently only used on i386 for MMX builtins
check_cc -msse <<EOF && builtin_vector=yes || builtin_vector=no
#include <xmmintrin.h>
int main(void) {
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2)
return 0;
#else
#error no vector builtins
#endif
}
EOF

# test for mm3dnow.h
test "$arch" = "x86_64" && march=k8 || march=athlon
check_cc -march=$march <<EOF && mm3dnow=yes || mm3dnow=no
#include <mm3dnow.h>
int main(void) {
__m64 b1;
b1 = _m_pswapd(b1);
_m_femms();
return 0;
}
EOF

# ---
# big/little-endian test
check_cc <<EOF || die "endian test failed"
unsigned int endian = 'B' << 24 | 'I' << 16 | 'G' << 8 | 'E';
EOF
od -A n -t x1 $TMPO | grep -q '42 *49 *47 *45' && enable bigendian

enabled bigendian && add_cppflags -DHAVE_BIGENDIAN

# add some useful compiler flags if supported
check_cflags -W
check_cflags -Wall
check_cppflags -D_LARGEFILE_SOURCE
check_cppflags -D_FILE_OFFSET_BITS=64
check_cppflags -D_REENTRANT

# default extralibs

#################################################
#   check for functions availability
#################################################

# pthread
check_lib pthread.h pthread_mutex_init -lpthread
if [ "$?" != 0 ]; then
  check_lib pthread.h pthread_mutex_init -lpthreadGC2
  [ "$?" != 0 ] && die "Error, can't find pthread_mutex_init !"
  add_pkgconfig_libs -lpthreadGC2
else
  add_pkgconfig_libs -lpthread
fi

# clock_gettime
check_lib time.h clock_gettime
if [ "$?" != 0 ]; then
  check_lib time.h clock_gettime -lrt
  if [ "$?" != 0 ]; then
    check_lib mach/clock.h clock_get_time
    if [ "$?" != 0 ]; then
      # QueryPerformanceCounter()
      check_header windows.h
      [ "$?" != 0 ] && die "Error, can't find clock_gettime !"
      add_cppflags -DOSDEP_CLOCK_GETTIME_WINDOWS
    else
      add_cppflags -DOSDEP_CLOCK_GETTIME_DARWIN
    fi
  else
    add_pkgconfig_libs -lrt
  fi
fi

# strndup
temp_cppflags -D_GNU_SOURCE
check_func_headers string.h strndup || add_cppflags -DOSDEP_STRNDUP
restore_flags

# strcasestr
temp_cppflags -D_GNU_SOURCE
check_func_headers string.h strcasestr || add_cppflags -DOSDEP_STRCASESTR
restore_flags

# strtok_r
check_func_headers string.h strtok_r || add_cppflags -DOSDEP_STRTOK_R

# lstat
check_func_headers "sys/types.h sys/stat.h unistd.h" lstat || add_cppflags -DOSDEP_LSTAT


#################################################
#   check for debug symbols
#################################################
enabled debug && add_cflags -g"$debuglevel" && add_cppflags -DHAVE_DEBUG

if enabled small; then
  check_cflags -Os
  add_cppflags -DCONFIG_SMALL
elif enabled optimize; then
  if test -n "`$cc -v 2>&1 | grep xlc`"; then
    add_cflags  "-O5"
    add_ldflags "-O5"
  else
    add_cflags "-O2"
  fi
fi


#################################################
#   check for FFmpeg libavformat
#################################################
if [ -n "$lavfdir" ]; then
  check_cppflags -I${lavfdir}/include
  check_ldflags -L${lavfdir}/lib
fi
if [ -n "$lavfincdir" ]; then
  check_cppflags -I${lavfincdir}
fi
if [ -n "$lavflibdir" ]; then
  check_ldflags -L${lavflibdir}
fi

echolog "Checking for libavformat ..."
check_lib_pkgcfg libavformat libavformat/avformat.h av_metadata_conv -lavformat || die "Error, can't find libavformat !"


#################################################
#   check for SQLite sqlite3
#################################################
if [ -n "$sqlite3dir" ]; then
  check_cppflags -I$sqlite3dir
  check_ldflags -L$sqlite3dir
fi

echolog "Checking for sqlite3 ..."
check_lib_pkgcfg sqlite3 sqlite3.h sqlite3_version -lsqlite3 || die "Error, can't find sqlite3 !"


#################################################
#   Grabber
#################################################

grabber_enabled(){
  local grabup value
  for grab in $@; do
    grabup=`echo $grab | tr "[:lower:]" "[:upper:]"`
    eval value=\$grabber_$grab
    if test "$value" = "auto" -o "$value" = "yes"; then
      add_cppflags -DHAVE_GRABBER_$grabup
      grabber="yes"
      eval grabber_$grab="yes"
    fi
  done
}

grabber_forced(){
  local value
  for grab in $@; do
    eval value=\$grabber_$grab
    [ "$value" = "yes" ] && return 1
  done
  return 0
}

grabber_set_no(){
  for grab in $@; do
    eval grabber_$grab="no"
  done
}

grabber_set_yes(){
  for grab in $@; do
    eval grabber_$grab="yes"
  done
}

grabber_enable_dep(){
  local value list dep
  eval list=\$$1
  dep=`echo $1 | sed "s/\([a-z]*\)_.*/\\1/"`
  eval $dep="no"
  for grab in $list; do
    eval value=\$grabber_$grab
    if test "$value" = "auto" -o "$value" = "yes"; then
      eval $dep="yes"
      break
    fi
  done
}

grabber="no"
grabbers="allocine amazon chartlyrics exif ffmpeg imdb lastfm local lyricwiki nfo tmdb tvdb tvrage"

if [ "$grabber_all" != "auto" ]; then
  eval grabber_set_$grabber_all \$grabbers
fi

avcodec_dep_grabber="ffmpeg"
grabber_enable_dep avcodec_dep_grabber

avutil_dep_grabber="amazon lastfm tmdb tvdb"
grabber_enable_dep avutil_dep_grabber

exif_dep_grabber="exif"
grabber_enable_dep exif_dep_grabber

nfo_dep_grabber="nfo"
grabber_enable_dep nfo_dep_grabber

xml_dep_grabber="allocine amazon chartlyrics imdb lastfm lyricwiki tmdb tvdb tvrage"
grabber_enable_dep xml_dep_grabber

if enabled nfo; then
  ###############################################
  #   check for libnfo
  ###############################################
  if [ -n "$nfodir" ]; then
    check_cppflags -I$nfodir
    check_ldflags -L$nfodir
  fi

  echologn "Checking for libnfo ... "
  check_lib_version libnfo "1.0.0" "2.0.0"
  if [ "$?" = 0 ]; then
    check_lib_pkgcfg libnfo nfo.h nfo_init -lnfo
    [ "$?" != 0 ] && die "Error, libnfo available but the compilation failed !"
    echolog "(yes)"
  else
    echolog "(no)"
    grabber_forced $nfo_dep_grabber
    [ "$?" != 0 ] && die "Error, can't find libnfo or bad version !"
    nfo="no"
    grabber_set_no $nfo_dep_grabber
  fi
fi

if enabled xml; then
  ###############################################
  #   check for libxml2
  ###############################################
  if [ -n "$xml2dir" ]; then
    check_cppflags -I$xml2dir
    check_ldflags -L$xml2dir
  fi

  echologn "Checking for libxml2 ... "
  check_lib_pkgcfg libxml-2.0 libxml/parser.h xmlReadMemory -lxml2
  if [ "$?" = 0 ]; then
    echolog "(yes)"
    add_cppflags -DUSE_XML
  else
    echolog "(no)"
    grabber_forced $xml_dep_grabber
    [ "$?" != 0 ] && die "Error, can't find libxml2 !"
    xml="no"
    grabber_set_no $xml_dep_grabber
  fi
fi

if enabled avutil; then
  ###############################################
  #   check for FFmpeg libavutil
  ###############################################
  if [ -n "$lavudir" ]; then
    check_cppflags -I${lavudir}/include
    check_ldflags -L${lavudir}/lib
  fi
  if [ -n "$lavuincdir" ]; then
    check_cppflags -I${lavuincdir}
  fi
  if [ -n "$lavulibdir" ]; then
    check_ldflags -L${lavulibdir}
  fi

  echologn "Checking for libavutil ... "
  check_lib_pkgcfg libavutil libavutil/md5.h av_md5_sum -lavutil
  if [ "$?" = 0 ]; then
    echolog "(yes)"
  else
    echolog "(no)"
    grabber_forced $avutil_dep_grabber
    [ "$?" != 0 ] && die "Error, can't find libavutil !"
    avutil="no"
    grabber_set_no $avutil_dep_grabber
  fi
fi

if enabled exif; then
  ###############################################
  #   check for libexif
  ###############################################
  if [ -n "$exifdir" ]; then
    check_cppflags -I$exifdir
    check_ldflags -L$exifdir
  fi

  echologn "Checking for libexif ... "
  check_lib_pkgcfg libexif libexif/exif-data.h exif_entry_get_value -lexif
  if [ "$?" = 0 ]; then
    echolog "(yes)"
  else
    echolog "(no)"
    grabber_forced $exif_dep_grabber
    [ "$?" != 0 ] && die "Error, can't find libexif !"
    exif="no"
    grabber_set_no $exif_dep_grabber
  fi
fi

if enabled avcodec; then
  ###############################################
  #   check for FFmpeg libavcodec
  ###############################################
  if [ -n "$lavcdir" ]; then
    check_cppflags -I${lavcdir}/include
    check_ldflags -L${lavcdir}/lib
  fi
  if [ -n "$lavcincdir" ]; then
    check_cflags -I${lavcincdir}
  fi
  if [ -n "$lavclibdir" ]; then
    check_ldflags -L${lavclibdir}
  fi

  echologn "Checking for libavcodec ... "
  check_lib_pkgcfg libavcodec libavcodec/avcodec.h av_lockmgr_register -lavcodec
  if [ "$?" = 0 ]; then
    echolog "(yes)"
    add_cppflags -DUSE_LAVC
  else
    echolog "(no)"
    grabber_forced $avcodec_dep_grabber
    [ "$?" != 0 ] && die "Error, can't find libavcodec !"
    avcodec="no"
    grabber_set_no $avcodec_dep_grabber
  fi
fi

grabber_enabled dummy $grabbers

if enabled grabber; then
  ###############################################
  #   check for libcurl
  ###############################################
  if [ -n "$curldir" ]; then
    check_cppflags -I$curldir
    check_ldflags -L$curldir
  fi

  echologn "Checking for libcurl ... "
  check_lib_pkgcfg libcurl curl/curl.h curl_global_init -lcurl
  if [ "$?" = 0 ]; then
    echolog "(yes)"
    add_cppflags -DUSE_GRABBER
  else
    echolog "(no)"
    if enabled grabber_all; then
      die "Error, can't find libcurl (mandatory for the grabbers) !"
    fi
    grabber="no"
    grabber_set_no dummy $grabbers
  fi
fi

#################################################
#   version
#################################################
get_version(){
  local name file version
  name=$1
  file=src/$2
  eval $(grep "#define ${name}_VERSION_M" "$file" | awk '{ print $2"="$3 }')
  eval version=\$${name}_VERSION_MAJOR.\$${name}_VERSION_MINOR.\$${name}_VERSION_MICRO
  echo $version
}

VERSION=`get_version LIBVALHALLA valhalla.h`


#################################################
#   Miscellaneous
#################################################
if enabled logcolor; then
  add_cppflags -DUSE_LOGCOLOR
fi

# Doxygen
if enabled doc; then
  doc="no"
  which doxygen 2>&1 > /dev/null
  [ "$?" = 0 ] && doc="yes" && doxygen="yes"
  which lyx 2>&1 > /dev/null
  if [ "$?" = 0 ]; then
    which dia 2>&1 > /dev/null
    [ "$?" = 0 ] && doc="yes" && lyx="yes"
  fi
fi

# Add all extralibs provided by the pkgconfig files
[ -n "$pkgconfig_requires" ] && add_extralibs `pkg-config $pkgconfig_requires --libs`


#################################################
#   logging result
#################################################
echolog ""
echolog "libvalhalla: configure is OK"
echolog "  version            $VERSION"
echolog "configuration:"
echolog "  install prefix     $PREFIX"
echolog "  C compiler         $cc"
echolog "  AR                 $ar"
echolog "  RANLIB             $ranlib"
echolog "  STRIP              $strip"
echolog "  make               $make"
echolog "  Architecture       $arch ($cpu)"
echolog "  big-endian         ${bigendian-no}"
echolog "  debug symbols      $debug"
echolog "  strip symbols      $dostrip"
echolog "  optimize           $optimize"
echolog "  static             ${static}"
echolog "  shared             ${shared}"
echolog ""
echolog "  CFLAGS             $CFLAGS $CPPFLAGS"
echolog "  LDFLAGS            $LDFLAGS"
echolog "  extralibs          $extralibs"
echolog ""
echolog "  Grabbers support:  $grabber"
echolog "    Dummy            $grabber_dummy"
echolog "    Allocine         $grabber_allocine"
echolog "    Amazon           $grabber_amazon"
echolog "    ChartLyrics      $grabber_chartlyrics"
echolog "    EXIF             $grabber_exif"
echolog "    FFmpeg           $grabber_ffmpeg"
echolog "    ImDB             $grabber_imdb"
echolog "    Last.fm          $grabber_lastfm"
echolog "    Local Files      $grabber_local"
echolog "    LyricWiki        $grabber_lyricwiki"
echolog "    NFO              $grabber_nfo"
echolog "    TheMovieDB       $grabber_tmdb"
echolog "    TheTVDB          $grabber_tvdb"
echolog "    TVRage           $grabber_tvrage"
echolog ""
echolog "Miscellaneous:"
echolog "  Documentation:     $doc"
echolog "    Doxygen          $doxygen"
echolog "    Lyx              $lyx"
echolog ""

#################################################
#   save configs attributes
#################################################
echolog "Creating config.mak ..."

echo "# Automatically generated by configure - do not modify!" > $CONFIGFILE

append_config "PREFIX=$PREFIX"
append_config "prefix=\$(DESTDIR)\$(PREFIX)"
append_config "bindir=\$(DESTDIR)$bindir"
append_config "libdir=\$(DESTDIR)$libdir"
append_config "includedir=\$(DESTDIR)$includedir"
append_config "docdir=\$(DESTDIR)$docdir"
append_config "mandir=\$(DESTDIR)$mandir"

append_config "MAKE=$make"
append_config "CC=$cc"
append_config "AR=$ar"
append_config "RANLIB=$ranlib"
append_config "LN=ln"

append_config "BUILD_STATIC=$static"
append_config "BUILD_SHARED=$shared"
append_config "BUILD_DYLIB=$dylib"
append_config "BUILD_MINGW32=$mingw32"

append_config "VERSION=$VERSION"

if enabled dostrip; then
  append_config "STRIP=$strip"
  append_config "INSTALLSTRIP=$installstrip"
else
  append_config "STRIP=echo ignoring strip"
  append_config "INSTALLSTRIP="
fi
append_config "EXTRALIBS=$extralibs"

append_config "CFG_CPPFLAGS=$CPPFLAGS"
append_config "OPTFLAGS=$CFLAGS"
append_config "CFG_LDFLAGS=$LDFLAGS"
append_config "INSTALL=$INSTALL"

if enabled bigendian; then
  append_config "WORDS_BIGENDIAN=yes"
fi

append_config "XML=$xml"
append_config "EXIF=$exif"
append_config "NFO=$nfo"
append_config "MD5=$avutil"
append_config "HMAC_SHA256=$grabber_amazon"
append_config "GRABBER=$grabber"
append_config "GRABBER_DUMMY=$grabber_dummy"
append_config "GRABBER_ALLOCINE=$grabber_allocine"
append_config "GRABBER_AMAZON=$grabber_amazon"
append_config "GRABBER_CHARTLYRICS=$grabber_chartlyrics"
append_config "GRABBER_EXIF=$grabber_exif"
append_config "GRABBER_FFMPEG=$grabber_ffmpeg"
append_config "GRABBER_IMDB=$grabber_imdb"
append_config "GRABBER_LASTFM=$grabber_lastfm"
append_config "GRABBER_LOCAL=$grabber_local"
append_config "GRABBER_LYRICWIKI=$grabber_lyricwiki"
append_config "GRABBER_NFO=$grabber_nfo"
append_config "GRABBER_TMDB=$grabber_tmdb"
append_config "GRABBER_TVDB=$grabber_tvdb"
append_config "GRABBER_TVRAGE=$grabber_tvrage"

append_config "DEBUG=$debug"
append_config "DOC=$doc"
if enabled doc; then
  append_config "DOC_DOXYGEN=$doxygen"
  append_config "DOC_LYX=$lyx"
fi

#################################################
#   make pkg-config files
#################################################
echolog "Creating libvalhalla.pc ..."

pkgconfig_generate libvalhalla \
                   "A tiny media scanner library" \
                   "$VERSION" \
                   "$pkgconfig_libs" \
                   "$pkgconfig_requires" \
                   ""

clean
exit 0
