| AC_INIT([libwebp], [1.0.0], |
| [https://bugs.chromium.org/p/webp],, |
| [http://developers.google.com/speed/webp]) |
| AC_CANONICAL_HOST |
| AC_PREREQ([2.60]) |
| AM_INIT_AUTOMAKE([-Wall foreign subdir-objects]) |
| |
| dnl === automake >= 1.12 requires this for 'unusual archivers' support. |
| dnl === it must occur before LT_INIT (AC_PROG_LIBTOOL). |
| m4_ifdef([AM_PROG_AR], [AM_PROG_AR]) |
| |
| AC_PROG_LIBTOOL |
| AC_PROG_SED |
| AM_PROG_CC_C_O |
| |
| dnl === Enable less verbose output when building. |
| m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) |
| |
| dnl == test endianness |
| AC_C_BIGENDIAN |
| |
| dnl === SET_IF_UNSET(shell_var, value) |
| dnl === Set the shell variable 'shell_var' to 'value' if it is unset. |
| AC_DEFUN([SET_IF_UNSET], [test "${$1+set}" = "set" || $1=$2]) |
| |
| AC_ARG_ENABLE([everything], |
| AS_HELP_STRING([--enable-everything], |
| [Enable all optional targets. These can still be |
| disabled with --disable-target]), |
| [SET_IF_UNSET([enable_libwebpdecoder], [$enableval]) |
| SET_IF_UNSET([enable_libwebpdemux], [$enableval]) |
| SET_IF_UNSET([enable_libwebpextras], [$enableval]) |
| SET_IF_UNSET([enable_libwebpmux], [$enableval])]) |
| |
| dnl === If --enable-asserts is not defined, define NDEBUG |
| |
| AC_MSG_CHECKING(whether asserts are enabled) |
| AC_ARG_ENABLE([asserts], |
| AS_HELP_STRING([--enable-asserts], |
| [Enable assert checks])) |
| if test "x${enable_asserts-no}" = "xno"; then |
| AM_CPPFLAGS="${AM_CPPFLAGS} -DNDEBUG" |
| fi |
| AC_MSG_RESULT(${enable_asserts-no}) |
| AC_SUBST([AM_CPPFLAGS]) |
| |
| 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]) |
| |
| dnl === TEST_AND_ADD_CFLAGS(var, flag) |
| dnl === Checks whether $CC supports 'flag' and adds it to 'var' |
| dnl === on success. |
| AC_DEFUN([TEST_AND_ADD_CFLAGS], |
| [SAVED_CFLAGS="$CFLAGS" |
| CFLAGS="-Werror $2" |
| AC_MSG_CHECKING([whether $CC supports $2]) |
| dnl Note AC_LANG_PROGRAM([]) uses an old-style main definition. |
| AC_COMPILE_IFELSE([AC_LANG_SOURCE([int main(void) { return 0; }])], |
| [AC_MSG_RESULT([yes])] |
| dnl Simply append the variable avoiding a |
| dnl compatibility ifdef for AS_VAR_APPEND as this |
| dnl variable shouldn't grow all that large. |
| [$1="${$1} $2"], |
| [AC_MSG_RESULT([no])]) |
| CFLAGS="$SAVED_CFLAGS"]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-fvisibility=hidden]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wall]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wconstant-conversion]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wdeclaration-after-statement]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wextra]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wfloat-conversion]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wformat -Wformat-nonliteral]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wformat -Wformat-security]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wmissing-declarations]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wmissing-prototypes]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wold-style-definition]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wparentheses-equality]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wshadow]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wshorten-64-to-32]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wundef]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunreachable-code]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunused-but-set-variable]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wunused]) |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wvla]) |
| # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=62040 |
| # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61622 |
| AS_IF([test "$GCC" = "yes" ], [ |
| gcc_version=`$CC -dumpversion` |
| gcc_wht_bug="" |
| case "$host_cpu" in |
| aarch64|arm64) |
| case "$gcc_version" in |
| 4.9|4.9.0|4.9.1) gcc_wht_bug=yes ;; |
| esac |
| esac |
| AS_IF([test "$gcc_wht_bug" = "yes"], [ |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-frename-registers])])]) |
| # Use -flax-vector-conversions, if available, when building intrinsics with |
| # older versions of gcc. The flag appeared in 4.3.x, but if backported, and |
| # -fno-lax-vector-conversions is set, errors may occur with the intrinsics |
| # files along with the older system includes, e.g., emmintrin.h. |
| # Originally observed with cc (GCC) 4.2.1 20070831 patched [FreeBSD] (9.3). |
| # https://bugs.chromium.org/p/webp/issues/detail?id=274 |
| AS_IF([test "$GCC" = "yes" ], [ |
| case "$host_cpu" in |
| amd64|i?86|x86_64) |
| AC_COMPILE_IFELSE( |
| dnl only check for -flax-vector-conversions with older gcc, skip |
| dnl clang as it reports itself as 4.2.1, but the flag isn't needed. |
| [AC_LANG_SOURCE([#if !defined(__clang__) && defined(__GNUC__) && \ |
| ((__GNUC__ << 8) | __GNUC_MINOR__) < 0x403 |
| #error old gcc |
| #endif |
| int main(void) { return 0; } |
| ])],, |
| [TEST_AND_ADD_CFLAGS([INTRINSICS_CFLAGS], |
| [-flax-vector-conversions])]) |
| ;; |
| esac]) |
| AC_SUBST([AM_CFLAGS]) |
| |
| dnl === Check for machine specific flags |
| AC_ARG_ENABLE([avx2], |
| AS_HELP_STRING([--disable-avx2], |
| [Disable detection of AVX2 support |
| @<:@default=auto@:>@])) |
| |
| AS_IF([test "x$enable_avx2" != "xno" -a "x$enable_sse4_1" != "xno" \ |
| -a "x$enable_sse2" != "xno"], [ |
| AVX2_CFLAGS="$INTRINSICS_CFLAGS $AVX2_FLAGS" |
| TEST_AND_ADD_CFLAGS([AVX2_FLAGS], [-mavx2]) |
| AS_IF([test -n "$AVX2_FLAGS"], [ |
| SAVED_CFLAGS=$CFLAGS |
| CFLAGS="$CFLAGS $AVX2_FLAGS" |
| AC_CHECK_HEADER([immintrin.h], |
| [AC_DEFINE(WEBP_HAVE_AVX2, [1], |
| [Set to 1 if AVX2 is supported])], |
| [AVX2_FLAGS=""], |
| dnl it's illegal to directly include avx2intrin.h, but it's |
| dnl included conditionally in immintrin.h, tricky! |
| [#ifndef __AVX2__ |
| #error avx2 is not enabled |
| #endif |
| ]) |
| CFLAGS=$SAVED_CFLAGS]) |
| AC_SUBST([AVX2_FLAGS])]) |
| |
| AC_ARG_ENABLE([sse4.1], |
| AS_HELP_STRING([--disable-sse4.1], |
| [Disable detection of SSE4.1 support |
| @<:@default=auto@:>@])) |
| |
| AS_IF([test "x$enable_sse4_1" != "xno" -a "x$enable_sse2" != "xno"], [ |
| SSE41_FLAGS="$INTRINSICS_CFLAGS $SSE41_FLAGS" |
| TEST_AND_ADD_CFLAGS([SSE41_FLAGS], [-msse4.1]) |
| AS_IF([test -n "$SSE41_FLAGS"], [ |
| SAVED_CFLAGS=$CFLAGS |
| CFLAGS="$CFLAGS $SSE41_FLAGS" |
| AC_CHECK_HEADER([smmintrin.h], |
| [AC_DEFINE(WEBP_HAVE_SSE41, [1], |
| [Set to 1 if SSE4.1 is supported])], |
| [SSE41_FLAGS=""]) |
| CFLAGS=$SAVED_CFLAGS]) |
| AC_SUBST([SSE41_FLAGS])]) |
| |
| AC_ARG_ENABLE([sse2], |
| AS_HELP_STRING([--disable-sse2], |
| [Disable detection of SSE2 support |
| @<:@default=auto@:>@])) |
| |
| AS_IF([test "x$enable_sse2" != "xno"], [ |
| SSE2_FLAGS="$INTRINSICS_CFLAGS $SSE2_FLAGS" |
| TEST_AND_ADD_CFLAGS([SSE2_FLAGS], [-msse2]) |
| AS_IF([test -n "$SSE2_FLAGS"], [ |
| SAVED_CFLAGS=$CFLAGS |
| CFLAGS="$CFLAGS $SSE2_FLAGS" |
| AC_CHECK_HEADER([emmintrin.h], |
| [AC_DEFINE(WEBP_HAVE_SSE2, [1], |
| [Set to 1 if SSE2 is supported])], |
| [SSE2_FLAGS=""]) |
| CFLAGS=$SAVED_CFLAGS]) |
| AC_SUBST([SSE2_FLAGS])]) |
| |
| AC_ARG_ENABLE([neon], |
| AS_HELP_STRING([--disable-neon], |
| [Disable detection of NEON support |
| @<:@default=auto@:>@])) |
| |
| AC_ARG_ENABLE([neon_rtcd], |
| AS_HELP_STRING([--disable-neon-rtcd], |
| [Disable runtime detection of NEON support via |
| /proc/cpuinfo on Linux hosts |
| @<:@default=auto@:>@])) |
| # For ARM(7) hosts: |
| # Both NEON flags unset and NEON support detected = build all modules with NEON |
| # NEON detected with the use of -mfpu=neon = build only NEON modules with NEON |
| AS_IF([test "x$enable_neon" != "xno"], [ |
| case "$host_cpu" in |
| arm|armv7*) |
| # Test for NEON support without flags before falling back to -mfpu=neon |
| for flag in '' '-mfpu=neon'; do |
| LOCAL_NEON_FLAGS="$INTRINSICS_CFLAGS $NEON_FLAGS" |
| TEST_AND_ADD_CFLAGS([LOCAL_NEON_FLAGS], [$flag]) |
| SAVED_CFLAGS=$CFLAGS |
| CFLAGS="$CFLAGS $LOCAL_NEON_FLAGS" |
| |
| dnl Note AC_LANG_PROGRAM([]) uses an old-style main definition. |
| AC_COMPILE_IFELSE([AC_LANG_SOURCE([ |
| #include <arm_neon.h> |
| int main(void) { |
| int8x8_t v = vdup_n_s8(0); |
| (void)v; |
| return 0; |
| }])], |
| [NEON_FLAGS="$(echo $LOCAL_NEON_FLAGS | $SED 's/^ *//')" |
| AS_IF([test -n "$NEON_FLAGS"], [ |
| AS_IF([test "${host_os%%-*}" = "linux" -o \ |
| "x$enable_neon_rtcd" = "xno"], [ |
| CFLAGS=$SAVED_CFLAGS |
| AC_DEFINE(WEBP_HAVE_NEON, [1], [Set to 1 if NEON is supported]) |
| break |
| ],[ |
| AC_MSG_WARN(m4_normalize([NEON runtime cpu-detection is |
| unavailable for ${host_os%%-*}. Force |
| with CFLAGS=-mfpu=neon or |
| --disable-neon-rtcd.])) |
| enable_neon_rtcd=no |
| NEON_FLAGS="" |
| ]) |
| ],[ |
| CFLAGS=$SAVED_CFLAGS |
| AC_DEFINE(WEBP_HAVE_NEON, [1], [Set to 1 if NEON is supported]) |
| break |
| ])]) |
| CFLAGS=$SAVED_CFLAGS |
| done |
| |
| AS_IF([test -n "$NEON_FLAGS"], [ |
| # If NEON is available and rtcd is disabled apply NEON_FLAGS globally. |
| AS_IF([test "x$enable_neon_rtcd" = "xno"], [ |
| AM_CFLAGS="$AM_CFLAGS $NEON_FLAGS" |
| NEON_FLAGS=""], |
| [AC_DEFINE(WEBP_HAVE_NEON_RTCD, [1], |
| [Set to 1 if runtime detection of NEON is enabled])])]) |
| |
| case "$host_os" in |
| *android*) AC_CHECK_HEADERS([cpu-features.h]) ;; |
| esac |
| ;; |
| esac |
| AC_SUBST([NEON_FLAGS])]) |
| |
| dnl === CLEAR_LIBVARS([var_pfx]) |
| dnl === Clears <var_pfx>_{INCLUDES,LIBS}. |
| AC_DEFUN([CLEAR_LIBVARS], [$1_INCLUDES=""; $1_LIBS=""]) |
| |
| dnl === WITHLIB_OPTION([opt_pfx], [outvar_pfx]) |
| dnl === Defines --with-<opt_pfx>{include,lib}dir options which set |
| dnl === the variables <outvar_pfx>_{INCLUDES,LIBS}. |
| AC_DEFUN([WITHLIB_OPTION], |
| [AC_ARG_WITH([$1includedir], |
| AS_HELP_STRING([--with-$1includedir=DIR], |
| [use $2 includes from DIR]), |
| $2_INCLUDES="-I$withval") |
| AC_ARG_WITH([$1libdir], |
| AS_HELP_STRING([--with-$1libdir=DIR], |
| [use $2 libraries from DIR]), |
| [$2_LIBS="-L$withval"])]) |
| |
| dnl === LIBCHECK_PROLOGUE([var_pfx]) |
| dnl === Caches the current values of CPPFLAGS/LIBS in SAVED_* then |
| dnl === prepends the current values with <var_pfx>_{INCLUDES,LIBS}. |
| AC_DEFUN([LIBCHECK_PROLOGUE], |
| [SAVED_CPPFLAGS=$CPPFLAGS |
| SAVED_LIBS=$LIBS |
| CPPFLAGS="$$1_INCLUDES $CPPFLAGS" |
| LIBS="$$1_LIBS $LIBS"]) |
| |
| dnl === LIBCHECK_EPILOGUE([var_pfx]) |
| dnl === Restores the values of CPPFLAGS/LIBS from SAVED_* and exports |
| dnl === <var_pfx>_{INCLUDES,LIBS} with AC_SUBST. |
| AC_DEFUN([LIBCHECK_EPILOGUE], |
| [AC_SUBST($1_LIBS) |
| AC_SUBST($1_INCLUDES) |
| CPPFLAGS=$SAVED_CPPFLAGS |
| LIBS=$SAVED_LIBS]) |
| |
| dnl === Check for gcc builtins |
| |
| dnl === CHECK_FOR_BUILTIN([builtin], [param], [define]) |
| dnl === links a C AC_LANG_PROGRAM, with <builtin>(<param>) |
| dnl === AC_DEFINE'ing <define> if successful. |
| AC_DEFUN([CHECK_FOR_BUILTIN], |
| [AC_LANG_PUSH([C]) |
| AC_MSG_CHECKING([for $1]) |
| AC_LINK_IFELSE([AC_LANG_PROGRAM([], [(void)$1($2)])], |
| [AC_MSG_RESULT([yes]) |
| AC_DEFINE([$3], [1], |
| [Set to 1 if $1 is available])], |
| [AC_MSG_RESULT([no])]), |
| AC_LANG_POP]) |
| |
| dnl AC_CHECK_FUNC doesn't work with builtin's. |
| CHECK_FOR_BUILTIN([__builtin_bswap16], [1u << 15], [HAVE_BUILTIN_BSWAP16]) |
| CHECK_FOR_BUILTIN([__builtin_bswap32], [1u << 31], [HAVE_BUILTIN_BSWAP32]) |
| CHECK_FOR_BUILTIN([__builtin_bswap64], [1ull << 63], [HAVE_BUILTIN_BSWAP64]) |
| |
| dnl === Check for pthread support |
| AC_ARG_ENABLE([threading], |
| AS_HELP_STRING([--disable-threading], |
| [Disable detection of thread support]),, |
| [enable_threading=yes]) |
| if test "$enable_threading" = "yes"; then |
| AC_MSG_NOTICE([checking for threading support...]) |
| AX_PTHREAD([AC_DEFINE([WEBP_USE_THREAD], [1], |
| [Undefine this to disable thread support.]) |
| LIBS="$PTHREAD_LIBS $LIBS" |
| CFLAGS="$CFLAGS $PTHREAD_CFLAGS" |
| CC="$PTHREAD_CC" |
| ], |
| [AC_CHECK_FUNC([_beginthreadex], |
| [AC_DEFINE([WEBP_USE_THREAD], [1], |
| [Undefine this to disable thread |
| support.])], |
| [enable_threading=no])]) |
| fi |
| AC_MSG_NOTICE([checking if threading is enabled... ${enable_threading-no}]) |
| |
| dnl === check for OpenGL/GLUT support === |
| |
| AC_ARG_ENABLE([gl], AS_HELP_STRING([--disable-gl], |
| [Disable detection of OpenGL support |
| @<:@default=auto@:>@])) |
| AS_IF([test "x$enable_gl" != "xno"], [ |
| CLEAR_LIBVARS([GL]) |
| WITHLIB_OPTION([gl], [GL]) |
| |
| LIBCHECK_PROLOGUE([GL]) |
| |
| glut_cflags="none" |
| glut_ldflags="none" |
| case $host_os in |
| darwin*) |
| # Special case for OSX builds. Append these to give the user a chance to |
| # override with --with-gl* |
| glut_cflags="$glut_cflags|-framework GLUT -framework OpenGL" |
| glut_ldflags="$glut_ldflags|-framework GLUT -framework OpenGL" |
| # quiet deprecation warnings for glut |
| TEST_AND_ADD_CFLAGS([AM_CFLAGS], [-Wno-deprecated-declarations]) |
| ;; |
| esac |
| |
| GLUT_SAVED_CPPFLAGS="$CPPFLAGS" |
| SAVED_IFS="$IFS" |
| IFS="|" |
| for flag in $glut_cflags; do |
| # restore IFS immediately as the autoconf macros may need the default. |
| IFS="$SAVED_IFS" |
| unset ac_cv_header_GL_glut_h |
| unset ac_cv_header_OpenGL_glut_h |
| |
| case $flag in |
| none) ;; |
| *) CPPFLAGS="$flag $CPPFLAGS";; |
| esac |
| AC_CHECK_HEADERS([GL/glut.h GLUT/glut.h OpenGL/glut.h], |
| [glut_headers=yes; |
| test "$flag" = "none" || GL_INCLUDES="$CPPFLAGS"; |
| break]) |
| CPPFLAGS="$GLUT_SAVED_CPPFLAGS" |
| test "$glut_headers" = "yes" && break |
| done |
| IFS="$SAVED_IFS" |
| |
| if test "$glut_headers" = "yes"; then |
| AC_LANG_PUSH([C]) |
| GLUT_SAVED_LDFLAGS="$LDFLAGS" |
| SAVED_IFS="$IFS" |
| IFS="|" |
| for flag in $glut_ldflags; do |
| # restore IFS immediately as the autoconf macros may need the default. |
| IFS="$SAVED_IFS" |
| unset ac_cv_search_glBegin |
| |
| case $flag in |
| none) ;; |
| *) LDFLAGS="$flag $LDFLAGS";; |
| esac |
| |
| # find libGL |
| GL_SAVED_LIBS="$LIBS" |
| AC_SEARCH_LIBS([glBegin], [GL OpenGL opengl32]) |
| LIBS="$GL_SAVED_LIBS" |
| |
| # A direct link to libGL may not be necessary on e.g., linux. |
| GLUT_SAVED_LIBS="$LIBS" |
| for lib in "" "-lglut" "-lglut $ac_cv_search_glBegin"; do |
| LIBS="$lib" |
| AC_LINK_IFELSE( |
| [AC_LANG_PROGRAM([ |
| #ifdef __cplusplus |
| # define EXTERN_C extern "C" |
| #else |
| # define EXTERN_C |
| #endif |
| EXTERN_C char glOrtho(); |
| EXTERN_C char glutMainLoop(); |
| ],[ |
| glOrtho(); |
| glutMainLoop(); |
| ]) |
| ], |
| AC_DEFINE(WEBP_HAVE_GL, [1], |
| [Set to 1 if OpenGL is supported]) |
| [glut_support=yes], [] |
| ) |
| if test "$glut_support" = "yes"; then |
| GL_LIBS="$LDFLAGS $lib" |
| break |
| fi |
| done |
| LIBS="$GLUT_SAVED_LIBS" |
| LDFLAGS="$GLUT_SAVED_LDFLAGS" |
| test "$glut_support" = "yes" && break |
| done |
| IFS="$SAVED_IFS" |
| AC_LANG_POP |
| fi |
| |
| LIBCHECK_EPILOGUE([GL]) |
| |
| if test "$glut_support" = "yes" -a "$enable_libwebpdemux" = "yes"; then |
| build_vwebp=yes |
| fi |
| ]) |
| AM_CONDITIONAL([BUILD_VWEBP], [test "$build_vwebp" = "yes"]) |
| |
| dnl === check for SDL support === |
| |
| AC_ARG_ENABLE([sdl], |
| AS_HELP_STRING([--disable-sdl], |
| [Disable detection of SDL support |
| @<:@default=auto@:>@])) |
| AS_IF([test "x$enable_sdl" != "xno"], [ |
| CLEAR_LIBVARS([SDL]) |
| AC_PATH_PROGS([LIBSDL_CONFIG], [sdl-config]) |
| if test -n "$LIBSDL_CONFIG"; then |
| SDL_INCLUDES=`$LIBSDL_CONFIG --cflags` |
| SDL_LIBS="`$LIBSDL_CONFIG --libs`" |
| fi |
| |
| WITHLIB_OPTION([sdl], [SDL]) |
| |
| sdl_header="no" |
| LIBCHECK_PROLOGUE([SDL]) |
| AC_CHECK_HEADER([SDL/SDL.h], [sdl_header="SDL/SDL.h"], |
| [AC_CHECK_HEADER([SDL.h], [sdl_header="SDL.h"], |
| [AC_MSG_WARN(SDL library not available - no sdl.h)])]) |
| if test x"$sdl_header" != "xno"; then |
| AC_LANG_PUSH(C) |
| SDL_SAVED_LIBS="$LIBS" |
| for lib in "" "-lSDL" "-lSDLmain -lSDL"; do |
| LIBS="$SDL_SAVED_LIBS $lib" |
| # Perform a full link to ensure SDL_main is resolved if needed. |
| AC_LINK_IFELSE( |
| [AC_LANG_SOURCE([ |
| #include <$sdl_header> |
| int main(int argc, char** argv) { |
| SDL_Init(0); |
| return 0; |
| }])], |
| [SDL_LIBS="$LDFLAGS $LIBS" |
| SDL_INCLUDES="$SDL_INCLUDES -DWEBP_HAVE_SDL" |
| AC_DEFINE(WEBP_HAVE_SDL, [1], |
| [Set to 1 if SDL library is installed]) |
| sdl_support=yes] |
| ) |
| if test x"$sdl_support" = "xyes"; then |
| break |
| fi |
| done |
| # LIBS is restored by LIBCHECK_EPILOGUE |
| AC_LANG_POP |
| if test x"$sdl_header" = "xSDL.h"; then |
| SDL_INCLUDES="$SDL_INCLUDES -DWEBP_HAVE_JUST_SDL_H" |
| fi |
| fi |
| LIBCHECK_EPILOGUE([SDL]) |
| |
| if test x"$sdl_support" = "xyes"; then |
| build_vwebp_sdl=yes |
| else |
| AC_MSG_WARN(Optional SDL library not found) |
| fi |
| ]) |
| |
| AM_CONDITIONAL([BUILD_VWEBP_SDL], [test "$build_vwebp_sdl" = "yes"]) |
| |
| dnl === check for PNG support === |
| |
| AC_ARG_ENABLE([png], AS_HELP_STRING([--disable-png], |
| [Disable detection of PNG format support |
| @<:@default=auto@:>@])) |
| AS_IF([test "x$enable_png" != "xno"], [ |
| CLEAR_LIBVARS([PNG]) |
| AC_PATH_PROGS([LIBPNG_CONFIG], |
| [libpng-config libpng16-config libpng15-config libpng14-config \ |
| libpng12-config]) |
| if test -n "$LIBPNG_CONFIG"; then |
| PNG_INCLUDES=`$LIBPNG_CONFIG --cflags` |
| PNG_LIBS="`$LIBPNG_CONFIG --ldflags`" |
| fi |
| |
| WITHLIB_OPTION([png], [PNG]) |
| |
| LIBCHECK_PROLOGUE([PNG]) |
| AC_CHECK_HEADER(png.h, |
| AC_SEARCH_LIBS(png_get_libpng_ver, [png], |
| [test "$ac_cv_search_png_get_libpng_ver" = "none required" \ |
| || PNG_LIBS="$PNG_LIBS $ac_cv_search_png_get_libpng_ver" |
| PNG_INCLUDES="$PNG_INCLUDES -DWEBP_HAVE_PNG" |
| AC_DEFINE(WEBP_HAVE_PNG, [1], |
| [Set to 1 if PNG library is installed]) |
| png_support=yes |
| ], |
| [AC_MSG_WARN(Optional png library not found) |
| PNG_LIBS="" |
| PNG_INCLUDES="" |
| ], |
| [$MATH_LIBS]), |
| [AC_MSG_WARN(png library not available - no png.h) |
| PNG_LIBS="" |
| PNG_INCLUDES="" |
| ], |
| ) |
| LIBCHECK_EPILOGUE([PNG]) |
| ]) |
| |
| dnl === check for JPEG support === |
| |
| AC_ARG_ENABLE([jpeg], |
| AS_HELP_STRING([--disable-jpeg], |
| [Disable detection of JPEG format support |
| @<:@default=auto@:>@])) |
| AS_IF([test "x$enable_jpeg" != "xno"], [ |
| CLEAR_LIBVARS([JPEG]) |
| WITHLIB_OPTION([jpeg], [JPEG]) |
| |
| LIBCHECK_PROLOGUE([JPEG]) |
| AC_CHECK_HEADER(jpeglib.h, |
| AC_CHECK_LIB(jpeg, jpeg_set_defaults, |
| [JPEG_LIBS="$JPEG_LIBS -ljpeg" |
| JPEG_INCLUDES="$JPEG_INCLUDES -DWEBP_HAVE_JPEG" |
| AC_DEFINE(WEBP_HAVE_JPEG, [1], |
| [Set to 1 if JPEG library is installed]) |
| jpeg_support=yes |
| ], |
| AC_MSG_WARN(Optional jpeg library not found), |
| [$MATH_LIBS]), |
| AC_MSG_WARN(jpeg library not available - no jpeglib.h) |
| ) |
| LIBCHECK_EPILOGUE([JPEG]) |
| ]) |
| |
| dnl === check for TIFF support === |
| |
| AC_ARG_ENABLE([tiff], |
| AS_HELP_STRING([--disable-tiff], |
| [Disable detection of TIFF format support |
| @<:@default=auto@:>@])) |
| AS_IF([test "x$enable_tiff" != "xno"], [ |
| CLEAR_LIBVARS([TIFF]) |
| WITHLIB_OPTION([tiff], [TIFF]) |
| |
| LIBCHECK_PROLOGUE([TIFF]) |
| AC_CHECK_HEADER(tiffio.h, |
| AC_CHECK_LIB(tiff, TIFFGetVersion, |
| [TIFF_LIBS="$TIFF_LIBS -ltiff" |
| TIFF_INCLUDES="$TIFF_INCLUDES -DWEBP_HAVE_TIFF" |
| AC_DEFINE(WEBP_HAVE_TIFF, [1], |
| [Set to 1 if TIFF library is installed]) |
| tiff_support=yes |
| ], |
| AC_MSG_WARN(Optional tiff library not found), |
| [$MATH_LIBS]), |
| AC_MSG_WARN(tiff library not available - no tiffio.h) |
| ) |
| LIBCHECK_EPILOGUE([TIFF]) |
| ]) |
| |
| dnl === check for GIF support === |
| |
| AC_ARG_ENABLE([gif], AS_HELP_STRING([--disable-gif], |
| [Disable detection of GIF format support |
| @<:@default=auto@:>@])) |
| AS_IF([test "x$enable_gif" != "xno"], [ |
| CLEAR_LIBVARS([GIF]) |
| WITHLIB_OPTION([gif], [GIF]) |
| |
| LIBCHECK_PROLOGUE([GIF]) |
| AC_CHECK_HEADER(gif_lib.h, |
| AC_CHECK_LIB([gif], [DGifOpenFileHandle], |
| [GIF_LIBS="$GIF_LIBS -lgif" |
| AC_DEFINE(WEBP_HAVE_GIF, [1], |
| [Set to 1 if GIF library is installed]) |
| gif_support=yes |
| ], |
| AC_MSG_WARN(Optional gif library not found), |
| [$MATH_LIBS]), |
| AC_MSG_WARN(gif library not available - no gif_lib.h) |
| ) |
| LIBCHECK_EPILOGUE([GIF]) |
| |
| if test "$gif_support" = "yes" -a \ |
| "$enable_libwebpdemux" = "yes"; then |
| build_anim_diff=yes |
| fi |
| |
| if test "$gif_support" = "yes" -a \ |
| "$enable_libwebpmux" = "yes"; then |
| build_gif2webp=yes |
| fi |
| ]) |
| AM_CONDITIONAL([BUILD_ANIMDIFF], [test "${build_anim_diff}" = "yes"]) |
| AM_CONDITIONAL([BUILD_GIF2WEBP], [test "${build_gif2webp}" = "yes"]) |
| |
| if test "$enable_libwebpdemux" = "yes" -a "$enable_libwebpmux" = "yes"; then |
| build_img2webp=yes |
| fi |
| AM_CONDITIONAL([BUILD_IMG2WEBP], [test "${build_img2webp}" = "yes"]) |
| |
| if test "$enable_libwebpmux" = "yes"; then |
| build_webpinfo=yes |
| fi |
| AM_CONDITIONAL([BUILD_WEBPINFO], [test "${build_webpinfo}" = "yes"]) |
| |
| dnl === check for WIC support === |
| |
| AC_ARG_ENABLE([wic], |
| AS_HELP_STRING([--disable-wic], |
| [Disable Windows Imaging Component (WIC) detection. |
| @<:@default=auto@:>@]),, |
| [enable_wic=yes]) |
| |
| case $host_os in |
| mingw*) |
| if test "$enable_wic" = "yes"; then |
| AC_CHECK_HEADERS([wincodec.h shlwapi.h windows.h]) |
| if test "$ac_cv_header_wincodec_h" = "yes"; then |
| AC_MSG_CHECKING(for Windows Imaging Component support) |
| SAVED_LIBS=$LIBS |
| LIBS="-lshlwapi -lole32 $LIBS" |
| # match include structure from [cd]webp.c |
| wic_headers=" |
| #define INITGUID |
| #define CINTERFACE |
| #define COBJMACROS |
| #define _WIN32_IE 0x500 |
| |
| #include <shlwapi.h> |
| #include <windows.h> |
| #include <wincodec.h> |
| " |
| # test for functions from each lib and the GUID is created properly |
| wic_main=" |
| int main(void) { |
| CLSID_WICImagingFactory; |
| CoInitialize(NULL); |
| SHCreateStreamOnFile(NULL, 0, NULL); |
| return 0; |
| } |
| " |
| AC_LANG_PUSH(C) |
| AC_LINK_IFELSE( |
| [AC_LANG_SOURCE([ |
| $wic_headers |
| $wic_main])], |
| [wic_support=yes], |
| [wic_support=no] |
| ) |
| AC_LANG_POP |
| |
| test "$wic_support" = "yes" || LIBS=$SAVED_LIBS |
| AC_MSG_RESULT(${wic_support-no}) |
| fi |
| fi |
| esac |
| |
| dnl === If --enable-swap-16bit-csp is defined, add -DWEBP_SWAP_16BIT_CSP=1 |
| |
| USE_SWAP_16BIT_CSP="" |
| AC_MSG_CHECKING(if --enable-swap-16bit-csp option is specified) |
| AC_ARG_ENABLE([swap-16bit-csp], |
| AS_HELP_STRING([--enable-swap-16bit-csp], |
| [Enable byte swap for 16 bit colorspaces])) |
| if test "$enable_swap_16bit_csp" = "yes"; then |
| USE_SWAP_16BIT_CSP="-DWEBP_SWAP_16BIT_CSP=1" |
| fi |
| AC_MSG_RESULT(${enable_swap_16bit_csp-no}) |
| AC_SUBST(USE_SWAP_16BIT_CSP) |
| |
| dnl === If --disable-near-lossless is defined, add -DWEBP_NEAR_LOSSLESS=0 |
| |
| AC_DEFINE(WEBP_NEAR_LOSSLESS, [1], [Enable near lossless encoding]) |
| AC_MSG_CHECKING(if --disable-near-lossless option is specified) |
| AC_ARG_ENABLE([near_lossless], |
| AS_HELP_STRING([--disable-near-lossless], |
| [Disable near lossless encoding]), |
| [], [enable_near_lossless=yes]) |
| if test "$enable_near_lossless" = "no"; then |
| AC_DEFINE(WEBP_NEAR_LOSSLESS, [0], [Enable near lossless encoding]) |
| AC_MSG_RESULT([yes]) |
| else |
| AC_MSG_RESULT([no]) |
| fi |
| |
| dnl === Check whether libwebpmux should be built |
| AC_MSG_CHECKING(whether libwebpmux is to be built) |
| AC_ARG_ENABLE([libwebpmux], |
| AS_HELP_STRING([--enable-libwebpmux], |
| [Build libwebpmux @<:@default=no@:>@])) |
| AC_MSG_RESULT(${enable_libwebpmux-no}) |
| AM_CONDITIONAL([WANT_MUX], [test "$enable_libwebpmux" = "yes"]) |
| |
| dnl === Check whether libwebpdemux should be built |
| AC_MSG_CHECKING(whether libwebpdemux is to be built) |
| AC_ARG_ENABLE([libwebpdemux], |
| AS_HELP_STRING([--disable-libwebpdemux], |
| [Disable libwebpdemux @<:@default=no@:>@]), |
| [], [enable_libwebpdemux=yes]) |
| AC_MSG_RESULT(${enable_libwebpdemux-no}) |
| AM_CONDITIONAL([WANT_DEMUX], [test "$enable_libwebpdemux" = "yes"]) |
| |
| dnl === Check whether decoder library should be built. |
| AC_MSG_CHECKING(whether decoder library is to be built) |
| AC_ARG_ENABLE([libwebpdecoder], |
| AS_HELP_STRING([--enable-libwebpdecoder], |
| [Build libwebpdecoder @<:@default=no@:>@])) |
| AC_MSG_RESULT(${enable_libwebpdecoder-no}) |
| AM_CONDITIONAL([BUILD_LIBWEBPDECODER], [test "$enable_libwebpdecoder" = "yes"]) |
| |
| dnl === Check whether libwebpextras should be built |
| AC_MSG_CHECKING(whether libwebpextras is to be built) |
| AC_ARG_ENABLE([libwebpextras], |
| AS_HELP_STRING([--enable-libwebpextras], |
| [Build libwebpextras @<:@default=no@:>@])) |
| AC_MSG_RESULT(${enable_libwebpextras-no}) |
| AM_CONDITIONAL([WANT_EXTRAS], [test "$enable_libwebpextras" = "yes"]) |
| |
| dnl ========================= |
| |
| AC_CONFIG_MACRO_DIR([m4]) |
| AC_CONFIG_HEADERS([src/webp/config.h]) |
| AC_CONFIG_FILES([Makefile src/Makefile man/Makefile \ |
| examples/Makefile extras/Makefile imageio/Makefile \ |
| src/dec/Makefile src/enc/Makefile src/dsp/Makefile \ |
| src/demux/Makefile src/mux/Makefile \ |
| src/utils/Makefile \ |
| src/libwebp.pc src/libwebpdecoder.pc \ |
| src/demux/libwebpdemux.pc src/mux/libwebpmux.pc]) |
| |
| |
| AC_OUTPUT |
| |
| AC_MSG_NOTICE([ |
| WebP Configuration Summary |
| -------------------------- |
| |
| Shared libraries: ${enable_shared} |
| Static libraries: ${enable_static} |
| Threading support: ${enable_threading-no} |
| libwebp: yes |
| libwebpdecoder: ${enable_libwebpdecoder-no} |
| libwebpdemux: ${enable_libwebpdemux-no} |
| libwebpmux: ${enable_libwebpmux-no} |
| libwebpextras: ${enable_libwebpextras-no} |
| |
| Tools: |
| cwebp : ${enable_libwebpdemux-no} |
| Input format support |
| ==================== |
| JPEG : ${jpeg_support-no} |
| PNG : ${png_support-no} |
| TIFF : ${tiff_support-no} |
| WIC : ${wic_support-no} |
| dwebp : ${enable_libwebpdemux-no} |
| Output format support |
| ===================== |
| PNG : ${png_support-no} |
| WIC : ${wic_support-no} |
| GIF support : ${gif_support-no} |
| anim_diff : ${build_anim_diff-no} |
| gif2webp : ${build_gif2webp-no} |
| img2webp : ${build_img2webp-no} |
| webpmux : ${enable_libwebpmux-no} |
| vwebp : ${build_vwebp-no} |
| webpinfo : ${build_webpinfo-no} |
| SDL support : ${sdl_support-no} |
| vwebp_sdl : ${build_vwebp_sdl-no} |
| ]) |
