configure.ac

#  Copyright © 1999 ImageMagick Studio LLC, a non-profit organization
#  dedicated to making software imaging solutions freely available.
#
#  You may not use this file except in compliance with the License.  You may
#  obtain a copy of the License at
#
#    https://imagemagick.org/script/license.php
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
#
#  Copyright (C) 2003 - 2008 GraphicsMagick Group
#
#  Copying and distribution of this file, with or without modification,
#  are permitted in any medium without royalty provided the copyright
#  notice and this notice are preserved.
AC_PREREQ([2.69])

# ==============================================================================
# Initialize Automake
# ==============================================================================
m4_include([m4/version.m4])
m4_define([magick_base_version],
          [magick_major_version.magick_minor_version.magick_micro_version])
m4_define([magick_version],
          [magick_base_version-magick_patchlevel_version])
m4_define([magick_lib_version_number],
          [magick_major_version,magick_minor_version,magick_micro_version,magick_patchlevel_version])
m4_define([magick_git_revision],
          m4_esyscmd([
            h=$(git rev-parse --short HEAD)
            d=$(git log -1 --format=:%cd --date=format:%Y%m%d || date -u +%Y%m%d -r ./m4/version.m4)
            printf %s "$h$d"
          ]))
m4_define([magick_release_date],
          m4_esyscmd([
            d=$(git log -1 --format=%cd --date=format:%Y-%m-%d || date -u +%F -r ./m4/version.m4)
            printf %s "$d"
          ]))

AC_INIT([magick_name],[magick_version],[magick_bugreport],[magick_tarname],[magick_url])

AC_CONFIG_SRCDIR([MagickCore/MagickCore.h])
AC_CONFIG_AUX_DIR([config])
AC_REQUIRE_AUX_FILE([tap-driver.sh])
AC_CONFIG_MACRO_DIR([m4])
AC_CONFIG_HEADERS([config/config.h])
AX_PREFIX_CONFIG_H([MagickCore/magick-baseconfig.h],[MagickCore])
AC_CANONICAL_TARGET

AM_INIT_AUTOMAKE([foreign no-define color-tests parallel-tests -Wall -Wno-portability subdir-objects dist-bzip2 dist-lzip dist-xz dist-zip tar-ustar])

AM_SILENT_RULES([yes])
AC_SUBST([CONFIGURE_DEPENDENCIES],["$CONFIGURE_DEPENDENCIES \$(top_srcdir)/m4/version.m4"])

#
# Save initial user-tunable values
#
USER_LIBS=$LIBS
for var in CC CFLAGS CPPFLAGS CXX CXXCPP LDFLAGS AR_FLAGS LIBS ; do
  eval isset=\${$var+set}
    if test "$isset" = 'set'; then
        eval val=$`echo $var`
        DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS}'${var}=${val}' "
    fi
done
AC_SUBST([DISTCHECK_CONFIG_FLAGS])

CONFIGURE_ARGS="$0 ${ac_configure_args}"
AC_SUBST([CONFIGURE_ARGS])

echo "Configuring ${PACKAGE_NAME} ${PACKAGE_VERSION}"

MAGICK_TARGET_CPU=$host_cpu
AC_SUBST([MAGICK_TARGET_CPU])
AC_DEFINE_UNQUOTED([MAGICK_TARGET_CPU],[$MAGICK_TARGET_CPU],[Target Host CPU])

MAGICK_TARGET_VENDOR=$host_vendor
AC_SUBST([MAGICK_TARGET_VENDOR])
AC_DEFINE_UNQUOTED([MAGICK_TARGET_VENDOR],[$MAGICK_TARGET_VENDOR],[Target Host Vendor])

MAGICK_TARGET_OS=$host_os
AC_SUBST([MAGICK_TARGET_OS])
AC_DEFINE_UNQUOTED([MAGICK_TARGET_OS],[$MAGICK_TARGET_OS],[Target Host OS])


# Substitute versioning
AC_SUBST([MAGICK_MAJOR_VERSION],[magick_major_version])
AC_SUBST([MAGICK_MINOR_VERSION],[magick_minor_version])
AC_SUBST([MAGICK_MICRO_VERSION],[magick_micro_version])
AC_SUBST([MAGICK_PATCHLEVEL_VERSION],[magick_patchlevel_version])
AC_SUBST([MAGICK_VERSION],[magick_version])
AC_SUBST([MAGICK_GIT_REVISION],[magick_git_revision])

# Substitute library versioning
AC_SUBST([MAGICK_LIBRARY_CURRENT],[magick_library_current])dnl
AC_SUBST([MAGICK_LIBRARY_REVISION],[magick_library_revision])dnl
AC_SUBST([MAGICK_LIBRARY_AGE],[magick_library_age])dnl
AC_SUBST([MAGICK_LIBRARY_CURRENT_MIN],
         [`expr $MAGICK_LIBRARY_CURRENT - $MAGICK_LIBRARY_AGE`])
AC_SUBST([MAGICK_LIBRARY_VERSION_INFO],
         [$MAGICK_LIBRARY_CURRENT:$MAGICK_LIBRARY_REVISION:$MAGICK_LIBRARY_AGE])

AC_SUBST([MAGICKPP_LIBRARY_CURRENT],[magickpp_library_current])dnl
AC_SUBST([MAGICKPP_LIBRARY_REVISION],[magickpp_library_revision])dnl
AC_SUBST([MAGICKPP_LIBRARY_AGE],[magickpp_library_age])dnl
AC_SUBST([MAGICKPP_LIBRARY_CURRENT_MIN],
         [`expr $MAGICKPP_LIBRARY_CURRENT - $MAGICKPP_LIBRARY_AGE`])
AC_SUBST([MAGICKPP_LIBRARY_VERSION_INFO],
         [$MAGICKPP_LIBRARY_CURRENT:$MAGICKPP_LIBRARY_REVISION:$MAGICKPP_LIBRARY_AGE])

AC_SUBST([PACKAGE_BASE_VERSION],[magick_base_version])
AC_SUBST([PACKAGE_PATCHLEVEL_VERSION],[magick_patchlevel_version])
if test "magick_is_beta" = 'y'; then
  PACKAGE_VERSION_ADDENDUM='-magick_patchlevel_version (Beta)'
else
  PACKAGE_VERSION_ADDENDUM=-magick_patchlevel_version
fi
AC_SUBST([PACKAGE_VERSION_ADDENDUM])
AC_SUBST([PACKAGE_LIB_VERSION],[magick_lib_version])
AC_SUBST([PACKAGE_LIB_VERSION_NUMBER],[magick_lib_version_number])
AC_SUBST([PACKAGE_RELEASE_DATE],[magick_release_date])

# Ensure that make can run correctly
AM_SANITY_CHECK

# versioning of library
MAGICK_LIB_VERSION="0x"
if test ${MAGICK_LIBRARY_CURRENT} -lt 10 ; then
  MAGICK_LIB_VERSION=${MAGICK_LIB_VERSION}0
fi
MAGICK_LIB_VERSION=${MAGICK_LIB_VERSION}${MAGICK_LIBRARY_CURRENT}
if test ${MAGICK_LIBRARY_AGE} -lt 10 ; then
  MAGICK_LIB_VERSION=${MAGICK_LIB_VERSION}0
fi
MAGICK_LIB_VERSION=${MAGICK_LIB_VERSION}${MAGICK_LIBRARY_AGE}
if test ${MAGICK_LIBRARY_REVISION} -lt 10 ; then
  MAGICK_LIB_VERSION=${MAGICK_LIB_VERSION}0
fi
MAGICK_LIB_VERSION=${MAGICK_LIB_VERSION}${MAGICK_LIBRARY_REVISION}
AC_SUBST([MAGICK_LIB_VERSION])

# Definition used to define MagickLibVersionText in version.h
MAGICK_LIB_VERSION_TEXT="${PACKAGE_BASE_VERSION}"
AC_SUBST([MAGICK_LIB_VERSION_TEXT])

# Definition used to define MagickLibVersionNumber in version.h
MAGICK_LIB_VERSION_NUMBER="${MAGICK_LIBRARY_CURRENT},${MAGICK_LIBRARY_AGE},${MAGICK_LIBRARY_REVISION}"
AC_SUBST([MAGICK_LIB_VERSION_NUMBER])

MAGICKPP_LIB_VERSION="0x"
if test ${MAGICKPP_LIBRARY_CURRENT} -lt 10 ; then
  MAGICKPP_LIB_VERSION=${MAGICKPP_LIB_VERSION}0
fi
MAGICKPP_LIB_VERSION=${MAGICKPP_LIB_VERSION}${MAGICKPP_LIBRARY_CURRENT}
if test ${MAGICKPP_LIBRARY_AGE} -lt 10 ; then
  MAGICKPP_LIB_VERSION=${MAGICKPP_LIB_VERSION}0
fi
MAGICKPP_LIB_VERSION=${MAGICKPP_LIB_VERSION}${MAGICKPP_LIBRARY_AGE}
if test ${MAGICKPP_LIBRARY_REVISION} -lt 10 ; then
  MAGICKPP_LIB_VERSION=${MAGICKPP_LIB_VERSION}0
fi
MAGICKPP_LIB_VERSION=${MAGICKPP_LIB_VERSION}${MAGICKPP_LIBRARY_REVISION}
AC_SUBST([MAGICKPP_LIB_VERSION])

# Definition used to define MagickLibVersionText in version.h
MAGICKPP_LIB_VERSION_TEXT="${PACKAGE_BASE_VERSION}"
AC_SUBST([MAGICKPP_LIB_VERSION_TEXT])

# Definition used to define MagickLibVersionNumber in version.h
MAGICK_LIB_VERSION_NUMBER="${MAGICK_LIBRARY_CURRENT},${MAGICK_LIBRARY_AGE},${MAGICK_LIBRARY_REVISION}"
AC_SUBST([MAGICK_LIB_VERSION_NUMBER])

PERLMAINCC=$CC

MAGICK_CFLAGS=''
MAGICK_CPPFLAGS=$CPPFLAGS_USER
MAGICK_PCFLAGS=$CPPFLAGS_USER
MAGICK_LDFLAGS=''
MAGICK_LIBS=''
MAGICK_FEATURES=''

#
# Evaluate shell variable equivalents to Makefile directory variables
#
if test "x$prefix" = xNONE; then
    prefix=$ac_default_prefix
fi
# Let make expand exec_prefix.
if test "x$exec_prefix" = xNONE; then
    exec_prefix='${prefix}'
fi

#
eval "eval PREFIX_DIR=${prefix}"
AC_SUBST([PREFIX_DIR])
eval "eval EXEC_PREFIX_DIR=${exec_prefix}"
AC_SUBST([EXEC_PREFIX_DIR])
eval "eval BIN_DIR=$bindir"
AC_SUBST([BIN_DIR])
eval "eval SBIN_DIR=$sbindir"
AC_SUBST([SBIN_DIR])
eval "eval LIBEXEC_DIR=$libexecdir"
AC_SUBST([LIBEXEC_DIR])
eval "eval DATA_DIR=$datadir"
AC_SUBST([DATA_DIR])
eval "eval DOC_DIR=$datadir/doc"
AC_SUBST([DOC_DIR])
eval "eval SYSCONF_DIR=$sysconfdir"
AC_SUBST([SYSCONF_DIR])
eval "eval SHAREDSTATE_DIR=$sharedstatedir"
AC_SUBST([SHAREDSTATE_DIR])
eval "eval LOCALSTATE_DIR=$localstatedir"
AC_SUBST([LOCALSTATE_DIR])
eval "eval LIB_DIR=$libdir"
AC_SUBST([LIB_DIR])
eval "eval INCLUDE_DIR=$includedir"
AC_SUBST([INCLUDE_DIR])
eval "eval PERSISTINCLUDE_DIR=$oldincludedir"
AC_SUBST([PERSISTINCLUDE_DIR])
eval "eval INFO_DIR=$infodir"
AC_SUBST([INFO_DIR])
eval "eval MAN_DIR=$mandir"
AC_SUBST([MAN_DIR])

# Get full paths to source and build directories
srcdirfull="`cd $srcdir && pwd`"
builddir="`pwd`"

#
# Compute variables useful for running uninstalled software.
#
MAGICK_CODER_MODULE_PATH="${builddir}/coders"
MAGICK_CONFIGURE_SRC_PATH="${srcdirfull}/config"
MAGICK_CONFIGURE_BUILD_PATH="${builddir}/config"
MAGICK_FILTER_MODULE_PATH="${builddir}/filters"
DIRSEP=':'
case "${build_os}" in
    mingw* )
        MAGICK_CODER_MODULE_PATH=`$WinPathScript "${MAGICK_CODER_MODULE_PATH}" 0`
        MAGICK_CONFIGURE_SRC_PATH=`$WinPathScript "${MAGICK_CONFIGURE_SRC_PATH}" 0`
        MAGICK_CONFIGURE_BUILD_PATH=`$WinPathScript "${MAGICK_CONFIGURE_BUILD_PATH}" 0`
        MAGICK_FILTER_MODULE_PATH=`$WinPathScript "${MAGICK_FILTER_MODULE_PATH}" 0`
        DIRSEP=';'
    ;;
esac
case "${host_os}" in
  mingw* )
    DIRSEP=';'
    ;;
esac
AC_SUBST([MAGICK_CODER_MODULE_PATH])
AC_SUBST([MAGICK_CONFIGURE_SRC_PATH])
AC_SUBST([MAGICK_CONFIGURE_BUILD_PATH])
AC_SUBST([MAGICK_FILTER_MODULE_PATH])
AC_SUBST([DIRSEP])


#
# Enable OS features.
#
AC_USE_SYSTEM_EXTENSIONS

# ==============================================================================
# Find required base packages
# ==============================================================================
m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
AC_PROG_CC
AC_PROG_CXX
AC_PROG_CPP
LT_PATH_LD
AC_SUBST([LD])
AM_PROG_CC_C_O
AX_CFLAGS_WARN_ALL
AC_PROG_INSTALL
AC_PROG_MAKE_SET
AC_PROG_LN_S
AC_PROG_SED
AC_PROG_AWK
AC_PROG_MKDIR_P
AM_WITH_DMALLOC
AX_C___ATTRIBUTE__
AX_GCC_ARCHFLAG([yes])
PKG_PROG_PKG_CONFIG([0.20])
AC_CANONICAL_BUILD
AC_CANONICAL_HOST

AX_COMPILER_VENDOR

if test "x$GCC" = "xyes"; then
  CFLAGS="$CFLAGS -fexceptions"
  touch local.exp
else
  cat > local.exp <<EOF
set CC_FOR_TARGET "$CC"
EOF
fi

# Check for linker script support
gl_LD_VERSION_SCRIPT

#
# Enable run-time checking.
#
AC_ARG_ENABLE([bounds-checking],
    [AS_HELP_STRING([--enable-bounds-checking],
                    [enable run-time bounds-checking])],
    [enable_bounds_checking=$enableval],
    [enable_bounds_checking='no'])

if test "$enable_bounds_checking" = yes; then
  AC_DEFINE([_FORTIFY_SOURCE], [2],
    [enable run-time bounds-checking])
fi

#
# Tests for Windows
#
AC_EXEEXT
AC_OBJEXT

native_win32_build='no'
cygwin_build='no'
case "${host_os}" in
    cygwin* )
        cygwin_build='yes'
    ;;
    mingw* )
        native_win32_build='yes'
    ;;
esac
AM_CONDITIONAL([WIN32_NATIVE_BUILD],[test "${native_win32_build}" = 'yes'])
AM_CONDITIONAL([CYGWIN_BUILD],[test "${cygwin_build}" = 'yes'])

WinPathScript="${srcdirfull}/winpath.sh"
AC_SUBST([WinPathScript])

#
# Compiler flags tweaks
#
if test "${GCC}" != "yes"; then
    case "${host}" in
        *-*-hpux* )
            # aCC: HP ANSI C++ B3910B A.03.34
            CFLAGS="${CFLAGS} -Wp,-H30000"
            if test -n "${CXXFLAGS}"; then
                CXXFLAGS='-AA'
            else
                CXXFLAGS="${CXXFLAGS} -AA"
            fi
        ;;
        *-dec-osf5.* )
            # Compaq alphaev68-dec-osf5.1 compiler
            if test -n "${CXXFLAGS}"; then
                CXXFLAGS='-std strict_ansi -noimplicit_include'
            else
                CXXFLAGS="${CXXFLAGS} -std strict_ansi -noimplicit_include"
            fi
  esac
fi

# Check for lazy-loading.
AC_CACHE_CHECK([for linker lazyload option],[im_cv_ld_lazyload],
[
im_cv_ld_lazyload='none'
case "${host}" in
  *-*-solaris2.8 | *-*-solaris2.9 | *-*-solaris2.1? )
    if test "$lt_cv_prog_gnu_ld" != 'yes' ; then
       im_cv_ld_lazyload='-Wl,-zlazyload'
    fi
    ;;
esac
])
if test "${im_cv_ld_lazyload}" != 'none' ; then
  if test -z "${LDFLAGS}" ; then
    LDFLAGS="${im_cv_ld_lazyload}"
  else
    LDFLAGS="${im_cv_ld_lazyload} ${LDFLAGS}"
  fi
fi

dnl Platform-specific stuff
case "$host" in
  *darwin* | *-macos10*)
    dnl Disable FORTIFY_SOURCE to fix a bug in LVVM / OpenMP support
    CFLAGS="${CFLAGS} -D_FORTIFY_SOURCE=0"
    dnl OS X universal binary support, requires --disable-dependency-tracking
    AC_ARG_ENABLE([osx-universal-binary],
        AS_HELP_STRING([--enable-osx-universal-binary],
           [build universal binary on OS X [[default=no]]]),
        [build_osxuniversal="${enableval}"], [build_osxuniversal=no])

    if test "${build_osxuniversal}" != no ; then
      if test "$enable_dependency_tracking" != no ; then
        AC_MSG_ERROR([--enable-osx-universal-binary requires --disable-dependency-tracking.
Re-run configure with these options:
  --disable-dependency-tracking --enable-osx-universal-binary
        ])
      fi
      CFLAGS="$CFLAGS -isysroot /Developer/SDKs/MacOSX10.5.sdk -arch ppc -arch i386"
      CXXFLAGS="$CXXFLAGS -isysroot /Developer/SDKs/MacOSX10.5.sdk -arch ppc -arch i386"
      LDFLAGS="$LDFLAGS -Wl,-syslibroot,/Developer/SDKs/MacOSX10.5.sdk -arch ppc -arch i386"
  fi
  ;;
esac

#
# ARCH specific include directory
#
AC_ARG_WITH([includearch-dir],
    [AS_HELP_STRING([--with-includearch-dir=DIR],
                    [ARCH specific include directory @<:@INCLUDEDIR@:>@])],
                    [includearch_dir=$withval],
                    [includearch_dir=$INCLUDE_DIR])

eval "eval INCLUDEARCH_DIR=$includearch_dir"
AC_SUBST([INCLUDEARCH_DIR])

#
# ARCH specific configuration directory
#
AC_ARG_WITH([sharearch-dir],
    [AS_HELP_STRING([--with-sharearch-dir=DIR],
                    [ARCH specific config directory @<:@LIBDIR@:>@])],
                    [sharearch_dir=$withval],
                    [sharearch_dir="${LIB_DIR}"])

eval "eval SHAREARCH_DIR=$sharearch_dir"
AC_SUBST([SHAREARCH_DIR])

# Path to the pkgconfig folder
AC_ARG_WITH([pkgconfigdir], AS_HELP_STRING([--with-pkgconfigdir=DIR],
            [Path to the pkgconfig directory @<:@LIBDIR/pkgconfig@:>@]),
            [pkgconfigdir="$withval"], [pkgconfigdir='${libdir}/pkgconfig'])
AC_SUBST([pkgconfigdir])

#
# Enable support for POSIX thread APIs
#
AC_ARG_WITH([threads],
    [AS_HELP_STRING([--without-threads], [disable POSIX threads API support])],
    [with_threads=$withval],
    [with_threads='yes'])

THREAD_LIBS=''
have_threads=no
if test "$with_threads" != 'no'; then
    AX_PTHREAD()
    if test "$ax_pthread_ok" = yes; then
        have_threads=yes
        DEF_THREAD="$PTHREAD_CFLAGS"
        CFLAGS="$CFLAGS $DEF_THREAD"
        CXXFLAGS="$CXXFLAGS $DEF_THREAD"
        THREAD_LIBS="$PTHREAD_LIBS"
        if test "$CC" != "$PTHREAD_CC"; then
            AC_MSG_WARN([Replacing compiler $CC with compiler $PTHREAD_CC to support pthreads.])
            CC="$PTHREAD_CC"
        fi
        AC_DEFINE([THREAD_SUPPORT],[1],[Define if you have POSIX threads libraries and header files.])
    fi
fi
LIBS="$LIBS $THREAD_LIBS"
AC_SUBST([THREAD_LIBS])

# Enable support for OpenMP
if test "$have_threads" != 'yes'; then
  ac_cv_prog_c_openmp=unsupported
fi  
AC_OPENMP([C])
CFLAGS="$OPENMP_CFLAGS $CFLAGS"
MAGICK_PCFLAGS="$MAGICK_PCFLAGS $OPENMP_CFLAGS"
AC_SUBST([OPENMP_CFLAGS])
AC_CHECK_DECL([_OPENMP],[OPENMP_ENABLED='yes'],[OPENMP_ENABLED='no'],[])
if test "${OPENMP_ENABLED}" = 'yes' && \
   test "$ac_cv_prog_c_openmp" != 'unsupported'; then
    MAGICK_FEATURES="OpenMP $MAGICK_FEATURES"
fi

# Enable support for OpenCL
no_cl=yes
AX_HAVE_OPENCL([C])
if test "X$no_cl" != 'Xyes'; then
  CPPFLAGS="$CL_CPPFLAGS $CPPFLAGS"
  MAGICK_FEATURES="OpenCL $MAGICK_FEATURES"
