efl/legacy/evas/configure.in

bn# get rid of that stupid cache mechanism
rm -f config.cache

AC_INIT(configure.in)
AC_CANONICAL_BUILD
AC_CANONICAL_HOST
AC_ISC_POSIX
AM_INIT_AUTOMAKE(evas, 0.9.9.032)
AM_CONFIG_HEADER(config.h)

AC_C_BIGENDIAN
AC_PROG_CC
AM_PROG_CC_STDC
AC_HEADER_STDC
AC_C_CONST
AM_ENABLE_SHARED
AM_PROG_LIBTOOL
AC_FUNC_ALLOCA

MODULE_ARCH="$host_os-$host_cpu"
AC_SUBST(MODULE_ARCH)
AC_DEFINE_UNQUOTED(MODULE_ARCH, "$MODULE_ARCH", "Module architecture")

if test "x${bindir}" = 'xNONE'; then
  if test "x${prefix}" = "xNONE"; then
    PACKAGE_BIN_DIR="${ac_default_prefix}/bin"
  else
    PACKAGE_BIN_DIR="${prefix}/bin"
  fi
else
  PACKAGE_BIN_DIR="${bindir}"
fi
AC_SUBST(PACKAGE_BIN_DIR)

if test "x${libdir}" = 'xNONE'; then
  if test "x${prefix}" = "xNONE"; then
    PACKAGE_LIB_DIR="${ac_default_prefix}/lib"
  else
    PACKAGE_LIB_DIR="${prefix}/lib"
  fi
else
  PACKAGE_LIB_DIR="${libdir}"
fi
AC_SUBST(PACKAGE_LIB_DIR)
		
if test "x${prefix}" = "xNONE"; then
  PACKAGE_DATA_DIR="${ac_default_prefix}/share/${PACKAGE}"
else
  PACKAGE_DATA_DIR="${prefix}/share/${PACKAGE}"
fi
AC_SUBST(PACKAGE_DATA_DIR)

x_dir=""
x_cflags=""
x_libs=""
xcb_dir=""
xcb_cflags=""
xcb_libs=""
gl_dir=""
gl_cflags=""
gl_libs=""
qt_dir=""
qt_cflags=""
qt_libs=""				 
qt_moc="moc"

#####################################################################

