Vignesh Venkatasubramanian | 2bd8b54 | 2014-02-20 10:50:35 -0800 | [diff] [blame] | 1 | dnl Process this file with autoconf to produce a configure script. -*-m4-*- |
| 2 | |
| 3 | dnl The package_version file will be automatically synced to the git revision |
| 4 | dnl by the update_version script when configured in the repository, but will |
| 5 | dnl remain constant in tarball releases unless it is manually edited. |
| 6 | m4_define([CURRENT_VERSION], |
| 7 | m4_esyscmd([ ./update_version 2>/dev/null || true |
| 8 | if test -e package_version; then |
| 9 | . ./package_version |
| 10 | printf "$PACKAGE_VERSION" |
| 11 | else |
| 12 | printf "unknown" |
| 13 | fi ])) |
| 14 | |
| 15 | AC_INIT([opus],[CURRENT_VERSION],[opus@xiph.org]) |
| 16 | |
| 17 | AC_CONFIG_SRCDIR(src/opus_encoder.c) |
| 18 | AC_CONFIG_MACRO_DIR([m4]) |
| 19 | |
| 20 | dnl enable silent rules on automake 1.11 and later |
| 21 | m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) |
| 22 | |
| 23 | # For libtool. |
| 24 | dnl Please update these for releases. |
| 25 | OPUS_LT_CURRENT=5 |
flim | c91ee5b | 2016-01-26 14:33:44 +0100 | [diff] [blame^] | 26 | OPUS_LT_REVISION=2 |
Vignesh Venkatasubramanian | 2bd8b54 | 2014-02-20 10:50:35 -0800 | [diff] [blame] | 27 | OPUS_LT_AGE=5 |
| 28 | |
| 29 | AC_SUBST(OPUS_LT_CURRENT) |
| 30 | AC_SUBST(OPUS_LT_REVISION) |
| 31 | AC_SUBST(OPUS_LT_AGE) |
| 32 | |
| 33 | AM_INIT_AUTOMAKE([no-define]) |
| 34 | AM_MAINTAINER_MODE([enable]) |
| 35 | |
| 36 | AC_CANONICAL_HOST |
| 37 | AC_MINGW32 |
| 38 | AM_PROG_LIBTOOL |
| 39 | AM_PROG_CC_C_O |
| 40 | |
| 41 | AC_PROG_CC_C99 |
| 42 | AC_C_CONST |
| 43 | AC_C_INLINE |
| 44 | |
| 45 | AM_PROG_AS |
| 46 | |
| 47 | AC_DEFINE([OPUS_BUILD], [], [This is a build of OPUS]) |
| 48 | |
| 49 | #Use a hacked up version of autoconf's AC_C_RESTRICT because it's not |
| 50 | #strong enough a test to detect old buggy versions of GCC (e.g. 2.95.3) |
| 51 | #Note: Both this and the test for variable-size arrays below are also |
| 52 | # done by AC_PROG_CC_C99, but not thoroughly enough apparently. |
| 53 | AC_CACHE_CHECK([for C/C++ restrict keyword], ac_cv_c_restrict, |
| 54 | [ac_cv_c_restrict=no |
| 55 | # The order here caters to the fact that C++ does not require restrict. |
| 56 | for ac_kw in __restrict __restrict__ _Restrict restrict; do |
| 57 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM( |
| 58 | [[typedef int * int_ptr; |
| 59 | int foo (int_ptr $ac_kw ip, int * $ac_kw baz[]) { |
| 60 | return ip[0]; |
| 61 | }]], |
| 62 | [[int s[1]; |
| 63 | int * $ac_kw t = s; |
| 64 | t[0] = 0; |
| 65 | return foo(t, (void *)0)]])], |
| 66 | [ac_cv_c_restrict=$ac_kw]) |
| 67 | test "$ac_cv_c_restrict" != no && break |
| 68 | done |
| 69 | ]) |
| 70 | |
| 71 | AH_VERBATIM([restrict], |
| 72 | [/* Define to the equivalent of the C99 'restrict' keyword, or to |
| 73 | nothing if this is not supported. Do not define if restrict is |
| 74 | supported directly. */ |
| 75 | #undef restrict |
| 76 | /* Work around a bug in Sun C++: it does not support _Restrict or |
| 77 | __restrict__, even though the corresponding Sun C compiler ends up with |
| 78 | "#define restrict _Restrict" or "#define restrict __restrict__" in the |
| 79 | previous line. Perhaps some future version of Sun C++ will work with |
| 80 | restrict; if so, hopefully it defines __RESTRICT like Sun C does. */ |
| 81 | #if defined __SUNPRO_CC && !defined __RESTRICT |
| 82 | # define _Restrict |
| 83 | # define __restrict__ |
| 84 | #endif]) |
| 85 | |
| 86 | case $ac_cv_c_restrict in |
| 87 | restrict) ;; |
| 88 | no) AC_DEFINE([restrict], []) ;; |
| 89 | *) AC_DEFINE_UNQUOTED([restrict], [$ac_cv_c_restrict]) ;; |
| 90 | esac |
| 91 | |
| 92 | AC_MSG_CHECKING(for C99 variable-size arrays) |
| 93 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], |
| 94 | [[static int x; char a[++x]; a[sizeof a - 1] = 0; int N; return a[0];]])], |
| 95 | [ has_var_arrays=yes |
| 96 | use_alloca="no (using var arrays)" |
| 97 | AC_DEFINE([VAR_ARRAYS], [1], [Use C99 variable-size arrays]) |
| 98 | ],[ |
| 99 | has_var_arrays=no |
| 100 | ]) |
| 101 | AC_MSG_RESULT([$has_var_arrays]) |
| 102 | |
| 103 | AS_IF([test "$has_var_arrays" = "no"], |
| 104 | [ |
| 105 | AC_CHECK_HEADERS([alloca.h]) |
| 106 | AC_MSG_CHECKING(for alloca) |
| 107 | AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <alloca.h>]], |
| 108 | [[int foo=10; int *array = alloca(foo);]])], |
| 109 | [ use_alloca=yes; |
| 110 | AC_DEFINE([USE_ALLOCA], [], [Make use of alloca]) |
| 111 | ],[ |
| 112 | use_alloca=no |
| 113 | ]) |
| 114 | AC_MSG_RESULT([$use_alloca]) |
| 115 | ]) |
| 116 | |
| 117 | LT_LIB_M |
| 118 | |
| 119 | AC_ARG_ENABLE([fixed-point], |
| 120 | [AS_HELP_STRING([--enable-fixed-point], |
| 121 | [compile without floating point (for machines without a fast enough FPU)])],, |
| 122 | [enable_fixed_point=no]) |
| 123 | |
| 124 | AS_IF([test "$enable_fixed_point" = "yes"],[ |
| 125 | enable_float="no" |
| 126 | AC_DEFINE([FIXED_POINT], [1], [Compile as fixed-point (for machines without a fast enough FPU)]) |
| 127 | PC_BUILD="fixed-point" |
| 128 | ],[ |
| 129 | enable_float="yes"; |
| 130 | PC_BUILD="floating-point" |
| 131 | ]) |
| 132 | |
| 133 | AM_CONDITIONAL([FIXED_POINT], [test "$enable_fixed_point" = "yes"]) |
| 134 | |
| 135 | AC_ARG_ENABLE([fixed-point-debug], |
| 136 | [AS_HELP_STRING([--enable-fixed-point-debug], [debug fixed-point implementation])],, |
| 137 | [enable_fixed_point_debug=no]) |
| 138 | |
| 139 | AS_IF([test "$enable_fixed_point_debug" = "yes"],[ |
| 140 | AC_DEFINE([FIXED_DEBUG], [1], [Debug fixed-point implementation]) |
| 141 | ]) |
| 142 | |
| 143 | AC_ARG_ENABLE([float_api], |
| 144 | [AS_HELP_STRING([--disable-float-api], |
| 145 | [compile without the floating point API (for machines with no float library)])],, |
| 146 | [enable_float_api=yes]) |
| 147 | |
| 148 | AM_CONDITIONAL([DISABLE_FLOAT_API], [test "$enable_float_api" = "no"]) |
| 149 | |
| 150 | AS_IF([test "$enable_float_api" = "no"],[ |
| 151 | AC_DEFINE([DISABLE_FLOAT_API], [1], [Do not build the float API]) |
| 152 | ]) |
| 153 | |
| 154 | AC_ARG_ENABLE([custom-modes], |
| 155 | [AS_HELP_STRING([--enable-custom-modes], [enable non-Opus modes, e.g. 44.1 kHz & 2^n frames])],, |
| 156 | [enable_custom_modes=no]) |
| 157 | |
| 158 | AS_IF([test "$enable_custom_modes" = "yes"],[ |
| 159 | AC_DEFINE([CUSTOM_MODES], [1], [Custom modes]) |
| 160 | PC_BUILD="$PC_BUILD, custom modes" |
| 161 | ]) |
| 162 | |
| 163 | AM_CONDITIONAL([CUSTOM_MODES], [test "$enable_custom_modes" = "yes"]) |
| 164 | |
| 165 | has_float_approx=no |
| 166 | #case "$host_cpu" in |
| 167 | #i[[3456]]86 | x86_64 | powerpc64 | powerpc32 | ia64) |
| 168 | # has_float_approx=yes |
| 169 | # ;; |
| 170 | #esac |
| 171 | |
| 172 | AC_ARG_ENABLE([float-approx], |
| 173 | [AS_HELP_STRING([--enable-float-approx], [enable fast approximations for floating point])], |
| 174 | [if test "$enable_float_approx" = "yes"; then |
| 175 | AC_WARN([Floating point approximations are not supported on all platforms.]) |
| 176 | fi |
| 177 | ], |
| 178 | [enable_float_approx=$has_float_approx]) |
| 179 | |
| 180 | AS_IF([test "$enable_float_approx" = "yes"],[ |
| 181 | AC_DEFINE([FLOAT_APPROX], [1], [Float approximations]) |
| 182 | ]) |
| 183 | |
| 184 | AC_ARG_ENABLE([asm], |
| 185 | [AS_HELP_STRING([--disable-asm], [Disable assembly optimizations])],, |
| 186 | [enable_asm=yes]) |
| 187 | |
| 188 | AC_ARG_ENABLE([rtcd], |
| 189 | [AS_HELP_STRING([--disable-rtcd], [Disable run-time CPU capabilities detection])],, |
| 190 | [enable_rtcd=yes]) |
| 191 | |
flim | c91ee5b | 2016-01-26 14:33:44 +0100 | [diff] [blame^] | 192 | AC_ARG_ENABLE([intrinsics], |
| 193 | [AS_HELP_STRING([--enable-intrinsics], [Enable intrinsics optimizations for ARM(float) X86(fixed)])],, |
| 194 | [enable_intrinsics=no]) |
| 195 | |
Vignesh Venkatasubramanian | 2bd8b54 | 2014-02-20 10:50:35 -0800 | [diff] [blame] | 196 | rtcd_support=no |
| 197 | cpu_arm=no |
| 198 | |
| 199 | AS_IF([test x"${enable_asm}" = x"yes"],[ |
flim | c91ee5b | 2016-01-26 14:33:44 +0100 | [diff] [blame^] | 200 | inline_optimization="No inline ASM for your platform, please send patches" |
Vignesh Venkatasubramanian | 2bd8b54 | 2014-02-20 10:50:35 -0800 | [diff] [blame] | 201 | case $host_cpu in |
| 202 | arm*) |
| 203 | dnl Currently we only have asm for fixed-point |
| 204 | AS_IF([test "$enable_float" != "yes"],[ |
| 205 | cpu_arm=yes |
| 206 | AC_DEFINE([OPUS_ARM_ASM], [], [Make use of ARM asm optimization]) |
| 207 | AS_GCC_INLINE_ASSEMBLY( |
| 208 | [inline_optimization="ARM"], |
| 209 | [inline_optimization="disabled"] |
| 210 | ) |
| 211 | AS_ASM_ARM_EDSP([OPUS_ARM_INLINE_EDSP=1],[OPUS_ARM_INLINE_EDSP=0]) |
| 212 | AS_ASM_ARM_MEDIA([OPUS_ARM_INLINE_MEDIA=1], |
| 213 | [OPUS_ARM_INLINE_MEDIA=0]) |
| 214 | AS_ASM_ARM_NEON([OPUS_ARM_INLINE_NEON=1],[OPUS_ARM_INLINE_NEON=0]) |
| 215 | AS_IF([test x"$inline_optimization" = x"ARM"],[ |
| 216 | AM_CONDITIONAL([OPUS_ARM_INLINE_ASM],[true]) |
| 217 | AC_DEFINE([OPUS_ARM_INLINE_ASM], 1, |
| 218 | [Use generic ARMv4 inline asm optimizations]) |
| 219 | AS_IF([test x"$OPUS_ARM_INLINE_EDSP" = x"1"],[ |
| 220 | AC_DEFINE([OPUS_ARM_INLINE_EDSP], [1], |
| 221 | [Use ARMv5E inline asm optimizations]) |
| 222 | inline_optimization="$inline_optimization (EDSP)" |
| 223 | ]) |
| 224 | AS_IF([test x"$OPUS_ARM_INLINE_MEDIA" = x"1"],[ |
| 225 | AC_DEFINE([OPUS_ARM_INLINE_MEDIA], [1], |
| 226 | [Use ARMv6 inline asm optimizations]) |
| 227 | inline_optimization="$inline_optimization (Media)" |
| 228 | ]) |
| 229 | AS_IF([test x"$OPUS_ARM_INLINE_NEON" = x"1"],[ |
| 230 | AC_DEFINE([OPUS_ARM_INLINE_NEON], 1, |
| 231 | [Use ARM NEON inline asm optimizations]) |
| 232 | inline_optimization="$inline_optimization (NEON)" |
| 233 | ]) |
| 234 | ]) |
| 235 | dnl We need Perl to translate RVCT-syntax asm to gas syntax. |
| 236 | AC_CHECK_PROG([HAVE_PERL], perl, yes, no) |
| 237 | AS_IF([test x"$HAVE_PERL" = x"yes"],[ |
| 238 | AM_CONDITIONAL([OPUS_ARM_EXTERNAL_ASM],[true]) |
| 239 | asm_optimization="ARM" |
| 240 | AS_IF([test x"$OPUS_ARM_INLINE_EDSP" = x"1"], [ |
| 241 | OPUS_ARM_PRESUME_EDSP=1 |
| 242 | OPUS_ARM_MAY_HAVE_EDSP=1 |
| 243 | ], |
| 244 | [ |
| 245 | OPUS_ARM_PRESUME_EDSP=0 |
| 246 | OPUS_ARM_MAY_HAVE_EDSP=0 |
| 247 | ]) |
| 248 | AS_IF([test x"$OPUS_ARM_INLINE_MEDIA" = x"1"], [ |
| 249 | OPUS_ARM_PRESUME_MEDIA=1 |
| 250 | OPUS_ARM_MAY_HAVE_MEDIA=1 |
| 251 | ], |
| 252 | [ |
| 253 | OPUS_ARM_PRESUME_MEDIA=0 |
| 254 | OPUS_ARM_MAY_HAVE_MEDIA=0 |
| 255 | ]) |
| 256 | AS_IF([test x"$OPUS_ARM_INLINE_NEON" = x"1"], [ |
| 257 | OPUS_ARM_PRESUME_NEON=1 |
| 258 | OPUS_ARM_MAY_HAVE_NEON=1 |
| 259 | ], |
| 260 | [ |
| 261 | OPUS_ARM_PRESUME_NEON=0 |
| 262 | OPUS_ARM_MAY_HAVE_NEON=0 |
| 263 | ]) |
| 264 | AS_IF([test x"$enable_rtcd" = x"yes"],[ |
| 265 | AS_IF([test x"$OPUS_ARM_MAY_HAVE_EDSP" != x"1"],[ |
| 266 | AC_MSG_NOTICE( |
| 267 | [Trying to force-enable armv5e EDSP instructions...]) |
| 268 | AS_ASM_ARM_EDSP_FORCE([OPUS_ARM_MAY_HAVE_EDSP=1]) |
| 269 | ]) |
| 270 | AS_IF([test x"$OPUS_ARM_MAY_HAVE_MEDIA" != x"1"],[ |
| 271 | AC_MSG_NOTICE( |
| 272 | [Trying to force-enable ARMv6 media instructions...]) |
| 273 | AS_ASM_ARM_MEDIA_FORCE([OPUS_ARM_MAY_HAVE_MEDIA=1]) |
| 274 | ]) |
| 275 | AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON" != x"1"],[ |
| 276 | AC_MSG_NOTICE( |
| 277 | [Trying to force-enable NEON instructions...]) |
| 278 | AS_ASM_ARM_NEON_FORCE([OPUS_ARM_MAY_HAVE_NEON=1]) |
| 279 | ]) |
| 280 | ]) |
| 281 | rtcd_support= |
| 282 | AS_IF([test x"$OPUS_ARM_MAY_HAVE_EDSP" = x"1"],[ |
| 283 | AC_DEFINE(OPUS_ARM_MAY_HAVE_EDSP, 1, |
| 284 | [Define if assembler supports EDSP instructions]) |
| 285 | AS_IF([test x"$OPUS_ARM_PRESUME_EDSP" = x"1"],[ |
| 286 | AC_DEFINE(OPUS_ARM_PRESUME_EDSP, 1, |
| 287 | [Define if binary requires EDSP instruction support]) |
| 288 | asm_optimization="$asm_optimization (EDSP)" |
| 289 | ], |
| 290 | [rtcd_support="$rtcd_support (EDSP)"] |
| 291 | ) |
| 292 | ]) |
| 293 | AC_SUBST(OPUS_ARM_MAY_HAVE_EDSP) |
| 294 | AS_IF([test x"$OPUS_ARM_MAY_HAVE_MEDIA" = x"1"],[ |
| 295 | AC_DEFINE(OPUS_ARM_MAY_HAVE_MEDIA, 1, |
| 296 | [Define if assembler supports ARMv6 media instructions]) |
| 297 | AS_IF([test x"$OPUS_ARM_PRESUME_MEDIA" = x"1"],[ |
| 298 | AC_DEFINE(OPUS_ARM_PRESUME_MEDIA, 1, |
| 299 | [Define if binary requires ARMv6 media instruction support]) |
| 300 | asm_optimization="$asm_optimization (Media)" |
| 301 | ], |
| 302 | [rtcd_support="$rtcd_support (Media)"] |
| 303 | ) |
| 304 | ]) |
| 305 | AC_SUBST(OPUS_ARM_MAY_HAVE_MEDIA) |
| 306 | AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON" = x"1"],[ |
| 307 | AC_DEFINE(OPUS_ARM_MAY_HAVE_NEON, 1, |
| 308 | [Define if compiler supports NEON instructions]) |
| 309 | AS_IF([test x"$OPUS_ARM_PRESUME_NEON" = x"1"], [ |
| 310 | AC_DEFINE(OPUS_ARM_PRESUME_NEON, 1, |
| 311 | [Define if binary requires NEON instruction support]) |
| 312 | asm_optimization="$asm_optimization (NEON)" |
| 313 | ], |
| 314 | [rtcd_support="$rtcd_support (NEON)"] |
| 315 | ) |
| 316 | ]) |
| 317 | AC_SUBST(OPUS_ARM_MAY_HAVE_NEON) |
| 318 | dnl Make sure turning on RTCD gets us at least one |
| 319 | dnl instruction set. |
| 320 | AS_IF([test x"$rtcd_support" != x""], |
| 321 | [rtcd_support=ARM"$rtcd_support"], |
| 322 | [rtcd_support="no"] |
| 323 | ) |
flim | c91ee5b | 2016-01-26 14:33:44 +0100 | [diff] [blame^] | 324 | AC_MSG_CHECKING([for apple style tools]) |
| 325 | AC_PREPROC_IFELSE([AC_LANG_PROGRAM([ |
| 326 | #ifndef __APPLE__ |
| 327 | #error 1 |
| 328 | #endif],[])], |
| 329 | [AC_MSG_RESULT([yes]); ARM2GNU_PARAMS="--apple"], |
| 330 | [AC_MSG_RESULT([no]); ARM2GNU_PARAMS=""]) |
| 331 | AC_SUBST(ARM2GNU_PARAMS) |
Vignesh Venkatasubramanian | 2bd8b54 | 2014-02-20 10:50:35 -0800 | [diff] [blame] | 332 | ], |
| 333 | [ |
| 334 | AC_MSG_WARN( |
| 335 | [*** ARM assembly requires perl -- disabling optimizations]) |
| 336 | asm_optimization="(missing perl dependency for ARM)" |
| 337 | ]) |
| 338 | ]) |
| 339 | ;; |
| 340 | esac |
| 341 | ],[ |
| 342 | inline_optimization="disabled" |
| 343 | asm_optimization="disabled" |
| 344 | ]) |
| 345 | |
Vignesh Venkatasubramanian | 2bd8b54 | 2014-02-20 10:50:35 -0800 | [diff] [blame] | 346 | AM_CONDITIONAL([OPUS_ARM_INLINE_ASM], |
flim | c91ee5b | 2016-01-26 14:33:44 +0100 | [diff] [blame^] | 347 | [test x"${inline_optimization%% *}" = x"ARM"]) |
Vignesh Venkatasubramanian | 2bd8b54 | 2014-02-20 10:50:35 -0800 | [diff] [blame] | 348 | AM_CONDITIONAL([OPUS_ARM_EXTERNAL_ASM], |
flim | c91ee5b | 2016-01-26 14:33:44 +0100 | [diff] [blame^] | 349 | [test x"${asm_optimization%% *}" = x"ARM"]) |
| 350 | |
| 351 | AM_CONDITIONAL([HAVE_SSE], [false]) |
| 352 | AM_CONDITIONAL([HAVE_SSE2], [false]) |
| 353 | AM_CONDITIONAL([HAVE_SSE4_1], [false]) |
| 354 | AM_CONDITIONAL([HAVE_AVX], [false]) |
| 355 | |
| 356 | m4_define([DEFAULT_X86_SSE_CFLAGS], [-msse]) |
| 357 | m4_define([DEFAULT_X86_SSE2_CFLAGS], [-msse2]) |
| 358 | m4_define([DEFAULT_X86_SSE4_1_CFLAGS], [-msse4.1]) |
| 359 | m4_define([DEFAULT_X86_AVX_CFLAGS], [-mavx]) |
| 360 | m4_define([DEFAULT_ARM_NEON_INTR_CFLAGS], [-mfpu=neon]) |
| 361 | # With GCC on ARM32 softfp architectures (e.g. Android, or older Ubuntu) you need to specify |
| 362 | # -mfloat-abi=softfp for -mfpu=neon to work. However, on ARM32 hardfp architectures (e.g. newer Ubuntu), |
| 363 | # this option will break things. |
| 364 | |
| 365 | # As a heuristic, if host matches arm*eabi* but not arm*hf*, it's probably soft-float. |
| 366 | m4_define([DEFAULT_ARM_NEON_SOFTFP_INTR_CFLAGS], [-mfpu=neon -mfloat-abi=softfp]) |
| 367 | |
| 368 | AS_CASE([$host], |
| 369 | [arm*hf*], [AS_VAR_SET([RESOLVED_DEFAULT_ARM_NEON_INTR_CFLAGS], "DEFAULT_ARM_NEON_INTR_CFLAGS")], |
| 370 | [arm*eabi*], [AS_VAR_SET([RESOLVED_DEFAULT_ARM_NEON_INTR_CFLAGS], "DEFAULT_ARM_NEON_SOFTFP_INTR_CFLAGS")], |
| 371 | [AS_VAR_SET([RESOLVED_DEFAULT_ARM_NEON_INTR_CFLAGS], "DEFAULT_ARM_NEON_INTR_CFLAGS")]) |
| 372 | |
| 373 | AC_ARG_VAR([X86_SSE_CFLAGS], [C compiler flags to compile SSE intrinsics @<:@default=]DEFAULT_X86_SSE_CFLAGS[@:>@]) |
| 374 | AC_ARG_VAR([X86_SSE2_CFLAGS], [C compiler flags to compile SSE2 intrinsics @<:@default=]DEFAULT_X86_SSE2_CFLAGS[@:>@]) |
| 375 | AC_ARG_VAR([X86_SSE4_1_CFLAGS], [C compiler flags to compile SSE4.1 intrinsics @<:@default=]DEFAULT_X86_SSE4_1_CFLAGS[@:>@]) |
| 376 | AC_ARG_VAR([X86_AVX_CFLAGS], [C compiler flags to compile AVX intrinsics @<:@default=]DEFAULT_X86_AVX_CFLAGS[@:>@]) |
| 377 | AC_ARG_VAR([ARM_NEON_INTR_CFLAGS], [C compiler flags to compile ARM NEON intrinsics @<:@default=]DEFAULT_ARM_NEON_INTR_CFLAGS / DEFAULT_ARM_NEON_SOFTFP_INTR_CFLAGS[@:>@]) |
| 378 | |
| 379 | AS_VAR_SET_IF([X86_SSE_CFLAGS], [], [AS_VAR_SET([X86_SSE_CFLAGS], "DEFAULT_X86_SSE_CFLAGS")]) |
| 380 | AS_VAR_SET_IF([X86_SSE2_CFLAGS], [], [AS_VAR_SET([X86_SSE2_CFLAGS], "DEFAULT_X86_SSE2_CFLAGS")]) |
| 381 | AS_VAR_SET_IF([X86_SSE4_1_CFLAGS], [], [AS_VAR_SET([X86_SSE4_1_CFLAGS], "DEFAULT_X86_SSE4_1_CFLAGS")]) |
| 382 | AS_VAR_SET_IF([X86_AVX_CFLAGS], [], [AS_VAR_SET([X86_AVX_CFLAGS], "DEFAULT_X86_AVX_CFLAGS")]) |
| 383 | AS_VAR_SET_IF([ARM_NEON_INTR_CFLAGS], [], [AS_VAR_SET([ARM_NEON_INTR_CFLAGS], ["$RESOLVED_DEFAULT_ARM_NEON_INTR_CFLAGS"])]) |
| 384 | |
| 385 | AC_DEFUN([OPUS_PATH_NE10], |
| 386 | [ |
| 387 | AC_ARG_WITH(NE10, |
| 388 | AC_HELP_STRING([--with-NE10=PFX],[Prefix where libNE10 is installed (optional)]), |
| 389 | NE10_prefix="$withval", NE10_prefix="") |
| 390 | AC_ARG_WITH(NE10-libraries, |
| 391 | AC_HELP_STRING([--with-NE10-libraries=DIR], |
| 392 | [Directory where libNE10 library is installed (optional)]), |
| 393 | NE10_libraries="$withval", NE10_libraries="") |
| 394 | AC_ARG_WITH(NE10-includes, |
| 395 | AC_HELP_STRING([--with-NE10-includes=DIR], |
| 396 | [Directory where libNE10 header files are installed (optional)]), |
| 397 | NE10_includes="$withval", NE10_includes="") |
| 398 | |
| 399 | if test "x$NE10_libraries" != "x" ; then |
| 400 | NE10_LIBS="-L$NE10_libraries" |
| 401 | elif test "x$NE10_prefix" = "xno" || test "x$NE10_prefix" = "xyes" ; then |
| 402 | NE10_LIBS="" |
| 403 | elif test "x$NE10_prefix" != "x" ; then |
| 404 | NE10_LIBS="-L$NE10_prefix/lib" |
| 405 | elif test "x$prefix" != "xNONE" ; then |
| 406 | NE10_LIBS="-L$prefix/lib" |
| 407 | fi |
| 408 | |
| 409 | if test "x$NE10_prefix" != "xno" ; then |
| 410 | NE10_LIBS="$NE10_LIBS -lNE10" |
| 411 | fi |
| 412 | |
| 413 | if test "x$NE10_includes" != "x" ; then |
| 414 | NE10_CFLAGS="-I$NE10_includes" |
| 415 | elif test "x$NE10_prefix" = "xno" || test "x$NE10_prefix" = "xyes" ; then |
| 416 | NE10_CFLAGS="" |
| 417 | elif test "x$ogg_prefix" != "x" ; then |
| 418 | NE10_CFLAGS="-I$NE10_prefix/include" |
| 419 | elif test "x$prefix" != "xNONE"; then |
| 420 | NE10_CFLAGS="-I$prefix/include" |
| 421 | fi |
| 422 | |
| 423 | AC_MSG_CHECKING(for NE10) |
| 424 | save_CFLAGS="$CFLAGS"; CFLAGS="$NE10_CFLAGS" |
| 425 | save_LIBS="$LIBS"; LIBS="$NE10_LIBS $LIBM" |
| 426 | AC_LINK_IFELSE( |
| 427 | [ |
| 428 | AC_LANG_PROGRAM( |
| 429 | [[#include <NE10_init.h> |
| 430 | ]], |
| 431 | [[ |
| 432 | ne10_fft_cfg_float32_t cfg; |
| 433 | cfg = ne10_fft_alloc_c2c_float32_neon(480); |
| 434 | ]] |
| 435 | ) |
| 436 | ],[ |
| 437 | HAVE_ARM_NE10=1 |
| 438 | AC_MSG_RESULT([yes]) |
| 439 | ],[ |
| 440 | HAVE_ARM_NE10=0 |
| 441 | AC_MSG_RESULT([no]) |
| 442 | NE10_CFLAGS="" |
| 443 | NE10_LIBS="" |
| 444 | ] |
| 445 | ) |
| 446 | CFLAGS="$save_CFLAGS"; LIBS="$save_LIBS" |
| 447 | #Now we know if libNE10 is installed or not |
| 448 | AS_IF([test x"$HAVE_ARM_NE10" = x"1"], |
| 449 | [ |
| 450 | AC_DEFINE([HAVE_ARM_NE10], 1, [NE10 library is installed on host. Make sure it is on target!]) |
| 451 | AC_SUBST(HAVE_ARM_NE10) |
| 452 | AC_SUBST(NE10_CFLAGS) |
| 453 | AC_SUBST(NE10_LIBS) |
| 454 | ] |
| 455 | ) |
| 456 | ] |
| 457 | ) |
| 458 | |
| 459 | AS_IF([test x"$enable_intrinsics" = x"yes"],[ |
| 460 | intrinsics_support="" |
| 461 | AS_CASE([$host_cpu], |
| 462 | [arm*], |
| 463 | [ |
| 464 | cpu_arm=yes |
| 465 | OPUS_CHECK_INTRINSICS( |
| 466 | [ARM Neon], |
| 467 | [$ARM_NEON_INTR_CFLAGS], |
| 468 | [OPUS_ARM_MAY_HAVE_NEON_INTR], |
| 469 | [OPUS_ARM_PRESUME_NEON_INTR], |
| 470 | [[#include <arm_neon.h> |
| 471 | ]], |
| 472 | [[ |
| 473 | static float32x4_t A0, A1, SUMM; |
| 474 | SUMM = vmlaq_f32(SUMM, A0, A1); |
| 475 | ]] |
| 476 | ) |
| 477 | AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1" && test x"$OPUS_ARM_PRESUME_NEON_INTR" != x"1"], |
| 478 | [ |
| 479 | OPUS_ARM_NEON_INTR_CFLAGS="$ARM_NEON_INTR_CFLAGS" |
| 480 | AC_SUBST([OPUS_ARM_NEON_INTR_CFLAGS]) |
| 481 | ] |
| 482 | ) |
| 483 | |
| 484 | AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1"], |
| 485 | [ |
| 486 | AC_DEFINE([OPUS_ARM_MAY_HAVE_NEON_INTR], 1, [Compiler supports ARMv7 Neon Intrinsics]) |
| 487 | intrinsics_support="$intrinsics_support (Neon_Intrinsics)" |
| 488 | |
| 489 | AS_IF([test x"enable_rtcd" != x"" && test x"$OPUS_ARM_PRESUME_NEON_INTR" != x"1"], |
| 490 | [rtcd_support="$rtcd_support (ARMv7_Neon_Intrinsics)"]) |
| 491 | |
| 492 | AS_IF([test x"$OPUS_ARM_PRESUME_NEON_INTR" = x"1"], |
| 493 | [AC_DEFINE([OPUS_ARM_PRESUME_NEON_INTR], 1, [Define if binary requires NEON intrinsics support])]) |
| 494 | |
| 495 | OPUS_PATH_NE10() |
| 496 | AS_IF([test x"$NE10_LIBS" != x""], |
| 497 | [ |
| 498 | intrinsics_support="$intrinsics_support (NE10)" |
| 499 | AS_IF([test x"enable_rtcd" != x"" \ |
| 500 | && test x"$OPUS_ARM_PRESUME_NEON_INTR" != x"1"], |
| 501 | [rtcd_support="$rtcd_support (NE10)"]) |
| 502 | ]) |
| 503 | |
| 504 | AS_IF([test x"$rtcd_support" = x""], |
| 505 | [rtcd_support=no]) |
| 506 | |
| 507 | AS_IF([test x"$intrinsics_support" = x""], |
| 508 | [intrinsics_support=no], |
| 509 | [intrinsics_support="arm$intrinsics_support"]) |
| 510 | ], |
| 511 | [ |
| 512 | AC_MSG_WARN([Compiler does not support ARM intrinsics]) |
| 513 | intrinsics_support=no |
| 514 | ]) |
| 515 | ], |
| 516 | [i?86|x86_64], |
| 517 | [ |
| 518 | OPUS_CHECK_INTRINSICS( |
| 519 | [SSE], |
| 520 | [$X86_SSE_CFLAGS], |
| 521 | [OPUS_X86_MAY_HAVE_SSE], |
| 522 | [OPUS_X86_PRESUME_SSE], |
| 523 | [[#include <xmmintrin.h> |
| 524 | ]], |
| 525 | [[ |
| 526 | static __m128 mtest; |
| 527 | mtest = _mm_setzero_ps(); |
| 528 | ]] |
| 529 | ) |
| 530 | AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE" = x"1" && test x"$OPUS_X86_PRESUME_SSE" != x"1"], |
| 531 | [ |
| 532 | OPUS_X86_SSE_CFLAGS="$X86_SSE_CFLAGS" |
| 533 | AC_SUBST([OPUS_X86_SSE_CFLAGS]) |
| 534 | ] |
| 535 | ) |
| 536 | OPUS_CHECK_INTRINSICS( |
| 537 | [SSE2], |
| 538 | [$X86_SSE2_CFLAGS], |
| 539 | [OPUS_X86_MAY_HAVE_SSE2], |
| 540 | [OPUS_X86_PRESUME_SSE2], |
| 541 | [[#include <emmintrin.h> |
| 542 | ]], |
| 543 | [[ |
| 544 | static __m128i mtest; |
| 545 | mtest = _mm_setzero_si128(); |
| 546 | ]] |
| 547 | ) |
| 548 | AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1" && test x"$OPUS_X86_PRESUME_SSE2" != x"1"], |
| 549 | [ |
| 550 | OPUS_X86_SSE2_CFLAGS="$X86_SSE2_CFLAGS" |
| 551 | AC_SUBST([OPUS_X86_SSE2_CFLAGS]) |
| 552 | ] |
| 553 | ) |
| 554 | OPUS_CHECK_INTRINSICS( |
| 555 | [SSE4.1], |
| 556 | [$X86_SSE4_1_CFLAGS], |
| 557 | [OPUS_X86_MAY_HAVE_SSE4_1], |
| 558 | [OPUS_X86_PRESUME_SSE4_1], |
| 559 | [[#include <smmintrin.h> |
| 560 | ]], |
| 561 | [[ |
| 562 | static __m128i mtest; |
| 563 | mtest = _mm_setzero_si128(); |
| 564 | mtest = _mm_cmpeq_epi64(mtest, mtest); |
| 565 | ]] |
| 566 | ) |
| 567 | AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1" && test x"$OPUS_X86_PRESUME_SSE4_1" != x"1"], |
| 568 | [ |
| 569 | OPUS_X86_SSE4_1_CFLAGS="$X86_SSE4_1_CFLAGS" |
| 570 | AC_SUBST([OPUS_X86_SSE4_1_CFLAGS]) |
| 571 | ] |
| 572 | ) |
| 573 | OPUS_CHECK_INTRINSICS( |
| 574 | [AVX], |
| 575 | [$X86_AVX_CFLAGS], |
| 576 | [OPUS_X86_MAY_HAVE_AVX], |
| 577 | [OPUS_X86_PRESUME_AVX], |
| 578 | [[#include <immintrin.h> |
| 579 | ]], |
| 580 | [[ |
| 581 | static __m256 mtest; |
| 582 | mtest = _mm256_setzero_ps(); |
| 583 | ]] |
| 584 | ) |
| 585 | AS_IF([test x"$OPUS_X86_MAY_HAVE_AVX" = x"1" && test x"$OPUS_X86_PRESUME_AVX" != x"1"], |
| 586 | [ |
| 587 | OPUS_X86_AVX_CFLAGS="$X86_AVX_CFLAGS" |
| 588 | AC_SUBST([OPUS_X86_AVX_CFLAGS]) |
| 589 | ] |
| 590 | ) |
| 591 | AS_IF([test x"$rtcd_support" = x"no"], [rtcd_support=""]) |
| 592 | AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE" = x"1"], |
| 593 | [ |
| 594 | AC_DEFINE([OPUS_X86_MAY_HAVE_SSE], 1, [Compiler supports X86 SSE Intrinsics]) |
| 595 | intrinsics_support="$intrinsics_support SSE" |
| 596 | |
| 597 | AS_IF([test x"$OPUS_X86_PRESUME_SSE" = x"1"], |
| 598 | [AC_DEFINE([OPUS_X86_PRESUME_SSE], 1, [Define if binary requires SSE intrinsics support])], |
| 599 | [rtcd_support="$rtcd_support SSE"]) |
| 600 | ], |
| 601 | [ |
| 602 | AC_MSG_WARN([Compiler does not support SSE intrinsics]) |
| 603 | ]) |
| 604 | |
| 605 | AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1"], |
| 606 | [ |
| 607 | AC_DEFINE([OPUS_X86_MAY_HAVE_SSE2], 1, [Compiler supports X86 SSE2 Intrinsics]) |
| 608 | intrinsics_support="$intrinsics_support SSE2" |
| 609 | |
| 610 | AS_IF([test x"$OPUS_X86_PRESUME_SSE2" = x"1"], |
| 611 | [AC_DEFINE([OPUS_X86_PRESUME_SSE2], 1, [Define if binary requires SSE2 intrinsics support])], |
| 612 | [rtcd_support="$rtcd_support SSE2"]) |
| 613 | ], |
| 614 | [ |
| 615 | AC_MSG_WARN([Compiler does not support SSE2 intrinsics]) |
| 616 | ]) |
| 617 | |
| 618 | AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1"], |
| 619 | [ |
| 620 | AC_DEFINE([OPUS_X86_MAY_HAVE_SSE4_1], 1, [Compiler supports X86 SSE4.1 Intrinsics]) |
| 621 | intrinsics_support="$intrinsics_support SSE4.1" |
| 622 | |
| 623 | AS_IF([test x"$OPUS_X86_PRESUME_SSE4_1" = x"1"], |
| 624 | [AC_DEFINE([OPUS_X86_PRESUME_SSE4_1], 1, [Define if binary requires SSE4.1 intrinsics support])], |
| 625 | [rtcd_support="$rtcd_support SSE4.1"]) |
| 626 | ], |
| 627 | [ |
| 628 | AC_MSG_WARN([Compiler does not support SSE4.1 intrinsics]) |
| 629 | ]) |
| 630 | AS_IF([test x"$OPUS_X86_MAY_HAVE_AVX" = x"1"], |
| 631 | [ |
| 632 | AC_DEFINE([OPUS_X86_MAY_HAVE_AVX], 1, [Compiler supports X86 AVX Intrinsics]) |
| 633 | intrinsics_support="$intrinsics_support AVX" |
| 634 | |
| 635 | AS_IF([test x"$OPUS_X86_PRESUME_AVX" = x"1"], |
| 636 | [AC_DEFINE([OPUS_X86_PRESUME_AVX], 1, [Define if binary requires AVX intrinsics support])], |
| 637 | [rtcd_support="$rtcd_support AVX"]) |
| 638 | ], |
| 639 | [ |
| 640 | AC_MSG_WARN([Compiler does not support AVX intrinsics]) |
| 641 | ]) |
| 642 | |
| 643 | AS_IF([test x"$intrinsics_support" = x""], |
| 644 | [intrinsics_support=no], |
| 645 | [intrinsics_support="x86$intrinsics_support"] |
| 646 | ) |
| 647 | AS_IF([test x"$rtcd_support" = x""], |
| 648 | [rtcd_support=no], |
| 649 | [rtcd_support="x86$rtcd_support"], |
| 650 | ) |
| 651 | |
| 652 | AS_IF([test x"$enable_rtcd" = x"yes" && test x"$rtcd_support" != x""],[ |
| 653 | get_cpuid_by_asm="no" |
| 654 | AC_MSG_CHECKING([How to get X86 CPU Info]) |
| 655 | AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
| 656 | #include <stdio.h> |
| 657 | ]],[[ |
| 658 | unsigned int CPUInfo0; |
| 659 | unsigned int CPUInfo1; |
| 660 | unsigned int CPUInfo2; |
| 661 | unsigned int CPUInfo3; |
| 662 | unsigned int InfoType; |
| 663 | __asm__ __volatile__ ( |
| 664 | "cpuid": |
| 665 | "=a" (CPUInfo0), |
| 666 | "=b" (CPUInfo1), |
| 667 | "=c" (CPUInfo2), |
| 668 | "=d" (CPUInfo3) : |
| 669 | "a" (InfoType), "c" (0) |
| 670 | ); |
| 671 | ]])], |
| 672 | [get_cpuid_by_asm="yes" |
| 673 | AC_MSG_RESULT([Inline Assembly]) |
| 674 | AC_DEFINE([CPU_INFO_BY_ASM], [1], [Get CPU Info by asm method])], |
| 675 | [AC_LINK_IFELSE([AC_LANG_PROGRAM([[ |
| 676 | #include <cpuid.h> |
| 677 | ]],[[ |
| 678 | unsigned int CPUInfo0; |
| 679 | unsigned int CPUInfo1; |
| 680 | unsigned int CPUInfo2; |
| 681 | unsigned int CPUInfo3; |
| 682 | unsigned int InfoType; |
| 683 | __get_cpuid(InfoType, &CPUInfo0, &CPUInfo1, &CPUInfo2, &CPUInfo3); |
| 684 | ]])], |
| 685 | [AC_MSG_RESULT([C method]) |
| 686 | AC_DEFINE([CPU_INFO_BY_C], [1], [Get CPU Info by c method])], |
| 687 | [AC_MSG_ERROR([no supported Get CPU Info method, please disable intrinsics])])])]) |
| 688 | ], |
| 689 | [ |
| 690 | AC_MSG_WARN([No intrinsics support for your architecture]) |
| 691 | intrinsics_support="no" |
| 692 | ]) |
| 693 | ], |
| 694 | [ |
| 695 | intrinsics_support="no" |
| 696 | ]) |
| 697 | |
| 698 | AM_CONDITIONAL([CPU_ARM], [test "$cpu_arm" = "yes"]) |
| 699 | AM_CONDITIONAL([OPUS_ARM_NEON_INTR], |
| 700 | [test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1"]) |
| 701 | AM_CONDITIONAL([HAVE_ARM_NE10], |
| 702 | [test x"$HAVE_ARM_NE10" = x"1"]) |
| 703 | AM_CONDITIONAL([HAVE_SSE], |
| 704 | [test x"$OPUS_X86_MAY_HAVE_SSE" = x"1"]) |
| 705 | AM_CONDITIONAL([HAVE_SSE2], |
| 706 | [test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1"]) |
| 707 | AM_CONDITIONAL([HAVE_SSE4_1], |
| 708 | [test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1"]) |
| 709 | AM_CONDITIONAL([HAVE_AVX], |
| 710 | [test x"$OPUS_X86_MAY_HAVE_AVX" = x"1"]) |
Vignesh Venkatasubramanian | 2bd8b54 | 2014-02-20 10:50:35 -0800 | [diff] [blame] | 711 | |
| 712 | AS_IF([test x"$enable_rtcd" = x"yes"],[ |
| 713 | AS_IF([test x"$rtcd_support" != x"no"],[ |
| 714 | AC_DEFINE([OPUS_HAVE_RTCD], [1], |
| 715 | [Use run-time CPU capabilities detection]) |
| 716 | OPUS_HAVE_RTCD=1 |
| 717 | AC_SUBST(OPUS_HAVE_RTCD) |
| 718 | ]) |
| 719 | ],[ |
| 720 | rtcd_support="disabled" |
| 721 | ]) |
| 722 | |
| 723 | AC_ARG_ENABLE([assertions], |
| 724 | [AS_HELP_STRING([--enable-assertions],[enable additional software error checking])],, |
| 725 | [enable_assertions=no]) |
| 726 | |
| 727 | AS_IF([test "$enable_assertions" = "yes"], [ |
| 728 | AC_DEFINE([ENABLE_ASSERTIONS], [1], [Assertions]) |
| 729 | ]) |
| 730 | |
| 731 | AC_ARG_ENABLE([fuzzing], |
| 732 | [AS_HELP_STRING([--enable-fuzzing],[causes the encoder to make random decisions])],, |
| 733 | [enable_fuzzing=no]) |
| 734 | |
| 735 | AS_IF([test "$enable_fuzzing" = "yes"], [ |
| 736 | AC_DEFINE([FUZZING], [1], [Fuzzing]) |
| 737 | ]) |
| 738 | |
| 739 | AC_ARG_ENABLE([doc], |
| 740 | [AS_HELP_STRING([--disable-doc], [Do not build API documentation])],, |
| 741 | [enable_doc=yes]) |
| 742 | |
| 743 | AS_IF([test "$enable_doc" = "yes"], [ |
| 744 | AC_CHECK_PROG(HAVE_DOXYGEN, [doxygen], [yes], [no]) |
| 745 | ],[ |
| 746 | HAVE_DOXYGEN=no |
| 747 | ]) |
| 748 | |
| 749 | AM_CONDITIONAL([HAVE_DOXYGEN], [test "$HAVE_DOXYGEN" = "yes"]) |
| 750 | |
| 751 | AC_ARG_ENABLE([extra-programs], |
| 752 | [AS_HELP_STRING([--disable-extra-programs], [Do not build extra programs (demo and tests)])],, |
| 753 | [enable_extra_programs=yes]) |
| 754 | |
| 755 | AM_CONDITIONAL([EXTRA_PROGRAMS], [test "$enable_extra_programs" = "yes"]) |
| 756 | |
| 757 | |
| 758 | saved_CFLAGS="$CFLAGS" |
| 759 | CFLAGS="$CFLAGS -fvisibility=hidden" |
| 760 | AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden]) |
| 761 | AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])], |
| 762 | [ AC_MSG_RESULT([yes]) ], |
| 763 | [ AC_MSG_RESULT([no]) |
| 764 | CFLAGS="$saved_CFLAGS" |
| 765 | ]) |
| 766 | |
| 767 | CFLAGS="$CFLAGS -W" |
| 768 | |
| 769 | warn_CFLAGS="-Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes" |
| 770 | saved_CFLAGS="$CFLAGS" |
| 771 | CFLAGS="$CFLAGS $warn_CFLAGS" |
| 772 | AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}]) |
| 773 | AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])], |
| 774 | [ AC_MSG_RESULT([yes]) ], |
| 775 | [ AC_MSG_RESULT([no]) |
| 776 | CFLAGS="$saved_CFLAGS" |
| 777 | ]) |
| 778 | |
| 779 | saved_LIBS="$LIBS" |
| 780 | LIBS="$LIBS $LIBM" |
| 781 | AC_CHECK_FUNCS([lrintf]) |
| 782 | AC_CHECK_FUNCS([lrint]) |
| 783 | LIBS="$saved_LIBS" |
| 784 | |
| 785 | AC_CHECK_FUNCS([__malloc_hook]) |
| 786 | |
| 787 | AC_SUBST([PC_BUILD]) |
| 788 | |
| 789 | AC_CONFIG_FILES([ |
| 790 | Makefile |
| 791 | opus.pc |
| 792 | opus-uninstalled.pc |
| 793 | celt/arm/armopts.s |
| 794 | doc/Makefile |
| 795 | doc/Doxyfile |
| 796 | ]) |
| 797 | AC_CONFIG_HEADERS([config.h]) |
| 798 | |
| 799 | AC_OUTPUT |
| 800 | |
| 801 | AC_MSG_NOTICE([ |
| 802 | ------------------------------------------------------------------------ |
| 803 | $PACKAGE_NAME $PACKAGE_VERSION: Automatic configuration OK. |
| 804 | |
| 805 | Compiler support: |
| 806 | |
| 807 | C99 var arrays: ................ ${has_var_arrays} |
| 808 | C99 lrintf: .................... ${ac_cv_func_lrintf} |
| 809 | Use alloca: .................... ${use_alloca} |
| 810 | |
| 811 | General configuration: |
| 812 | |
| 813 | Floating point support: ........ ${enable_float} |
| 814 | Fast float approximations: ..... ${enable_float_approx} |
| 815 | Fixed point debugging: ......... ${enable_fixed_point_debug} |
| 816 | Inline Assembly Optimizations: . ${inline_optimization} |
| 817 | External Assembly Optimizations: ${asm_optimization} |
flim | c91ee5b | 2016-01-26 14:33:44 +0100 | [diff] [blame^] | 818 | Intrinsics Optimizations.......: ${intrinsics_support} |
Vignesh Venkatasubramanian | 2bd8b54 | 2014-02-20 10:50:35 -0800 | [diff] [blame] | 819 | Run-time CPU detection: ........ ${rtcd_support} |
| 820 | Custom modes: .................. ${enable_custom_modes} |
| 821 | Assertion checking: ............ ${enable_assertions} |
| 822 | Fuzzing: ....................... ${enable_fuzzing} |
| 823 | |
| 824 | API documentation: ............. ${enable_doc} |
| 825 | Extra programs: ................ ${enable_extra_programs} |
| 826 | ------------------------------------------------------------------------ |
| 827 | |
| 828 | Type "make; make install" to compile and install |
| 829 | Type "make check" to run the test suite |
| 830 | ]) |
| 831 | |