fi

########
#
# Check for large file support
#
########
AC_SYS_LARGEFILE
AC_FUNC_FSEEKO
LFS_CPPFLAGS=''
if test "$enable_largefile" != no; then
    case $ac_cv_sys_file_offset_bits in
    no)
        # nothing to do here as the host supports LFS fine
        ;;
    unknown)
        AC_MSG_CHECKING([for native large file support])
        AC_RUN_IFELSE([AC_LANG_PROGRAM([#include <unistd.h>
          #include <stdlib.h>
          int main () {
          exit(!(sizeof(off_t) == 8));
        }])],
        [ac_cv_sys_file_offset_bits=64; AC_DEFINE(_FILE_OFFSET_BITS,64)
         AC_MSG_RESULT([yes])],
        [AC_MSG_RESULT([no])])
        ;;
    *)
        if test "$ac_cv_sys_file_offset_bits" = ''; then
            ac_cv_sys_file_offset_bits=64;
        fi
        LFS_CPPFLAGS="$LFS_CPPFLAGS -D_FILE_OFFSET_BITS=$ac_cv_sys_file_offset_bits"
        ;;
    esac
    if test "$ac_cv_sys_large_files" != 'no'; then
        LFS_CPPFLAGS="$LFS_CPPFLAGS -D_LARGE_FILES=1"
    fi
    if test "$ac_cv_sys_largefile_source" != 'no'; then
        LFS_CPPFLAGS="$LFS_CPPFLAGS -D_LARGEFILE_SOURCE=1"
    fi
fi
AC_SUBST([LFS_CPPFLAGS])

#
# Check for sendfile support
#
########
AC_CACHE_CHECK([Linux compatible sendfile()],ac_cv_have_linux_sendfile,[
  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
    #undef _FILE_OFFSET_BITS
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <sys/sendfile.h>
  ], [
    sendfile(0, 0, (void *) 0, 0);
  ])], [
    ac_cv_have_linux_sendfile=yes
  ], [
    ac_cv_have_linux_sendfile=no
  ])])
if test "$ac_cv_have_linux_sendfile" = 'yes'; then
  AC_DEFINE([HAVE_LINUX_SENDFILE],[1], [Define if you have Linux-compatible sendfile()])
fi

#
# Set SETJMP_IS_THREAD_SAFE define.
#
case "${host_os}" in
  solaris2* ) ;;
  *) AC_DEFINE([SETJMP_IS_THREAD_SAFE],[1],[Setjmp/longjmp are thread safe]) ;;
esac

# Configure libtool
: ${AR_FLAGS=cr}
LT_INIT([win32-dll dlopen])
LT_LANG([C++])
AC_SUBST([LIBTOOL_DEPS])

# Check to see if building shared libraries
libtool_build_shared_libs='no'
if test "$enable_shared" = 'yes'; then
    libtool_build_shared_libs='yes'
fi

# Check to see if building static libraries
libtool_build_static_libs='no'
if test "$enable_static" = 'yes'; then
    libtool_build_static_libs='yes'
fi

AM_CONDITIONAL([WITH_SHARED_LIBS],[test "${libtool_build_shared_libs}" = 'yes'])
#
# Enable support for building loadable modules
#
build_modules='no'
AC_ARG_WITH([modules],
    [AS_HELP_STRING([--with-modules],
                    [enable building dynamically loadable modules])],
    [with_modules=$withval],
    [with_modules='no'])

# Only allow building loadable modules if we are building shared libraries
if test "$with_modules" != 'no' ; then
    if test "$libtool_build_shared_libs" = 'no'; then
        AC_MSG_WARN([Modules may only be built if building shared libraries is enabled.])
    build_modules='no'
  else
    build_modules='yes'
  fi
fi
if test "$build_modules" != 'no' ; then
    AC_DEFINE([BUILD_MODULES],[1],[Define if coders and filters are to be built as modules.])
    MAGICK_FEATURES="Modules $MAGICK_FEATURES"
fi
AM_CONDITIONAL([WITH_MODULES],[test "$build_modules" != 'no'])

# Enable build using delegate libraries built in subdirectories rather than installed
# delegate libraries (bzlib fftw fpx gslib jp2 jbig jpeg lcms lzma png tiff ttf uhdr wmf xml zlib zip)
AC_ARG_ENABLE([delegate-build],
    [AS_HELP_STRING([--enable-delegate-build],
                    [look for delegate libraries in build directory])],
    [enable_delegate_build=$enableval],
    [enable_delegate_build='no'])

AC_ARG_ENABLE([deprecated],
    [AS_HELP_STRING([--disable-deprecated],
                    [exclude deprecated methods in MagickCore and MagickWand APIs])],
    [enable_deprecated=$enableval],
    [enable_deprecated='no'])

if test "$enable_deprecated" = 'yes'; then
  AC_DEFINE([EXCLUDE_DEPRECATED],[1],[exclude deprecated methods in MagickCore API])
else
  DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --disable-deprecated "
fi

# Build a version of ImageMagick which operates uninstalled.
# Used to build distributions located via MAGICK_HOME / executable path
AC_ARG_ENABLE([installed],
    [AS_HELP_STRING([--disable-installed],
                    [Formally install ImageMagick under PREFIX])],
    [enable_installed=$enableval],
    [enable_installed='yes'])

if test "$enable_installed" = 'yes'; then
    AC_DEFINE([INSTALLED_SUPPORT],[1],[ImageMagick is formally installed under prefix])
else
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --disable-installed "
fi

# Build a zero-configuration version of ImageMagick.
AC_ARG_ENABLE([zero-configuration],
    [AS_HELP_STRING([--enable-zero-configuration],
                    [enable self-contained, embeddable, zero-configuration ImageMagick])],
    [enable_zero_configuration=$enableval],
    [enable_zero_configuration='no'])

if test "$enable_zero_configuration" = 'yes'; then
    AC_DEFINE([ZERO_CONFIGURATION_SUPPORT],[1],[Build self-contained, embeddable, zero-configuration ImageMagick])
    MAGICK_FEATURES="Zero-configuration $MAGICK_FEATURES"
fi
AM_CONDITIONAL([MAGICKCORE_ZERO_CONFIGURATION_SUPPORT],[test "$enable_zero_configuration" = yes])

#
# Build a high dynamic range version of ImageMagick.
#
AC_ARG_ENABLE([hdri],
    [AS_HELP_STRING([--enable-hdri],
                    [accurately represent the wide range of intensity levels found in real scenes])],
    [enable_hdri=$enableval],
    [enable_hdri='yes'])

MAGICK_HDRI=""
if test "$enable_hdri" = 'yes'; then
    MAGICK_HDRI="HDRI"
    magick_hdri_enable='1';
    MAGICK_FEATURES="HDRI $MAGICK_FEATURES"
else
    magick_hdri_enable='0'
fi
AC_SUBST([MAGICK_HDRI])dnl
MAGICK_PCFLAGS="$MAGICK_PCFLAGS -DMAGICKCORE_HDRI_ENABLE=$magick_hdri_enable"
CFLAGS="$CFLAGS -DMAGICKCORE_HDRI_ENABLE=$magick_hdri_enable"
CPPFLAGS="$CPPFLAGS -DMAGICKCORE_HDRI_ENABLE=$magick_hdri_enable"

#
# Support the distributed pixel cache.
#
AC_ARG_ENABLE([dpc],
    [AS_HELP_STRING([--disable-dpc],
                    [disable distributed pixel cache support])],
    [enable_dpc=$enableval],
    [enable_dpc='yes'])

if test "$enable_dpc" = 'yes'; then
    AC_DEFINE([DPC_SUPPORT],[1],[Define to 1 to enable distributed pixel cache support.])
    MAGICK_FEATURES="DPC $MAGICK_FEATURES"
fi

# Enable pipes (|) in filenames.
AC_ARG_ENABLE([pipes],
    [AS_HELP_STRING([--enable-pipes],
                    [enable pipes (|) in filenames. Be sure to properly validate and sanitize user input to prevent malicious behaviors.])],
    [enable_pipes=$enableval],
    [enable_pipes='no'])

if test "$enable_pipes" = 'yes'; then
    AC_DEFINE([PIPES_SUPPORT],[1],[enable pipes (|) in filenames])
    MAGICK_FEATURES="Pipes $MAGICK_FEATURES"
fi

# Don't emit "rebuild rules" for configure, Makefile.ins, etc.
AM_MAINTAINER_MODE

# Enable hugepages support
AC_ARG_ENABLE([hugepages],
    [AS_HELP_STRING([--enable-hugepages],
                    [enable 'huge pages' support])],
    [enable_hugepages=$enableval],
    [enable_hugepages='no'])

# Enable ccmalloc memory debugging support
AC_ARG_ENABLE([ccmalloc],
    [AS_HELP_STRING([--enable-ccmalloc],
                    [enable 'ccmalloc' memory debug support])],
    [enable_ccmalloc=$enableval],
    [enable_ccmalloc='no'])

# Enable Electric Fence memory debugging support
AC_ARG_ENABLE([efence],
    [AS_HELP_STRING([--enable-efence],
                    [enable 'efence' memory debug support])],
    [enable_efence=$enableval],
    [enable_efence='no'])

# Enable prof-based profiling support
AC_ARG_ENABLE([prof],
    [AS_HELP_STRING([--enable-prof],
                    [enable 'prof' profiling support])],
    [enable_prof=$enableval],
    [enable_prof='no'])

# Enable gprof-based profiling support
AC_ARG_ENABLE([gprof],
    [AS_HELP_STRING([--enable-gprof],
                    [enable 'gprof' profiling support])],
    [enable_gprof=$enableval],
    [enable_gprof='no'])

# Enable gcov-based profiling support
AC_ARG_ENABLE([gcov],
    [AS_HELP_STRING([--enable-gcov],
                    [enable 'gcov' profiling support])],
    [enable_gcov=$enableval],
    [enable_gcov='no'])

enable_profiling='no'
if test "$enable_prof" = 'yes' || test "$enable_gprof" = 'yes' || test "$enable_gcov" = 'yes'; then
    enable_profiling='yes'
    if test "$libtool_build_shared_libs" = 'yes'; then
        echo "Warning: Can not profile code using shared libraries"
    fi
fi

# Magick API method prefix
AC_ARG_WITH([method-prefix],
    [AS_HELP_STRING([--with-method-prefix=PREFIX],
                    [prefix MagickCore API methods])],
    [with_method_prefix=$withval],
    [with_method_prefix='no'])

if test "$with_method_prefix" != 'no'; then
    AC_DEFINE_UNQUOTED([NAMESPACE_PREFIX],[$with_method_prefix],[Magick API method prefix])
    AC_DEFINE_UNQUOTED([NAMESPACE_PREFIX_TAG],[$with_method_prefix],[Magick API method prefix tag])
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-method-prefix "
fi

# Enable legacy support (default no)
AC_ARG_ENABLE([legacy-support],
              [  --enable-legacy-support install legacy command-line utilities (default disabled)],
              [with_legacy_support=$enableval],
              [with_legacy_support='no'])
AM_CONDITIONAL([LEGACY_SUPPORT],[test "$with_legacy_support" != 'no'])

# Enable building command line utilities (default yes)
AC_ARG_WITH([utilities],
            [  --with-utilities	enable building command-line utilities (default yes)],
            [with_utilities=$withval], [with_utilities='yes'])
AM_CONDITIONAL([WITH_UTILITIES],[test "$with_utilities" = 'yes'])

# Number of bits in a Quantum
AC_ARG_WITH([quantum-depth],
    [AS_HELP_STRING([--with-quantum-depth=DEPTH],
                    [number of bits in a pixel quantum (default 16)])],
    [with_quantum_depth=$withval],
    [with_quantum_depth=16])

if test "$with_quantum_depth" != '8'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-quantum-depth=$with_quantum_depth "
fi

case "${with_quantum_depth}" in
    8 ) ;;
    16 ) ;;
    32 ) ;;
    64 ) ;;
    * ) AC_MSG_ERROR("Pixel quantum depth must have value of 8, 16, 32, or 64") ;;
esac
QUANTUM_DEPTH="$with_quantum_depth"
AC_DEFINE_UNQUOTED([QUANTUM_DEPTH_OBSOLETE_IN_H],[$QUANTUM_DEPTH],[Number of bits in a pixel Quantum (8/16/32/64)])
AC_SUBST([QUANTUM_DEPTH])dnl
MAGICK_PCFLAGS="$MAGICK_PCFLAGS -DMAGICKCORE_QUANTUM_DEPTH=$QUANTUM_DEPTH"
CFLAGS="$CFLAGS -DMAGICKCORE_QUANTUM_DEPTH=$QUANTUM_DEPTH"
CPPFLAGS="$CPPFLAGS -DMAGICKCORE_QUANTUM_DEPTH=$QUANTUM_DEPTH"

# define a lib suffix for abi purpose
MAGICK_ABI_SUFFIX="Q${QUANTUM_DEPTH}"
if test "$enable_hdri" = 'yes'; then
  MAGICK_ABI_SUFFIX="Q${QUANTUM_DEPTH}${MAGICK_HDRI}"
fi
AC_SUBST([MAGICK_ABI_SUFFIX])

# Set pixel cache threshold
AC_ARG_WITH([cache],
    [AS_HELP_STRING([--with-cache=THRESHOLD],
                    [set pixel cache memory threshold (default available memory)])],
    [with_cache=$withval],
    [with_cache=''])

if test "$with_cache" != ''; then
    AC_DEFINE_UNQUOTED([PixelCacheThreshold],["$with_cache"],[Pixel cache memory threshold (defaults to available memory)])
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-cache=$with_cache "
fi

# Set security policy
security_policy="open"
m4_define([_MAGICK_SECURITY_POLICY],
[m4_define([MAGICK_SECURITY_POLICY_DEFAULT], [m4_if($1, limited, limited, m4_if($1, secure, secure, open))])dnl
  AC_MSG_CHECKING([which variant of security policy to enforce])
  AC_ARG_WITH([security-policy],
    [AS_HELP_STRING([--with-security-policy=open|limited|secure|websafe],
      [security policy variant to enforce, @<:@default=]MAGICK_SECURITY_POLICY_DEFAULT[@:>@.])],
    [case $withval in
    open|limited|secure|websafe)
      security_policy=$withval
      ;;
    *)
      AC_MSG_ERROR([Unknown argument to --with-security-policy])
      ;;
    esac
    magick_cv_with_security_policy=$security_policy],
    [AC_CACHE_VAL([magick_cv_with_security_policy],
      [magick_cv_with_security_policy=]MAGICK_SECURITY_POLICY_DEFAULT)
    MAGICK_SECURITY_POLICY=$magick_cv_with_security_policy])
  AC_MSG_RESULT([$security_policy])
]) # MAGICK_SECURITY_POLICY

_MAGICK_SECURITY_POLICY([open])
AC_SUBST([MAGICK_SECURITY_POLICY])

# Disable/Enable support for full delegate paths
AC_ARG_WITH([frozenpaths],
    [AS_HELP_STRING([--with-frozenpaths],
                    [freeze delegate paths])],
    [with_frozenpaths=$withval],
    [with_frozenpaths='no'])

# Enable build/install of Magick++
AC_ARG_WITH([magick-plus-plus],
    [AS_HELP_STRING([--without-magick-plus-plus],
                    [disable build/install of Magick++])],
    [with_magick_plus_plus=$withval],
    [with_magick_plus_plus='yes'])

# Encode the this name into the shared library.
AC_ARG_WITH([package-release-name],
    [AS_HELP_STRING([--with-package-release-name=NAME],
                    [encode this name into the shared library])],
[MAGICK_LT_RELEASE_OPTS="-release $withval"])
AC_SUBST([MAGICK_LT_RELEASE_OPTS])

# Disable build/install of PerlMagick.
AC_ARG_WITH([perl],
    [AS_HELP_STRING([--with-perl],
                    [enable build/install of PerlMagick])],
    [with_perl=$withval],
    [with_perl='no'])

# Options to pass when configuring PerlMagick
AC_ARG_WITH([perl-options],
    [AS_HELP_STRING([--with-perl-options=OPTIONS],
                    [options to pass on command-line when generating PerlMagick build file])],
PERL_MAKE_OPTIONS=$withval)
AC_SUBST([PERL_MAKE_OPTIONS])

# Enable jemalloc, object-caching memory allocation library.
AC_ARG_WITH([jemalloc],
        [  --with-jemalloc         enable jemalloc memory allocation library support],
        [with_jemalloc=$withval],
        [with_jemalloc='no'])
if test "$with_jemalloc" != 'yes' ; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-jemalloc=$with_jemalloc "
fi

# Enable use of MTMalloc library.
AC_ARG_WITH([mtmalloc],
   AS_HELP_STRING([--with-mtmalloc],
                  [enable mtmalloc memory allocation library support]),
   [with_mtmalloc=$withval],
   [with_mtmalloc='no'])
if test "$with_mtmalloc" != 'no' ; then
   DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-mtmalloc=$with_mtmalloc "
fi

# Enable use of TCMalloc library.
AC_ARG_WITH([tcmalloc],
   AS_HELP_STRING([--with-tcmalloc],
                  [enable tcmalloc memory allocation library support]),
   [with_tcmalloc=$withval],
   [with_tcmalloc='no'])
if test "$with_tcmalloc" != 'no' ; then
   DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-tcmalloc=$with_tcmalloc "
fi

# Enable umem, object-caching memory allocation library.
AC_ARG_WITH([umem],
        [  --with-umem             enable umem memory allocation library support],
        [with_umem=$withval],
        [with_umem='no'])
if test "$with_umem" != 'yes' ; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-umem=$with_umem "
fi

#
# Specify path to shared libstdc++ if not in normal location
#
AC_ARG_WITH([libstdc],
    [AS_HELP_STRING([--with-libstdc=DIR],
                    [ use libstdc++ in DIR (for GNU C++)])],
    [with_libstdc=$withval],
    [with_libstdc=''])

if test "$with_libstdc" != ''; then
    if test -d "$with_libstdc"; then
        LIBSTDCLDFLAGS="-L$with_libstdc"
    fi
fi
AC_SUBST([LIBSTDCLDFLAGS])

########
#
# Set defines required to build DLLs and modules using MinGW
#
########
# These options are set for multi-thread DLL module build
#  libMagickCore:           _DLL _MAGICKMOD_ _MAGICKLIB_
#  module:              _DLL
#  executable/Magick++: _DLL _MAGICKMOD_
MODULE_EXTRA_CPPFLAGS=''
LIBRARY_EXTRA_CPPFLAGS=''
if test "${native_win32_build}" = 'yes'; then
    if test "${libtool_build_shared_libs}" = 'yes'; then
        CPPFLAGS="$CPPFLAGS -D_DLL"
        MAGICK_CPPFLAGS="$MAGICK_CPPFLAGS -D_DLL"
        MAGICK_PCFLAGS="$MAGICK_PCFLAGS -D_DLL"
        LIBRARY_EXTRA_CPPFLAGS="$LIBRARY_EXTRA_CPPFLAGS -D_MAGICKLIB_"
        if test "$build_modules" = 'yes'; then
            LIBRARY_EXTRA_CPPFLAGS="$LIBRARY_EXTRA_CPPFLAGS -D_MAGICKMOD_"
        else
            MODULE_EXTRA_CPPFLAGS="$MODULE_EXTRA_CPPFLAGS -D_MAGICKLIB_"
        fi
    else
        CPPFLAGS="$CPPFLAGS -D_LIB"
        MAGICK_CPPFLAGS="$MAGICK_CPPFLAGS -D_LIB"
        MAGICK_PCFLAGS="$MAGICK_PCFLAGS -D_LIB"
    fi
    if test "$with_threads" = 'yes'; then
         CPPFLAGS="$CPPFLAGS -D_MT"
         MAGICK_CPPFLAGS="$MAGICK_CPPFLAGS -D_MT"
         MAGICK_PCFLAGS="$MAGICK_PCFLAGS -D_MT"
    fi
fi
AC_SUBST([MODULE_EXTRA_CPPFLAGS])
AC_SUBST([LIBRARY_EXTRA_CPPFLAGS])

# Check standard headers
AC_HEADER_ASSERT
AC_HEADER_DIRENT

# Check additional headers
AC_CHECK_HEADERS(arm/limits.h arpa/inet.h complex.h errno.h fcntl.h float.h inttypes.h limits.h linux/unistd.h locale.h machine/param.h mach-o/dyld.h malloc.h netdb.h netinet/in.h OS.h process.h sun_prefetch.h stdarg.h stddef.h stdint.h strings.h sys/ipc.h sys/mman.h sys/resource.h sys/sendfile.h sys/socket.h sys/syslimits.h sys/time.h sys/times.h sys/uio.h unistd.h sys/wait.h utime.h wchar.h xlocale.h)

########
#
# Checks for typedefs, structures, and compiler characteristics.
#
########

AC_HEADER_STDBOOL
AC_C_VOLATILE
AC_C_STRINGIZE
AC_HEADER_STAT
AC_STRUCT_TM
AC_STRUCT_TIMEZONE
AC_SYS_INTERPRETER

#
# Checks for language qualifiers and semantics.
#
AC_C_CHAR_UNSIGNED
AC_C_CONST
AC_C_INLINE
AC_C_RESTRICT
AC_C_VOLATILE

# If words are stored with the most significant byte first (like
# Motorola and SPARC CPUs), define `WORDS_BIGENDIAN'.
AC_C_BIGENDIAN

# Define to a suitable type, if standard headers do not define it.
AC_TYPE_INT8_T
AC_TYPE_INT16_T
AC_TYPE_INT32_T
AC_TYPE_INT64_T
AC_TYPE_INTMAX_T
AC_TYPE_INTPTR_T
AC_TYPE_MBSTATE_T
AC_TYPE_MODE_T
AC_TYPE_OFF_T
AC_TYPE_PID_T
AC_TYPE_SIZE_T
AC_TYPE_SSIZE_T
AC_TYPE_UID_T
AC_TYPE_UINT8_T
AC_TYPE_UINT16_T
AC_TYPE_UINT32_T
AC_TYPE_UINT64_T
AC_TYPE_UINTMAX_T
AC_TYPE_UINTPTR_T