# blah-config style checks
# qtdir setting
AC_ARG_WITH(qtdir,
AC_HELP_STRING([--with-qtdir=QT_DIR],[use qt directory specified]),
[ 
  qt_dir=$withval;
  echo "using "$qt_dir" for qt directory.";
],[
  qt_dir="/opt/Qtopia";
])
# check for freetype
AC_PATH_GENERIC(freetype, 9.3.0,
  [ ],
  [ AC_MSG_ERROR(Freetype isn't installed) ]
)

#######################################
## FontConfig

AC_MSG_CHECKING(whether fontconfig searching is to be built)
AC_ARG_ENABLE(fontconfig, AC_HELP_STRING([--enable-fontconfig],[enable fontconfig for finding fonts]), [
	   if test x"$enableval" = x"yes" ; then
	     have_fontconfig="yes"
	   else
	     have_fontconfig="no"
	   fi
        ], [
	     have_fontconfig="yes"
	]
)
if test "x$have_fontconfig" = "xyes"; then
   # Check if really available
   PKG_CHECK_MODULES(FONTCONFIG, fontconfig,
	 [ 
	     have_fontconfig="yes"
	     AC_DEFINE(HAVE_FONTCONFIG, 1, [have fontconfig searching capabilities])
	 ],
	 [ 
	     have_fontconfig="no"
	 ]
    )
else 
   AC_MSG_RESULT(no)
fi

###############   
## dlopen

dlopen_libs=""
AC_CHECK_FUNCS(dlopen, res=yes, res=no)
if test "x$res" = "xyes"; then
  AC_CHECK_FUNCS(dladdr, AC_DEFINE(HAVE_DLADDR))
else
  AC_CHECK_LIB(dl, dlopen, res=yes, res=no)
  if test "x$res" = "xyes"; then
    AC_CHECK_LIB(dl, dladdr, AC_DEFINE(HAVE_DLADDR))
    dlopen_libs=-ldl
  else
    AC_MSG_ERROR(Cannot find dlopen)
  fi
fi
AC_SUBST(dlopen_libs)

#####################################################################
## Engines

#######################################
## Check if we should build the software_x11 engine
have_evas_software_x11="no";
ENGINE_SOFTWARE_X11_PRG="";
## Automatic check...
AC_CHECK_HEADER(X11/X.h,
  [ have_evas_software_x11="yes" ],
  [ have_evas_software_x11="no" ]
)
## Manual override
AC_MSG_CHECKING(whether software x11 backend is to be built)
AC_ARG_ENABLE(software-x11, AC_HELP_STRING([--enable-software-x11],[enable the Software X11 rendering backend]), [
	   if test x"$enableval" = x"yes" ; then
	     AC_MSG_RESULT(yes)
	     have_evas_software_x11="yes"
	   else
	     AC_MSG_RESULT(no)
	     have_evas_software_x11="no"
	   fi
        ], [
	   AC_MSG_RESULT($have_evas_software_x11)
	]
)
if test "x$have_evas_software_x11" = "xyes"; then
  AC_PATH_XTRA
  AC_CHECK_HEADER(X11/X.h,
    [
      AC_DEFINE(BUILD_ENGINE_SOFTWARE_X11, 1, [Software X11 Rendering Backend])
      x_dir=${x_dir:-/usr/X11R6}
      x_cflags=${x_cflags:--I${x_includes:-$x_dir/include}}
      x_libs="${x_libs:--L${x_libraries:-$x_dir/lib}} -lX11 -lXext"
      ENGINE_SOFTWARE_X11_PRG="evas_software_x11_test evas_software_x11_perf_test evas_software_x11_perf_load"
    ],
    [
      AC_MSG_RESULT(disabling software X11 engine)
      have_evas_software_x11="no"
    ]
  )
fi
AM_CONDITIONAL(BUILD_ENGINE_SOFTWARE_X11, test "x$have_evas_software_x11" = "xyes")

#######################################
## Check if we should build the software_xcb engine
have_evas_software_xcb="no";
ENGINE_SOFTWARE_XCB_PRG="";

## Automatic check...
PKG_CHECK_MODULES(
  XCB,
  xcb xcb-shm xcb-image xcb-icccm,
  [AC_CHECK_HEADER(
      X11/X.h,
      [have_evas_software_xcb="yes"],
      [have_evas_software_xcb="no"])],
  [ have_evas_software_xcb="no" ])

## manually disable xcb engine by default - not auto detected.
have_evas_software_xcb="no"
## Manual override
AC_MSG_CHECKING(whether software xcb backend is to be built)
AC_ARG_ENABLE(software-xcb, AC_HELP_STRING([--enable-software-xcb],[enable the Software XCB rendering backend]), [
	   if test x"$enableval" = x"yes" ; then
	     AC_MSG_RESULT(yes)
	     have_evas_software_xcb="yes"
	   else
	     AC_MSG_RESULT(no)
	     have_evas_software_xcb="no"
	   fi
        ], [
	   AC_MSG_RESULT($have_evas_software_xcb)
	]
)
if test "x$have_evas_software_xcb" = "xyes"; then
  AC_PATH_XTRA

  PKG_CHECK_MODULES(
    XCB,
    xcb xcb-shm xcb-aux xcb-image xcb-icccm,
    [AC_DEFINE(BUILD_ENGINE_SOFTWARE_XCB, 1, [Software XCB Rendering Backend])
     xcb_cflags=$XCB_CFLAGS
     xcb_libs=$XCB_LIBS
     ENGINE_SOFTWARE_XCB_PRG="evas_software_xcb_test evas_software_xcb_perf_test evas_software_xcb_perf_load"],
    [AC_MSG_RESULT(disabling software XCB engine)
     have_evas_software_xcb="no"])
fi
AM_CONDITIONAL(BUILD_ENGINE_SOFTWARE_XCB, test "x$have_evas_software_xcb" = "xyes")

#######################################
## Check if we should build the directfb engine
have_evas_directfb="no";
ENGINE_DIRECTFB_PRG="";
## Automatic check...
PKG_CHECK_MODULES(DIRECTFB, directfb >= 0.9.16,
  [ have_evas_directfb="yes" ],
  [ have_evas_directfb="no" ]
)
## manually disable directfb engine by default - not auto detected.
have_evas_directfb="no"
## Manual override
AC_MSG_CHECKING(whether directfb backend is to be built)
AC_ARG_ENABLE(directfb, AC_HELP_STRING([--enable-directfb],[enable the DirectFB rendering backend]), [
	   if test x"$enableval" = x"yes" ; then
	     AC_MSG_RESULT(yes)
	     have_evas_directfb="yes"
	   else
	     AC_MSG_RESULT(no)
	     have_evas_directfb="no"
	   fi
	], [
	   AC_MSG_RESULT($have_evas_directfb)
	]
)
if test "x$have_evas_directfb" = "xyes"; then
  PKG_CHECK_MODULES(DIRECTFB, directfb >= 0.9.16,
    [
      AC_DEFINE(BUILD_ENGINE_DIRECTFB, 1, [DirectFB Rendering Backend])
      ENGINE_DIRECTFB_PRG="evas_directfb_test evas_directfb_window"
    ], [
      AC_MSG_RESULT(disabling directfb engine)
      have_evas_directfb="no"
    ]
  )
fi
AM_CONDITIONAL(BUILD_ENGINE_DIRECTFB, test "x$have_evas_directfb" = "xyes")

#######################################
## Check if we should build the fb engine
have_evas_fb="no";
ENGINE_FB_PRG="";
## Automatic check...
AC_CHECK_HEADER(linux/fb.h,
  [ have_evas_fb="yes" ],
  [ have_evas_fb="no" ]
)
## Manual override
AC_MSG_CHECKING(whether fb backend is to be built)
AC_ARG_ENABLE(fb, AC_HELP_STRING([--enable-fb],[enable the FB rendering backend]), [
	   if test x"$enableval" = x"yes" ; then
	     AC_MSG_RESULT(yes)
	     have_evas_fb="yes"
	   else
	     AC_MSG_RESULT(no)
	     have_evas_fb="no"
	   fi
	], [
	   AC_MSG_RESULT($have_evas_fb)
	]
)
if test "x$have_evas_fb" = "xyes"; then
  AC_CHECK_HEADER(linux/fb.h,
    [
      AM_CONDITIONAL(BUILD_ENGINE_FB, true)
      AC_DEFINE(BUILD_ENGINE_FB, 1, [Linux FB Rendering Backend])
      ENGINE_FB_PRG="evas_fb_test"
    ], [
      AM_CONDITIONAL(BUILD_ENGINE_FB, false)
      AC_MSG_RESULT(disabling fb engine)
      have_evas_fb="no"
    ]
  )
else
  AM_CONDITIONAL(BUILD_ENGINE_FB, false)
  have_evas_fb="no"
fi

#######################################
## Check if we should build the buffer engine
have_evas_buffer="no";
ENGINE_BUFFER_PRG="";
## Automatic check...
have_evas_buffer="yes"
## Manual override
AC_MSG_CHECKING(whether buffer backend is to be built)
AC_ARG_ENABLE(buffer, AC_HELP_STRING([--enable-buffer],[enable the Buffer rendering backend]), [
	   if test x"$enableval" = x"yes" ; then
	     AC_MSG_RESULT(yes)
	     have_evas_buffer="yes"
	   else
	     AC_MSG_RESULT(no)
	     have_evas_buffer="no"
	   fi
	], [
	   AC_MSG_RESULT($have_evas_buffer)
	]
)
if test "x$have_evas_buffer" = "xyes"; then
  AM_CONDITIONAL(BUILD_ENGINE_BUFFER, true)
  AC_DEFINE(BUILD_ENGINE_BUFFER, 1, [Buffer Rendering Backend])
  ENGINE_BUFFER_PRG="evas_buffer_test"
else
  AM_CONDITIONAL(BUILD_ENGINE_BUFFER, false)
fi

#######################################
## Check if we should build the software_qtopia engine
have_evas_qtopia="no";
ENGINE_SOFTWARE_QTOPIA_PRG="";
## Automatic check...
AC_CHECK_HEADER(qdirectpainter_qws.h,
  [ have_evas_qtopia="yes" ],
  [ have_evas_qtopia="no" ],
  [
    #include <qwidget.h>
    #include <qnamespace.h>
    #include <qbrush.h>
    #include <qpainter.h>
  ]
)
## manually disable qtopia engine by default - not auto detected.
have_evas_qtopia="no"
## Manual override
AC_MSG_CHECKING(whether software qtopia backend is to be built)
AC_ARG_ENABLE(software-qtopia, [  --enable-software-qtopia        enable the Software Qtopia rendering backend], [
	   if test x"$enableval" = x"yes" ; then
	     AC_MSG_RESULT(yes)
	     have_evas_qtopia="yes"
	   else
	     AC_MSG_RESULT(no)
	     have_evas_qtopia="no"
	   fi
        ], [
	   AC_MSG_RESULT($have_evas_qtopia)
	]
)
if test "x$have_evas_qtopia" = "xyes"; then
  AC_PROG_CXX
  AC_CHECK_HEADER(qdirectpainter_qws.h,
    [
      AM_CONDITIONAL(BUILD_ENGINE_SOFTWARE_QTOPIA, test "$enableval" = "yes")
      AC_DEFINE(BUILD_ENGINE_SOFTWARE_QTOPIA, 1, [Qtopia Rendering Backend])
      qt_cflags="-fno-exceptions -fno-rtti -I"$qt_dir"/include"
      qt_libs="-L"$qt_dir"/lib -lqte -lqpe"
      qt_moc=$qt_dir"/bin/moc"
      ENGINE_SOFTWARE_QTOPIA_PRG="evas_software_qtopia_test"
    ], [
      AM_CONDITIONAL(BUILD_ENGINE_SOFTWARE_QTOPIA, false)
      AC_MSG_RESULT(disabling qtopia engine)
      have_evas_qtopia="no"
    ],
    [
      #include <qwidget.h>
      #include <qnamespace.h>
      #include <qbrush.h>
      #include <qpainter.h>
    ]
  )
else
  AM_CONDITIONAL(BUILD_ENGINE_SOFTWARE_QTOPIA, false)
fi

#######################################
## Check if we should build the gl_x11 engine
have_evas_gl_x11="no";
ENGINE_GL_X11_PRG="";
## Automatic check...
  AC_CHECK_HEADER(GL/gl.h,
    [
      AC_CHECK_HEADER(X11/X.h,
        [ have_evas_gl_x11="yes" ],
	[ have_evas_gl_x11="no" ]
      )
    ],
    [ have_evas_gl_x11="no" ]
)
## manually disable gl engine by default - not auto detected.
have_evas_gl_x11="no"
## Manual override
AC_MSG_CHECKING(whether gl x11 backend is to be built)
AC_ARG_ENABLE(gl-x11, [  --enable-gl-x11                 enable the OpenGL X11 display engine], [
	   if test x"$enableval" = x"yes" ; then
	     AC_MSG_RESULT(yes)
	     have_evas_gl_x11="yes"
	   else
	     AC_MSG_RESULT(no)
	     have_evas_gl_x11="no"
	   fi
        ], [
	   AC_MSG_RESULT($have_evas_gl_x11)
	]
)
if test "x$have_evas_gl_x11" = "xyes"; then
  AC_CHECK_HEADER(GL/gl.h,
    [
      AC_CHECK_HEADER(GL/glu.h,
        [
          AC_CHECK_HEADER(X11/X.h,
            [
              AM_CONDITIONAL(BUILD_ENGINE_GL_X11, true)
	      AC_DEFINE(BUILD_ENGINE_GL_X11, 1, [OpenGL X11 Rendering Backend])
	      AM_CONDITIONAL(BUILD_ENGINE_GL_COMMON, true)
	      AC_DEFINE(BUILD_ENGINE_GL_COMMON, 1, [Generic OpenGL Rendering Support])
	      x_dir=${x_dir:-/usr/X11R6};
	      x_cflags=${x_cflags:--I$x_dir/include}
	      x_libs="${x_libs:--L$x_dir/lib -lX11 -lXext}"
	      gl_cflags="-I/usr/include"
	      gl_libs="-lGL -lGLU -lpthread"
	      gl_dir=""
	      ENGINE_GL_X11_PRG="evas_gl_x11_test"
            ], [
              AM_CONDITIONAL(BUILD_ENGINE_GL_X11, false)
              AM_CONDITIONAL(BUILD_ENGINE_GL_COMMON, false)
              AC_MSG_RESULT(disabling GL X11 engine)
              have_evas_gl_x11="no"
            ]
	  )
        ], [
          AM_CONDITIONAL(BUILD_ENGINE_GL_X11, false)
          AM_CONDITIONAL(BUILD_ENGINE_GL_COMMON, false)
          AC_MSG_RESULT(disabling GL X11 engine)
          have_evas_gl_x11="no"
        ]
      )
    ], [
      AM_CONDITIONAL(BUILD_ENGINE_GL_X11, false)
      AM_CONDITIONAL(BUILD_ENGINE_GL_COMMON, false)
      AC_MSG_RESULT(disabling GL X11 engine)
      have_evas_gl_x11="no"
    ]
  )
else
  AM_CONDITIONAL(BUILD_ENGINE_GL_X11, false)
  AM_CONDITIONAL(BUILD_ENGINE_GL_COMMON, false)
  have_evas_gl_x11="no"
fi



#######################################
## Check if we should build the gl_x11 engine
have_evas_cairo_x11="no";
ENGINE_CAIRO_X11_PRG="";
# Automatic check...
#PKG_CHECK_MODULES(CAIRO, cairo >= 1.0.0,
#  [ have_evas_cairo_x11="yes" ],
#  [ have_evas_cairo_x11="no" ]
#)
# Manual override
#AC_MSG_CHECKING(whether cairo x11 backend is to be built)
#AC_ARG_ENABLE(cairo-x11, [  --enable-cairo-x11              enable the Cairo X11 display engine], [
#	   if test x"$enableval" = x"yes" ; then
#	     AC_MSG_RESULT(yes)
#	     have_evas_cairo_x11="yes"
#	   else
#	     AC_MSG_RESULT(no)
#	     have_evas_cairo_x11="no"
#	   fi
#        ], [
#	   AC_MSG_RESULT($have_evas_cairo_x11)
#	]
#)
if test "x$have_evas_cairo_x11" = "xyes"; then
  AC_CHECK_HEADER(X11/X.h,
    [
      AM_CONDITIONAL(BUILD_ENGINE_CAIRO_X11, true)
      AC_DEFINE(BUILD_ENGINE_CAIRO_X11, 1, [Cairo X11 Rendering Backend])
      AM_CONDITIONAL(BUILD_ENGINE_CAIRO_COMMON, true)
      AC_DEFINE(BUILD_ENGINE_CAIRO_COMMON, 1, [Generic Cairo Rendering Support])
      x_dir="/usr/X11R6";
      x_cflags="-I"$x_dir"/include"
      x_libs="-L"$x_dir"/lib -lX11 -lXext"
      ENGINE_CAIRO_X11_PRG="evas_cairo_x11_test"
    ], [
      AM_CONDITIONAL(BUILD_ENGINE_CAIRO_X11, false)
      AM_CONDITIONAL(BUILD_ENGINE_CAIRO_COMMON, false)
      AC_MSG_RESULT(disabling Cairo X11 engine)
    ]
  )
else
  AM_CONDITIONAL(BUILD_ENGINE_CAIRO_X11, false)
  AM_CONDITIONAL(BUILD_ENGINE_CAIRO_COMMON, false)
fi

#######################################
## Check if we should build the xrender_x11 engine
have_evas_xrender_x11="no";
ENGINE_XRENDER_X11_PRG="";
## Automatic check...
AC_CHECK_HEADER(X11/X.h,
  [ have_evas_xrender_x11="yes" ],
  [ have_evas_xrender_x11="no" ]
)
## Manual override
AC_MSG_CHECKING(whether xrender x11 backend is to be built)
AC_ARG_ENABLE(xrender-x11, [  --enable-xrender-x11            enable the XRender X11 rendering backend], [
	   if test x"$enableval" = x"yes" ; then
	     AC_MSG_RESULT(yes)
	     have_evas_xrender_x11="yes"
	   else
	     AC_MSG_RESULT(no)
	     have_evas_xrender_x11="no"
	   fi
        ], [
	   AC_MSG_RESULT($have_evas_xrender_x11)
	]
)
if test "x$have_evas_xrender_x11" = "xyes"; then
  AC_PATH_XTRA
  AC_CHECK_HEADER(X11/X.h,
    [
      AC_CHECK_HEADER(X11/extensions/Xrender.h,
        [
          AC_DEFINE(BUILD_ENGINE_XRENDER_X11, 1, [XRender X11 Rendering Backend])
          x_dir=${x_dir:-/usr/X11R6}
          x_cflags=${x_cflags:--I${x_includes:-$x_dir/include}}
          x_libs="${x_libs:--L${x_libraries:-$x_dir/lib}} -lX11 -lXext -lXrender"
          ENGINE_XRENDER_X11_PRG="evas_xrender_x11_test"
	],
	[
          AC_MSG_RESULT(disabling xrender X11 engine)
          have_evas_xrender_x11="no"
	]
      )
    ],
    [
      AC_MSG_RESULT(disabling xrender X11 engine)
      have_evas_xrender_x11="no"
    ]
  )
fi
AM_CONDITIONAL(BUILD_ENGINE_XRENDER_X11, test "x$have_evas_xrender_x11" = "xyes")

#######################################
## Check if we should build the xrender_xcb engine
have_evas_xrender_xcb="no";
ENGINE_XRENDER_XCB_PRG="";

## Automatic check...
PKG_CHECK_MODULES(
  XCBRENDER,
  xcb xcb-shm xcb-render xcb-image xcb-icccm,
  [AC_CHECK_HEADER(
      X11/X.h,
      [have_evas_xrender_xcb="yes"],
      [have_evas_xrender_xcb="no"])],
  [ have_evas_xrender_xcb="no" ])

## manually disable xcb engine by default - not auto detected.
have_evas_xrender_xcb="no"
## Manual override
AC_MSG_CHECKING(whether xrender xcb backend is to be built)
AC_ARG_ENABLE(xrender-xcb, [  --enable-xrender-xcb            enable the Xrender XCB rendering backend], [
	   if test x"$enableval" = x"yes" ; then
	     AC_MSG_RESULT(yes)
	     have_evas_xrender_xcb="yes"
	   else
	     AC_MSG_RESULT(no)
	     have_evas_xrender_xcb="no"
	   fi
        ], [
	   AC_MSG_RESULT($have_evas_xrender_xcb)
	]
)
if test "x$have_evas_xrender_xcb" = "xyes"; then
  AC_PATH_XTRA

  PKG_CHECK_MODULES(
    XCBRENDER,
    xcb xcb-shm xcb-render xcb-image xcb-icccm,
    [AC_DEFINE(BUILD_ENGINE_XRENDER_XCB, 1, [Xrender XCB Rendering Backend])
     xcbrender_cflags=$XCBRENDER_CFLAGS
     xcbrender_libs=$XCBRENDER_LIBS
     ENGINE_XRENDER_XCB_PRG="evas_xrender_xcb_test"],
    [AC_MSG_RESULT(disabling xrender XCB engine)
     have_evas_xrender_xcb="no"])
fi
AM_CONDITIONAL(BUILD_ENGINE_XRENDER_XCB, test "x$have_evas_xrender_xcb" = "xyes")


#####################################################################
## Image loaders

#######################################
## GIF
have_gif="no";
AC_CHECK_HEADER(gif_lib.h,
  [ have_gif="yes" ],
  [ have_gif="no" ]
)
AC_MSG_CHECKING(whether to enable gif image loader)
AC_ARG_ENABLE(image-loader-gif, 
  [  --enable-image-loader-gif       enable GIF image loader], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
	have_gif="yes"
      else
        AC_MSG_RESULT(no)
	have_gif="no"
      fi
  ], [
      AC_MSG_RESULT($have_gif)
  ]
)
if test "x$have_gif" = "xyes"; then
  AC_CHECK_HEADER(gif_lib.h,
    [ AC_CHECK_LIB(gif, DGifOpenFileName,
       [ gif_libs="-lgif"
         have_gif="yes" ],
       [ AC_CHECK_LIB(ungif, DGifOpenFileName,
          [ gif_libs="-lungif"
            have_gif="yes" ],
          [ have_gif="no" ]) ]) ],
    [ have_gif="no" ]
  )
fi
if test "x$have_gif" = "xyes"; then
  AC_DEFINE(BUILD_LOADER_GIF, 1, [GIF Image Loader Support])
  gif_cflags=""
fi

AM_CONDITIONAL(BUILD_LOADER_GIF, test x$have_gif = xyes)

#######################################
## PNG
have_png="no";
AC_MSG_CHECKING(whether to enable png image loader)
if   pkg-config --exists libpng12; then
  have_png="yes";
elif pkg-config --exists libpng10; then
  have_png="yes";
elif pkg-config --exists libpng; then
  have_png="yes";
fi

AC_ARG_ENABLE(image-loader-png, 
  [  --enable-image-loader-png       enable PNG image loader], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
	have_png="yes"
      else
        AC_MSG_RESULT(no)
	have_png="no"
      fi
  ], [
      AC_MSG_RESULT($have_png)
  ]
)
if test "x$have_png" = "xyes"; then
  if   pkg-config --exists libpng12; then
    png_cflags=`pkg-config --cflags libpng12`
    png_libs=`pkg-config --libs libpng12`
    AC_MSG_CHECKING(libpng 1.2.x)
  elif pkg-config --exists libpng10; then
    png_cflags=`pkg-config --cflags libpng10`
    png_libs=`pkg-config --libs libpng10`
    AC_MSG_CHECKING(libpng 1.0.x)
  elif pkg-config --exists libpng; then
    png_cflags=`pkg-config --cflags libpng`
    png_libs=`pkg-config --libs libpng`
    AC_MSG_CHECKING(generic system libpng)
  fi
  AC_MSG_RESULT($have_png)
