1dnl Process this file with autoconf to produce a configure script. -*-m4-*- 2 3dnl The package_version file will be automatically synced to the git revision 4dnl by the update_version script when configured in the repository, but will 5dnl remain constant in tarball releases unless it is manually edited. 6m4_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 15AC_INIT([opus],[CURRENT_VERSION],[opus@xiph.org]) 16 17AC_CONFIG_SRCDIR(src/opus_encoder.c) 18AC_CONFIG_MACRO_DIR([m4]) 19 20dnl enable silent rules on automake 1.11 and later 21m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) 22 23# For libtool. 24dnl Please update these for releases. 25OPUS_LT_CURRENT=5 26OPUS_LT_REVISION=4 27OPUS_LT_AGE=5 28 29AC_SUBST(OPUS_LT_CURRENT) 30AC_SUBST(OPUS_LT_REVISION) 31AC_SUBST(OPUS_LT_AGE) 32 33AM_INIT_AUTOMAKE([no-define]) 34AM_MAINTAINER_MODE([enable]) 35 36AC_CANONICAL_HOST 37AC_MINGW32 38AM_PROG_LIBTOOL 39AM_PROG_CC_C_O 40 41AC_PROG_CC_C99 42AC_C_CONST 43AC_C_INLINE 44 45AM_PROG_AS 46 47AC_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. 53AC_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 71AH_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 86case $ac_cv_c_restrict in 87 restrict) ;; 88 no) AC_DEFINE([restrict], []) ;; 89 *) AC_DEFINE_UNQUOTED([restrict], [$ac_cv_c_restrict]) ;; 90esac 91 92AC_MSG_CHECKING(for C99 variable-size arrays) 93AC_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 ]) 101AC_MSG_RESULT([$has_var_arrays]) 102 103AS_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 117LT_LIB_M 118 119AC_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 124AS_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 133AM_CONDITIONAL([FIXED_POINT], [test "$enable_fixed_point" = "yes"]) 134 135AC_ARG_ENABLE([fixed-point-debug], 136 [AS_HELP_STRING([--enable-fixed-point-debug], [debug fixed-point implementation])],, 137 [enable_fixed_point_debug=no]) 138 139AS_IF([test "$enable_fixed_point_debug" = "yes"],[ 140 AC_DEFINE([FIXED_DEBUG], [1], [Debug fixed-point implementation]) 141]) 142 143AC_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 148AM_CONDITIONAL([DISABLE_FLOAT_API], [test "$enable_float_api" = "no"]) 149 150AS_IF([test "$enable_float_api" = "no"],[ 151 AC_DEFINE([DISABLE_FLOAT_API], [1], [Do not build the float API]) 152]) 153 154AC_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 158AS_IF([test "$enable_custom_modes" = "yes"],[ 159 AC_DEFINE([CUSTOM_MODES], [1], [Custom modes]) 160 PC_BUILD="$PC_BUILD, custom modes" 161]) 162 163AM_CONDITIONAL([CUSTOM_MODES], [test "$enable_custom_modes" = "yes"]) 164 165has_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 172AC_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 180AS_IF([test "$enable_float_approx" = "yes"],[ 181 AC_DEFINE([FLOAT_APPROX], [1], [Float approximations]) 182]) 183 184AC_ARG_ENABLE([asm], 185 [AS_HELP_STRING([--disable-asm], [Disable assembly optimizations])],, 186 [enable_asm=yes]) 187 188AC_ARG_ENABLE([rtcd], 189 [AS_HELP_STRING([--disable-rtcd], [Disable run-time CPU capabilities detection])],, 190 [enable_rtcd=yes]) 191 192AC_ARG_ENABLE([intrinsics], 193 [AS_HELP_STRING([--disable-intrinsics], [Disable intrinsics optimizations])],, 194 [enable_intrinsics=yes]) 195 196rtcd_support=no 197cpu_arm=no 198 199AS_IF([test x"${enable_asm}" = x"yes"],[ 200 inline_optimization="No inline ASM for your platform, please send patches" 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 ) 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) 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 346AM_CONDITIONAL([OPUS_ARM_INLINE_ASM], 347 [test x"${inline_optimization%% *}" = x"ARM"]) 348AM_CONDITIONAL([OPUS_ARM_EXTERNAL_ASM], 349 [test x"${asm_optimization%% *}" = x"ARM"]) 350 351AM_CONDITIONAL([HAVE_SSE], [false]) 352AM_CONDITIONAL([HAVE_SSE2], [false]) 353AM_CONDITIONAL([HAVE_SSE4_1], [false]) 354AM_CONDITIONAL([HAVE_AVX], [false]) 355 356m4_define([DEFAULT_X86_SSE_CFLAGS], [-msse]) 357m4_define([DEFAULT_X86_SSE2_CFLAGS], [-msse2]) 358m4_define([DEFAULT_X86_SSE4_1_CFLAGS], [-msse4.1]) 359m4_define([DEFAULT_X86_AVX_CFLAGS], [-mavx]) 360m4_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. 366m4_define([DEFAULT_ARM_NEON_SOFTFP_INTR_CFLAGS], [-mfpu=neon -mfloat-abi=softfp]) 367 368AS_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 373AC_ARG_VAR([X86_SSE_CFLAGS], [C compiler flags to compile SSE intrinsics @<:@default=]DEFAULT_X86_SSE_CFLAGS[@:>@]) 374AC_ARG_VAR([X86_SSE2_CFLAGS], [C compiler flags to compile SSE2 intrinsics @<:@default=]DEFAULT_X86_SSE2_CFLAGS[@:>@]) 375AC_ARG_VAR([X86_SSE4_1_CFLAGS], [C compiler flags to compile SSE4.1 intrinsics @<:@default=]DEFAULT_X86_SSE4_1_CFLAGS[@:>@]) 376AC_ARG_VAR([X86_AVX_CFLAGS], [C compiler flags to compile AVX intrinsics @<:@default=]DEFAULT_X86_AVX_CFLAGS[@:>@]) 377AC_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 379AS_VAR_SET_IF([X86_SSE_CFLAGS], [], [AS_VAR_SET([X86_SSE_CFLAGS], "DEFAULT_X86_SSE_CFLAGS")]) 380AS_VAR_SET_IF([X86_SSE2_CFLAGS], [], [AS_VAR_SET([X86_SSE2_CFLAGS], "DEFAULT_X86_SSE2_CFLAGS")]) 381AS_VAR_SET_IF([X86_SSE4_1_CFLAGS], [], [AS_VAR_SET([X86_SSE4_1_CFLAGS], "DEFAULT_X86_SSE4_1_CFLAGS")]) 382AS_VAR_SET_IF([X86_AVX_CFLAGS], [], [AS_VAR_SET([X86_AVX_CFLAGS], "DEFAULT_X86_AVX_CFLAGS")]) 383AS_VAR_SET_IF([ARM_NEON_INTR_CFLAGS], [], [AS_VAR_SET([ARM_NEON_INTR_CFLAGS], ["$RESOLVED_DEFAULT_ARM_NEON_INTR_CFLAGS"])]) 384 385AC_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 459AS_IF([test x"$enable_intrinsics" = x"yes"],[ 460 intrinsics_support="" 461 AS_CASE([$host_cpu], 462 [arm*|aarch64*], 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 return (int)vgetq_lane_f32(SUMM, 0); 476 ]] 477 ) 478 AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1" && test x"$OPUS_ARM_PRESUME_NEON_INTR" != x"1"], 479 [ 480 OPUS_ARM_NEON_INTR_CFLAGS="$ARM_NEON_INTR_CFLAGS" 481 AC_SUBST([OPUS_ARM_NEON_INTR_CFLAGS]) 482 ] 483 ) 484 485 AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1"], 486 [ 487 AC_DEFINE([OPUS_ARM_MAY_HAVE_NEON_INTR], 1, [Compiler supports ARMv7/Aarch64 Neon Intrinsics]) 488 intrinsics_support="$intrinsics_support (NEON)" 489 490 AS_IF([test x"$enable_rtcd" != x"no" && test x"$OPUS_ARM_PRESUME_NEON_INTR" != x"1"], 491 [AS_IF([test x"$rtcd_support" = x"no"], 492 [rtcd_support="ARM (NEON Intrinsics)"], 493 [rtcd_support="$rtcd_support (NEON Intrinsics)"])]) 494 495 AS_IF([test x"$OPUS_ARM_PRESUME_NEON_INTR" = x"1"], 496 [AC_DEFINE([OPUS_ARM_PRESUME_NEON_INTR], 1, [Define if binary requires NEON intrinsics support])]) 497 498 OPUS_PATH_NE10() 499 AS_IF([test x"$NE10_LIBS" != x""], 500 [ 501 intrinsics_support="$intrinsics_support (NE10)" 502 AS_IF([test x"enable_rtcd" != x"" \ 503 && test x"$OPUS_ARM_PRESUME_NEON_INTR" != x"1"], 504 [rtcd_support="$rtcd_support (NE10)"]) 505 ]) 506 507 OPUS_CHECK_INTRINSICS( 508 [Aarch64 Neon], 509 [$ARM_NEON_INTR_CFLAGS], 510 [OPUS_ARM_MAY_HAVE_AARCH64_NEON_INTR], 511 [OPUS_ARM_PRESUME_AARCH64_NEON_INTR], 512 [[#include <arm_neon.h> 513 ]], 514 [[ 515 static int32_t IN; 516 static int16_t OUT; 517 OUT = vqmovns_s32(IN); 518 ]] 519 ) 520 521 AS_IF([test x"$OPUS_ARM_PRESUME_AARCH64_NEON_INTR" = x"1"], 522 [ 523 AC_DEFINE([OPUS_ARM_PRESUME_AARCH64_NEON_INTR], 1, [Define if binary requires Aarch64 Neon Intrinsics]) 524 intrinsics_support="$intrinsics_support (NEON [Aarch64])" 525 ]) 526 527 AS_IF([test x"$intrinsics_support" = x""], 528 [intrinsics_support=no], 529 [intrinsics_support="ARM$intrinsics_support"]) 530 ], 531 [ 532 AC_MSG_WARN([Compiler does not support ARM intrinsics]) 533 intrinsics_support=no 534 ]) 535 ], 536 [i?86|x86_64], 537 [ 538 OPUS_CHECK_INTRINSICS( 539 [SSE], 540 [$X86_SSE_CFLAGS], 541 [OPUS_X86_MAY_HAVE_SSE], 542 [OPUS_X86_PRESUME_SSE], 543 [[#include <xmmintrin.h> 544 #include <time.h> 545 ]], 546 [[ 547 __m128 mtest; 548 mtest = _mm_set1_ps((float)time(NULL)); 549 mtest = _mm_mul_ps(mtest, mtest); 550 return _mm_cvtss_si32(mtest); 551 ]] 552 ) 553 AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE" = x"1" && test x"$OPUS_X86_PRESUME_SSE" != x"1"], 554 [ 555 OPUS_X86_SSE_CFLAGS="$X86_SSE_CFLAGS" 556 AC_SUBST([OPUS_X86_SSE_CFLAGS]) 557 ] 558 ) 559 OPUS_CHECK_INTRINSICS( 560 [SSE2], 561 [$X86_SSE2_CFLAGS], 562 [OPUS_X86_MAY_HAVE_SSE2], 563 [OPUS_X86_PRESUME_SSE2], 564 [[#include <emmintrin.h> 565 #include <time.h> 566 ]], 567 [[ 568 __m128i mtest; 569 mtest = _mm_set1_epi32((int)time(NULL)); 570 mtest = _mm_mul_epu32(mtest, mtest); 571 return _mm_cvtsi128_si32(mtest); 572 ]] 573 ) 574 AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1" && test x"$OPUS_X86_PRESUME_SSE2" != x"1"], 575 [ 576 OPUS_X86_SSE2_CFLAGS="$X86_SSE2_CFLAGS" 577 AC_SUBST([OPUS_X86_SSE2_CFLAGS]) 578 ] 579 ) 580 OPUS_CHECK_INTRINSICS( 581 [SSE4.1], 582 [$X86_SSE4_1_CFLAGS], 583 [OPUS_X86_MAY_HAVE_SSE4_1], 584 [OPUS_X86_PRESUME_SSE4_1], 585 [[#include <smmintrin.h> 586 #include <time.h> 587 ]], 588 [[ 589 __m128i mtest; 590 mtest = _mm_set1_epi32((int)time(NULL)); 591 mtest = _mm_mul_epi32(mtest, mtest); 592 return _mm_cvtsi128_si32(mtest); 593 ]] 594 ) 595 AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1" && test x"$OPUS_X86_PRESUME_SSE4_1" != x"1"], 596 [ 597 OPUS_X86_SSE4_1_CFLAGS="$X86_SSE4_1_CFLAGS" 598 AC_SUBST([OPUS_X86_SSE4_1_CFLAGS]) 599 ] 600 ) 601 OPUS_CHECK_INTRINSICS( 602 [AVX], 603 [$X86_AVX_CFLAGS], 604 [OPUS_X86_MAY_HAVE_AVX], 605 [OPUS_X86_PRESUME_AVX], 606 [[#include <immintrin.h> 607 #include <time.h> 608 ]], 609 [[ 610 __m256 mtest; 611 mtest = _mm256_set1_ps((float)time(NULL)); 612 mtest = _mm256_addsub_ps(mtest, mtest); 613 return _mm_cvtss_si32(_mm256_extractf128_ps(mtest, 0)); 614 ]] 615 ) 616 AS_IF([test x"$OPUS_X86_MAY_HAVE_AVX" = x"1" && test x"$OPUS_X86_PRESUME_AVX" != x"1"], 617 [ 618 OPUS_X86_AVX_CFLAGS="$X86_AVX_CFLAGS" 619 AC_SUBST([OPUS_X86_AVX_CFLAGS]) 620 ] 621 ) 622 AS_IF([test x"$rtcd_support" = x"no"], [rtcd_support=""]) 623 AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE" = x"1"], 624 [ 625 AC_DEFINE([OPUS_X86_MAY_HAVE_SSE], 1, [Compiler supports X86 SSE Intrinsics]) 626 intrinsics_support="$intrinsics_support SSE" 627 628 AS_IF([test x"$OPUS_X86_PRESUME_SSE" = x"1"], 629 [AC_DEFINE([OPUS_X86_PRESUME_SSE], 1, [Define if binary requires SSE intrinsics support])], 630 [rtcd_support="$rtcd_support SSE"]) 631 ], 632 [ 633 AC_MSG_WARN([Compiler does not support SSE intrinsics]) 634 ]) 635 636 AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1"], 637 [ 638 AC_DEFINE([OPUS_X86_MAY_HAVE_SSE2], 1, [Compiler supports X86 SSE2 Intrinsics]) 639 intrinsics_support="$intrinsics_support SSE2" 640 641 AS_IF([test x"$OPUS_X86_PRESUME_SSE2" = x"1"], 642 [AC_DEFINE([OPUS_X86_PRESUME_SSE2], 1, [Define if binary requires SSE2 intrinsics support])], 643 [rtcd_support="$rtcd_support SSE2"]) 644 ], 645 [ 646 AC_MSG_WARN([Compiler does not support SSE2 intrinsics]) 647 ]) 648 649 AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1"], 650 [ 651 AC_DEFINE([OPUS_X86_MAY_HAVE_SSE4_1], 1, [Compiler supports X86 SSE4.1 Intrinsics]) 652 intrinsics_support="$intrinsics_support SSE4.1" 653 654 AS_IF([test x"$OPUS_X86_PRESUME_SSE4_1" = x"1"], 655 [AC_DEFINE([OPUS_X86_PRESUME_SSE4_1], 1, [Define if binary requires SSE4.1 intrinsics support])], 656 [rtcd_support="$rtcd_support SSE4.1"]) 657 ], 658 [ 659 AC_MSG_WARN([Compiler does not support SSE4.1 intrinsics]) 660 ]) 661 AS_IF([test x"$OPUS_X86_MAY_HAVE_AVX" = x"1"], 662 [ 663 AC_DEFINE([OPUS_X86_MAY_HAVE_AVX], 1, [Compiler supports X86 AVX Intrinsics]) 664 intrinsics_support="$intrinsics_support AVX" 665 666 AS_IF([test x"$OPUS_X86_PRESUME_AVX" = x"1"], 667 [AC_DEFINE([OPUS_X86_PRESUME_AVX], 1, [Define if binary requires AVX intrinsics support])], 668 [rtcd_support="$rtcd_support AVX"]) 669 ], 670 [ 671 AC_MSG_WARN([Compiler does not support AVX intrinsics]) 672 ]) 673 674 AS_IF([test x"$intrinsics_support" = x""], 675 [intrinsics_support=no], 676 [intrinsics_support="x86$intrinsics_support"] 677 ) 678 AS_IF([test x"$rtcd_support" = x""], 679 [rtcd_support=no], 680 [rtcd_support="x86$rtcd_support"], 681 ) 682 683 AS_IF([test x"$enable_rtcd" = x"yes" && test x"$rtcd_support" != x""],[ 684 get_cpuid_by_asm="no" 685 AC_MSG_CHECKING([How to get X86 CPU Info]) 686 AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 687 #include <stdio.h> 688 ]],[[ 689 unsigned int CPUInfo0; 690 unsigned int CPUInfo1; 691 unsigned int CPUInfo2; 692 unsigned int CPUInfo3; 693 unsigned int InfoType; 694 __asm__ __volatile__ ( 695 "cpuid": 696 "=a" (CPUInfo0), 697 "=b" (CPUInfo1), 698 "=c" (CPUInfo2), 699 "=d" (CPUInfo3) : 700 "a" (InfoType), "c" (0) 701 ); 702 ]])], 703 [get_cpuid_by_asm="yes" 704 AC_MSG_RESULT([Inline Assembly]) 705 AC_DEFINE([CPU_INFO_BY_ASM], [1], [Get CPU Info by asm method])], 706 [AC_LINK_IFELSE([AC_LANG_PROGRAM([[ 707 #include <cpuid.h> 708 ]],[[ 709 unsigned int CPUInfo0; 710 unsigned int CPUInfo1; 711 unsigned int CPUInfo2; 712 unsigned int CPUInfo3; 713 unsigned int InfoType; 714 __get_cpuid(InfoType, &CPUInfo0, &CPUInfo1, &CPUInfo2, &CPUInfo3); 715 ]])], 716 [AC_MSG_RESULT([C method]) 717 AC_DEFINE([CPU_INFO_BY_C], [1], [Get CPU Info by c method])], 718 [AC_MSG_ERROR([no supported Get CPU Info method, please disable intrinsics])])])]) 719 ], 720 [ 721 AC_MSG_WARN([No intrinsics support for your architecture]) 722 intrinsics_support="no" 723 ]) 724], 725[ 726 intrinsics_support="no" 727]) 728 729AM_CONDITIONAL([CPU_ARM], [test "$cpu_arm" = "yes"]) 730AM_CONDITIONAL([HAVE_ARM_NEON_INTR], 731 [test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1"]) 732AM_CONDITIONAL([HAVE_ARM_NE10], 733 [test x"$HAVE_ARM_NE10" = x"1"]) 734AM_CONDITIONAL([HAVE_SSE], 735 [test x"$OPUS_X86_MAY_HAVE_SSE" = x"1"]) 736AM_CONDITIONAL([HAVE_SSE2], 737 [test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1"]) 738AM_CONDITIONAL([HAVE_SSE4_1], 739 [test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1"]) 740AM_CONDITIONAL([HAVE_AVX], 741 [test x"$OPUS_X86_MAY_HAVE_AVX" = x"1"]) 742 743AS_IF([test x"$enable_rtcd" = x"yes"],[ 744 AS_IF([test x"$rtcd_support" != x"no"],[ 745 AC_DEFINE([OPUS_HAVE_RTCD], [1], 746 [Use run-time CPU capabilities detection]) 747 OPUS_HAVE_RTCD=1 748 AC_SUBST(OPUS_HAVE_RTCD) 749 ]) 750],[ 751 rtcd_support="disabled" 752]) 753 754AC_ARG_ENABLE([assertions], 755 [AS_HELP_STRING([--enable-assertions],[enable additional software error checking])],, 756 [enable_assertions=no]) 757 758AS_IF([test "$enable_assertions" = "yes"], [ 759 AC_DEFINE([ENABLE_ASSERTIONS], [1], [Assertions]) 760]) 761 762AC_ARG_ENABLE([fuzzing], 763 [AS_HELP_STRING([--enable-fuzzing],[causes the encoder to make random decisions])],, 764 [enable_fuzzing=no]) 765 766AS_IF([test "$enable_fuzzing" = "yes"], [ 767 AC_DEFINE([FUZZING], [1], [Fuzzing]) 768]) 769 770AC_ARG_ENABLE([ambisonics], 771 [AS_HELP_STRING([--enable-ambisonics],[enable experimental ambisonic encoding and decoding support])],, 772 [enable_ambisonics=no]) 773 774AS_IF([test "$enable_ambisonics" = "yes"], [ 775 AC_DEFINE([ENABLE_EXPERIMENTAL_AMBISONICS], [1], [Ambisonics Support]) 776]) 777 778AC_ARG_ENABLE([doc], 779 [AS_HELP_STRING([--disable-doc], [Do not build API documentation])],, 780 [enable_doc=yes]) 781 782AS_IF([test "$enable_doc" = "yes"], [ 783 AC_CHECK_PROG(HAVE_DOXYGEN, [doxygen], [yes], [no]) 784],[ 785 HAVE_DOXYGEN=no 786]) 787 788AM_CONDITIONAL([HAVE_DOXYGEN], [test "$HAVE_DOXYGEN" = "yes"]) 789 790AC_ARG_ENABLE([extra-programs], 791 [AS_HELP_STRING([--disable-extra-programs], [Do not build extra programs (demo and tests)])],, 792 [enable_extra_programs=yes]) 793 794AM_CONDITIONAL([EXTRA_PROGRAMS], [test "$enable_extra_programs" = "yes"]) 795 796 797saved_CFLAGS="$CFLAGS" 798CFLAGS="$CFLAGS -fvisibility=hidden" 799AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden]) 800AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])], 801 [ AC_MSG_RESULT([yes]) ], 802 [ AC_MSG_RESULT([no]) 803 CFLAGS="$saved_CFLAGS" 804 ]) 805 806CFLAGS="$CFLAGS -W" 807 808warn_CFLAGS="-Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes" 809saved_CFLAGS="$CFLAGS" 810CFLAGS="$CFLAGS $warn_CFLAGS" 811AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}]) 812AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])], 813 [ AC_MSG_RESULT([yes]) ], 814 [ AC_MSG_RESULT([no]) 815 CFLAGS="$saved_CFLAGS" 816 ]) 817 818saved_LIBS="$LIBS" 819LIBS="$LIBS $LIBM" 820AC_CHECK_FUNCS([lrintf]) 821AC_CHECK_FUNCS([lrint]) 822LIBS="$saved_LIBS" 823 824AC_CHECK_FUNCS([__malloc_hook]) 825 826AC_SUBST([PC_BUILD]) 827 828AC_CONFIG_FILES([ 829 Makefile 830 opus.pc 831 opus-uninstalled.pc 832 celt/arm/armopts.s 833 doc/Makefile 834 doc/Doxyfile 835]) 836AC_CONFIG_HEADERS([config.h]) 837 838AC_OUTPUT 839 840AC_MSG_NOTICE([ 841------------------------------------------------------------------------ 842 $PACKAGE_NAME $PACKAGE_VERSION: Automatic configuration OK. 843 844 Compiler support: 845 846 C99 var arrays: ................ ${has_var_arrays} 847 C99 lrintf: .................... ${ac_cv_func_lrintf} 848 Use alloca: .................... ${use_alloca} 849 850 General configuration: 851 852 Floating point support: ........ ${enable_float} 853 Fast float approximations: ..... ${enable_float_approx} 854 Fixed point debugging: ......... ${enable_fixed_point_debug} 855 Inline Assembly Optimizations: . ${inline_optimization} 856 External Assembly Optimizations: ${asm_optimization} 857 Intrinsics Optimizations.......: ${intrinsics_support} 858 Run-time CPU detection: ........ ${rtcd_support} 859 Custom modes: .................. ${enable_custom_modes} 860 Assertion checking: ............ ${enable_assertions} 861 Fuzzing: ....................... ${enable_fuzzing} 862 Ambisonics support: .............${enable_ambisonics} 863 864 API documentation: ............. ${enable_doc} 865 Extra programs: ................ ${enable_extra_programs} 866------------------------------------------------------------------------ 867 868 Type "make; make install" to compile and install 869 Type "make check" to run the test suite 870]) 871 872