# Float_t and double_t are intended to be the most efficient type.
AC_CHECK_SIZEOF([float_t], [], [[#include <math.h>]])
AC_CHECK_SIZEOF([double_t], [], [[#include <math.h>]])

# Get size of float, double and long double for comparison.
AC_CHECK_SIZEOF([float])
AC_CHECK_SIZEOF([double])
AC_CHECK_SIZEOF([long double])

# Obtain size of a 'unsigned long long' and define as
# SIZEOF_UNSIGNED_LONG_LONG.  If 'unsigned long long' is not
# supported then the value defined is zero.
AC_CHECK_SIZEOF([unsigned long long])
AC_CHECK_SIZEOF([size_t])

AC_CHECK_SIZEOF([void *])

#
# Check for __func__ support
#
########
AC_MSG_CHECKING([whether our compiler supports __func__])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
 [{ const char *func = __func__; return(func != 0 ? 0 : 1); }],
 AC_MSG_RESULT([yes]),
 AC_MSG_RESULT([no])
 AC_MSG_CHECKING([whether our compiler supports __FUNCTION__])
 AC_COMPILE_IFELSE([],
   [{ const char *func = __FUNCTION__; return(func != 0 ? 0 : 1); }],
   AC_MSG_RESULT([yes])
   AC_DEFINE(__func__, __FUNCTION__,
     [Define to appropriate substitute if compiler does not have __func__]),
   AC_MSG_RESULT([no])
   AC_DEFINE(__func__, __FILE__,
     [Define to appropriate substitute if compiler does not have __func__])))])

########
#
# Check for functions
#
########
AC_FUNC_MMAP
AC_FUNC_STRTOD
AC_FUNC_STRERROR_R

#
# Find math library
#
MATH_LIBS=''
AC_CHECK_LIB([m],[sqrt],[MATH_LIBS="-lm"],[])
LIBS="$MATH_LIBS $LIBS"
AC_SUBST([MATH_LIBS])

#
# Find socket library
#
AC_SEARCH_LIBS(gethostbyname, resolv nsl)
AC_SEARCH_LIBS(socket, socket,
[
  AC_DEFINE([HAVE_SOCKET],[1],[Define to 1 if you have socket support.])
])

#
# Check for clock_gettime().
#
AC_SEARCH_LIBS(clock_gettime, rt,
[
  AC_DEFINE([HAVE_CLOCK_GETTIME],[1],[Define to 1 if you have clock_gettime.])
  AC_MSG_CHECKING([whether clock_gettime supports CLOCK_REALTIME])
  AC_COMPILE_IFELSE([
    AC_LANG_PROGRAM(
      [[#include <time.h>]],
       [[clockid_t clockType = CLOCK_REALTIME;]])],
      [
        AC_MSG_RESULT([yes])
        AC_DEFINE([HAVE_CLOCK_REALTIME],[1],
          [Define to 1 if clock_gettime supports CLOCK_REALTIME.])
      ],
      AC_MSG_RESULT([no])
    )
  ],
  [
    AC_CHECK_FUNCS([gettimeofday ftime], [break])
  ]
)

########
#
# Check for function prototypes
#
########

AC_CHECK_DECLS([pread, pwrite],[],[],[
#include <unistd.h>])

AC_CHECK_DECLS([strlcpy],[],[],[
#include <strings.h>])

AC_CHECK_DECLS([vsnprintf],[],[],[
#include <stdio.h>
#include <stdarg.h>])

########
#
# C++ Support Tests (For Magick++)
#
########
have_magick_plus_plus='no'
if test "$with_magick_plus_plus" = 'yes'; then
    OLIBS="$LIBS"
    LIBS=''
    AC_LANG_PUSH([C++])

    # Full set of headers used...
    # algorithm cctype cerrno cmath cstdio cstdlib cstring ctime exception
    # functional iomanip iosfwd iostream iterator list string strstream utility
    AC_LANG([C++])
    AC_PROG_CXX
    AX_CXX_BOOL
    AX_CXX_NAMESPACES
    AX_CXX_NAMESPACE_STD
    AC_OPENMP([C++])
    AC_LANG_POP

    AC_MSG_CHECKING([whether C++ compiler is sufficient for Magick++])
    if \
        test $ax_cv_cxx_bool = 'yes' && \
        test $ax_cv_cxx_namespaces = 'yes' && \
        test $ax_cv_cxx_have_std_namespace = 'yes'; then
        have_magick_plus_plus='yes'
    else
        have_magick_plus_plus='no (failed tests)'
    fi
    AC_MSG_RESULT([$have_magick_plus_plus])
    LIBS="$OLIBS"
fi
AM_CONDITIONAL([WITH_MAGICK_PLUS_PLUS],[test "$have_magick_plus_plus" = 'yes'])

# Only check for delegate libraries in subdirectories if requested.
if test "$enable_delegate_build" != 'no'; then
    # Check for delegate sub-directories and add -I & -L options as required.
    # This presumes that delegates are installed as detailed in the ImageMagick
    # README. If delegates are installed in a standard location where the
    # compiler will automatically find them then these options should not be
    # required.

    #
    # Most delegates have includes in the same directory as the library, but not all...
    #
    # Includes
    for dir in bzlib fftw fpx gslib/src jp2 jbig/libjbig jpeg lcms/include lzma magick openjp2/include png tiff/libtiff ttf/include uhdr wand webp/src wmf/include xml/include zlib zip; do
        if test -d "$builddir/$dir"; then
            CPPFLAGS="$CPPFLAGS -I$builddir/$dir"
        else
            if test -d "$srcdirfull/$dir"; then
                CPPFLAGS="$CPPFLAGS -I$srcdirfull/$dir"
            fi
        fi
    done

    # Libraries
    for dir in bzlib fftw fpx gslib/src jbig/libjbig jpeg lcms/src lzma magick openjp2 png tiff/libtiff ttf/objs uhdr wand webp wmf/src xml zlib zip; do
    if test -d "$builddir/$dir/.libs"; then
        LDFLAGS="$LDFLAGS -L$builddir/$dir/.libs"
    else
        if test -d "$srcdirfull/$dir/.libs"; then
            LDFLAGS="$LDFLAGS -L$srcdirfull/$dir/.libs"
        fi
    fi
    if test -d "$builddir/$dir"; then
        LDFLAGS="$LDFLAGS -L$builddir/$dir"
    else
        if test -d "$srcdirfull/$dir"; then
            LDFLAGS="$LDFLAGS -L$srcdirfull/$dir"
        fi
    fi
  done
fi

# Assume that delegate headers reside under same directory as ImageMagick
# installation prefix.
MAGICK_CPPFLAGS="-I$INCLUDE_DIR/${PACKAGE_NAME}-$MAGICK_MAJOR_VERSION $MAGICK_CPPFLAGS"

#
# Find the X11 RGB database
#
AC_CACHE_CHECK([for X11 configure files],[im_cv_x_configure],
[# Look for the header file in a standard set of common directories.
# Check X11 before X11Rn because it is often a symlink to the current release.
    for ac_dir in          \
    /lib/usr/lib/X11       \
    /usr/X11/lib           \
    /usr/X11R4/lib         \
    /usr/X11R5/lib         \
    /usr/X11R6/lib         \
    /usr/X11R7/lib         \
    /usr/X386/lib          \
    /usr/XFree86/lib/X11   \
    /usr/athena/lib        \
    /usr/lib               \
    /usr/lib/X11           \
    /usr/lib/X11R4         \
    /usr/lib/X11R5         \
    /usr/lib/X11R6         \
    /usr/lib/X11R7         \
    /usr/local/X11/lib     \
    /usr/local/X11R4/lib   \
    /usr/local/X11R5/lib   \
    /usr/local/X11R6/lib   \
    /usr/local/lib         \
    /usr/local/lib/X11     \
    /usr/local/lib/X11R4   \
    /usr/local/lib/X11R5   \
    /usr/local/lib/X11R6   \
    /usr/local/lib/X11R7   \
    /usr/local/x11r5/lib   \
    /usr/lpp/Xamples/lib   \
    /usr/openwin/lib       \
    /usr/openwin/share/lib \
    /usr/unsupported/lib   \
    /usr/x386/lib          \
    ; do
    if test -f "$ac_dir/X11/rgb.txt"; then
      im_cv_x_configure="$ac_dir/X11/"
      break
    elif test -f "$ac_dir/rgb.txt"; then
      im_cv_x_configure="$ac_dir/"
      break
    fi

  done])
X11_CONFIGURE_PATH="$im_cv_x_configure"
case "${build_os}" in
  mingw* )
    X11ConfigurePath=`$WinPathScript "$X11ConfigurePath=" 1`
  ;;
esac
AC_DEFINE_UNQUOTED([X11_CONFIGURE_PATH],["$X11ConfigurePath"],[Location of X11 configure files])

#
# Find OpenMP library
#
GOMP_LIBS=''
if test "${OPENMP_ENABLED}" = 'yes'; then
  AC_CHECK_HEADER([omp.h], [], [AC_MSG_RESULT([OpenMP header file not found])])
  if test "${GCC}" = "yes"; then
    # Open64 (passes for GCC but uses different OpenMP implementation)
    if test "x$GOMP_LIBS" = x ; then
      if $CC --version 2>&1 | grep Open64 > /dev/null ; then
        AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include <omp.h>], [
          omp_set_num_threads(1);])],[GOMP_LIBS="-lopenmp"],[])
      fi
    fi
    # Clang (passes for GCC but uses different OpenMP implementation)
    if test "x$GOMP_LIBS" = x ; then
      if $CC --version 2>&1 | grep clang > /dev/null ; then
        AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include <omp.h>], [
          omp_set_num_threads(1);])],[GOMP_LIBS="-lomp"],[])
      fi
    fi
    # GCC
    if test "x$GOMP_LIBS" = x ; then
      AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include <omp.h>], [
        omp_set_num_threads(1);])],[GOMP_LIBS="-lgomp"],[])
    fi
  else
    # Sun CC
    if test "x$GOMP_LIBS" = x ; then
      AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include <omp.h>], [
        omp_set_num_threads(1);])],[GOMP_LIBS="-lmtsk"],[])
    fi
    # AIX xlc
    if test "x$GOMP_LIBS" = x ; then
      AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include <omp.h>], [
        omp_set_num_threads(1);])],[GOMP_LIBS="-lxmlsmp"],[])
    fi
    # SGI IRIX 6.5 MIPSpro C/C++
    if test "x$GOMP_LIBS" = x ; then
      AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([#include <omp.h>], [
        omp_set_num_threads(1);])],[GOMP_LIBS="-lmp"],[])
    fi
  fi
  AC_MSG_CHECKING([for OpenMP library ])
  if test "x$GOMP_LIBS" = x ; then
    AC_MSG_RESULT([not found!])
  else
    AC_MSG_RESULT([${GOMP_LIBS}])
  fi
fi
AC_SUBST([GOMP_LIBS])

#
# Check for jemalloc.
#
have_jemalloc='no'
JEMALLOC_LIBS=''
if test "$with_jemalloc" != 'no'; then
  AC_MSG_CHECKING([for JEMALLOC support])
  AC_MSG_RESULT([])
  failed=0
  passed=0
  AC_CHECK_HEADER([jemalloc/jemalloc.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
  AC_CHECK_LIB([jemalloc],[malloc_stats_print],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])
  AC_MSG_CHECKING([if jemalloc memory allocation library is complete])
  if test $passed -gt 0; then
    if test $failed -gt 0; then
      AC_MSG_RESULT([no -- some components failed test])
      have_jemalloc='no (failed tests)'
    else
      JEMALLOC_LIBS='-ljemalloc'
      LIBS="$JEMALLOC_LIBS $LIBS"
      AC_DEFINE([HAVE_JEMALLOC],[1],[Define if you have jemalloc memory allocation library])
      AC_MSG_RESULT([yes])
      have_jemalloc='yes'
    fi
  else
    AC_MSG_RESULT([no])
  fi
fi
AM_CONDITIONAL([HAVE_JEMALLOC],[test "$have_jemalloc" = 'yes'])
AC_SUBST([JEMALLOC_LIBS])

#
# Check for MTMalloc library
#
have_mtmalloc='no'
MTMALLOC_LIBS=''
OLIBS="$LIBS"
if test "$have_threads" = 'yes' -a "$with_mtmalloc" != 'no'; then
    AC_MSG_CHECKING([mtmalloc library support])
    AC_MSG_RESULT([])
    failed=0
    passed=0

    AC_CHECK_HEADER([mtmalloc.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])
    AC_CHECK_LIB([mtalloc],[mallocctl],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])

    if test $passed -gt 0; then
        if test $failed -gt 0; then
            have_mtmalloc='no (some components failed test)'
        else
            MTMALLOC_LIBS=-lmtalloc
            LIBS="$MTMALLOC_LIBS $LIBS"
            CFLAGS="$CFLAGS -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free"
            AC_DEFINE([HAVE_MTMALLOC],[1],[Define if you have the mtmalloc memory allocation library])
            have_mtmalloc='yes'
        fi
    fi
    AC_MSG_CHECKING([if mtmalloc memory allocation library is complete])
    AC_MSG_RESULT([$have_mtmalloc])
fi
AM_CONDITIONAL([HAVE_MTMALLOC],[test "$have_mtmalloc" = 'yes'])
AC_SUBST([MTMALLOC_LIBS])

#
# Check for TCMalloc library
#
have_tcmalloc='no'
TCMALLOC_LIBS=''
OLIBS="$LIBS"
if test "$have_threads" = 'yes' -a "$with_tcmalloc" != 'no'; then
    AC_MSG_CHECKING([tcmalloc library support])
    AC_MSG_RESULT([])
    failed=0
    passed=0

    AC_CHECK_LIB([tcmalloc_minimal],[mallinfo],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])

    if test $passed -gt 0; then
        if test $failed -gt 0; then
            have_tcmalloc='no (some components failed test)'
        else
            TCMALLOC_LIBS=-ltcmalloc_minimal
            LIBS="$TCMALLOC_LIBS $LIBS"
            CFLAGS="$CFLAGS -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free"
            AC_DEFINE([HAVE_TCMALLOC],[1],[Define if you have the tcmalloc memory allocation library])
            have_tcmalloc='yes'
        fi
    fi
    AC_MSG_CHECKING([if tcmalloc memory allocation library is complete])
    AC_MSG_RESULT([$have_tcmalloc])
fi
AM_CONDITIONAL([HAVE_TCMALLOC],[test "$have_tcmalloc" = 'yes'])
AC_SUBST([TCMALLOC_LIBS])

#
# Check for umem.
#
have_umem='no'
UMEM_LIBS=''
if test "$with_umem" != 'no'; then
  AC_MSG_CHECKING([for UMEM support])
  AC_MSG_RESULT([])
  failed=0
  passed=0
  AC_CHECK_HEADER([umem.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
  AC_CHECK_LIB([umem],[umem_alloc],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])

  AC_CHECK_LIB([umem],[umem_free],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])

  AC_MSG_CHECKING([if umem memory allocation library is complete])
  if test $passed -gt 0; then
    if test $failed -gt 0; then
      AC_MSG_RESULT([no -- some components failed test])
      have_umem='no (failed tests)'
    else
      UMEM_LIBS='-lumem'
      LIBS="$UMEM_LIBS $LIBS"
      AC_DEFINE([HAVE_UMEM],[1],[Define if you have umem memory allocation library])
      AC_MSG_RESULT([yes])
      have_umem='yes'
    fi
  else
    AC_MSG_RESULT([no])
  fi
fi
AM_CONDITIONAL([HAVE_UMEM],[test "$have_umem" = 'yes'])
AC_SUBST([UMEM_LIBS])

#
# Add support for ccmalloc memory debugging library if requested
#
have_ccmalloc='no'
CCMALLOC_LIBS=''
if test "$enable_ccmalloc" = 'yes'; then
    AC_PATH_PROG([CCMALLOCDelegate],[ccmalloc],[])
    if test -n "$CCMALLOCDelegate"; then
        eval `grep PREFIX= $CCMALLOCDelegate | sed -e 's/PREFIX/CCMALLOC_PREFIX/'`
        OLIBS="$LIBS"
        # Assume that gcc is used with ccmalloc.
        LIBS="$LIBS $CCMALLOC_PREFIX/lib/ccmalloc-gcc.o"
        AC_CHECK_LIB([ccmalloc],[ccmalloc_malloc],[CCMALLOC_LIBS="$CCMALLOC_PREFIX/lib/ccmalloc-gcc.o -lccmalloc -ldl"],[,-ldl])
        if test -n "$CCMALLOC_LIBS"; then
            LIBS="$OLIBS"
            LIBS="$LIBS $CCMALLOC_LIBS"
            have_ccmalloc='yes'
        else
            LIBS="$OLIBS"
        fi
    fi
fi

#
# Add support for 'huge pages' if requested
#
AS_IF([test "x$enable_hugepages" != "xno"],[
  AC_DEFINE([HAVE_HUGEPAGES],[ 1],[ [Compile with hugepage support]])
])

#
# Add support for efence memory debugging library if requested
#
if test "$enable_efence" = 'yes'; then
    EFENCE_LIBS='-lefence'
    LIBS="$EFENCE_LIBS $LIBS"
fi

dnl ===========================================================================

#
# Check for BZLIB
#

AC_ARG_WITH([bzlib],
    [AS_HELP_STRING([--without-bzlib],
                    [disable BZLIB support])],
    [with_bzlib=$withval],
    [with_bzlib='yes'])

if test "$with_bzlib" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-bzlib=$with_bzlib "
fi

have_bzlib='no'
if test "$with_bzlib" != 'no'; then
  BZLIB_LIBS=''
  AC_MSG_CHECKING([for BZLIB support ])
  AC_MSG_RESULT()
  failed=0
  passed=0
  found_libbz=0

  PKG_CHECK_MODULES([BZLIB],[bzip2 >= 1.0.0],[have_bzlib=yes],[have_bzlib=no])
  CFLAGS="$CFLAGS $BZLIB_CFLAGS"
  LIBS="$LIBS $BZLIB_LIBS"

  AC_CHECK_HEADER([bzlib.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
  AC_CHECK_LIB([bz2],[BZ2_bzDecompress],[found_libbz=`expr $found_libbz + 1`],,)
  if test "$native_win32_build" = 'yes'; then
    AC_CHECK_LIB([bz2],[_imp__BZ2_decompress],[found_libbz=`expr $found_libbz + 1`],,)
  fi
  if test $found_libbz -gt 0; then
    passed=`expr $passed + 1`
  else
    failed=`expr $failed + 1`
  fi
  AC_MSG_CHECKING([if BZLIB package is complete])
  if test $passed -gt 0; then
    if test $failed -gt 0; then
      AC_MSG_RESULT([no -- some components failed test])
      have_bzlib='no (failed tests)'
    else
      BZLIB_LIBS='-lbz2'
      LIBS="$BZLIB_LIBS $LIBS"
      AC_DEFINE([BZLIB_DELEGATE],[1],[Define if you have the bzip2 library])
      AC_MSG_RESULT([yes])
      have_bzlib='yes'
    fi
  else
    AC_MSG_RESULT([no])
  fi
fi
AM_CONDITIONAL([BZLIB_DELEGATE],[test "$have_bzlib" = 'yes'])
AC_SUBST([BZLIB_LIBS])
AC_SUBST([BZLIB_CFLAGS])

#
# Find the X11 include and library directories.
#
IPC_LIBS=''
X11_LIBS=''
XEXT_LIBS=''
XT_LIBS=''
AC_PATH_XTRA
if test "$no_x" != 'yes'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for X11])
    AC_MSG_RESULT([])
    LDFLAGS="$LDFLAGS $X_LIBS"
    X11_LIBS="$X_PRE_LIBS -lX11 $X_EXTRA_LIBS"
    LIBS="$X11_LIBS $LIBS"
    CPPFLAGS="$CPPFLAGS $X_CFLAGS"

    AC_DEFINE([X11_DELEGATE],[1],[Define if you have X11 library])dnl

    #
    # Check for X11 shared memory extension
    #
    # shmctl is required to support the shared memory extension
    AC_CHECK_FUNC([shmctl],[have_shmctl='yes'],[])
    if test "$have_shmctl" != 'yes'; then
        PERSIST_LIBS=$LIBS
        LIBS="$LIBS -lcygipc"
        AC_TRY_LINK_FUNC([shmctl],[have_shmctl='yes'; IPC_LIBS='-lcygipc'],[])
        LIBS=$PERSIST_LIBS
    fi

    if test "$have_shmctl" = 'yes'; then
        AC_CHECK_LIB([Xext],[XShmAttach],[XEXT_LIBS='-lXext' ; AC_DEFINE(HAVE_SHARED_MEMORY,1,X11 server supports shared memory extension)],[],[])
    fi

    #
    # Check for X11 shape extension
    #
    AC_CHECK_LIB([Xext],[XShapeCombineMask],[XEXT_LIBS='-lXext' ; AC_DEFINE(HAVE_SHAPE,1,X11 server supports shape extension)],[],[])
    AC_CHECK_LIB([Xt],[XtSetEventDispatcher],[XT_LIBS='-lXt'],[],[])
    LIBS="$XEXT_LIBS $XT_LIBS $LIBS"
fi
if test "$no_x" != 'yes'; then
  have_x='yes'
else
  have_x='no'
fi
AM_CONDITIONAL([X11_DELEGATE],[test "$have_x" = 'yes'])
AC_SUBST([X11_LIBS])
AC_SUBST([XEXT_LIBS])

dnl ===========================================================================

#
# Check for ZIP
#
AC_ARG_WITH([zip],
    [AS_HELP_STRING([--without-zip],
                    [disable ZIP support])],
    [with_zip=$withval],
    [with_zip='yes'])