fi

AM_CONDITIONAL(BUILD_LOADER_PNG, test x$have_png = xyes)

#######################################
## JPEG
have_jpeg="no";
AC_CHECK_HEADER(jpeglib.h,
  [ have_jpeg="yes" ],
  [ have_jpeg="no" ]
)
AC_MSG_CHECKING(whether to enable jpeg image loader)
AC_ARG_ENABLE(image-loader-jpeg, 
  [  --enable-image-loader-jpeg      enable JPEG image loader], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
	have_jpeg="yes"
      else
        AC_MSG_RESULT(no)
	have_jpeg="no"
      fi
  ], [
      AC_MSG_RESULT($have_jpeg)
  ]
)
if test "x$have_jpeg" = "xyes"; then
  AC_CHECK_HEADER(jpeglib.h,
    [ have_jpeg="yes" ],
    [ have_jpeg="no" ]
  )
fi
if test "x$have_jpeg" = "xyes"; then
  AC_DEFINE(BUILD_LOADER_JPEG, 1, [JPEG Image Loader Support])
  jpeg_cflags=""
  jpeg_libs="-ljpeg"
fi

AM_CONDITIONAL(BUILD_LOADER_JPEG, test x$have_jpeg = xyes)

#######################################
## EET
AC_ARG_WITH(eet-config, [  --with-eet-config=EET_CONFIG     use eet-config specified],
[ EET_CONFIG=$withval;
  echo "using "$EET_CONFIG" for eet-config"; ],
[ if test -z "$EET_CONFIG"; then
    AC_PATH_PROG(EET_CONFIG, "eet-config", "", $PATH)
  fi
])
if test -z "$EET_CONFIG" ; then EET_CONFIG="eet-config"; fi
eet_cflags=`$EET_CONFIG --cflags`
eet_libs=`$EET_CONFIG --libs`
eet_version=`$EET_CONFIG --version`

