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=8 26OPUS_LT_REVISION=0 27OPUS_LT_AGE=8 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$NE10_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="$CFLAGS $NE10_CFLAGS" 425 save_LIBS="$LIBS"; LIBS="$LIBS $NE10_LIBS $LIBM" 426 AC_LINK_IFELSE( 427 [ 428 AC_LANG_PROGRAM( 429 [[#include <NE10_dsp.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 run-time CPU capabilities detection or 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([hardening], 763 [AS_HELP_STRING([--disable-hardening],[disable run-time checks that are cheap and safe for use in production])],, 764 [enable_hardening=yes]) 765 766AS_IF([test "$enable_hardening" = "yes"], [ 767 AC_DEFINE([ENABLE_HARDENING], [1], [Hardening]) 768]) 769 770AC_ARG_ENABLE([fuzzing], 771 [AS_HELP_STRING([--enable-fuzzing],[causes the encoder to make random decisions (do not use in production)])],, 772 [enable_fuzzing=no]) 773 774AS_IF([test "$enable_fuzzing" = "yes"], [ 775 AC_DEFINE([FUZZING], [1], [Fuzzing]) 776]) 777 778AC_ARG_ENABLE([check-asm], 779 [AS_HELP_STRING([--enable-check-asm], 780 [enable bit-exactness checks between optimized and c implementations])],, 781 [enable_check_asm=no]) 782 783AS_IF([test "$enable_check_asm" = "yes"], [ 784 AC_DEFINE([OPUS_CHECK_ASM], [1], [Run bit-exactness checks between optimized and c implementations]) 785]) 786 787AC_ARG_ENABLE([doc], 788 [AS_HELP_STRING([--disable-doc], [Do not build API documentation])],, 789 [enable_doc=yes]) 790 791AS_IF([test "$enable_doc" = "yes"], [ 792 AC_CHECK_PROG(HAVE_DOXYGEN, [doxygen], [yes], [no]) 793 AC_CHECK_PROG(HAVE_DOT, [dot], [yes], [no]) 794],[ 795 HAVE_DOXYGEN=no 796]) 797 798AM_CONDITIONAL([HAVE_DOXYGEN], [test "$HAVE_DOXYGEN" = "yes"]) 799 800AC_ARG_ENABLE([extra-programs], 801 [AS_HELP_STRING([--disable-extra-programs], [Do not build extra programs (demo and tests)])],, 802 [enable_extra_programs=yes]) 803 804AM_CONDITIONAL([EXTRA_PROGRAMS], [test "$enable_extra_programs" = "yes"]) 805 806 807AC_ARG_ENABLE([rfc8251], 808 AS_HELP_STRING([--disable-rfc8251], [Disable bitstream fixes from RFC 8251]),, 809 [enable_rfc8251=yes]) 810 811AS_IF([test "$enable_rfc8251" = "no"], [ 812 AC_DEFINE([DISABLE_UPDATE_DRAFT], [1], [Disable bitstream fixes from RFC 8251]) 813]) 814 815 816saved_CFLAGS="$CFLAGS" 817CFLAGS="$CFLAGS -fvisibility=hidden" 818AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden]) 819AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])], 820 [ AC_MSG_RESULT([yes]) ], 821 [ AC_MSG_RESULT([no]) 822 CFLAGS="$saved_CFLAGS" 823 ]) 824 825on_x86=no 826case "$host_cpu" in 827i[[3456]]86 | x86_64) 828 on_x86=yes 829 ;; 830esac 831 832on_windows=no 833case $host in 834*cygwin*|*mingw*) 835 on_windows=yes 836 ;; 837esac 838 839dnl Enable stack-protector-all only on x86 where it's well supported. 840dnl on some platforms it causes crashes. Hopefully the OS's default's 841dnl include this on platforms that work but have been missed here. 842AC_ARG_ENABLE([stack-protector], 843 [AS_HELP_STRING([--disable-stack-protector],[Disable compiler stack hardening])],, 844 [ 845 AS_IF([test "$ac_cv_c_compiler_gnu" = "yes" && test "$on_x86" = "yes" && test "$on_windows" = "no"], 846 [enable_stack_protector=yes],[enable_stack_protector=no]) 847 ]) 848 849AS_IF([test "$enable_stack_protector" = "yes"], 850 [ 851 saved_CFLAGS="$CFLAGS" 852 CFLAGS="$CFLAGS -fstack-protector-strong" 853 AC_MSG_CHECKING([if ${CC} supports -fstack-protector-strong]) 854 AC_LINK_IFELSE([AC_LANG_PROGRAM([],[[char foo;]])], 855 [ AC_MSG_RESULT([yes]) ], 856 [ 857 AC_MSG_RESULT([no]) 858 enable_stack_protector=no 859 CFLAGS="$saved_CFLAGS" 860 ]) 861 ]) 862 863AS_IF([test x$ac_cv_c_compiler_gnu = xyes], 864 [AX_ADD_FORTIFY_SOURCE] 865) 866 867CFLAGS="$CFLAGS -W" 868 869warn_CFLAGS="-Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes" 870saved_CFLAGS="$CFLAGS" 871CFLAGS="$CFLAGS $warn_CFLAGS" 872AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}]) 873AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])], 874 [ AC_MSG_RESULT([yes]) ], 875 [ AC_MSG_RESULT([no]) 876 CFLAGS="$saved_CFLAGS" 877 ]) 878 879saved_LIBS="$LIBS" 880LIBS="$LIBS $LIBM" 881AC_CHECK_FUNCS([lrintf]) 882AC_CHECK_FUNCS([lrint]) 883LIBS="$saved_LIBS" 884 885AC_CHECK_FUNCS([__malloc_hook]) 886 887AC_SUBST([PC_BUILD]) 888 889AC_CONFIG_FILES([ 890 Makefile 891 opus.pc 892 opus-uninstalled.pc 893 celt/arm/armopts.s 894 doc/Makefile 895 doc/Doxyfile 896]) 897AC_CONFIG_HEADERS([config.h]) 898 899AC_OUTPUT 900 901AC_MSG_NOTICE([ 902------------------------------------------------------------------------ 903 $PACKAGE_NAME $PACKAGE_VERSION: Automatic configuration OK. 904 905 Compiler support: 906 907 C99 var arrays: ................ ${has_var_arrays} 908 C99 lrintf: .................... ${ac_cv_func_lrintf} 909 Use alloca: .................... ${use_alloca} 910 911 General configuration: 912 913 Floating point support: ........ ${enable_float} 914 Fast float approximations: ..... ${enable_float_approx} 915 Fixed point debugging: ......... ${enable_fixed_point_debug} 916 Inline Assembly Optimizations: . ${inline_optimization} 917 External Assembly Optimizations: ${asm_optimization} 918 Intrinsics Optimizations: ...... ${intrinsics_support} 919 Run-time CPU detection: ........ ${rtcd_support} 920 Custom modes: .................. ${enable_custom_modes} 921 Assertion checking: ............ ${enable_assertions} 922 Hardening: ..................... ${enable_hardening} 923 Fuzzing: ....................... ${enable_fuzzing} 924 Check ASM: ..................... ${enable_check_asm} 925 926 API documentation: ............. ${enable_doc} 927 Extra programs: ................ ${enable_extra_programs} 928------------------------------------------------------------------------ 929 930 Type "make; make install" to compile and install 931 Type "make check" to run the test suite 932]) 933 934