if test "$with_zip" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-zip=$with_zip "
fi

have_zip='no'
ZIP_CFLAGS=""
ZIP_LIBS=""
ZIP_PKG=""
if test "x$with_zip" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([ZIP],[libzip >= 1.0.0],[have_zip=yes],[have_zip=no])
  AC_MSG_RESULT([])
fi

if test "$have_zip" = 'yes'; then
  AC_DEFINE([ZIP_DELEGATE],[1],[Define if you have ZIP library])
  CFLAGS="$ZIP_CFLAGS $CFLAGS"
  LIBS="$ZIP_LIBS $LIBS"
fi

AM_CONDITIONAL([ZIP_DELEGATE],[test "$have_zip" = 'yes'])
AC_SUBST([ZIP_CFLAGS])
AC_SUBST([ZIP_LIBS])

dnl ===========================================================================

#
# Check for ZLIB
#
AC_ARG_WITH([zlib],
    [AS_HELP_STRING([--without-zlib],
                    [disable ZLIB support])],
    [with_zlib=$withval],
    [with_zlib='yes'])

if test "$with_zlib" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-zlib=$with_zlib "
fi

have_zlib='no'
ZLIB_CFLAGS=""
ZLIB_LIBS=""
ZLIB_PKG=""
if test "x$with_zlib" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([ZLIB],[zlib >= 1.0.0],[have_zlib=yes],[have_zlib=no])
  AC_MSG_RESULT([])
fi

if test "$have_zlib" = 'yes'; then
  AC_DEFINE([ZLIB_DELEGATE],[1],[Define if you have ZLIB library])
  CFLAGS="$ZLIB_CFLAGS $CFLAGS"
  LIBS="$ZLIB_LIBS $LIBS"
fi

AM_CONDITIONAL([ZLIB_DELEGATE],[test "$have_zlib" = 'yes'])
AC_SUBST([ZLIB_CFLAGS])
AC_SUBST([ZLIB_LIBS])

dnl ===========================================================================

#
# Check for ZSTD
#
AC_ARG_WITH([zstd],
    [AS_HELP_STRING([--without-zstd],
                    [disable ZSTD support])],
    [with_zstd=$withval],
    [with_zstd='yes'])

if test "$with_zstd" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-zstd=$with_zstd "
fi

have_zstd='no'
ZSTD_CFLAGS=""
ZSTD_LIBS=""
ZSTD_PKG=""
if test "x$with_zstd" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([LIBZSTD],[libzstd >= 1.0.0],[have_zstd=yes],[have_zstd=no])
  AC_MSG_RESULT([])
fi

if test "$have_zstd" = 'yes'; then
  AC_DEFINE([ZSTD_DELEGATE],[1],[Define if you have ZSTD library])
  CFLAGS="$ZSTD_CFLAGS $CFLAGS"
  LIBS="$ZSTD_LIBS $LIBS"
fi

AM_CONDITIONAL([ZSTD_DELEGATE],[test "$have_zstd" = 'yes'])
AC_SUBST([ZSTD_CFLAGS])
AC_SUBST([ZSTD_LIBS])

dnl ===========================================================================

# whether modules are built or not.
if test "$build_modules" != 'no' || test "X$no_cl" != 'Xyes'; then
  with_ltdl='yes'
else
  with_ltdl='no'