have_eet="no";
have_eet_fonts="no";
if test -n "$eet_version" ; then
  eet_ok="yes";
  have_eet="yes";
  have_eet_fonts="yes";
fi

AC_MSG_CHECKING(whether to enable eet image loader)
AC_ARG_ENABLE(image-loader-eet, 
  [  --enable-image-loader-eet       enable EET image loader], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
	have_eet="yes"
      else
        AC_MSG_RESULT(no)
	have_eet="no"
	eet_cflags=""
	eet_libs=""
      fi
  ], [
      AC_MSG_RESULT($have_eet)
  ]
)
AC_MSG_CHECKING(whether to enable eet font loader)
AC_ARG_ENABLE(font-loader-eet, 
  [  --enable-font-loader-eet        enable EET font loader], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
	have_eet_fonts="yes"
      else
        AC_MSG_RESULT(no)
	have_eet_fonts="no"
      fi
  ], [
      AC_MSG_RESULT($have_eet_fonts)
  ]
)

AC_MSG_CHECKING(whether to enable eet support)
if test "x$eet_ok" = "xyes"; then
  AC_MSG_RESULT(yes)
  if test "x$have_eet" = "xyes"; then
    AC_DEFINE(BUILD_LOADER_EET, 1, [EET Image Loader Support])
  fi
  if test "x$have_eet_fonts" = "xyes"; then
    AC_DEFINE(BUILD_FONT_LOADER_EET, 1, [EET Font Loader Support])
  fi
else
  AC_MSG_RESULT(no)
fi

AM_CONDITIONAL(BUILD_LOADER_EET, test x$have_eet = xyes)

#######################################
## EDB
AC_ARG_WITH(edb-config, [  --with-edb-config=EDB_CONFIG     use edb-config specified ],
[ EDB_CONFIG=$withval;
  echo "using "$EDB_CONFIG" for edb-config"; ],
[ if test -z "$EDB_CONFIG"; then
    AC_PATH_PROG(EDB_CONFIG, "edb-config", "", $PATH)
  fi
])
if test -z "$EDB_CONFIG" ; then EDB_CONFIG="edb-config"; fi
edb_cflags=`$EDB_CONFIG --cflags`
edb_libs=`$EDB_CONFIG --libs`
edb_version=`$EDB_CONFIG --version`

have_edb="no";
if test -n "$edb_version" ; then
  edb_ok="yes";
  have_edb="yes";
fi

AC_MSG_CHECKING(whether to enable edb image loader)
AC_ARG_ENABLE(image-loader-edb, 
  [  --enable-image-loader-edb       enable EDB image loader], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
	have_edb="yes"
      else
        AC_MSG_RESULT(no)
	have_edb="no"
	edb_ok="no"
	edb_cflags=""
	edb_libs=""
      fi
  ], [
      AC_MSG_RESULT($have_edb)
  ]
)

AC_MSG_CHECKING(whether to enable edb support)
if test "x$edb_ok" = "xyes"; then
  AC_MSG_RESULT(yes)
  if test "x$have_edb" = "xyes"; then
    AC_DEFINE(BUILD_LOADER_EDB, 1, [EDB Image Loader Support])
  fi
else
  AC_MSG_RESULT(no)
fi

AM_CONDITIONAL(BUILD_LOADER_EDB, test x$have_edb = xyes)

#######################################
## TIFF
have_tiff="no";
AC_CHECK_HEADER(tiffio.h,
  [ have_tiff="yes" ],
  [ have_tiff="no" ]
)
AC_MSG_CHECKING(whether to enable tiff image loader)
AC_ARG_ENABLE(image-loader-tiff, 
  [  --enable-image-loader-tiff      enable TIFF image loader], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
	have_tiff="yes"
      else
        AC_MSG_RESULT(no)
	have_tiff="no"
      fi
  ], [
      AC_MSG_RESULT($have_tiff)
  ]
)
if test "x$have_tiff" = "xyes"; then
  AC_CHECK_HEADER(tiffio.h,
    [ AC_CHECK_LIB(tiff, TIFFReadScanline,
       [ tiff_libs="-ltiff"
         have_tiff="yes" ],
       [ AC_CHECK_LIB(tiff, TIFFReadScanline,
          [ tiff_libs="-ltiff -ljpeg -lz -lm"
            have_tiff="yes" ],
          [ AC_CHECK_LIB(tiff34, TIFFReadScanline,
             [ tiff_libs="-ltiff34 -ljpeg -lz -lm"
               have_tiff="yes" ],
             [ have_tiff="no" ]) ]) ]) ],
    [ have_tiff="no" ]
  )
fi
if test "x$have_tiff" = "xyes"; then
  AC_DEFINE(BUILD_LOADER_TIFF, 1, [TIFF Image Loader Support])
  tiff_cflags=""
fi

AM_CONDITIONAL(BUILD_LOADER_TIFF, test x$have_tiff = xyes)

#######################################
## XPM
have_xpm="yes";
AC_MSG_CHECKING(whether to enable xpm image loader)

AC_ARG_ENABLE(image-loader-xpm, 
  [  --enable-image-loader-xpm       enable XPM image loader], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
	have_xpm="yes"
      else
        AC_MSG_RESULT(no)
	have_xpm="no"
      fi
  ], [
      AC_MSG_RESULT($have_xpm)
  ]
)
if test "x$have_xpm" = "xyes"; then
  AC_MSG_RESULT($have_xpm)
fi

xpm_cflags=""
xpm_libs=""

AM_CONDITIONAL(BUILD_LOADER_XPM, test x$have_xpm = xyes)

#####################################################################
## Cpu based optimizations

#######################################
## MMX
build_cpu_mmx="no"
case $host_cpu in
  i*86)
    build_cpu_mmx="yes"
    ;;
  x86_64)
    build_cpu_mmx="yes"
    ;;
esac
AC_MSG_CHECKING(whether to build mmx code)
AC_ARG_ENABLE(cpu-mmx, 
  [  --enable-cpu-mmx                enable mmx code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_MMX, 1, [Build MMX Code])
        build_cpu_mmx="yes"
      else
        AC_MSG_RESULT(no)
        build_cpu_mmx="no"
      fi
  ],
  [
    AC_MSG_RESULT($build_cpu_mmx)
    if test x"$build_cpu_mmx" = x"yes" ; then
      AC_DEFINE(BUILD_MMX, 1, [Build MMX Code])
    fi
  ]
)

#######################################
## SSE
build_cpu_sse="no"
case $host_cpu in
  i*86)
    build_cpu_sse="yes"
    ;;
  x86_64)
    build_cpu_sse="yes"
    ;;
esac
AC_MSG_CHECKING(whether to build sse code)
AC_ARG_ENABLE(cpu-sse, 
  [  --enable-cpu-sse                enable sse code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_SSE, 1, [Build SSE Code])
        build_cpu_sse="yes"
      else
        AC_MSG_RESULT(no)
        build_cpu_sse="no"
      fi
  ],
  [ 
    AC_MSG_RESULT($build_cpu_sse)
    if test x"$build_cpu_sse" = x"yes" ; then
      AC_DEFINE(BUILD_SSE, 1, [Build SSE Code])
    fi
  ]
)

#######################################
## ALTIVEC
build_cpu_altivec="no"
case $host_cpu in
  *power* | *ppc*)
    build_cpu_altivec="yes"
    ;;
esac
altivec_cflags=""
AC_MSG_CHECKING(whether to build altivec code)
AC_ARG_ENABLE(cpu-altivec, 
  [  --enable-cpu-altivec            enable altivec code], [
     build_cpu_altivec=$enableval
  ]
)
AC_MSG_RESULT($build_cpu_altivec)
if test "x$build_cpu_altivec" = "xyes"; then
   AC_CHECK_HEADER(altivec.h,
     [
        AC_DEFINE(BUILD_ALTIVEC, 1, [Build Altivec Code])
        AC_DEFINE(HAVE_ALTIVEC_H, 1, [Have altivec.h header file])
        build_cpu_altivec="yes"
     ],
     [
       save_CFLAGS=$CFLAGS
       save_CPPFLAGS=$CPPFLAGS
       CFLAGS=$CFLAGS" -maltivec"
       CPPFLAGS=$CPPFLAGS" -maltivec"
       unset ac_cv_header_altivec_h
       AC_CHECK_HEADER(altivec.h,
         [
            AC_DEFINE(BUILD_ALTIVEC, 1, [Build Altivec Code])
            AC_DEFINE(HAVE_ALTIVEC_H, 1, [Have altivec.h header file])
            build_cpu_altivec="yes"
         ],
         [
            build_cpu_altivec="no"
         ]
       )
       CFLAGS=$save_CFLAGS
       CPPFLAGS=$save_CPPFLAGS
     ]
   )
fi
if test "x$build_cpu_altivec" = "xyes"; then
   AC_MSG_CHECKING(whether to use altivec compiler flag)
   if test x"$GCC" = x"yes"; then
      if echo "int main(){return 0;}" | ${CPP} -faltivec - > /dev/null 2>&1; then
         altivec_cflags="-faltivec"
         AC_DEFINE(BUILD_ALTIVEC, 1, [Build Altivec Code])
      elif echo "int main(){return 0;}" | ${CPP} -maltivec - > /dev/null 2>&1; then
         altivec_cflags="-maltivec"
         AC_DEFINE(BUILD_ALTIVEC, 1, [Build Altivec Code])
      fi
   fi
   AC_MSG_RESULT($altivec_cflags)
   CFLAGS="$CFLAGS $altivec_cflags"
fi


#######################################
## C
build_cpu_c="no"
build_cpu_c="yes"
AC_MSG_CHECKING(whether to build c code)
AC_ARG_ENABLE(cpu-c, 
  [  --enable-cpu-c                  enable C code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_C, 1, [Build plain C code])
	build_cpu_c="yes"
      else
        AC_MSG_RESULT(no)
	build_cpu_c="no"
      fi
  ], [
      AC_MSG_RESULT($build_cpu_c)
      if test x"$build_cpu_c" = x"yes" ; then
        AC_DEFINE(BUILD_C, 1, [Build plain C code])
      fi
  ]
)

#####################################################################
## ARGB engine options

#######################################
## Nearest sampling scaler
scaler_sample="no"
scaler_sample="yes"
AC_MSG_CHECKING(whether to build sampling scaler)
AC_ARG_ENABLE(scale-sample, 
  [  --enable-scale-sample           enable sampling scaler code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_SCALE_SAMPLE, 1, [Sampling Scaler Support])
        scaler_sample="yes"
      else
        AC_MSG_RESULT(no)
        scaler_sample="no"
      fi
  ], [
      AC_MSG_RESULT($scaler_sample)
      if test x"$scaler_sample" = x"yes" ; then
        AC_DEFINE(BUILD_SCALE_SAMPLE, 1, [Sampling Scaler Support])
      fi
  ]
)

#######################################
## Smooth super and sub sampling scaler
scaler_smooth="no"
scaler_smooth="yes"
AC_MSG_CHECKING(whether to build smooth scaler)
AC_ARG_ENABLE(scale-smooth, 
  [  --enable-scale-smooth           enable smooth scaler code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_SCALE_SMOOTH, 1, [Smooth Scaler Support])
        scaler_smooth="yes"
      else
        AC_MSG_RESULT(no)
        scaler_smooth="no"
      fi
  ], [
      AC_MSG_RESULT($scaler_smooth)
      if test x"$scaler_smooth" = x"yes" ; then
        AC_DEFINE(BUILD_SCALE_SMOOTH, 1, [Smooth Scaler Support])
      fi
  ]
)

#######################################
## YUV -> ARGB converter
conv_yuv="no"
conv_yuv="yes"
AC_MSG_CHECKING(whether to build yuv converter code)
AC_ARG_ENABLE(convert-yuv, 
  [  --enable-convert-yuv            enable yuv converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_YUV, 1, [YUV Converter Support])
	conv_yuv="yes"
      else
        AC_MSG_RESULT(no)
	conv_yuv="no"
      fi
  ], [
      AC_MSG_RESULT($conv_yuv)
      if test x"$conv_yuv" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_YUV, 1, [YUV Converter Support])
      fi
  ]
)

#####################################################################
## Output rendering features

#######################################
## Small dither mask instead of big one (lower quality)
conv_small_dither="no"
conv_small_dither="no"
AC_MSG_CHECKING(whether to build small dither mask code)
AC_ARG_ENABLE(small-dither-mask, 
  [  --enable-small-dither-mask      enable small dither mask code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
      	AC_DEFINE(BUILD_SMALL_DITHER_MASK, 1, [Small Dither Mask Support])
        conv_small_dither="yes"
      else
        AC_MSG_RESULT(no)
        conv_small_dither="no"
      fi
  ], [
      AC_MSG_RESULT($conv_small_dither)
      if test x"$conv_small_dither" = x"yes" ; then
        AC_DEFINE(BUILD_SMALL_DITHER_MASK, 1, [Small Dither Mask Support])
      fi
  ]
)

#######################################
## Convert to 8bpp RGB 332
conv_8_rgb_332="no"
conv_8_rgb_332="yes"
AC_MSG_CHECKING(whether to build 8bpp 332 converter code)
AC_ARG_ENABLE(convert-8-rgb-332, 
  [  --enable-convert-8-rgb-332      enable 8bpp 332 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_8_RGB_332, 1, [8bpp 332 Converter Support])
        conv_8_rgb_332="yes"
      else
        AC_MSG_RESULT(no)
	conv_8_rgb_332="no"
      fi
  ], [
      AC_MSG_RESULT($conv_8_rgb_332)
      if test x"$conv_8_rgb_332" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_8_RGB_332, 1, [8bpp 332 Converter Support])
      fi
  ]
)

#######################################
## Convert to 8bpp RGB 666
conv_8_rgb_666="no"
conv_8_rgb_666="yes"
AC_MSG_CHECKING(whether to build 8bpp 666 converter code)
AC_ARG_ENABLE(convert-8-rgb-666, 
  [  --enable-convert-8-rgb-666      enable 8bpp 666 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_8_RGB_666, 1, [8bpp 666 Converter Support])
        conv_8_rgb_666="yes"
      else
        AC_MSG_RESULT(no)
	conv_8_rgb_666="no"
      fi
  ], [
      AC_MSG_RESULT($conv_8_rgb_666)
      if test x"$conv_8_rgb_666" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_8_RGB_666, 1, [8bpp 666 Converter Support])
      fi
  ]
)

#######################################
## Convert to 8bpp RGB 232
conv_8_rgb_232="no"
conv_8_rgb_232="yes"
AC_MSG_CHECKING(whether to build 8bpp 232 converter code)
AC_ARG_ENABLE(convert-8-rgb-232, 
  [  --enable-convert-8-rgb-232      enable 8bpp 232 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_8_RGB_232, 1, [8bpp 232 Converter Support])
        conv_8_rgb_232="yes"
      else
        AC_MSG_RESULT(no)
	conv_8_rgb_232="no"
      fi
  ], [
      AC_MSG_RESULT($conv_8_rgb_232)
      if test x"$conv_8_rgb_232" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_8_RGB_232, 1, [8bpp 232 Converter Support])
      fi
  ]
)