fi
have_ltdl='no'
LTDL_LIBS=''
if test "$with_ltdl" = 'yes'; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  AC_MSG_CHECKING([for libltdl])
  AC_MSG_RESULT([])
  failed=0
  passed=0
  AC_CHECK_HEADER([ltdl.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
  AC_COMPILE_IFELSE([
    AC_LANG_PROGRAM([[
      #include <ltdl.h>
    ]], [[
      lt_dlinit();
    ]])
  ], [passed=`expr $passed + 1`], [failed=`expr $failed + 1`])
  AC_MSG_CHECKING([if libltdl package is complete])
  if test $passed -gt 0 ; then
    if test $failed -gt 0 ; then
      AC_MSG_RESULT([no -- some components failed test])
      have_ltdl='no (failed tests)'
    else
      LTDL_LIBS='-lltdl'
      LIBS="$LTDL_LIBS $LIBS"
      AC_DEFINE([LTDL_DELEGATE],[1],[Define if using libltdl to support dynamically loadable modules and OpenCL])
      AC_DEFINE_UNQUOTED([LTDL_MODULE_EXT],["${shrext_cmds}"],[Native module suffix])
      AC_MSG_RESULT([yes])
      have_ltdl='yes'
    fi
  else
    AC_MSG_RESULT([no])
  fi
  if test "$have_ltdl" != 'yes' ; then
    AC_MSG_FAILURE([libltdl is required for modules and OpenCL builds],[1])
  fi
fi
AM_CONDITIONAL([WITH_LTDL],[test "$have_ltdl" != 'no'])

#
# If profiling, then check for -ldl and dlopen (required for Solaris & gcc)
#
LIB_DL=''
if test "$enable_profiling" = 'yes'; then
    AC_CHECK_LIB([dl],[dlopen],[LIB_DL='-ldl'],[],[])
    LIBS="$LIB_DL $LIBS"
fi
AC_SUBST([LIB_DL])

dnl ===========================================================================

#
# Set Apple font directory.
#
AC_ARG_WITH([apple-font-dir],
    [AS_HELP_STRING([--with-apple-font-dir=DIR],
                    [Apple font directory])],
    [with_apple_font_dir=$withval],
    [with_apple_font_dir='default'])

if test "$with_apple_font_dir" != 'default'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-apple-font-dir=$with_apple_font_dir "
fi

dnl ===========================================================================

#
# Check for Autotrace delegate library.
#
AC_ARG_WITH([autotrace],
    [AS_HELP_STRING([--with-autotrace],
                    [enable autotrace support])],
        [with_autotrace=$withval],
        [with_autotrace='no'])

if test "$with_autotrace" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-autotrace=$with_autotrace "
fi

have_autotrace='no'
AUTOTRACE_CFLAGS=""
AUTOTRACE_LIBS=""
AUTOTRACE_PKG=""
if test "x$with_autotrace" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([AUTOTRACE],[autotrace >= 0.31.2],[have_autotrace=yes],[have_autotrace=no])
  AC_MSG_RESULT([])
fi

if test "$have_autotrace" = 'yes'; then
  AC_DEFINE([AUTOTRACE_DELEGATE],[1],[Define if you have AUTOTRACE library])
  CFLAGS="$AUTOTRACE_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([AUTOTRACE_DELEGATE],[test "$have_autotrace" = 'yes'])
AC_SUBST([AUTOTRACE_CFLAGS])
AC_SUBST([AUTOTRACE_LIBS])

dnl ===========================================================================

#
# Check for Display Postscript delegate library.
#
AC_ARG_WITH([dps],
    [AS_HELP_STRING([--with-dps],
                    [enable Display Postscript support])],
    [with_dps=$withval],
    [with_dps='no'])

if test "$with_dps" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-dps=$with_dps "
fi

have_dps='no'
DPS_LIBS=''
if test "$with_dps" != 'no' && test "$with_x" != 'no'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for DPS])
    AC_MSG_RESULT([])
    failed=0
    passed=0
    PERSIST_CPPFLAGS="$CPPFLAGS"
    CPPFLAGS="$CPPFLAGS -I${ac_x_includes}/X11"
    AC_CHECK_HEADER([DPS/dpsXclient.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
    # DPS issues:
    # XFree86-4.x needs -lXt to provide XtMalloc for -ldps.
    # Cygwin doesn't deliver -lXt as a DLL, which prevents a DLL build.
    # Adobe DPS (as delivered on Solaris) doesn't require -lXt.
    # ImageMagick itself doesn't use -lXt.
    have_libdps='no'
    LIBDPS_XT=''
    AC_CHECK_LIB([dps],[DPSInitialize],[have_libdps='yes'],[have_libdps='no',])
    if test "$have_libdps" != 'yes'; then
        # Unset cache variable so we can try again.
        unset ac_cv_lib_dps_DPSInitialize
        AC_CHECK_LIB([dps],[DPSInitialize],[have_libdps='yes'],[have_libdps='no',-lXt])
        if test "$have_libdps" = 'yes'; then
            LIBDPS_XT='-lXt'
        fi
    fi
    if test "$have_libdps" = 'yes'; then
        passed=`expr $passed + 1`
    else
        failed=`expr $failed + 1`
    fi
    AC_CHECK_LIB([dpstk],[XDPSPixelsPerPoint],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`,-ldps $LIBDPS_XT])
    AC_MSG_CHECKING([if DPS package is complete])
    if test $passed -gt 0; then
        if test $failed -gt 0; then
            AC_MSG_RESULT([no -- some components failed test])
            have_dps='no (failed tests)'
            CPPFLAGS="$PERSIST_CPPFLAGS"
        else
            DPS_LIBS="-ldpstk -ldps ${LIBDPS_XT}"
            LIBS="$DPS_LIBS $LIBS"
            AC_DEFINE([DPS_DELEGATE],[1],[Define if you have Display Postscript])
            AC_MSG_RESULT([yes])
            have_dps='yes'
        fi
    else
        AC_MSG_RESULT([no])
        CPPFLAGS=$PERSIST_CPPFLAGS
    fi
fi
AM_CONDITIONAL([DPS_DELEGATE],[test "$have_dps" = 'yes'])
AC_SUBST([DPS_LIBS])

dnl ===========================================================================

#
# Set DejaVu font directory.
#
AC_ARG_WITH([dejavu-font-dir],
    [AS_HELP_STRING([--with-dejavu-font-dir=DIR],
                    [DejaVu font directory])],
    [with_dejavu_font_dir=$withval],
    [with_dejavu_font_dir='default'])

if test "$with_dejavu_font_dir" != 'default'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-dejavu-font-dir=$with_dejavu_font_dir "
fi

dnl ===========================================================================

#
# Check for FFTW delegate library.
#
AC_ARG_WITH([fftw],
    [AS_HELP_STRING([--with-fftw],
                    [enable FFTW support])],
    [with_fftw=$withval],
    [with_fftw='no'])

if test "$with_fftw" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-fftw=$with_fftw "
fi

have_fftw='no'
FFTW_CFLAGS=""
FFTW_LIBS=""
FFTW_PKG=""
if test "x$with_fftw" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([fftw3],[fftw3 >= 3.0.0],[have_fftw=yes],[have_fftw=no])
  AC_MSG_RESULT([])
fi

if test "$have_fftw" = 'yes'; then
  AC_DEFINE([FFTW_DELEGATE],[1],[Define if you have FFTW library])
  FFTW_CFLAGS="$fftw3_CFLAGS"
  FFTW_LIBS="$fftw3_LIBS"
  CFLAGS="$fftw3_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([FFTW_DELEGATE],[test "$have_fftw" = 'yes'])
AC_SUBST([FFTW_CFLAGS])
AC_SUBST([FFTW_LIBS])

dnl ===========================================================================

#
# Check for FLIF delegate library.
#
AC_ARG_WITH([flif],
    [AS_HELP_STRING([--with-flif],
                    [enable FLIF support])],
    [with_flif=$withval],
    [with_flif='no'])

if test "$with_flif" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-flif=$with_flif "
fi

have_flif='no'
FLIF_LIBS=''
if test "$with_flif" != 'no'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for FLIF])
    AC_MSG_RESULT([])
    failed=0
    passed=0
    AC_CHECK_HEADER([flif.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
    AC_CHECK_LIB([flif],[flif_create_decoder],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])
    AC_MSG_CHECKING([if FLIF package is complete])
    if test $passed -gt 0; then
        if test $failed -gt 0; then
            AC_MSG_RESULT([no -- some components failed test])
            have_flif='no (failed tests)'
        else
            FLIF_LIBS='-lflif'
            LIBS="$FLIF_LIBS $LIBS"
            AC_DEFINE([FLIF_DELEGATE],[1],[Define if you have FLIF library])
            AC_MSG_RESULT([yes])
            have_flif='yes'
        fi
    else
        AC_MSG_RESULT([no])
    fi
fi
AM_CONDITIONAL([FLIF_DELEGATE],[test "$have_flif" = 'yes'])
AC_SUBST([FLIF_LIBS])

dnl ===========================================================================

#
# Check for FlashPIX delegate library.
#
AC_ARG_WITH([fpx],
    [AS_HELP_STRING([--with-fpx],
                    [enable FlashPIX support])],
    [with_fpx=$withval],
    [with_fpx='no'])

if test "$with_fpx" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-fpx=$with_fpx "
fi

have_fpx='no'
FPX_LIBS=''
if test "$with_fpx" != 'no'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for FlashPIX])
    AC_MSG_RESULT([])
    failed=0
    passed=0
    AC_LANG_PUSH([C++])
    AC_CHECK_HEADER([fpxlib.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
    AC_CHECK_LIB([fpx],[FPX_OpenImageByFilename],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])

    AC_LANG_POP
    AC_MSG_CHECKING([if FlashPIX package is complete])
    if test $passed -gt 0; then
        if test $failed -gt 0; then
            AC_MSG_RESULT([no -- some components failed test])
            have_fpx='no (failed tests)'
        else
            FPX_LIBS='-lfpx'
            AC_DEFINE([FPX_DELEGATE],[1],[Define if you have FlashPIX library])
            AC_MSG_RESULT([yes])
            have_fpx='yes'
            PERLMAINCC="$CXX"
        fi
    else
        AC_MSG_RESULT([no])
    fi
fi
AM_CONDITIONAL([FPX_DELEGATE],[test "$have_fpx" = 'yes'])
AC_SUBST([FPX_LIBS])

dnl ===========================================================================

#
# Check for DJVU delegate library.
#
AC_ARG_WITH([djvu],
    [AS_HELP_STRING([--without-djvu],
                    [disable DjVu support])],
    [with_djvu=$withval],
    [with_djvu='yes'])

if test "$with_djvu" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-djvu=$with_djvu "
fi

have_djvu='no'
DJVU_CFLAGS=""
DJVU_LIBS=""
DJVU_PKG=""
if test "x$with_djvu" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([ddjvuapi],[ddjvuapi >= 3.5.0],[have_djvu=yes],[have_djvu=no])
  AC_MSG_RESULT([])
fi

if test "$have_djvu" = 'yes'; then
  AC_DEFINE([DJVU_DELEGATE],[1],[Define if you have DJVU library])
  DJVU_CFLAGS="$ddjvuapi_CFLAGS"
  DJVU_LIBS="$ddjvuapi_LIBS"
  CFLAGS="$ddjvuapi_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([DJVU_DELEGATE],[test "$have_djvu" = 'yes'])
AC_SUBST([DJVU_CFLAGS])
AC_SUBST([DJVU_LIBS])

dnl ===========================================================================

#
# Check for fontconfig delegate library.
#
AC_ARG_WITH([fontconfig],
    [AS_HELP_STRING([--without-fontconfig],
                    [disable fontconfig support])],
        [with_fontconfig=$withval],
        [with_fontconfig='yes'])

if test "$with_fontconfig" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-fontconfig=$with_fontconfig "
fi

have_fontconfig='no'
FONTCONFIG_CFLAGS=""
FONTCONFIG_LIBS=""
FONTCONFIG_PKG=""
if test "x$with_fontconfig" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([FONTCONFIG],[fontconfig >= 2.1.0],[have_fontconfig=yes],[have_fontconfig=no])
  AC_MSG_RESULT([])
fi

if test "$have_fontconfig" = 'yes'; then
  AC_DEFINE([FONTCONFIG_DELEGATE],[1],[Define if you have FONTCONFIG library])
  CFLAGS="$FONTCONFIG_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([FONTCONFIG_DELEGATE],[test "$have_fontconfig" = 'yes'])
AC_SUBST([FONTCONFIG_CFLAGS])
AC_SUBST([FONTCONFIG_LIBS])

dnl ===========================================================================

#
# Check for the Freetype delegate library.
#
AC_ARG_WITH([freetype],
    [AS_HELP_STRING([--without-freetype],
                    [disable Freetype support])],
    [with_freetype=$withval],
    [with_freetype='yes'])

if test "$with_freetype" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-freetype=$with_freetype "
fi

have_freetype='no'
FREETYPE_CFLAGS=""
FREETYPE_LIBS=""
FREETYPE_PKG=""
if test "x$with_freetype" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([FREETYPE],[freetype2 >= 2.8.0],[have_freetype=yes],[have_freetype=no])
  AC_MSG_RESULT([])
fi

if test "$have_freetype" = 'yes'; then
  AC_DEFINE([FREETYPE_DELEGATE],[1],[Define if you have FREETYPE library])
  CFLAGS="$FREETYPE_CFLAGS $CFLAGS"
  MAGICKCORE_FREETYPE_DELEGATE=1
else
  MAGICKCORE_FREETYPE_DELEGATE=0
fi

AC_SUBST([FREETYPE_CFLAGS])
AC_SUBST([FREETYPE_LIBS])
AC_SUBST([MAGICKCORE_FREETYPE_DELEGATE])

dnl ===========================================================================

#
# Check for the raqm delegate library.
#
AC_ARG_WITH([raqm],
    [AS_HELP_STRING([--without-raqm],
                    [disable Raqm support])],
    [with_raqm=$withval],
    [with_raqm='yes'])

if test "$with_raqm" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-raqm=$with_raqm "
fi

have_raqm='no'
RAQM_CFLAGS=""
RAQM_LIBS=""
RAQM_PKG=""
if test "x$with_raqm" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([RAQM],[raqm],[have_raqm=yes],[have_raqm=no])
  AC_MSG_RESULT([])
fi

if test "$have_raqm" = 'yes'; then
  AC_DEFINE([RAQM_DELEGATE],[1],[Define if you have RAQM library])
  CFLAGS="$RAQM_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([RAQM_DELEGATE],[test "$have_raqm" = 'yes'])
AC_SUBST([RAQM_CFLAGS])
AC_SUBST([RAQM_LIBS])

dnl ===========================================================================

#
# Enable Windows gdi32 libraries
#
AC_ARG_WITH([gdi32],
    AS_HELP_STRING([--without-gdi32],
                   [disable Windows gdi32 support]),
    [with_gdi32=$withval],
    [with_gdi32='yes'])
if test "$with_gdi32" != 'yes' ; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-gdi32=$with_gdi32 "
fi

#
# Check for Windows gdi32 library.
#
have_gdi32='no'
if test "$with_gdi32" != 'no'; then
  GDI32_LIBS=''
  AC_MSG_CHECKING([for Windows GDI32 support])
  AC_MSG_RESULT()
  failed=0
  passed=0
  AC_CHECK_HEADER([windows.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
  AC_CHECK_HEADER([winuser.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[#include <windows.h>])
  AC_CHECK_HEADER([wingdi.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[#include <windows.h>])
  if test "$cygwin_build" = yes -o "$native_win32_build" = yes; then
    passed=`expr $passed + 1`
  fi
  AC_MSG_CHECKING([if Windows GDI32 support is complete])
  if test $passed -gt 0; then
    if test $failed -gt 0; then
      AC_MSG_RESULT([no -- some components failed test])
      have_gdi32='no (failed tests)'
    else
      GDI32_LIBS='-lgdi32 -luser32'
      LIBS="$GDI32_LIBS $LIBS"
      AC_DEFINE([WINGDI32_DELEGATE],[1],[Define to use the Windows GDI32 library])
      AC_MSG_RESULT([yes])
      have_gdi32='yes'
    fi
  else
    AC_MSG_RESULT([no])
  fi
fi
AM_CONDITIONAL([WINGDI32_DELEGATE], [test "$have_gdi32" = 'yes'])
AC_SUBST([GDI32_LIBS])


dnl ===========================================================================

#
# Check for Ghostscript library or framework.
#
# Test for iapi.h & test for gsapi_new_instance in -lgs
# or -framework Ghostscript

AC_ARG_WITH([gslib],
    [AS_HELP_STRING([--with-gslib],
                    [enable Ghostscript library support])],
    [with_gslib=$withval],
    [with_gslib='no'])

gslib_framework='no'
if test "$with_gslib" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-gslib=$with_gslib "
fi

have_gslib='no'
GS_LIBS=''
if test "$with_gslib" != 'no'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for Ghostscript])
    AC_MSG_RESULT([])
    framework=0
    failed=0
    passed=0
    AC_CHECK_HEADER([ghostscript/iapi.h],[passed=`expr $passed + 1`],
      [failed=`expr $failed + 1`],[])
    AC_CHECK_HEADER([ghostscript/ierrors.h],[passed=`expr $passed + 1`],
      [failed=`expr $failed + 1`],[])
    AC_CHECK_FRAMEWORK([Ghostscript],[gsapi_new_instance],[framework=`expr $framework + 1`],
      AC_CHECK_LIB([gs],[gsapi_new_instance],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[]),[])
    AC_MSG_CHECKING([if Ghostscript package is complete])
    if test $passed -gt 0; then
        if test $failed -gt 0; then
            AC_MSG_RESULT([no -- some components failed test])
            have_gslib='no (failed tests)'
        else
            if test $framework -gt 0; then
                GS_LIBS='-framework Ghostscript'
                gslib_framework='yes'
                AC_MSG_RESULT([yes, using framework.])
            else
                AC_MSG_RESULT([yes, using library.])
                GS_LIBS='-lgs'
            fi
            LIBS="$GS_LIBS $LIBS"
            AC_DEFINE([GS_DELEGATE],[1],[Define if you have Ghostscript library or framework])
            have_gslib='yes'
        fi
    else
        AC_MSG_RESULT([no])
    fi
fi
AM_CONDITIONAL([GS_DELEGATE],[test "$have_gslib" = 'yes'])
AC_SUBST([GS_LIBS])

# Set default font search path
AC_ARG_WITH([fontpath],
    [AS_HELP_STRING([--with-fontpath=DIR],
                    [prepend to default font search path])],
    [with_fontpath=$withval],
    [with_fontpath=''])

if test "$with_fontpath" != "yes" && test -z "$with_fontpath"; then
    with_fontpath=''
else
    AC_DEFINE_UNQUOTED([MAGICK_FONT_PATH],["$with_fontpath"],[Define to prepend to default font search path.])
fi
if test "$with_fontpath=" != ''; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-fontpath=$with_fontpath "
fi

# Set Ghostscript font directory
AC_ARG_WITH([gs-font-dir],
    [AS_HELP_STRING([--with-gs-font-dir=DIR],
                    [Ghostscript font directory])],
    [with_gs_font_dir=$withval],
    [with_gs_font_dir='default'])

if test "$with_gs_font_dir" != 'default'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-gs-font-dir=$with_gs_font_dir "
fi

dnl ===========================================================================

#
# Check for GVC delegate library.
#
AC_ARG_WITH([gvc],
    [AS_HELP_STRING([--with-gvc],
                    [enable GVC support])],
    [with_gvc=$withval],
    [with_gvc='yes'])

if test "$with_gvc" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-gvc=$with_gvc "
fi

GVC_PKG=""
if test "x$with_gvc" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([GVC],[libgvc >= 2.9.0],[have_gvc=yes],[have_gvc=no])
  AC_MSG_RESULT([])
fi

if test "$have_gvc" = 'yes'; then
  AC_DEFINE([GVC_DELEGATE],[1],[Define if you have GVC library])
  CFLAGS="$GVC_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([GVC_DELEGATE],[test "$have_gvc" = 'yes'])
AC_SUBST([GVC_CFLAGS])
AC_SUBST([GVC_LIBS])

dnl ===========================================================================

#
# Check for DMR, digital media repository, delegate library.
#
AC_ARG_WITH([dmr],
    [AS_HELP_STRING([--without-dmr], [disable digital media repository support])],
    [with_dmr=$withval],
    [with_dmr='yes'])

if test "$with_dmr" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-dmr=$with_dmr "
fi

have_dmr='no'
DMR_CFLAGS=""
DMR_LIBS=""
DMR_PKG=""
if test "x$with_dmr" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([MagickCache],[MagickCache >= 0.9.3],[have_dmr=yes],[have_dmr=no])
  AC_MSG_RESULT([])
fi

if test "$have_dmr" = 'yes'; then
  AC_DEFINE([DMR_DELEGATE],[1],[Define if you have DMR library])
  DMR_CFLAGS="$MagickCache_CFLAGS"
  DMR_LIBS="$MagickCache_LIBS"
  CFLAGS="$DMR_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([DMR_DELEGATE],[test "$have_dmr" = 'yes'])
AC_SUBST([DMR_CFLAGS])
AC_SUBST([DMR_LIBS])

dnl ===========================================================================

#
# Check for the HEIC delegate library.
#
AC_ARG_WITH([heic],
    [AS_HELP_STRING([--without-heic],
                    [disable HEIC support])],
    [with_heic=$withval],
    [with_heic='yes'])

if test "$with_heic" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-heic=$with_heic "
fi

have_heic='no'
HEIF_CFLAGS=""
HEIF_LIBS=""
HEIF_PKG=""
if test "x$with_heic" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([HEIF],[libheif >= 1.4.0],[have_heic=yes],[have_heic=no])
  AC_MSG_RESULT([])
fi

if test "$have_heic" = 'yes'; then
  AC_DEFINE([HEIC_DELEGATE],[1],[Define if you have libheif library])
  CFLAGS="$HEIF_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([HEIC_DELEGATE],[test "$have_heic" = 'yes'])
AC_SUBST([HEIF_CFLAGS])
AC_SUBST([HEIF_LIBS])

dnl ===========================================================================

#
# Check for JBIG delegate library.
#
AC_ARG_WITH([jbig],
    [AS_HELP_STRING([--without-jbig],
                    [disable JBIG support])],
    [with_jbig=$withval],
    [with_jbig='yes'])

have_jbig='no'
JBIG_LIBS=''
if test "$with_jbig" != 'no'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for JBIG])
    AC_MSG_RESULT([])
    failed=0
    passed=0
    AC_CHECK_HEADER([jbig.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
    AC_CHECK_LIB([jbig],[jbg_dec_init],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])

    AC_MSG_CHECKING([if JBIG package is complete])
    if test $passed -gt 0; then
        if test $failed -gt 0; then
            AC_MSG_RESULT([no -- some components failed test])
            have_jbig='no (failed tests)'
        else
            JBIG_LIBS='-ljbig'
            LIBS="$JBIG_LIBS $LIBS"
            AC_DEFINE([JBIG_DELEGATE],[1],[Define if you have JBIG library])
            AC_MSG_RESULT([yes])
            have_jbig='yes'
        fi
    else
        AC_MSG_RESULT([no])
    fi
fi
AM_CONDITIONAL([JBIG_DELEGATE],[test "$have_jbig" = 'yes'])
AC_SUBST([JBIG_LIBS])

dnl ===========================================================================

#
# Check for JPEG delegate library.
#
AC_ARG_WITH([jpeg],
    [AS_HELP_STRING([--without-jpeg],
                    [disable JPEG support])],
    [with_jpeg=$withval],
    [with_jpeg='yes'])

if test "$with_jpeg" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-jpeg=$with_jpeg "
fi

have_jpeg='no'
JPEG_LIBS=''
if test "$with_jpeg" != 'no'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for JPEG])
    AC_MSG_RESULT([])
    failed=0
    passed=0

    PKG_CHECK_MODULES([JPEG],[libjpeg >= 2.0.0],[have_jpeg=yes],[have_jpeg=no])
    CFLAGS="$CFLAGS $JPEG_CFLAGS"
    LIBS="$LIBS $JPEG_LIBS"

    AC_CHECK_HEADER([jconfig.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
    AC_CHECK_HEADER([jerror.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
    AC_CHECK_HEADER([jmorecfg.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
    AC_CHECK_HEADER([jpeglib.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
    AC_CHECK_LIB([jpeg],[jpeg_read_header],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])

    AC_MSG_CHECKING([if JPEG package is complete])
    if test $passed -gt 0; then
        if test $failed -gt 0; then
            AC_MSG_RESULT([no -- some components failed test])
            have_jpeg='no (failed tests)'
        else
            JPEG_LIBS='-ljpeg'
            LIBS="$JPEG_LIBS $LIBS"
            AC_DEFINE([JPEG_DELEGATE],[1],[Define if you have JPEG library])
            AC_MSG_RESULT([yes])
            have_jpeg='yes'
        fi
        AC_CHECK_FUNCS([jpeg12_read_scanlines jpeg12_write_scanlines jpeg16_read_scanlines jpeg16_write_scanlines jpeg_enable_lossless jpeg_simple_lossless])
    else
        AC_MSG_RESULT([no])
    fi
fi
AM_CONDITIONAL([JPEG_DELEGATE],[test "$have_jpeg" = 'yes'])
AC_SUBST([JPEG_CFLAGS])
AC_SUBST([JPEG_LIBS])

dnl ===========================================================================

#
# Check for JPEG-XL delegate library.
#
AC_ARG_WITH([jxl],
    [AS_HELP_STRING([--without-jxl],
                    [disable JPEG-XL support])],
    [with_jxl=$withval],
    [with_jxl='yes'])

# Check for the JPEG-XL library.
have_jxl='no'
JXL_CFLAGS=''
JXL_LIBS=''
JXL_PKG=''
if test "$with_jxl" != 'no'; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([JXL],[libjxl >= 0.7.0 libjxl_threads],[have_jxl=yes],[have_jxl=no])
  AC_MSG_RESULT([])
fi

if test "$have_jxl" = 'yes'; then
  AC_DEFINE([JXL_DELEGATE],[1],[Define if you have jpeg-xl library])
fi

AM_CONDITIONAL([JXL_DELEGATE],[test "$have_jxl" = 'yes'])
AC_SUBST([JXL_CFLAGS])
AC_SUBST([JXL_LIBS])

dnl ===========================================================================

#
# Check for LCMS delegate library.
#
AC_ARG_WITH([lcms],
        [  --without-lcms          disable lcms (v1.1X) support],
        [with_lcms=$withval],
        [with_lcms='yes'])
if test "$with_lcms" != 'yes' ; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-lcms=$with_lcms "
fi

have_lcms='no'
LCMS_CFLAGS=""
LCMS_LIBS=""
LCMS_PKG=""
if test "x$with_lcms" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([LCMS2],[lcms2 >= 2.0.0],[have_lcms=yes],[have_lcms=no])
  AC_MSG_RESULT([])
fi

if test "$have_lcms" = 'yes'; then
  AC_DEFINE([LCMS_DELEGATE],[1],[Define if you have LCMS library])
  LCMS_CFLAGS="$LCMS2_CFLAGS"
  LCMS_LIBS="$LCMS2_LIBS"
  CFLAGS="$LCMS2_CFLAGS $CFLAGS"
  AC_CHECK_HEADER([lcms2/lcms2.h],[have_lcms_header='yes'],[])
  if test "$have_lcms_header" = 'yes'; then
    AC_DEFINE([HAVE_LCMS2_LCMS2_H],[1],[Define if you have the <lcms2/lcms2.h> header file.])
  else
    AC_DEFINE([HAVE_LCMS2_H],[1],[Define if you have the <lcms2.h> header file.])
  fi
fi

AM_CONDITIONAL([LCMS_DELEGATE],[test "$have_lcms" = 'yes'])
AC_SUBST([LCMS_CFLAGS])
AC_SUBST([LCMS_LIBS])

dnl ===========================================================================

#
# Check for the OpenJP2 delegate library.
#
AC_ARG_WITH([openjp2],
    [AS_HELP_STRING([--without-openjp2],
                    [disable OpenJP2 support])],
    [with_openjp2=$withval],
    [with_openjp2='yes'])

if test "$with_openjp2" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-openjp2=$with_openjp2 "
fi

have_openjp2='no'
LIBOPENJP2_CFLAGS=""
LIBOPENJP2_LIBS=""
LIBOPENJP2_PKG=""
if test "$with_openjp2" != 'no'; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([LIBOPENJP2],[libopenjp2 >= 2.1.0],[have_openjp2=yes],[have_openjp2=no])
  AC_MSG_RESULT([])
fi

if test "$have_openjp2" = 'yes'; then
  AC_DEFINE([LIBOPENJP2_DELEGATE],[1],[Define if you have OPENJP2 library])
  CFLAGS="$LIBOPENJP2_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([LIBOPENJP2_DELEGATE],[test "$have_openjp2" = 'yes'])
AC_SUBST([LIBOPENJP2_CFLAGS])
AC_SUBST([LIBOPENJP2_LIBS])


dnl ===========================================================================

#
# Check for the LQR (Liquid Rescale) delegate library.
#
AC_ARG_WITH([lqr],
    [AS_HELP_STRING([--without-lqr],
                    [disable Liquid Rescale support])],
    [with_lqr=$withval],
    [with_lqr='yes'])

if test "$with_lqr" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-lqr=$with_lqr "
fi

have_lqr='no'
LQR_CFLAGS=""
LQR_LIBS=""
LQR_PKG=""
if test "x$with_lqr" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([LQR],[lqr-1 >= 0.1.0],[have_lqr=yes],[have_lqr=no])
  AC_MSG_RESULT([])
fi

if test "$have_lqr" = 'yes'; then
  AC_DEFINE([LQR_DELEGATE],[1],[Define if you have LQR library])
  CFLAGS="$LQR_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([LQR_DELEGATE],[test "$have_lqr" = 'yes'])
AC_SUBST([LQR_CFLAGS])
AC_SUBST([LQR_LIBS])

dnl ===========================================================================

# Disable LZMA (lzma library)
AC_ARG_WITH([lzma],
            [  --without-lzma          disable LZMA support],
            [with_lzma=$withval],
            [with_lzma='yes'])
if test "$with_lzma" != 'yes' ; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-lzma=$with_lzma "
fi

LZMA_PKG=""
if test "x$with_lzma" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([LZMA],[liblzma >= 2.9.0],[have_lzma=yes],[have_lzma=no])
  AC_MSG_RESULT([])
else
  have_lzma=no
fi

if test "$have_lzma" = 'yes'; then
  AC_DEFINE([LZMA_DELEGATE],[1],[Define if you have LZMA library])
  CFLAGS="$LZMA_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([LZMA_DELEGATE],[test "$have_lzma" = 'yes'])
AC_SUBST([LZMA_CFLAGS])
AC_SUBST([LZMA_LIBS])

dnl ===========================================================================

#
# Check for the OpenEXR delegate library.
#
AC_ARG_WITH([openexr],
    [AS_HELP_STRING([--without-openexr],
                    [disable OpenEXR support])],
    [with_openexr=$withval],
    [with_openexr='yes'])

if test "$with_openexr" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-openexr=$with_openexr "
fi

have_openexr='no'
OPENEXR_CFLAGS=""
OPENEXR_LIBS=""
OPENEXR_PKG=""
if test "x$with_openexr" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([OPENEXR],[OpenEXR >= 1.0.6],[have_openexr=yes],[have_openexr=no])
  AC_MSG_RESULT([])
fi

if test "$have_openexr" = 'yes'; then
  AC_DEFINE([OPENEXR_DELEGATE],[1],[Define if you have OPENEXR library])
  CFLAGS="$OPENEXR_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([OPENEXR_DELEGATE],[test "$have_openexr" = 'yes'])
AC_SUBST([OPENEXR_CFLAGS])
AC_SUBST([OPENEXR_LIBS])

dnl ===========================================================================

#
# Check for PANGO delegate library.
#
AC_ARG_WITH([pango],
    [AS_HELP_STRING([--without-pango],
                    [disable PANGO support])],
    [with_pango=$withval],
    [with_pango='yes'])

if test "$with_pango" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-pango=$with_pango "
fi

have_pango='no'
have_pangocairo='no'
PANGO_CFLAGS=""
PANGO_LIBS=""
PANGO_PKG=""
if test "x$with_pango" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([PANGO],[pangocairo >= 1.28.1],[have_pangocairo=yes],[have_pangocairo=no])
  AC_MSG_RESULT([])
  PKG_CHECK_MODULES([PANGO],[pango >= 1.28.1],[have_pango=yes],[have_pango=no])
  AC_MSG_RESULT([])
fi

if test "${have_pango}x${have_pangocairo}" = 'yesxyes'; then
  AC_DEFINE([PANGOCAIRO_DELEGATE],[1],[Define if you have PANGOCAIRO library])
  CFLAGS="$PANGO_CFLAGS $PANGOCAIRO_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([PANGOCAIRO_DELEGATE],[test "$have_pangocairo" = 'yes'])
AC_SUBST([PANGO_CFLAGS])
AC_SUBST([PANGO_LIBS])

dnl ===========================================================================

#
# Check for PNG delegate library.
#
AC_ARG_WITH([png],
    [AS_HELP_STRING([--without-png], [disable PNG support])],
    [with_png=$withval],
    [with_png='yes'])

if test "$with_png" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-png=$with_png "
fi

have_png='no'
PNG_CFLAGS=""
PNG_LIBS=""
PNG_PKG=""
if test "x$with_png" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([PNG],[libpng >= 1.0.0],[have_png=yes],[have_png=no])
  AC_MSG_RESULT([])
fi

if test "$have_png" = 'yes'; then
  AC_DEFINE([PNG_DELEGATE],[1],[Define if you have PNG library])
  CFLAGS="$PNG_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([PNG_DELEGATE],[test "$have_png" = 'yes'])
AC_SUBST([PNG_CFLAGS])
AC_SUBST([PNG_LIBS])

dnl ===========================================================================

#
# Check for the Raw delegate library.
#
AC_ARG_WITH([raw],
    [AS_HELP_STRING([--without-raw],
                    [disable Raw support])],
    [with_raw=$withval],
    [with_raw='yes'])

if test "$with_raw" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-libraw=$with_raw "
fi

have_raw='no'
RAW_R_CFLAGS=""
RAW_R_LIBS=""
RAW_R_PKG=""
if test "x$with_raw" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([RAW_R],[libraw_r >= 0.14.8],[have_raw=yes],[have_raw=no])
  AC_MSG_RESULT([])
fi

if test "$have_raw" = 'yes'; then
  AC_DEFINE([RAW_R_DELEGATE],[1],[Define if you have LIBRAW library])
  CFLAGS="$RAW_R_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([RAW_R_DELEGATE],[test "$have_raw" = 'yes'])
AC_SUBST([RAW_R_CFLAGS])
AC_SUBST([RAW_R_LIBS])

dnl ===========================================================================

#
# Check for RSVG delegate library.
#
AC_ARG_WITH([rsvg],
    [AS_HELP_STRING([--with-rsvg],
                    [enable RSVG support])],
    [with_rsvg=$withval],
    [with_rsvg='no'])

if test "$with_rsvg" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-rsvg=$with_rsvg "
fi

have_rsvg='no'
have_cairo='no'
RSVG_CFLAGS=""
RSVG_LIBS=""
RSVG_PKG=""
if test "x$with_rsvg" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([RSVG],[librsvg-2.0 >= 2.9.0],[have_rsvg=yes],[have_rsvg=no])
  AC_MSG_RESULT([])
  PKG_CHECK_MODULES([CAIRO_SVG],[cairo-svg],[have_cairo=yes],[have_cairo=no])
  AC_MSG_RESULT([])
fi

if test "$have_rsvg" = 'yes'; then
  AC_DEFINE([RSVG_DELEGATE],[1],[Define if you have RSVG library])
  CFLAGS="$RSVG_CFLAGS $CFLAGS"
fi

if test "$have_cairo" = 'yes'; then
  AC_DEFINE([CAIRO_DELEGATE],[1],[Define if you have CAIRO library])
  CFLAGS="$CAIRO_SVG_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([RSVG_DELEGATE],[test "$have_rsvg" = 'yes'])
AM_CONDITIONAL([CAIRO_DELEGATE],[test "$have_cairo" = 'yes'])
AC_SUBST([RSVG_CFLAGS])
AC_SUBST([RSVG_LIBS])

dnl ===========================================================================

#
# Check for TIFF delegate library.
#
AC_ARG_WITH([tiff],
    [AS_HELP_STRING([--without-tiff], [disable TIFF support])],
    [with_tiff=$withval],
    [with_tiff='yes'])

if test "$with_tiff" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-tiff=$with_tiff "
fi

have_tiff='no'
TIFF_CFLAGS=""
TIFF_LIBS=""
TIFF_PKG=""
if test "x$with_tiff" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([TIFF],[libtiff-4 >= 4.0.0],[have_tiff=yes],[have_tiff=no])
  AC_MSG_RESULT([])
fi

if test "$have_tiff" = 'yes'; then
  AC_DEFINE([TIFF_DELEGATE],[1],[Define if you have TIFF library])
  CFLAGS="$TIFF_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([TIFF_DELEGATE],[test "$have_tiff" = 'yes'])
AC_SUBST([TIFF_CFLAGS])
AC_SUBST([TIFF_LIBS])

dnl ===========================================================================

#
# Check for google libultrahdr delegate library
#
# Test for ultrahdr_api.h & test for uhdr_create_decoder in -luhdr
#
AC_ARG_WITH([uhdr],
    [AS_HELP_STRING([--with-uhdr],
                    [enable google ultrahdr support])],
    [with_uhdr=$withval],
    [with_uhdr='no'])

if test "$with_uhdr" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-uhdr=$with_uhdr "
fi

have_uhdr='no'
UHDR_LIBS=""
if test "$with_uhdr" != 'no'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for google ultrahdr])
    AC_MSG_RESULT([])
    failed=0
    passed=0

    PKG_CHECK_MODULES([UHDR],[libuhdr >= 1.0],[have_uhdr=yes],[have_uhdr=no])
    CFLAGS="$CFLAGS $UHDR_CFLAGS"
    LIBS="$LIBS $UHDR_LIBS"
    AC_LANG_PUSH([C++])
    AC_CHECK_HEADER([ultrahdr_api.h],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`])
    AC_CHECK_LIB([uhdr],[uhdr_create_decoder],[passed=`expr $passed + 1`],[failed=`expr $failed + 1`],[])

    AC_MSG_CHECKING([if google ultrahdr package is complete])

    if test $passed -gt 0; then
        if test $failed -gt 0; then
            AC_MSG_RESULT([no -- some components failed test])
            have_uhdr='no (failed tests)'
        else
            UHDR_LIBS='-luhdr'
            LIBS="$UHDR_LIBS $LIBS"
            AC_DEFINE([UHDR_DELEGATE],[1],[Define if you have google ultrahdr library])
            AC_MSG_RESULT([yes])
            have_uhdr='yes'
        fi
    else
        AC_MSG_RESULT([no])
    fi
    AC_LANG_POP([C++])
fi

AM_CONDITIONAL([UHDR_DELEGATE],[test "$have_uhdr" = 'yes'])
AC_SUBST([UHDR_CFLAGS])
AC_SUBST([UHDR_LIBS])

dnl ===========================================================================

#
# Set URW Base35 font directory.
#
AC_ARG_WITH([urw-base35-font-dir],
    [AS_HELP_STRING([--with-urw-base35-font-dir=DIR],
                    [URW-base35 font directory])],
    [with_urw_base35_font_dir=$withval],
    [with_urw_base35_font_dir='default'])

if test "$with_urw_base35_font_dir" != 'default'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-urw-base35-font-dir=$with_urw_base35_font_dir "
fi

dnl ===========================================================================

#
# Check for the WEBP delegate library.
#
AC_ARG_WITH([webp],
    [AS_HELP_STRING([--without-webp],
                    [disable WEBP support])],
    [with_webp=$withval],
    [with_webp='yes'])

if test "$with_webp" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-webp=$with_webp "
fi

have_webp='no'
have_webpmux='no'
WEBP_CFLAGS=""
WEBP_LIBS=""
WEBP_PKG=""
WEBPMUX_CFLAGS=""
WEBPMUX_LIBS=""
WEBPMUX_PKG=""
if test "x$with_webp" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([WEBP],[libwebp >= 0.4.1],[have_webp=yes],[have_webp=no])
  PKG_CHECK_MODULES([WEBPMUX],[libwebpmux >= 0.5.0 libwebpdemux >= 0.5.0],[have_webpmux=yes],[have_webpmux=no])
  AC_MSG_RESULT([])
fi

if test "$have_webp" = 'yes'; then
  AC_DEFINE([WEBP_DELEGATE],[1],[Define if you have WEBP library])
  CFLAGS="$WEBP_CFLAGS $CFLAGS"
fi

if test "$have_webpmux" = 'yes'; then
  AC_DEFINE([WEBPMUX_DELEGATE],[1],[Define if you have WEBPMUX library])
  CFLAGS="$WEBPMUX_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([WEBP_DELEGATE],[test "$have_webp" = 'yes'])
AM_CONDITIONAL([WEBPMUX_DELEGATE],[test "$have_webpmux" = 'yes'])
AC_SUBST([WEBPMUX_CFLAGS])
AC_SUBST([WEBPMUX_LIBS])
AC_SUBST([WEBP_CFLAGS])
AC_SUBST([WEBP_LIBS])

dnl ===========================================================================

#
# Set Windows font directory.
#
AC_ARG_WITH([windows-font-dir],
    [AS_HELP_STRING([--with-windows-font-dir=DIR],
                    [Windows font directory])],
    [with_windows_font_dir=$withval],
    [with_windows_font_dir='default'])

if test "$with_windows_font_dir" != 'default'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-windows-font-dir=$with_windows_font_dir "
fi

dnl ===========================================================================

#
# Check for WMF delegate library.
#
AC_ARG_WITH([wmf],
    [AS_HELP_STRING([--with-wmf],
                    [enable WMF support])],
    [with_wmf=$withval],
    [with_wmf=$build_modules])

if test "$with_wmf" != 'yes'; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-wmf=$with_wmf "
fi

have_wmf='no'
WMF_LIBS=''
WMF_CFLAGS=''
OLIBS="$LIBS"
if test "$with_wmf" != 'no'; then
  AC_MSG_CHECKING([for WMF support])
  AC_MSG_RESULT([])

  have_libwmflite='no'
  have_libwmf_ipa_h='no'

  AC_CHECK_HEADER([libwmf/ipa.h],[have_libwmf_ipa_h='yes'],[],[$FT2BUILD_H])
  if test "$have_libwmf_ipa_h" = 'yes'; then
    AC_CHECK_LIB([wmflite],[wmf_lite_create],[have_libwmflite='yes'],[],[])
    if test "$have_libwmflite" = 'yes'; then
      AC_DEFINE([WMF_DELEGATE],[1],[Define if you have WMF library])
      WMF_LIBS='-lwmflite'
      LIBS="$WMF_LIBS $LIBS"
      have_wmf='yes'
    else
      AC_MSG_RESULT([no -- some components failed test])
      have_wmf='no (failed tests)'
      have_wmflite='no (failed tests)'
      LIBS="$OLIBS"
      WMF_LIBS=''
    fi
  fi
fi
AC_MSG_CHECKING([if WMF package is complete])
if test "$have_wmf" = 'yes'; then
  AC_MSG_RESULT([yes])
else
  AC_MSG_RESULT([no])
fi
AM_CONDITIONAL([WMF_DELEGATE],[test "$have_wmf" = 'yes'])
AC_SUBST([WMF_CFLAGS])
AC_SUBST([WMF_LIBS])

dnl ===========================================================================

#
# Check for XML delegate library.
#
AC_ARG_WITH([xml],
    [AS_HELP_STRING([--without-xml],
                    [disable XML support])],
    [with_xml=$withval],
    [with_xml='yes'])

if test "$with_xml" != 'yes' ; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-xml=$with_xml "
fi

have_xml='no'
XML_CFLAGS=""
XML_LIBS=""
XML_PKG=""
if test "x$with_xml" = "xyes"; then
  AC_MSG_RESULT([-------------------------------------------------------------])
  PKG_CHECK_MODULES([XML],[libxml-2.0 >= 2.0.0],[have_xml=yes],[have_xml=no])
  AC_MSG_RESULT([])
fi

if test "$have_xml" = 'yes'; then
  AC_DEFINE([XML_DELEGATE],[1],[Define if you have XML library])
  CFLAGS="$XML_CFLAGS $CFLAGS"
fi

AM_CONDITIONAL([XML_DELEGATE],[test "$have_xml" = 'yes'])
AC_SUBST([XML_CFLAGS])
AC_SUBST([XML_LIBS])

dnl ===========================================================================

# Check for functions
#
AC_CHECK_FUNCS([acosh _aligned_malloc aligned_malloc asinh atanh atoll atexit cabs carg cimag creal clock clock_getres clock_gettime ctime_r directio erf _exit execvp fchmod floor fork ftime ftruncate getc_unlocked getcwd getentropy getexecname getdtablesize getpagesize getpid getpwnam_r getrlimit getrusage gettimeofday gmtime_r isnan j0 j1 lltostr localtime_r lstat memmove memset mkdir mkstemp mmap munmap nanosleep newlocale _NSGetExecutablePath pclose _pclose poll popen _popen posix_fadvise posix_fallocate posix_madvise posix_memalign posix_spawnp pow pread putenv pwrite qsort_r raise rand_r readlink realpath select seekdir sendfile setlocale socket sqrt setvbuf stat strcasestr strchr strrchr strcspn strdup strpbrk strspn strstr strtod strtod_l strtol strtoul symlink sysconf sigemptyset sigaction spawnvp strerror strlcat strlcpy strcasecmp strncasecmp system telldir tempnam times ulltostr uselocale usleep utime utimensat vfprintf vfprintf_l vsprintf vsnprintf vsnprintf_l waitpid _wfopen _wstat])

# Substitute compiler name to build/link PerlMagick
#
AC_SUBST([PERLMAINCC])

#
# Configure install Paths
#

# Path to ImageMagick header files
INCLUDE_RELATIVE_PATH="${PACKAGE_NAME}-${MAGICK_MAJOR_VERSION}"
INCLUDE_PATH="${INCLUDE_DIR}/${INCLUDE_RELATIVE_PATH}"
DEFINE_INCLUDE_PATH="${INCLUDE_DIR}/${INCLUDE_RELATIVE_PATH}/"
case "${build_os}" in
  mingw* )
    DEFINE_INCLUDE_PATH=`$WinPathScript "$DEFINE_INCLUDE_PATH" 1`
    ;;