#######################################
## Convert to 8bpp RGB 222
conv_8_rgb_222="no"
conv_8_rgb_222="yes"
AC_MSG_CHECKING(whether to build 8bpp 222 converter code)
AC_ARG_ENABLE(convert-8-rgb-222, 
  [  --enable-convert-8-rgb-222      enable 8bpp 222 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_8_RGB_222, 1, [8bpp 222 Converter Support])
        conv_8_rgb_222="yes"
      else
        AC_MSG_RESULT(no)
	conv_8_rgb_222="no"
      fi
  ], [
      AC_MSG_RESULT($conv_8_rgb_222)
      if test x"$conv_8_rgb_222" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_8_RGB_222, 1, [8bpp 222 Converter Support])
      fi
  ]
)

#######################################
## Convert to 8bpp RGB 221
conv_8_rgb_221="no"
conv_8_rgb_221="yes"
AC_MSG_CHECKING(whether to build 8bpp 221 converter code)
AC_ARG_ENABLE(convert-8-rgb-221, 
  [  --enable-convert-8-rgb-221      enable 8bpp 221 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_8_RGB_221, 1, [8bpp 221 Converter Support])
        conv_8_rgb_221="yes"
      else
        AC_MSG_RESULT(no)
	conv_8_rgb_221="no"
      fi
  ], [
      AC_MSG_RESULT($conv_8_rgb_221)
      if test x"$conv_8_rgb_221" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_8_RGB_221, 1, [8bpp 221 Converter Support])
      fi
  ]
)

#######################################
## Convert to 8bpp RGB 121
conv_8_rgb_121="no"
conv_8_rgb_121="yes"
AC_MSG_CHECKING(whether to build 8bpp 121 converter code)
AC_ARG_ENABLE(convert-8-rgb-121, 
  [  --enable-convert-8-rgb-121      enable 8bpp 121 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_8_RGB_121, 1, [8bpp 121 Converter Support])
        conv_8_rgb_121="yes"
      else
        AC_MSG_RESULT(no)
	conv_8_rgb_121="no"
      fi
  ], [
      AC_MSG_RESULT($conv_8_rgb_121)
      if test x"$conv_8_rgb_121" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_8_RGB_121, 1, [8bpp 121 Converter Support])
      fi
  ]
)

#######################################
## Convert to 8bpp RGB 111
conv_8_rgb_111="no"
conv_8_rgb_111="yes"
AC_MSG_CHECKING(whether to build 8bpp 111 converter code)
AC_ARG_ENABLE(convert-8-rgb-111, 
  [  --enable-convert-8-rgb-111      enable 8bpp 111 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_8_RGB_111, 1, [8bpp 111 Converter Support])
        conv_8_rgb_111="yes"
      else
        AC_MSG_RESULT(no)
	conv_8_rgb_111="no"
      fi
  ], [
      AC_MSG_RESULT($conv_8_rgb_111)
      if test x"$conv_8_rgb_111" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_8_RGB_111, 1, [8bpp 111 Converter Support])
      fi
  ]
)

#######################################
## Convert to 16bpp RGB 565
conv_16_rgb_565="no"
conv_16_rgb_565="yes"
AC_MSG_CHECKING(whether to build 16bpp 565 converter code)
AC_ARG_ENABLE(convert-16-rgb-565, 
  [  --enable-convert-16-rgb-565     enable 16bpp 565 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_16_RGB_565, 1, [16bpp 565 Converter Support])
        conv_16_rgb_565="yes"
      else
        AC_MSG_RESULT(no)
	conv_16_rgb_565="no"
      fi
  ], [
      AC_MSG_RESULT($conv_16_rgb_565)
      if test x"$conv_16_rgb_565" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_16_RGB_565, 1, [16bpp 565 Converter Support])
      fi
  ]
)

#######################################
## Convert to 16bpp RGB 555
conv_16_rgb_555="no"
conv_16_rgb_555="yes"
AC_MSG_CHECKING(whether to build 16bpp 555 converter code)
AC_ARG_ENABLE(convert-16-rgb-555, 
  [  --enable-convert-16-rgb-555     enable 16bpp 555 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_16_RGB_555, 1, [16bpp 555 Converter Support])
        conv_16_rgb_555="yes"
      else
        AC_MSG_RESULT(no)
	conv_16_rgb_555="no"
      fi
  ], [
      AC_MSG_RESULT($conv_16_rgb_555)
      if test x"$conv_16_rgb_555" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_16_RGB_555, 1, [16bpp 555 Converter Support])
      fi
  ]
)

#######################################
## Convert to 16bpp RGB 444
conv_16_rgb_444="no"
conv_16_rgb_444="yes"
AC_MSG_CHECKING(whether to build 16bpp 444 converter code)
AC_ARG_ENABLE(convert-16-rgb-444, 
  [  --enable-convert-16-rgb-444     enable 16bpp 444 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_16_RGB_444, 1, [16bpp 444 Converter Support])
        conv_16_rgb_444="yes"
      else
        AC_MSG_RESULT(no)
	conv_16_rgb_444="no"
      fi
  ], [
      AC_MSG_RESULT($conv_16_rgb_444)
      if test x"$conv_16_rgb_444" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_16_RGB_444, 1, [16bpp 444 Converter Support])
      fi
  ]
)

#######################################
## Convert to 16bpp RGB 565 (444 ipaq)
conv_16_rgb_ipq="no"
conv_16_rgb_ipq="yes"
AC_MSG_CHECKING(whether to build 16bpp 565 (444 ipaq) converter code)
AC_ARG_ENABLE(convert-16-rgb-ipq, 
  [  --enable-convert-16-rgb-ipq     enable 16bpp 565 (444 ipaq) converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_16_RGB_454645, 1, [16bpp 565 (444 ipaq) Converter Support])
        conv_16_rgb_ipq="yes"
      else
        AC_MSG_RESULT(no)
	conv_16_rgb_ipq="no"
      fi
  ], [
      AC_MSG_RESULT($conv_16_rgb_ipq)
      if test x"$conv_16_rgb_ipq" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_16_RGB_454645, 1, [16bpp 565 (444 ipaq) Converter Support])
      fi
  ]
)

#######################################
## Convert to 16bpp RGB with rotation of 0
conv_16_rgb_rot_0="no"
conv_16_rgb_rot_0="yes"
AC_MSG_CHECKING(whether to build 16bpp rotation 0 converter code)
AC_ARG_ENABLE(convert-16-rgb-rot-0, 
  [  --enable-convert-16-rgb-rot-0   enable 16bpp rotation 0 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_16_RGB_ROT0, 1, [16bpp Rotation 0 Converter Code])
	conv_16_rgb_rot_0="yes"
      else
        AC_MSG_RESULT(no)
	conv_16_rgb_rot_0="no"
      fi
  ], [
      AC_MSG_RESULT($conv_16_rgb_rot_0)
      if test x"$conv_16_rgb_rot_0" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_16_RGB_ROT0, 1, [16bpp Rotation 0 Converter Code])
      fi
  ]
)

#######################################
## Convert to 16bpp RGB with rotation of 270
conv_16_rgb_rot_270="no"
conv_16_rgb_rot_270="yes"
AC_MSG_CHECKING(whether to build 16bpp rotation 270 converter code)
AC_ARG_ENABLE(convert-16-rgb-rot-270, 
  [  --enable-convert-16-rgb-rot-270 enable 16bpp rotation 270 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_16_RGB_ROT270, 1, [16bpp Rotation 270 Converter Code])
	conv_16_rgb_rot_270="yes"
      else
        AC_MSG_RESULT(no)
	conv_16_rgb_rot_270="no"
      fi
  ], [
      AC_MSG_RESULT($conv_16_rgb_rot_270)
      if test x"$conv_16_rgb_rot_270" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_16_RGB_ROT270, 1, [16bpp Rotation 270 Converter Code])
      fi
  ]
)

#######################################
## Convert to 16bpp RGB with rotation of 90
conv_16_rgb_rot_90="no"
conv_16_rgb_rot_90="yes"
AC_MSG_CHECKING(whether to build 16bpp rotation 90 converter code)
AC_ARG_ENABLE(convert-16-rgb-rot-90, 
  [  --enable-convert-16-rgb-rot-90  enable 16bpp rotation 90 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_16_RGB_ROT90, 1, [16bpp Rotation 90 Converter Code])
	conv_16_rgb_rot_90="yes"
      else
        AC_MSG_RESULT(no)
	conv_16_rgb_rot_90="no"
      fi
  ], [
      AC_MSG_RESULT($conv_16_rgb_rot_90)
      if test x"$conv_16_rgb_rot_90" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_16_RGB_ROT90, 1, [16bpp Rotation 90 Converter Code])
      fi
  ]
)

#######################################
## Convert to 24bpp RGB 888
conv_24_rgb_888="no"
conv_24_rgb_888="yes"
AC_MSG_CHECKING(whether to build 24bpp 888 rgb converter code)
AC_ARG_ENABLE(convert-24-rgb-888, 
  [  --enable-convert-24-rgb-888     enable 24bpp rgb 888 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_24_RGB_888, 1, [24bpp RGB 888 Converter Support])
	conv_24_rgb_888="yes"
      else
        AC_MSG_RESULT(no)
	conv_24_rgb_888="no"
      fi
  ], [
      AC_MSG_RESULT($conv_24_rgb_888)
      if test x"$conv_24_rgb_888" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_24_RGB_888, 1, [24bpp RGB 888 Converter Support])
      fi
  ]
)

#######################################
## Convert to 24bpp BGR 888
conv_24_bgr_888="no"
conv_24_bgr_888="yes"
AC_MSG_CHECKING(whether to build 24bpp 888 bgr converter code)
AC_ARG_ENABLE(convert-24-bgr-888, 
  [  --enable-convert-24-bgr-888     enable 24bpp bgr 888 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_24_BGR_888, 1, [24bpp BGR 888 Converter Support])
	conv_24_bgr_888="yes"
      else
        AC_MSG_RESULT(no)
	conv_24_bgr_888="no"
      fi
  ], [
      AC_MSG_RESULT(yes)
      if test x"$conv_24_bgr_888" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_24_BGR_888, 1, [24bpp BGR 888 Converter Support])
      fi
  ]
)

#######################################
## Convert to 32bpp RGB 8888
conv_32_rgb_8888="no"
conv_32_rgb_8888="yes"
AC_MSG_CHECKING(whether to build 32bpp 8888 rgb converter code)
AC_ARG_ENABLE(convert-32-rgb-8888, 
  [  --enable-convert-32-rgb-8888    enable 32bpp rgb 8888 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_32_RGB_8888, 1, [32bpp RGB 8888 Converter Support])
	conv_32_rgb_8888="yes"
      else
        AC_MSG_RESULT(no)
	conv_32_rgb_8888="no"
      fi
  ], [
      AC_MSG_RESULT($conv_32_rgb_8888)
      if test x"$conv_32_rgb_8888" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_32_RGB_8888, 1, [32bpp RGB 8888 Converter Support])
      fi
  ]
)

#######################################
## Convert to 32bpp RGBX 8888
conv_32_rgbx_8888="no"
conv_32_rgbx_8888="yes"
AC_MSG_CHECKING(whether to build 32bpp 8888 rgbx converter code)
AC_ARG_ENABLE(convert-32-rgbx-8888, 
  [  --enable-convert-32-rgbx-8888   enable 32bpp rgbx 8888 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_32_RGBX_8888, 1, [32bpp RGBX 8888 Converter Support])
	conv_32_rgbx_8888="yes"
      else
        AC_MSG_RESULT(no)
	conv_32_rgbx_8888="no"
      fi
  ], [
      AC_MSG_RESULT($conv_32_rgbx_8888)
      if test x"$conv_32_rgbx_8888" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_32_RGBX_8888, 1, [32bpp RBGX 8888 Converter Support])
      fi
  ]
)

#######################################
## Convert to 32bpp BGR 8888
conv_32_bgr_8888="no"
conv_32_bgr_8888="yes"
AC_MSG_CHECKING(whether to build 32bpp 8888 bgr converter code)
AC_ARG_ENABLE(convert-32-bgr-8888, 
  [  --enable-convert-32-bgr-8888    enable 32bpp bgr 8888 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_32_BGR_8888, 1, [32bpp BGR 8888 Converter Support])
	conv_32_bgr_8888="yes"
      else
        AC_MSG_RESULT(no)
	conv_32_bgr_8888="no"
      fi
  ], [
      AC_MSG_RESULT($conv_32_bgr_8888)
      if test x"$conv_32_bgr_8888" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_32_BGR_8888, 1, [32bpp BGR 8888 Converter Support])
      fi
  ]
)

#######################################
## Convert to 32bpp BGRX 8888
conv_32_bgrx_8888="no"
conv_32_bgrx_8888="yes"
AC_MSG_CHECKING(whether to build 32bpp 8888 bgrx converter code)
AC_ARG_ENABLE(convert-32-bgrx-8888, 
  [  --enable-convert-32-bgrx-8888   enable 32bpp bgrx 8888 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_32_BGRX_8888, 1, [32bpp BGRX 8888 Converter Support])
	conv_32_bgrx_8888="yes"
      else
        AC_MSG_RESULT(no)
	conv_32_bgrx_8888="no"
      fi
  ], [
      AC_MSG_RESULT($conv_32_bgrx_8888)
      if test x"$conv_32_bgrx_8888" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_32_BGRX_8888, 1, [32bpp RBGX 8888 Converter Support])
      fi
  ]
)

#######################################
## Convert to 32bpp RGB with rotation of 0
conv_32_rgb_rot_0="no"
conv_32_rgb_rot_0="yes"
AC_MSG_CHECKING(whether to build 32bpp rotation 0 converter code)
AC_ARG_ENABLE(convert-32-rgb-rot-0, 
  [  --enable-convert-32-rgb-rot-0   enable 32bpp rotation 0 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_32_RGB_ROT0, 1, [32bpp Rotation 0 Converter Support])
	conv_32_rgb_rot_0="yes"
      else
        AC_MSG_RESULT(no)
	conv_32_rgb_rot_0="no"
      fi
  ], [
      AC_MSG_RESULT($conv_32_rgb_rot_0)
      if test x"$conv_32_rgb_rot_0" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_32_RGB_ROT0, 1, [32bpp Rotation 0 Converter Support])
      fi
  ]
)

#######################################
## Convert to 32bpp RGB with rotation of 270
conv_32_rgb_rot_270="no"
conv_32_rgb_rot_270="yes"
AC_MSG_CHECKING(whether to build 32bpp rotation 270 converter code)
AC_ARG_ENABLE(convert-32-rgb-rot-270, 
  [  --enable-convert-32-rgb-rot-270 enable 32bpp rotation 270 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_32_RGB_ROT270, 1, [32bpp Rotation 270 Converter Support])
	conv_32_rgb_rot_270="yes"
      else
        AC_MSG_RESULT(no)
	conv_32_rgb_rot_270="no"
      fi
  ], [
      AC_MSG_RESULT($conv_32_rgb_rot_270)
      if test x"$conv_32_rgb_rot_270" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_32_RGB_ROT270, 1, [32bpp Rotation 270 Converter Support])
      fi
  ]
)

#######################################
## Convert to 32bpp RGB with rotation of 90
conv_32_rgb_rot_90="no"
conv_32_rgb_rot_90="yes"
AC_MSG_CHECKING(whether to build 32bpp rotation 90 converter code)
AC_ARG_ENABLE(convert-32-rgb-rot-90, 
  [  --enable-convert-32-rgb-rot-90  enable 32bpp rotation 90 converter code], [
      if test x"$enableval" = x"yes" ; then
        AC_MSG_RESULT(yes)
        AC_DEFINE(BUILD_CONVERT_32_RGB_ROT90, 1, [32bpp Rotation 90 Converter Support])
	conv_32_rgb_rot_90="yes"
      else
        AC_MSG_RESULT(no)
	conv_32_rgb_rot_90="no"
      fi
  ], [
      AC_MSG_RESULT($conv_32_rgb_rot_90)
      if test x"$conv_32_rgb_rot_90" = x"yes" ; then
        AC_DEFINE(BUILD_CONVERT_32_RGB_ROT90, 1, [32bpp Rotation 90 Converter Support])
      fi
  ]
)

# Setting have_valgrind to "no" seems pointless, but we just need to
# put something in as the 4th parameter, so configure doesn't abort
# when valgrind.pc isn't found.
have_valgrind="no"
PKG_CHECK_MODULES(VALGRIND, valgrind >= 2.4.0, have_valgrind=yes, have_valgrind=no)
VALGRIND_LIBS="" # dont use LIBS

AC_ARG_ENABLE(valgrind,
  [  --enable-valgrind               enable valgrind fixes to stop false reports], [
      if test x"$enableval" = x"yes" ; then
        have_valgrind="yes"
      else
        have_valgrind="no"
        VALGRIND_CFLAGS=""
      fi
  ], [
    have_valgrind=$have_valgrind
  ]
)

if test x$have_valgrind = "xyes"; then
  AC_DEFINE(HAVE_VALGRIND, 1, [Valgrind support])
fi

#####################################################################
## Fill in flags

AC_SUBST(VALGRIND_CFLAGS)

AC_SUBST(x_cflags)
AC_SUBST(x_libs)

AC_SUBST(xcb_cflags)
AC_SUBST(xcb_libs)
AC_SUBST(xcbrender_cflags)
AC_SUBST(xcbrender_libs)

AC_SUBST(gl_cflags)
AC_SUBST(gl_libs)