esac
AC_DEFINE_UNQUOTED([INCLUDE_PATH],["$DEFINE_INCLUDE_PATH"],[Directory where ImageMagick headers live.])
AC_SUBST([INCLUDE_PATH])

# Path to ImageMagick header files (arch part)
INCLUDEARCH_PATH="${INCLUDEARCH_DIR}/${INCLUDE_RELATIVE_PATH}"
DEFINE_INCLUDEARCH_PATH="${INCLUDEARCH_DIR}/${INCLUDE_RELATIVE_PATH}/"
case "${build_os}" in
  mingw* )
    DEFINE_INCLUDEARCH_PATH=`$WinPathScript "$DEFINE_INCLUDEARCH_PATH" 1`
    ;;
esac
AC_DEFINE_UNQUOTED([INCLUDEARCH_PATH],["$DEFINE_INCLUDE_PATH"],[Directory where ImageMagick architecture headers live.])
AC_SUBST([INCLUDEARCH_PATH])

# Subdirectory under lib to place ImageMagick lib files
LIBRARY_RELATIVE_PATH="${PACKAGE_NAME}-${PACKAGE_BASE_VERSION}"
AC_DEFINE_UNQUOTED([LIBRARY_RELATIVE_PATH],["$LIBRARY_RELATIVE_PATH"],[Subdirectory of lib where ImageMagick architecture dependent files are installed.])

# Path to ImageMagick bin directory
EXECUTABLE_PATH="${BIN_DIR}"
DEFINE_EXECUTABLE_PATH="${BIN_DIR}/"
case "${build_os}" in
  mingw* )
    DEFINE_EXECUTABLE_PATH=`$WinPathScript "$DEFINE_EXECUTABLE_PATH" 1`
    ;;
esac
AC_DEFINE_UNQUOTED([EXECUTABLE_PATH],["$DEFINE_EXECUTABLE_PATH"],[Directory where executables are installed.])
AC_SUBST([EXECUTABLE_PATH])

# Path to ImageMagick lib
LIBRARY_PATH="${LIB_DIR}/${LIBRARY_RELATIVE_PATH}"
DEFINE_LIBRARY_PATH="${LIB_DIR}/${LIBRARY_RELATIVE_PATH}/"
case "${build_os}" in
  mingw* )
    DEFINE_LIBRARY_PATH=`$WinPathScript "$DEFINE_LIBRARY_PATH" 1`
    ;;
esac
AC_DEFINE_UNQUOTED([LIBRARY_PATH],["$DEFINE_LIBRARY_PATH"],[Directory where architecture-dependent files live.])
AC_SUBST([LIBRARY_PATH])

#
# path to local binaries
if test "x$LIB_BIN_BASEDIRNAME" = "x"; then
   LIB_BIN_BASEDIRNAME="bin"
fi
AC_DEFINE_UNQUOTED([LIB_BIN_BASEDIRNAME],["$LIB_BIN_BASEDIRNAME"],[Binaries in libraries path base name (will be during install linked to bin)])
AC_SUBST([LIB_BIN_BASEDIRNAME])

if test "x$LIB_BIN_DIR" = "x"; then
   LIB_BIN_DIR=${LIB_BIN_BASEDIRNAME}-${MAGICK_ABI_SUFFIX}
fi
AC_SUBST([LIB_BIN_DIR])

LIB_BIN_DIR_RELATIVE_PATH=$LIB_BIN_DIR
AC_SUBST([LIB_BIN_DIR_RELATIVE_PATH])
LIB_BIN_DIR_PATH="${LIBRARY_PATH}/${LIB_BIN_DIR_RELATIVE_PATH}"
AC_SUBST([LIB_BIN_DIR_PATH])

#
# path to modules lib
if test "x$MODULES_BASEDIRNAME" = "x"; then
   MODULES_BASEDIRNAME="modules"
fi
AC_DEFINE_UNQUOTED([MODULES_BASEDIRNAME],["$MODULES_BASEDIRNAME"],[Module directory name without ABI part.])
AC_SUBST([MODULES_BASEDIRNAME])

if test "x$MODULES_DIRNAME" = "x"; then
  MODULES_DIRNAME=${MODULES_BASEDIRNAME}-${MAGICK_ABI_SUFFIX}
else
  AC_DEFINE_UNQUOTED([MODULES_DIRNAME],["$MODULES_DIRNAME"],[Module directory dirname])
fi
AC_SUBST([MODULES_DIRNAME])

MODULES_RELATIVE_PATH="${MODULES_DIRNAME}"
AC_SUBST([MODULES_RELATIVE_PATH])
MODULES_PATH="${LIBRARY_PATH}/${MODULES_RELATIVE_PATH}"
AC_SUBST([MODULES_PATH])

#
# path to coders lib
if test "x$CODER_DIRNAME" = "x"; then
   CODER_DIRNAME="coders"
fi
AC_DEFINE_UNQUOTED([CODER_DIRNAME],["$CODER_DIRNAME"],[coders subdirectory.])
AC_SUBST([CODER_DIRNAME])

CODER_RELATIVE_PATH="${CODER_DIRNAME}"
CODER_PATH="${MODULES_PATH}/${CODER_DIRNAME}"
AC_SUBST([CODER_PATH])

#
# Subdirectory under lib to place ImageMagick filter module files
#
# path to coders lib
if test "x$FILTER_DIRNAME" = "x"; then
   FILTER_DIRNAME="filters"
fi
AC_DEFINE_UNQUOTED([FILTER_DIRNAME],["$FILTER_DIRNAME"],[filter subdirectory.])
AC_SUBST([FILTER_DIRNAME])

FILTER_RELATIVE_PATH="${FILTER_DIRNAME}"
FILTER_PATH="${MODULES_PATH}/${FILTER_DIRNAME}"
AC_SUBST([FILTER_PATH])

#
# Path to ImageMagick documentation files
DOCUMENTATION_RELATIVE_PATH="${PACKAGE_NAME}-${MAGICK_MAJOR_VERSION}"
DOCUMENTATION_PATH="${DOC_DIR}/${DOCUMENTATION_RELATIVE_PATH}"
DEFINE_DOCUMENTATION_PATH="${DOC_DIR}/${DOCUMENTATION_RELATIVE_PATH}/"
case "${build_os}" in
  mingw* )
    DEFINE_DOCUMENTATION_PATH=`$WinPathScript "$DEFINE_DOCUMENTATION_PATH" 1`
    ;;
esac
AC_DEFINE_UNQUOTED([DOCUMENTATION_PATH],["$DEFINE_DOCUMENTATION_PATH"],[Directory where ImageMagick documents live.])
AC_SUBST([DOCUMENTATION_PATH])

#
# Enable/Disable documentation
AC_ARG_ENABLE([docs],
  [AS_HELP_STRING([--disable-docs],
    [disable building of documentation])],
  wantdocs=$enableval, wantdocs=yes)
AM_CONDITIONAL([INSTALL_DOC],[test "$wantdocs" = "yes"])

# Subdirectory to place architecture-dependent configuration files
CONFIGURE_RELATIVE_PATH="${PACKAGE_NAME}-${MAGICK_MAJOR_VERSION}"
AC_DEFINE_UNQUOTED([CONFIGURE_RELATIVE_PATH],["$CONFIGURE_RELATIVE_PATH"],[Subdirectory of lib where architecture-dependent configuration files live.])
CONFIGURE_PATH="${SYSCONF_DIR}/${CONFIGURE_RELATIVE_PATH}/"
DEFINE_CONFIGURE_PATH="${SYSCONF_DIR}/${CONFIGURE_RELATIVE_PATH}/"
case "${build_os}" in
  mingw* )
    DEFINE_CONFIGURE_PATH=`$WinPathScript "$DEFINE_CONFIGURE_PATH" 1`
    ;;
esac
AC_DEFINE_UNQUOTED([CONFIGURE_PATH],["$DEFINE_CONFIGURE_PATH"],[Directory where architecture-dependent configuration files live.])
AC_SUBST([CONFIGURE_PATH])

# Subdirectory to place architecture-independent configuration files
SHARE_RELATIVE_PATH="${PACKAGE_NAME}-${MAGICK_MAJOR_VERSION}"
AC_DEFINE_UNQUOTED([SHARE_RELATIVE_PATH],["$SHARE_RELATIVE_PATH"],[Subdirectory of lib where architecture-independent configuration files live.])
SHARE_PATH="${DATA_DIR}/${SHARE_RELATIVE_PATH}"
DEFINE_SHARE_PATH="${DATA_DIR}/${SHARE_RELATIVE_PATH}/"
case "${build_os}" in
  mingw* )
    DEFINE_SHARE_PATH=`$WinPathScript "$DEFINE_SHARE_PATH" 1`
    ;;
esac
AC_DEFINE_UNQUOTED([SHARE_PATH],["$DEFINE_SHARE_PATH"],[Directory where architecture-independent configuration files live.])
AC_SUBST([SHARE_PATH])

#
# Subdirectory to place architecture-dependent configuration files.
if test "x$SHAREARCH_BASEDIRNAME" = "x"; then
   SHAREARCH_BASEDIRNAME="config"
fi
AC_DEFINE_UNQUOTED([SHAREARCH_BASEDIRNAME],["$SHAREARCH_BASEDIRNAME"],[Sharearch directory name without ABI part.])
AC_SUBST([SHAREARCH_BASEDIRNAME])

if test "x$SHAREARCH_DIRNAME" = "x"; then
  SHAREARCH_DIRNAME=${SHAREARCH_BASEDIRNAME}-${MAGICK_ABI_SUFFIX}
else
  AC_DEFINE_UNQUOTED([SHAREARCH_DIRNAME],["$SHAREARCH_DIRNAME"],[Sharearch directory dirname])
fi
AC_SUBST([SHAREARCH_DIRNAME])

SHAREARCH_RELATIVE_PATH="${SHAREARCH_DIRNAME}"
AC_SUBST([SHAREARCH_RELATIVE_PATH])
SHAREARCH_PATH="${LIBRARY_PATH}/${SHAREARCH_RELATIVE_PATH}"
AC_SUBST([SHAREARCH_PATH])

#
# program_transform_name is formed for use in a Makefile, so create a
# modified version for use in a shell script.
configure_transform_name=`echo ${program_transform_name} | sed 's,\\$\\$,$,'`

# Default delegate definitions
AC_MSG_RESULT([-------------------------------------------------------------])
AC_MSG_CHECKING([for ImageMagick delegate programs])
AC_MSG_RESULT([])
BPGDecodeDelegateDefault='bpgdec'
BPGEncodeDelegateDefault='bpgenc'
BlenderDecodeDelegateDefault='blender'
BrowseDelegateDefault='xdg-open'
DNGDecodeDelegateDefault='darktable-cli'
DOCDecodeDelegateDefault='libreoffice'
GVCDecodeDelegateDefault='dot'
DVIDecodeDelegateDefault='dvips'
EditorDelegateDefault='xterm'
ConvertDelegateDefault=`echo magick | sed ${configure_transform_name}`
DisplayDelegateDefault=`echo magick | sed ${configure_transform_name}`
Fig2devDelegateDefault='fig2dev'
MogrifyDelegateDefault=`echo magick | sed ${configure_transform_name}`
HPGLDecodeDelegateDefault='hp2xx'
HTMLDecodeDelegateDefault='html2ps'
ILBMDecodeDelegateDefault='ilbmtoppm'
ILBMEncodeDelegateDefault='ppmtoilbm'
JXRDecodeDelegateDefault='JxrDecApp'
JXREncodeDelegateDefault='JxrEncApp'
LEPDelegateDefault='lepton'
LPDelegateDefault='lp'
LPRDelegateDefault='lpr'
LaunchDelegateDefault='gimp'
MrSIDDecodeDelegateDefault='mrsidgeodecode'
MVDelegateDefault='mv'
PCLDelegateDefault='pcl6'
if test "$native_win32_build" = 'yes'; then
    PSDelegateDefault='gswin32c'
elif test "$gslib_framework" = 'yes'; then
    PSDelegateDefault='gsc'
else
    PSDelegateDefault='gs'
fi
RMDelegateDefault='rm'
RSVGDecodeDelegateDefault='rsvg-convert'
SVGDecodeDelegateDefault='inkscape'
TextEncodeDelegateDefault='tesseract'
TraceEncodeDelegateDefault='potrace'
VIDEODecodeDelegateDefault='ffmpeg'
VIDEOEncodeDelegateDefault='ffmpeg'
WebPDecodeDelegateDefault='dwebp'
WebPEncodeDelegateDefault='cwebp'
WWWDecodeDelegateDefault='curl'
XPSDelegateDefault='gxps'

# Search for delegates
AC_PATH_PROG([BPGDecodeDelegate],["$BPGDecodeDelegateDefault"],["$BPGDecodeDelegateDefault"])
AC_PATH_PROG([BPGEncodeDelegate],["$BPGEncodeDelegateDefault"],["$BPGEncodeDelegateDefault"])
AC_PATH_PROG([BlenderDecodeDelegate],["$BlenderDecodeDelegateDefault"],["$BlenderDecodeDelegateDefault"])
AC_PATH_PROGS([BrowseDelegate],["$BrowseDelegateDefault" google-chrome firefox konqueror mozilla lynx],["$BrowseDelegateDefault"])
AC_PATH_PROG([DNGDecodeDelegate],["$DNGDecodeDelegateDefault"],["$DNGDecodeDelegateDefault"])
AC_PATH_PROG([DOCDecodeDelegate],["$DOCDecodeDelegateDefault"],["$DOCDecodeDelegateDefault"])
AC_PATH_PROG([DVIDecodeDelegate],["$DVIDecodeDelegateDefault"],["$DVIDecodeDelegateDefault"])
AC_PATH_PROG([ConvertDelegate],["$ConvertDelegateDefault"],["$ConvertDelegateDefault"])
AC_PATH_PROG([DisplayDelegate],["$DisplayDelegateDefault"],["$DisplayDelegateDefault"])
AC_PATH_PROG([EditorDelegate],["$EditorDelegateDefault"],["$EditorDelegateDefault"])
AC_PATH_PROG([GVCDecodeDelegate],["$GVCDecodeDelegateDefault"],["$GVCDecodeDelegateDefault"])
AC_PATH_PROG([HPGLDecodeDelegate],["$HPGLDecodeDelegateDefault"],["$HPGLDecodeDelegateDefault"])
AC_PATH_PROG([HTMLDecodeDelegate],["$HTMLDecodeDelegateDefault"],["$HTMLDecodeDelegateDefault"])
AC_PATH_PROG([ILBMDecodeDelegate],["$ILBMDecodeDelegateDefault"],["$ILBMDecodeDelegateDefault"])
AC_PATH_PROG([ILBMEncodeDelegate],["$ILBMEncodeDelegateDefault"],["$ILBMEncodeDelegateDefault"])
AC_PATH_PROG([JXRDecodeDelegate],["$JXRDecodeDelegateDefault"],["$JXRDecodeDelegateDefault"])
AC_PATH_PROG([JXREncodeDelegate],["$JXREncodeDelegateDefault"],["$JXREncodeDelegateDefault"])
AC_PATH_PROG([LEPDelegate],["$LEPDelegateDefault"],["$LEPDelegateDefault"])
AC_PATH_PROG([LPDelegate],["$LPDelegateDefault"],[no])
AC_PATH_PROG([LPRDelegate],["$LPRDelegateDefault"],["$LPRDelegateDefault"])
AC_PATH_PROG([LaunchDelegate],["$LaunchDelegateDefault"],["$LaunchDelegateDefault"])
AC_PATH_PROG([MogrifyDelegate],["$MogrifyDelegateDefault"],["$MogrifyDelegateDefault"])
AC_PATH_PROG([VIDEODecodeDelegate],["$VIDEODecodeDelegateDefault"],["$VIDEODecodeDelegateDefault"])
AC_PATH_PROG([VIDEOEncodeDelegate],["$VIDEOEncodeDelegateDefault"],["$VIDEOEncodeDelegateDefault"])
AC_PATH_PROG([MrSIDDecodeDelegate],["$MrSIDDecodeDelegateDefault"],["$MrSIDDecodeDelegateDefault"])
AC_PATH_PROG([MVDelegate],["$MVDelegateDefault"],["$MVDelegateDefault"])
AC_PATH_PROG([PCLDelegate],["$PCLDelegateDefault"],["$PCLDelegateDefault"])
AC_PATH_PROGS([PSDelegate],[gsx gsc "$PSDelegateDefault"],["$PSDelegateDefault"])
AC_PATH_PROG([RMDelegate],["$RMDelegateDefault"],["$RMDelegateDefault"])
AC_PATH_PROG([RSVGDecodeDelegate],["$RSVGDecodeDelegateDefault"],["$RSVGDecodeDelegateDefault"])
AC_PATH_PROG([SVGDecodeDelegate],["$SVGDecodeDelegateDefault"],["$SVGDecodeDelegateDefault"])
AC_PATH_PROG([TextEncodeDelegate],["$TextEncodeDelegateDefault"],["$TextEncodeDelegateDefault"])
AC_PATH_PROG([TraceEncodeDelegate],["$TraceEncodeDelegateDefault"],["$TraceEncodeDelegateDefault"])
AC_PATH_PROG([Fig2devDelegate],["$Fig2devDelegateDefault"],["$Fig2devDelegateDefault"])
AC_PATH_PROG([WebPDecodeDelegate],["$WebPDecodeDelegateDefault"],["$WebPDecodeDelegateDefault"])
AC_PATH_PROG([WebPEncodeDelegate],["$WebPEncodeDelegateDefault"],["$WebPEncodeDelegateDefault"])
AC_PATH_PROG([WWWDecodeDelegate],["$WWWDecodeDelegateDefault"],["$WWWDecodeDelegateDelegateDefault"])
AC_PATH_PROG([XPSDelegate],["$XPSDelegateDefault"],["$XPSDelegateDefault"])