AC_SUBST(qt_cflags)
AC_SUBST(qt_libs)
AC_SUBST(qt_moc)

AC_SUBST(gif_cflags)
AC_SUBST(gif_libs)
AC_SUBST(png_cflags)
AC_SUBST(png_libs)
AC_SUBST(jpeg_cflags)
AC_SUBST(jpeg_libs)
AC_SUBST(eet_cflags)
AC_SUBST(eet_libs)
AC_SUBST(edb_cflags)
AC_SUBST(edb_libs)
AC_SUBST(tiff_cflags)
AC_SUBST(tiff_libs)
AC_SUBST(xpm_cflags)
AC_SUBST(xpm_libs)

# Build the list of required libs for evas.pc.in. Only works for libs
# which install a .pc file of course
if test "x$eet_libs" != "x"; then
  requirements=eet
fi
if test "x$edb_libs" != "x"; then
  requirements="$requirements edb"
fi
if test "x$png_libs" != "x"; then
  requirements="$requirements libpng12"
fi
AC_SUBST(requirements)

AC_SUBST(ENGINE_SOFTWARE_X11_PRG)
AC_SUBST(ENGINE_SOFTWARE_XCB_PRG)
AC_SUBST(ENGINE_DIRECTFB_PRG)
AC_SUBST(ENGINE_FB_PRG)
AC_SUBST(ENGINE_BUFFER_PRG)
AC_SUBST(ENGINE_SOFTWARE_QTOPIA_PRG)
AC_SUBST(ENGINE_GL_X11_PRG)
AC_SUBST(ENGINE_CAIRO_X11_PRG)
AC_SUBST(ENGINE_XRENDER_X11_PRG)
AC_SUBST(ENGINE_XRENDER_XCB_PRG)

AC_SUBST(altivec_cflags)

#####################################################################
## Output

AC_OUTPUT([
Makefile
evas.pc
data/Makefile
src/Makefile
src/bin/Makefile
src/bin/evas_software_win32/Makefile
src/lib/Makefile
src/lib/canvas/Makefile
src/lib/data/Makefile
src/lib/file/Makefile
src/lib/imaging/Makefile
src/lib/engines/Makefile
src/lib/engines/common/Makefile
src/lib/engines/common/evas_op_add/Makefile
src/lib/engines/common/evas_op_blend/Makefile
src/lib/engines/common/evas_op_copy/Makefile
src/lib/engines/common/evas_op_mask/Makefile
src/lib/engines/common/evas_op_mul/Makefile
src/lib/engines/common/evas_op_sub/Makefile
src/modules/Makefile
src/modules/engines/Makefile
src/modules/engines/software_generic/Makefile
src/modules/engines/software_x11/Makefile
src/modules/engines/software_xcb/Makefile
src/modules/engines/fb/Makefile
src/modules/engines/buffer/Makefile
src/modules/engines/software_win32_gdi/Makefile
src/modules/engines/software_qtopia/Makefile
src/modules/engines/directfb/Makefile
src/modules/engines/gl_common/Makefile
src/modules/engines/gl_x11/Makefile
src/modules/engines/cairo_common/Makefile
src/modules/engines/cairo_x11/Makefile
src/modules/engines/xrender_x11/Makefile
src/modules/engines/xrender_xcb/Makefile
src/modules/loaders/Makefile
src/modules/loaders/edb/Makefile
src/modules/loaders/eet/Makefile
src/modules/loaders/gif/Makefile
src/modules/loaders/jpeg/Makefile
src/modules/loaders/png/Makefile
src/modules/loaders/tiff/Makefile
src/modules/loaders/xpm/Makefile
src/modules/savers/Makefile
src/modules/savers/edb/Makefile
src/modules/savers/eet/Makefile
src/modules/savers/jpeg/Makefile
src/modules/savers/png/Makefile
src/modules/savers/tiff/Makefile
src/lib/include/Makefile
proj/Makefile
proj/win32_gdi/Makefile
evas-config
README
evas.spec
debian/changelog
],[
chmod +x evas-config
])

#####################################################################
## Info

echo
echo
echo
echo "------------------------------------------------------------------------"
echo "$PACKAGE $VERSION"
echo "------------------------------------------------------------------------"
echo
echo "Configuration Options Summary:"
echo
echo "Engines:"
echo "  Software X11............: $have_evas_software_x11"
echo "  Software XCB............: $have_evas_software_xcb"
echo "  Software Framebuffer....: $have_evas_fb"
echo "  Software Qtopia.........: $have_evas_qtopia"
echo "  Software Memory Buffer..: $have_evas_buffer"
echo "  DirectFB................: $have_evas_directfb"
echo "  OpenGL X11..............: $have_evas_gl_x11"
echo "  Cairo X11...............: $have_evas_cairo_x11"
echo "  XRender X11.............: $have_evas_xrender_x11"
echo "  XRender Xcb.............: $have_evas_xrender_xcb"
# FIXME: opengl engine needs to be fixed and tested lots for all drivers
# FIXME: xrender engine to be written
echo
echo "Image Loaders:"
echo "  GIF.....................: $have_gif"
echo "  PNG.....................: $have_png"
echo "  JPEG....................: $have_jpeg"
echo "  EET.....................: $have_eet"
echo "  EDB.....................: $have_edb"
echo "  TIFF....................: $have_tiff"
echo "  XPM.....................: $have_xpm"
# FIXME: need to add modular image loader system
# FIXME: add more image loader modules
echo
echo "Font Sourcing Systems:"
echo "  EET.....................: $have_eet_fonts"
echo
echo "Font Searching Systems:"
echo "  FontConfig..............: $have_fontconfig"
# FIXME: add non freetype2 font engine support
# FIXME: make freetype2 optional
echo
echo "CPU Specific Extensions:"
echo "  Fallback C Code.........: $build_cpu_c"
echo "  MMX.....................: $build_cpu_mmx"
echo "  SSE.....................: $build_cpu_sse"
echo "  ALTIVEC.................: $build_cpu_altivec"
echo
echo "ARGB Software Engine Options:"
echo "  Sampling Scaler.........: $scaler_sample"
echo "  Smooth Scaler...........: $scaler_smooth"
# FIXME: add an mxx scaler routine
echo "  YUV Converter...........: $conv_yuv"
# FIXME: add more YUV format and colorvariant support
echo
echo "ARGB Conversion Options:"
echo "  Smaller Dither Mask.....: $conv_small_dither"
echo "  8bpp RGB 332............: $conv_8_rgb_332"
echo "  8bpp RGB 666............: $conv_8_rgb_666"
echo "  8bpp RGB 232............: $conv_8_rgb_232"
echo "  8bpp RGB 222............: $conv_8_rgb_222"
echo "  8bpp RGB 221............: $conv_8_rgb_221"
echo "  8bpp RGB 121............: $conv_8_rgb_121"
echo "  8bpp RGB 111............: $conv_8_rgb_111"
# FIXME: add grayscale and B&W support
echo "  16bpp RGB 565...........: $conv_16_rgb_565"
echo "  16bpp RGB 555...........: $conv_16_rgb_555"
echo "  16bpp RGB 444...........: $conv_16_rgb_444"
echo "  16bpp RGB 565 (444 ipaq): $conv_16_rgb_ipq"
# FIXME: add 555 (444 ipaq) support
# FIXME: add 24bpp 666 support
# FIXME: add 32bpp 666 support
# FIXME: add 30bpp support
# FIXME: add palletted support
# FIXME: add 8bpp and below rotation
echo "  16bpp Rotation 0........: $conv_16_rgb_rot_0"
echo "  16bpp Rotation 90.......: $conv_16_rgb_rot_90"
echo "  16bpp Rotation 270......: $conv_16_rgb_rot_270"
# FIXME: add 180 rotation
echo "  24bpp RGB 888...........: $conv_24_rgb_888"
echo "  24bpp BGR 888...........: $conv_24_bgr_888"
# FIXME: add 24bpp rotation
echo "  32bpp RGB 8888..........: $conv_32_rgb_8888"
echo "  32bpp RGBX 8888.........: $conv_32_rgbx_8888"
echo "  32bpp BGR 8888..........: $conv_32_bgr_8888"
echo "  32bpp BGRX 8888.........: $conv_32_bgrx_8888"
echo "  32bpp Rotation 0........: $conv_32_rgb_rot_0"
echo "  32bpp Rotation 90.......: $conv_32_rgb_rot_90"
echo "  32bpp Rotation 270......: $conv_32_rgb_rot_270"
# FIXME: add 180 rotation
echo
echo "------------------------------------------------------------------------"
echo
echo "Now type 'make' ('gmake' on some systems) to compile $PACKAGE,"
echo "and then afterwards as root (or the user who will install this), type"
echo "'make install'. Change users with 'su' or 'sudo' appropriately."
echo