# Prefer lpr to lp; lp needs options tacked on.
if test "$LPRDelegate" != no; then
    PrintDelegate="$LPRDelegate"
else
    PrintDelegate="$LPDelegate -c -s"
fi
AC_SUBST([PrintDelegate])

# Installed ImageMagick utility paths
ConvertDelegate="${BIN_DIR}/${ConvertDelegateDefault}"
DisplayDelegate="${BIN_DIR}/${DisplayDelegateDefault}"
MogrifyDelegate="${BIN_DIR}/${MogrifyDelegateDefault}"

# Set delegate booleans
have_gs='no'         ; if test "$PSDelegate" != "$PSDelegateDefault"; then have_gs='yes'; fi
have_hp2xx='no'      ; if test "$HPGLDecodeDelegate" !=  "$HPGLDecodeDelegateDefault" ; then have_hp2xx='yes'; fi
have_ilbmtoppm='no'  ; if test "$ILBMDecodeDelegate" != "$ILBMDecodeDelegateDefault" ; then have_ilbmtoppm='yes'; fi
have_mrsid='no'; if test "$MrSIDDecodeDelegate" != "$MrSIDDecodeDelegateDefault" ; then have_mrsid='yes'; fi
have_pcl='no'        ; if test "$PCLDelegate" != "$PCLDelegateDefault"; then have_pcl='yes'; fi
have_ppmtoilbm='no'  ; if test "$ILBMEncodeDelegate" != "$ILBMEncodeDelegateDefault" ; then have_ppmtoilbm='yes'; fi
have_video='no'; if test "$VIDEODecodeDelegate" != "$VIDEODecodeDelegateDefault" ; then have_video='yes'; fi
have_xps='no'        ; if test "$XPSDelegate" != "$XPSDelegateDefault"; then have_xps='yes'; fi

#
# Test for font directories
#
type_include_files=''

# Apple fonts.
AC_MSG_CHECKING([for Apple fonts directory])
apple_font_dir=''
if test "${with_apple_font_dir}" != 'default'; then
  apple_font_dir="${with_apple_font_dir}/"
else
  for font_dir in '/Library/Fonts/'; do
    if test -f "${font_dir}Arial.ttf"; then
      apple_font_dir="${font_dir}"
      break 1
    fi
  done
fi
if test "${apple_font_dir}x" != 'x'; then
  type_include_files="${type_include_files} "'<include file="type-apple.xml" />'
  AC_MSG_RESULT([$apple_font_dir])
else
  AC_MSG_RESULT([not found!]);
fi
AC_SUBST([apple_font_dir])

# Dejavu fonts.
AC_MSG_CHECKING([for Dejavu fonts directory])
dejavu_font_dir=''
if test "${with_dejavu_font_dir}" != 'default'; then
  dejavu_font_dir="${with_dejavu_font_dir}/"
else
  for font_dir in "${prefix}/share/dejavu/fonts/" '/usr/share/fonts/dejavu/'; do
    if test -f "${font_dir}DejaVuSerif.ttf"; then
      dejavu_font_dir="${font_dir}"
      break 1
    fi
  done
fi
if test "${dejavu_font_dir}x" != 'x'; then
  type_include_files="${type_include_files} "'<include file="type-dejavu.xml" />'
  AC_MSG_RESULT([$dejavu_font_dir])
else
  AC_MSG_RESULT([not found!]);
fi
AC_SUBST([dejavu_font_dir])

# Ghostscript
AC_MSG_CHECKING([for Ghostscript fonts directory])
ghostscript_font_dir=''
if test "${with_gs_font_dir}" != 'default'; then
  ghostscript_font_dir="${with_gs_font_dir}/"
else
  if test "${native_win32_build}" = 'yes'; then
    # Native Windows Build
    for font_dir in "c:\\Program Files\\gs\\fonts\\" "c:\\Program Files \(x86\)\\gs\\fonts\\" "c:\\gs\\fonts\\"; do
      if test -f "${font_dir}a010013l.pfb"; then
        ghostscript_font_dir="$font_dir"
        break 1
      fi
    done
    if test "${PSDelegate}" != 'gswin32c'; then
      ghostscript_font_dir=`echo "${PSDelegate}" | sed -e 's:/gs/.*:/gs:;s:^/::;s/./&:/;s:/:\\\\:g'`"\\fonts\\"
    fi
  else
    # Linux / Mac OS X / Unix Build
    for font_dir in "${prefix}/share/ghostscript/fonts/" '/usr/share/fonts/default/Type1/' '/usr/share/ghostscript/fonts/' '/usr/share/fonts/ghostscript/' '/usr/share/fonts/type1/gsfonts/' '/opt/local/share/ghostscript/fonts/' '/sw/share/ghostscript/fonts/' '/System/Library/Frameworks/Ghostscript.framework/Resources/fonts/'; do
      if test -f "${font_dir}a010013l.pfb"; then
        ghostscript_font_dir="${font_dir}"
        break 1
      fi
    done
    if test "${ghostscript_font_dir}x" = 'x'; then
      if test "$PSDelegate" != 'gs'; then
        ghostscript_font_dir=`echo "$PSDelegate" | sed -e 's:/bin/gs:/share/ghostscript/fonts:'`"/"
      fi
    fi
  fi
fi
if test "${ghostscript_font_dir}x" != 'x'; then
  type_include_files="${type_include_files} "'<include file="type-ghostscript.xml" />'
  AC_MSG_RESULT([$ghostscript_font_dir])
else
  AC_MSG_RESULT([not found!]);
fi
AC_SUBST([ghostscript_font_dir])
case "${build_os}" in
  mingw* )
    PSDelegate=`$WinPathScript "$PSDelegate" 1`
    ;;
esac

# URW-base35 fonts.
AC_MSG_CHECKING([for URW-base35 fonts directory])
urw_base35_font_dir=''
if test "${with_urw_base35_font_dir}" != 'default'; then
  urw_base35_font_dir="${with_urw_base35_font_dir}/"
fi
if test "${urw_base35_font_dir}x" != 'x'; then
  type_include_files="${type_include_files} "'<include file="type-urw-base35.xml" />'
  AC_MSG_RESULT([$urw_base35_font_dir])
else
  AC_MSG_RESULT([not found!]);
fi
AC_SUBST([urw_base35_font_dir])

# Windows fonts.
AC_MSG_CHECKING([for Windows fonts directory])
windows_font_dir=''
if test "${with_windows_font_dir}" != 'default'; then
  windows_font_dir="${with_windows_font_dir}/"
else
  for font_dir in '/usr/X11R6/lib/X11/fonts/truetype/' '/usr/X11R7/lib/X11/fonts/truetype/' '/usr/share/fonts/msttcore/' '/usr/share/fonts/microsoft/' '/usr/share/fonts/truetype/msttcorefonts/'; do
    if test -f "${font_dir}arial.ttf"; then
      windows_font_dir="${font_dir}"
      break 1
    fi
  done
fi
if test "${windows_font_dir}x" != 'x'; then
  type_include_files="${type_include_files} "'<include file="type-windows.xml" />'
  AC_MSG_RESULT([$windows_font_dir])
else
  AC_MSG_RESULT([not found!]);
fi
AC_SUBST([windows_font_dir])

AC_SUBST([type_include_files])

# Permit enciphering and deciphering image pixels.
AC_ARG_ENABLE([cipher],
    [AS_HELP_STRING([--disable-cipher],
                    [disable enciphering and deciphering image pixels])],
    [enable_cipher=$enableval],
    [enable_cipher='yes'])

if test "$enable_cipher" = 'yes'; then
    AC_DEFINE([CIPHER_SUPPORT],[1],[permit enciphering and deciphering image pixels])
    MAGICK_FEATURES="Cipher $MAGICK_FEATURES"
fi

#
# Check for extended channel masks.
#
AC_ARG_ENABLE([64bit_channel_masks],
    [AS_HELP_STRING([--enable-64bit-channel-masks],
                    [enable 64-bit channel masks])],
    [enable_64bit_channel_masks=$enableval],
    [enable_64bit_channel_masks='no'])

AC_ARG_ENABLE([force_cpp],
    [AS_HELP_STRING([--enable-force-cpp],
                    [treat the input files as C++ code])],
    [enable_force_cpp=$enableval],
    [enable_force_cpp='no'])

magick_channel_mask_depth='32';
if test "$enable_64bit_channel_masks" = 'yes'; then
    if test "$enable_force_cpp" = 'yes'; then
        AC_MSG_CHECKING([whether the compiler supports -x c++ option])
        old_CFLAGS="$CFLAGS"
        CFLAGS="$CFLAGS -x c++"
        AC_COMPILE_IFELSE([
          AC_LANG_PROGRAM([
            enum Days : int { Monday = 1 };
          ],
          [
          ])
        ], [
          AC_MSG_RESULT([yes])
          magick_channel_mask_depth='64';
        ], [
          AC_MSG_RESULT([no])
        ])
        if test "$magick_channel_mask_depth" != '64'; then
          CFLAGS="$old_CFLAGS"
        fi
    else
        AC_MSG_CHECKING([whether the compiler supports enum type modifiers])
        AC_COMPILE_IFELSE([
          AC_LANG_PROGRAM([
            enum Days : int { Monday = 1 };
          ],
          [
          ])
        ], [
          AC_MSG_RESULT([yes])
          magick_channel_mask_depth='64';
        ], [
          AC_MSG_RESULT([no])
        ])
    fi
fi
if test "$magick_channel_mask_depth" = '64'; then
    MAGICK_FEATURES="Channel-masks(64-bit) $MAGICK_FEATURES"
else
    MAGICK_FEATURES="Channel-masks(32-bit) $MAGICK_FEATURES"
fi
AC_DEFINE_UNQUOTED([CHANNEL_MASK_DEPTH],[$magick_channel_mask_depth],[Channel mask depth])
CHANNEL_MASK_DEPTH=$magick_channel_mask_depth
AC_SUBST([CHANNEL_MASK_DEPTH])dnl
MAGICK_PCFLAGS="$MAGICK_PCFLAGS -DMAGICKCORE_CHANNEL_MASK_DEPTH=$magick_channel_mask_depth"
CFLAGS="$CFLAGS -DMAGICKCORE_CHANNEL_MASK_DEPTH=$magick_channel_mask_depth"
CPPFLAGS="$CPPFLAGS -DMAGICKCORE_CHANNEL_MASK_DEPTH=$magick_channel_mask_depth"

#
# Handle case where user doesn't want frozen paths
#
if test "$with_frozenpaths" != 'yes'; then
  # Re-set delegate definitions to default (no paths)
  BPGDecodeDelegate="$BPGDecodeDelegateDefault"
  BPGEncodeDelegate="$BPGEncodeDelegateDefault"
  BlenderDecodeDelegate="$BlenderDecodeDelegateDefault"
  BrowseDelegate="$BrowseDelegateDefault"
  ConvertDelegate="$ConvertDelegateDefault"
  DisplayDelegate="$DisplayDelegateDefault"
  DNGDecodeDelegate="$DNGDecodeDelegateDefault"
  DOCDecodeDelegate="$DOCDecodeDelegateDefault"
  DVIDecodeDelegate="$DVIDecodeDelegateDefault"
  EditorDelegate="$EditorDelegateDefault"
  GVCDecodeDelegate="$GVCDecodeDelegateDefault"
  HPGLDecodeDelegate="$HPGLDecodeDelegateDefault"
  HTMLDecodeDelegate="$HTMLDecodeDelegateDefault"
  ILBMDecodeDelegate="$ILBMDecodeDelegateDefault"
  ILBMEncodeDelegate="$ILBMEncodeDelegateDefault"
  JXRDecodeDelegate="$JXRDecodeDelegateDefault"
  JXREncodeDelegate="$JXREncodeDelegateDefault"
  LEPDelegate="$LEPDelegateDefault"
  LPDelegate="$LPDelegateDefault"
  LaunchDelegate="$LaunchDelegateDefault"
  MogrifyDelegate="$MogrifyDelegateDefault"
  MrSIDDecodeDelegate="$MrSIDDecodeDelegateDefault"
  PCLDelegate="$PCLDelegateDefault"
  PSDelegate="$PSDelegateDefault"
  RSVGDecodeDelegate="$RSVGDecodeDelegateDefault"
  SVGDecodeDelegate="$SVGDecodeDelegateDefault"
  ShowImageDelegate="$ShowImageDelegateDefault"
  TextEncodeDelegate="$TextEncodeDelegateDefault"
  TraceEncodeDelegate="$TraceEncodeDelegateDefault"
  Fig2devDelegate="$Fig2devDelegateDefault"
  VIDEODecodeDelegate="$VIDEODecodeDelegateDefault"
  VIDEOEncodeDelegate="$VIDEOEncodeDelegateDefault"
  WebPDecodeDelegate="$WebPDecodeDelegateDefault"
  WebPEncodeDelegate="$WebPEncodeDelegateDefault"
  WWWDecodeDelegate="$WWWDecodeDelegateDefault"
  XPSDelegate="$XPSDelegateDefault"
fi

# Delegate substitutions
AC_SUBST([BPGDecodeDelegate])
AC_SUBST([BPGEncodeDelegate])
AC_SUBST([BlenderDecodeDelegate])
AC_SUBST([BrowseDelegate])
AC_SUBST([ConvertDelegate])
AC_SUBST([GVCDecodeDelegate])
AC_SUBST([DVIDecodeDelegate])
AC_SUBST([EditorDelegate])
AC_SUBST([Fig2devDelegate])
AC_SUBST([HPGLDecodeDelegate])
AC_SUBST([HTMLDecodeDelegate])
AC_SUBST([ILBMDecodeDelegate])
AC_SUBST([ILBMEncodeDelegate])
AC_SUBST([JXRDecodeDelegate])
AC_SUBST([JXREncodeDelegate])
AC_SUBST([LaunchDelegate])
AC_SUBST([LEPDelegate])
AC_SUBST([LPDelegate])
AC_SUBST([VIDEODecodeDelegate])
AC_SUBST([VIDEOEncodeDelegate])
AC_SUBST([MogrifyDelegate])
AC_SUBST([MrSIDDecodeDelegate])
AC_SUBST([PCLDelegate])
AC_SUBST([PSDelegate])
AC_SUBST([ShowImageDelegate])
AC_SUBST([TextEncodeDelegate])
AC_SUBST([TraceEncodeDelegate])
AC_SUBST([WebPDecodeDelegate])
AC_SUBST([WebPEncodeDelegate])
AC_SUBST([WWWDecodeDelegate])
AC_SUBST([XPSDelegate])

#
# RPM support.
#
RPM=''
AC_CHECK_PROGS([TAR],[gnutar gtar tar])
AC_CHECK_PROGS([PERL],[perl])
AC_CHECK_PROGS([RPM],[rpmbuild rpm])
AM_MISSING_PROG([ACLOCAL],[aclocal],[$missing_dir])
AM_MISSING_PROG([AUTOCONF],[autoconf],[$missing_dir])
AM_MISSING_PROG([AUTOMAKE],[automake],[$missing_dir])
AM_MISSING_PROG([AUTOHEADER],[autoheader],[$missing_dir])
AC_SUBST([RPM])
AM_CONDITIONAL([RPM_DELEGATE],[test "x$RPM" != "x"])

#
# 7ZIP support (http://p7zip.sourceforge.net/)
#
P7ZIP=''
AC_CHECK_PROGS([P7ZIP],[7za])
AC_SUBST([P7ZIP])
AM_CONDITIONAL([P7ZIP_DELEGATE],[test "x$P7ZIP" != "x"])

#
# ZIP support (http://www.info-zip.org/Zip.html)
#
ZIP=''
AC_CHECK_PROGS([ZIP],[zip])
AC_SUBST([ZIP])
AM_CONDITIONAL([ZIP_DELEGATE],[test "x$ZIP" != "x"])

#
# GhostPCL related configuration.
#
PCLColorDevice=ppmraw
PCLCMYKDevice=pamcmyk32
PCLMonoDevice=pbmraw
if test -z "$PCLVersion"; then
    PCLVersion='unknown'
fi
if test $have_pcl = 'yes'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for PCL])
    AC_MSG_RESULT([])
    # PCLColorDevice
    AC_MSG_CHECKING([for pcl color device])
    if $PCLDelegate -dBATCH -sDEVICE=$PCLColorDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        PCLColorDevice=ppmraw
    fi
    AC_MSG_RESULT([$PCLColorDevice])

    # PCLCMYKDevice
    AC_MSG_CHECKING([for pcl CMYK device])
    if $PCLDelegate -dBATCH -sDEVICE=$PCLColorDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        PCLCMYKDevice=$PCLColorDevice
    fi
    AC_MSG_RESULT([$PCLCMYKDevice])

    # PCLMonoDevice
    AC_MSG_CHECKING([for pcl mono device])
    if $PCLDelegate -dBATCH -sDEVICE=$PCLMonoDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        PCLMonoDevice=$PCLColorDevice
    fi
    AC_MSG_RESULT([$PCLMonoDevice])
fi

AC_SUBST([PCLMonoDevice])
AC_SUBST([PCLColorDevice])
AC_SUBST([PCLCMYKDevice])
AC_SUBST([PCLVersion])

#
# GhostXPS related configuration.
#
XPSColorDevice=ppmraw
XPSCMYKDevice=bmpsep8
XPSMonoDevice=pbmraw
if test -z "$XPSVersion"; then
    XPSVersion='unknown'
fi
if test $have_xps = 'yes'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for XPS])
    AC_MSG_RESULT([])
    # XPSColorDevice
    AC_MSG_CHECKING([for xps color device])
    if $XPSDelegate -dBATCH -sDEVICE=$XPSColorDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        XPSColorDevice=ppmraw
    fi
    AC_MSG_RESULT([$XPSColorDevice])

    # XPSCMYKDevice
    AC_MSG_CHECKING([for xps CMYK device])
    if $XPSDelegate -dBATCH -sDEVICE=$XPSColorDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        XPSCMYKDevice=$XPSColorDevice
    fi
    AC_MSG_RESULT([$XPSCMYKDevice])

    # XPSMonoDevice
    AC_MSG_CHECKING([for xps mono device])
    if $XPSDelegate -dBATCH -sDEVICE=$XPSMonoDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        XPSMonoDevice=$XPSColorDevice
    fi
    AC_MSG_RESULT([$XPSMonoDevice])
fi

AC_SUBST([XPSMonoDevice])
AC_SUBST([XPSColorDevice])
AC_SUBST([XPSCMYKDevice])
AC_SUBST([XPSVersion])

#
# Ghostscript related configuration.
#
GSAlphaDevice=pngalpha
GSColorDevice=png16m
GSCMYKDevice=pamcmyk32
GSMonoDevice=pbmraw
GSPDFDevice=pdfwrite
GSPSDevice=ps2write
GSEPSDevice=eps2write
GSVersion='unknown'
if test $have_gs = 'yes'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for Ghostscript])
    AC_MSG_RESULT([])
    AC_MSG_CHECKING([for Ghostscript version])
    if GSVersion=`$PSDelegate --version`; then
        :
    else
        GSVersion=`$PSDelegate --help | sed -e '1q' | awk '{ print $3 }'`
    fi
    AC_MSG_RESULT([$GSVersion])

    # GSColorDevice
    AC_MSG_CHECKING([for gs color device])
    if $PSDelegate -q -dBATCH -sDEVICE=$GSColorDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        GSColorDevice=ppmraw
    fi
    AC_MSG_RESULT([$GSColorDevice])

    # GSAlphaDevice
    AC_MSG_CHECKING([for gs alpha device])
    if $PSDelegate -q -dBATCH -sDEVICE=$GSAlphaDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        GSAlphaDevice=$GSColorDevice
    fi
    AC_MSG_RESULT([$GSAlphaDevice])

    # GSCMYKDevice
    AC_MSG_CHECKING([for gs CMYK device])
    if $PSDelegate -q -dBATCH -sDEVICE=$GSCMYKDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        GSCMYKDevice=pam
    fi
    AC_MSG_RESULT([$GSCMYKDevice])

    # GSMonoDevice
    AC_MSG_CHECKING([for gs mono device])
    if $PSDelegate -q -dBATCH -sDEVICE=$GSMonoDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        GSMonoDevice=$GSColorDevice
    fi
    AC_MSG_RESULT([$GSMonoDevice])

    # GSPDFDevice
    AC_MSG_CHECKING([for gs PDF writing device])
    if $PSDelegate -q -dBATCH -sDEVICE=$GSPDFDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        GSPDFDevice=nodevice
    fi
    AC_MSG_RESULT([$GSPDFDevice])

    # GSPSDevice
    AC_MSG_CHECKING([for gs PS writing device])
    if $PSDelegate -q -dBATCH -sDEVICE=$GSPSDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        GSPSDevice=pswrite
    fi
    AC_MSG_RESULT([$GSPSDevice])

    # GSEPSDevice
    AC_MSG_CHECKING([for gs EPS writing device])
    if $PSDelegate -q -dBATCH -sDEVICE=$GSEPSDevice -sOutputFile=/dev/null < /dev/null 1>&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
        :
    else
        GSEPSDevice=epswrite
    fi
    AC_MSG_RESULT([$GSEPSDevice])
fi

AC_SUBST([GSAlphaDevice])
AC_SUBST([GSCMYKDevice])
AC_SUBST([GSColorDevice])
AC_SUBST([GSEPSDevice])
AC_SUBST([GSMonoDevice])
AC_SUBST([GSPDFDevice])
AC_SUBST([GSPSDevice])
AC_SUBST([GSVersion])

#
# PerlMagick-related configuration
#

# Look for PERL if PerlMagick requested
# If name/path of desired PERL interpreter is specified, look for that one first
have_perl='no'
if test "$with_perl" != 'no'; then
    AC_MSG_RESULT([-------------------------------------------------------------])
    AC_MSG_CHECKING([for Perl])
    AC_MSG_RESULT([])
    if test "$with_perl" != 'yes'; then
        AC_CACHE_CHECK([for perl],[ac_cv_path_PERL],[ac_cv_path_PERL="$with_perl"]);
        PERL=$ac_cv_path_PERL
        AC_SUBST([PERL])dnl
        have_perl="$ac_cv_path_PERL"
    else
        AC_PATH_PROGS([PERL],[perl perl5],[])dnl
        if test "$ac_cv_path_PERL"; then
            have_perl="$ac_cv_path_PERL"
        fi
    fi
fi

if test "$with_perl" != 'yes' ; then
    DISTCHECK_CONFIG_FLAGS="${DISTCHECK_CONFIG_FLAGS} --with-perl=$with_perl "
fi

PERL_SUPPORTS_DESTDIR='no'

with_perl_static='no'
with_perl_dynamic='no'
if test "$have_perl" != 'no'; then
    if test "$with_perl" != 'no' && test "$libtool_build_shared_libs" = 'no'; then
        with_perl_static='yes'
    fi
    if test "$with_perl" != 'no' && test "$libtool_build_shared_libs" = 'yes'; then
        with_perl_dynamic='yes'
    fi
    # Is PERL's MakeMaker new enough to support DESTDIR?
    AX_PROG_PERL_VERSION(5.8.1,[PERL_SUPPORTS_DESTDIR='yes'],[PERL_SUPPORTS_DESTDIR='no'])
fi
AM_CONDITIONAL([WITH_PERL],[test "$have_perl" != 'no'])
AM_CONDITIONAL([WITH_PERL_STATIC],[test $with_perl_static = 'yes'])
AM_CONDITIONAL([WITH_PERL_DYNAMIC],[test $with_perl_dynamic = 'yes'])
AC_SUBST([PERL_SUPPORTS_DESTDIR])

# Determine path to pick up MagickCore library from for use with building PerlMagick
MAGICKCORE_PATH="${LIB_DIR}"
if test $with_perl_static = 'yes'; then
    # Find out where libtool hides its uninstalled libraries (as libtool_objdir)
    libtool_objdir=$objdir

    # Linker search path to library, followed by -lMagickCore
    MAGICKCORE_PATH="${builddir}/MagickCore/${libtool_objdir}"
fi
AC_SUBST([MAGICKCORE_PATH])

# Create a simple string containing format names for all delegate libraries.
MAGICK_DELEGATES=''
if test "$have_autotrace"  = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES autotrace"
fi
if test "$have_bzlib"  = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES bzlib"
fi
if test "$have_cairo"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES cairo"
fi
if test "$have_dmr"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES dmr"
fi
if test "$have_djvu"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES djvu"
fi
if test "$have_dps"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES dps"
fi
if test "$have_fftw"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES fftw"
fi
if test "$have_flif"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES flif"
fi
if test "$have_fpx"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES fpx"
fi
if test "$have_fontconfig"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES fontconfig"
fi
if test "$have_freetype"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES freetype"
fi
if test "$have_gslib"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES gslib"
fi
if test "$have_heic"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES heic"
fi
if test "$have_jbig"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES jbig"
fi
if test "$have_png$have_jpeg" = 'yesyes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES jng"
fi
if test "$have_openjp2"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES jp2"
fi
if test "$have_jpeg"   = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES jpeg"
fi
if test "$have_jxl"   = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES jxl"
fi
if test "$have_lcms" = 'yes' || test "$have_lcms2" = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES lcms"
fi
if test "$have_lqr"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES lqr"
fi
if test "$have_lzma"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES lzma"
fi
if test "$have_openexr"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES openexr"
fi
if test "$have_pangocairo" = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES pangocairo"
fi
if test "$have_png"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES png"
fi
have_ps='no'
if test "$have_dps"    = 'yes' || \
   test "$have_gs" = 'yes' || \
   test "${native_win32_build}" = 'yes' ; then
   have_ps='yes'
fi
if test "$have_ps"     = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES ps"
fi
if test "$have_raqm"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES raqm"
fi
if test "$have_raw"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES raw"
fi
if test "$have_ra_ppm" = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES rad"
fi
if test "$have_rsvg"   = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES rsvg"
fi
if test "$have_tiff"   = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES tiff"
fi
if test "$have_ttf"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES ttf"
fi
if test "$have_uhdr"   = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES uhdr"
fi
if test "$have_video"   = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES video"
fi
if test "$have_webp"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES webp"
fi
if test "$have_wmf"    = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES wmf"
fi
if test "$have_x"      = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES x"
fi
if test "$have_xml"      = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES xml"
fi
if test "$have_zip"   = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES zip"
fi
if test "$have_zlib"   = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES zlib"
fi
if test "$have_zstd"   = 'yes' ; then
   MAGICK_DELEGATES="$MAGICK_DELEGATES zstd"
fi

# Remove extraneous spaces from output variables (aesthetic)
MAGICK_DELEGATES=`echo $MAGICK_DELEGATES | sed -e 's/  */ /g'`
MAGICK_FEATURES=`echo $MAGICK_FEATURES | sed -e 's/  */ /g'`
AC_SUBST([MAGICK_DELEGATES])
AC_SUBST([MAGICK_FEATURES])

#
# Handle special compiler flags
#

# Add '-p' if prof source profiling support enabled
if test "$enable_prof" = 'yes'; then
    CFLAGS="-p $CFLAGS"
    CXXFLAGS="-p $CXXFLAGS"
    LDFLAGS="-p $LDFLAGS"
fi

# Add '-pg' if gprof source profiling support enabled
if test "$enable_gprof" = 'yes'; then
    CFLAGS="-pg $CFLAGS"
    CXXFLAGS="-pg $CXXFLAGS"
    LDFLAGS="-pg $LDFLAGS"
fi

# Add '-ftest-coverage -fprofile-arcs' if gcov source profiling support enabled
# This is a gcc-specific feature
if test "$enable_gcov" = 'yes'; then
    AC_CHECK_LIB([gcov],[_gcov_init],[],[])
    AC_CHECK_LIB([gcov],[__gcov_init],[],[])
    case "$target_os" in
        darwin*)
            OSX_GCOV_LDFLAG="-Wl,-single_module"
        ;;
        *)
            OSX_GCOV_LDFLAG=""
        ;;
    esac
    AC_SUBST([OSX_GCOV_LDFLAG])
    CFLAGS="-ftest-coverage -fprofile-arcs  $CFLAGS"
    CXXFLAGS="-ftest-coverage -fprofile-arcs  $CXXFLAGS"
    LDFLAGS="-ftest-coverage -fprofile-arcs $LDFLAGS"
fi

#
# Build library dependency list for libMagickCore
#

if test "$build_modules" != 'no'; then
    MAGICK_DEP_LIBS="$USER_LIBS $LCMS_LIBS $DMR_LIBS $FREETYPE_LIBS $RAQM_LIBS $LQR_LIBS $FFTW_LIBS $XML_LIBS $FLIF_LIBS $FONTCONFIG_LIBS $XEXT_LIBS $IPC_LIBS $X11_LIBS $XT_LIBS $BZLIB_LIBS $ZLIB_LIBS $ZIP_LIBS $ZSTD_LIBS $LTDL_LIBS $GDI32_LIBS $MATH_LIBS $CL_LIBS $UMEM_LIBS $JEMALLOC_LIBS $THREAD_LIBS $TCMALLOC_LIBS $MTMALLOC_LIBS"
else
    MAGICK_DEP_LIBS="$USER_LIBS $JBIG_LIBS $LCMS_LIBS $DMR_LIBS $TIFF_LIBS $FREETYPE_LIBS $RAQM_LIBS $JPEG_LIBS $JXL_LIBS $GS_LIBS $LQR_LIBS $PNG_LIBS $AUTOTRACE_LIBS $DJVU_LIBS $FFTW_LIBS $FLIF_LIBS $FPX_LIBS $FONTCONFIG_LIBS $HEIF_LIBS $WEBPMUX_LIBS $WEBP_LIBS $WMF_LIBS $DPS_LIBS $XEXT_LIBS $XT_LIBS $IPC_LIBS $X11_LIBS $LZMA_LIBS $BZLIB_LIBS $OPENEXR_LIBS $LIBOPENJP2_LIBS $PANGO_LIBS $RAW_R_LIBS $RSVG_LIBS $XML_LIBS $GVC_LIBS $ZLIB_LIBS $ZIP_LIBS $ZSTD_LIBS $LTDL_LIBS $GDI32_LIBS $MATH_LIBS $CL_LIBS $UMEM_LIBS $JEMALLOC_LIBS $THREAD_LIBS $TCMALLOC_LIBS $MTMALLOC_LIBS $UHDR_LIBS"
fi
MAGICK_EXTRA_DEP_LIBS="$GOMP_LIBS"
AC_SUBST([MAGICK_DEP_LIBS])
AC_SUBST([MAGICK_EXTRA_DEP_LIBS])

# Pass only user-provided LIBS as "global" libraries
LIBS=$USER_LIBS

#AC_SUBST([CPPFLAGS])
AC_SUBST([X_CFLAGS])
#AC_SUBST([LDFLAGS])
#AC_SUBST([X_PRE_LIBS])
#AC_SUBST([X_LIBS])
#AC_SUBST([X_EXTRA_LIBS])

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'`
LIBS=`echo $LIBS | sed -e 's/  */ /g'`

MAGICK_CFLAGS=$CFLAGS
MAGICK_CXXFLAGS="$CXXFLAGS"
MAGICK_CPPFLAGS=`echo $MAGICK_CPPFLAGS | sed -e 's/  */ /g'`
MAGICK_PCFLAGS=`echo $MAGICK_PCFLAGS | sed -e 's/  */ /g'`
MAGICK_LDFLAGS="-L$LIB_DIR $LDFLAGS"
MAGICK_LIBS="$MAGICK_DEP_LIBS $MAGICK_EXTRA_DEP_LIBS"
MAGICK_DEP_LIBS=`echo $MAGICK_DEP_LIBS | sed -e 's/  */ /g'`
MAGICK_EXTRA_DEP_LIBS=`echo $MAGICK_EXTRA_DEP_LIBS | sed -e 's/  */ /g'`

AC_SUBST([MAGICK_CFLAGS])
AC_SUBST([MAGICK_CXXFLAGS])
AC_SUBST([MAGICK_CPPFLAGS])
AC_SUBST([MAGICK_PCFLAGS])
AC_SUBST([MAGICK_LDFLAGS])
AC_SUBST([MAGICK_LIBS])

# Set configured scripts to executable.
AC_CONFIG_COMMANDS([default],[],[])
AC_CONFIG_COMMANDS([magick.sh.in],[chmod +x magick.sh])
AC_CONFIG_COMMANDS([MagickCore-config.in],[chmod +x MagickCore/MagickCore-config])
AC_CONFIG_COMMANDS([MagickWand-config.in],[chmod +x MagickWand/MagickWand-config])
AC_CONFIG_COMMANDS([Magick++-config.in],[chmod +x Magick++/bin/Magick++-config])
AC_CONFIG_COMMANDS([PerlMagick/check.sh.in],[chmod +x PerlMagick/check.sh])

AC_MSG_RESULT([-------------------------------------------------------------])
AC_MSG_RESULT([Update ImageMagick configuration])

rm -f magick-version

result_dejavu_font_dir='none'
if test "${dejavu_font_dir}x" != 'x'; then
    result_dejavu_font_dir=$dejavu_font_dir
fi

result_ghostscript_font_dir='none'
if test "${ghostscript_font_dir}x" != 'x'; then
    result_ghostscript_font_dir=$ghostscript_font_dir
fi

result_urw_base35_font_dir='none'
if test "${urw_base35_font_dir}x" != 'x'; then
    result_urw_base35_font_dir=$urw_base35_font_dir
fi

result_windows_font_dir='none'
if test "${windows_font_dir}x" != 'x'; then
    result_windows_font_dir=${windows_font_dir}
fi

# ==============================================================================
# Generate build environment
# ==============================================================================
AC_CONFIG_FILES([\
    app-image/AppRun \
    common.shi \
    config/policy.xml:config/policy-"$magick_cv_with_security_policy".xml \
    config/configure.xml \
    config/delegates.xml \
    config/ImageMagick.rdf \
    config/MagickCore.dox \
    config/MagickWand.dox \
    config/Magick++.dox \
    config/type-apple.xml \
    config/type-dejavu.xml \
    config/type-ghostscript.xml \
    config/type-urw-base35.xml \
    config/type-windows.xml \
    config/type.xml \
    ImageMagick.spec \
    Magick++/bin/Magick++-config \
    MagickCore/ImageMagick.pc \
    Magick++/lib/Magick++.pc \
    MagickCore/MagickCore-config \
    MagickCore/MagickCore.pc \
    MagickCore/version.h \
    Makefile \
    magick.sh \
    PerlMagick/check.sh \
    PerlMagick/default/Magick.pm \
    PerlMagick/Makefile.PL \
    PerlMagick/default/Makefile.PL \
    PerlMagick/quantum/Makefile.PL \
    PerlMagick/quantum/quantum.pm \
    PerlMagick/quantum/quantum.xs \
    PerlMagick/quantum/typemap \
    utilities/animate.1 \
    utilities/compare.1 \
    utilities/composite.1 \
    utilities/conjure.1 \
    utilities/convert.1 \
    utilities/display.1 \
    utilities/identify.1 \
    utilities/ImageMagick.1 \
    utilities/import.1 \
    utilities/magick.1 \
    utilities/magick-script.1 \
    utilities/mogrify.1 \
    utilities/montage.1 \
    utilities/stream.1 \
    MagickWand/MagickWand-config \
    MagickWand/MagickWand.pc])
AC_OUTPUT

# ==============================================================================
# ImageMagick Configuration
# ==============================================================================
AC_MSG_NOTICE([
==============================================================================
${PACKAGE_NAME} ${PACKAGE_VERSION} is configured as follows. Verify that this configuration
matches your expectations.

Host system type: $host
Build system type: $build

                    Option				Value
------------------------------------------------------------------------------
Shared libraries    --enable-shared=$enable_shared			$libtool_build_shared_libs
Static libraries    --enable-static=$enable_static			$libtool_build_static_libs
Build utilities     --with-utilities=$with_utilities		$with_utilities
Module support      --with-modules=$build_modules			$build_modules
GNU ld              --with-gnu-ld=$with_gnu_ld			$lt_cv_prog_gnu_ld
OpenMP              --enable-openmp=$enable_openmp			${OPENMP_ENABLED}
Security policy     --with-security-policy=$security_policy	        $security_policy
Quantum depth       --with-quantum-depth=$with_quantum_depth		$with_quantum_depth
Channel mask depth  --enable-64bit-channel-masks=$enable_64bit_channel_masks	$magick_channel_mask_depth
High Dynamic Range Imagery
                    --enable-hdri=$enable_hdri			$enable_hdri

Install documentation:					$wantdocs

Memory allocation library:
  JEMalloc          --with-jemalloc=$with_jemalloc			$have_jemalloc
  MTMalloc          --with-mtmalloc=$with_mtmalloc			$have_mtmalloc
  TCMalloc          --with-tcmalloc=$with_tcmalloc			$have_tcmalloc
  UMem              --with-umem=$with_umem			$have_umem

Delegate library configuration:
  BZLIB             --with-bzlib=$with_bzlib			$have_bzlib
  Autotrace         --with-autotrace=$with_autotrace			$have_autotrace
  DJVU              --with-djvu=$with_djvu			$have_djvu
  DPS               --with-dps=$with_dps			$have_dps
  FFTW              --with-fftw=$with_fftw			$have_fftw
  FLIF              --with-flif=$with_flif			$have_flif
  FlashPIX          --with-fpx=$with_fpx			$have_fpx
  FontConfig        --with-fontconfig=$with_fontconfig		$have_fontconfig
  FreeType          --with-freetype=$with_freetype			$have_freetype
  Ghostscript lib   --with-gslib=$with_gslib			$have_gslib
  Graphviz          --with-gvc=$with_gvc			$have_gvc
  HEIC              --with-heic=$with_heic			$have_heic
  JBIG              --with-jbig=$with_jbig			$have_jbig
  JPEG v1           --with-jpeg=$with_jpeg			$have_jpeg
  JPEG XL           --with-jxl=$with_jxl			$have_jxl
  DMR               --with-dmr=$with_dmr			$have_dmr
  LCMS              --with-lcms=$with_lcms			$have_lcms
  LQR               --with-lqr=$with_lqr			$have_lqr
  LTDL              --with-ltdl=$with_ltdl			$have_ltdl
  LZMA              --with-lzma=$with_lzma			$have_lzma
  Magick++          --with-magick-plus-plus=$with_magick_plus_plus		$have_magick_plus_plus
  OpenEXR           --with-openexr=$with_openexr			$have_openexr
  OpenJP2           --with-openjp2=$with_openjp2			$have_openjp2
  PANGO             --with-pango=$with_pango			$have_pangocairo
  PERL              --with-perl=$with_perl			$have_perl
  PNG               --with-png=$with_png			$have_png
  RAQM              --with-raqm=$with_raqm			$have_raqm
  RAW               --with-raw=$with_raw			$have_raw
  RSVG              --with-rsvg=$with_rsvg			$have_rsvg
  TIFF              --with-tiff=$with_tiff			$have_tiff
  UHDR              --with-uhdr=$with_uhdr			$have_uhdr
  WEBP              --with-webp=$with_webp			$have_webp
  WMF               --with-wmf=$with_wmf			$have_wmf
  X11               --with-x=$with_x				$have_x
  XML               --with-xml=$with_xml			$have_xml
  ZIP               --with-zip=$with_zip			$have_zip
  ZLIB              --with-zlib=$with_zlib			$have_zlib
  ZSTD              --with-zstd=$with_zstd			$have_zstd

Delegate program configuration:
  GhostPCL          None				$PCLDelegate ($PCLVersion)
  GhostXPS          None				$XPSDelegate ($XPSVersion)
  Ghostscript       None				$PSDelegate ($GSVersion)

Font configuration:
  Apple fonts       --with-apple-font-dir=$with_apple_font_dir	$result_apple_font_dir
  Dejavu fonts      --with-dejavu-font-dir=$with_dejavu_font_dir	$result_dejavu_font_dir
  Ghostscript fonts --with-gs-font-dir=$with_gs_font_dir		$result_ghostscript_font_dir
  URW-base35 fonts  --with-urw-base35-font-dir=$with_urw_base35_font_dir	$result_urw_base35_font_dir
  Windows fonts     --with-windows-font-dir=$with_windows_font_dir	$result_windows_font_dir

X11 configuration:
  X_CFLAGS          = $X_CFLAGS
  X_PRE_LIBS        = $X_PRE_LIBS
  X_LIBS            = $X_LIBS
  X_EXTRA_LIBS      = $X_EXTRA_LIBS

Options used to compile and link:
  PREFIX            = $PREFIX_DIR
  EXEC-PREFIX       = $EXEC_PREFIX_DIR
  VERSION           = $PACKAGE_VERSION
  CC                = $CC
  CFLAGS            = $CFLAGS
  CPPFLAGS          = $CPPFLAGS
  PCFLAGS           = $PCFLAGS
  DEFS              = $DEFS
  LDFLAGS           = $LDFLAGS
  LIBS              = $MAGICK_DEP_LIBS $MAGICK_EXTRA_DEP_LIBS
  CXX               = $CXX
  CXXFLAGS          = $CXXFLAGS
  FEATURES          = $MAGICK_FEATURES
  DELEGATES         = $MAGICK_DELEGATES
==============================================================================
])