Mercurial > hg > sv-dependency-builds

comparison src/opus-1.3/configure.ac @ 69:7aeed7906520

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add Opus sources and macOS builds
author Chris Cannam
date Wed, 23 Jan 2019 13:48:08 +0000
parents
children
comparison
equal deleted inserted replaced
68:85d5306e114e 69:7aeed7906520
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=7
26 OPUS_LT_REVISION=0
27 OPUS_LT_AGE=7
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
192 AC_ARG_ENABLE([intrinsics],
193 [AS_HELP_STRING([--disable-intrinsics], [Disable intrinsics optimizations])],,
194 [enable_intrinsics=yes])
195
196 rtcd_support=no
197 cpu_arm=no
198
199 AS_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
346 AM_CONDITIONAL([OPUS_ARM_INLINE_ASM],
347 [test x"${inline_optimization%% *}" = x"ARM"])
348 AM_CONDITIONAL([OPUS_ARM_EXTERNAL_ASM],
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$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
459 AS_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
729 AM_CONDITIONAL([CPU_ARM], [test "$cpu_arm" = "yes"])
730 AM_CONDITIONAL([HAVE_ARM_NEON_INTR],
731 [test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1"])
732 AM_CONDITIONAL([HAVE_ARM_NE10],
733 [test x"$HAVE_ARM_NE10" = x"1"])
734 AM_CONDITIONAL([HAVE_SSE],
735 [test x"$OPUS_X86_MAY_HAVE_SSE" = x"1"])
736 AM_CONDITIONAL([HAVE_SSE2],
737 [test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1"])
738 AM_CONDITIONAL([HAVE_SSE4_1],
739 [test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1"])
740 AM_CONDITIONAL([HAVE_AVX],
741 [test x"$OPUS_X86_MAY_HAVE_AVX" = x"1"])
742
743 AS_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
754 AC_ARG_ENABLE([assertions],
755 [AS_HELP_STRING([--enable-assertions],[enable additional software error checking])],,
756 [enable_assertions=no])
757
758 AS_IF([test "$enable_assertions" = "yes"], [
759 AC_DEFINE([ENABLE_ASSERTIONS], [1], [Assertions])
760 ])
761
762 AC_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
766 AS_IF([test "$enable_hardening" = "yes"], [
767 AC_DEFINE([ENABLE_HARDENING], [1], [Hardening])
768 ])
769
770 AC_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
774 AS_IF([test "$enable_fuzzing" = "yes"], [
775 AC_DEFINE([FUZZING], [1], [Fuzzing])
776 ])
777
778 AC_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
783 AS_IF([test "$enable_check_asm" = "yes"], [
784 AC_DEFINE([OPUS_CHECK_ASM], [1], [Run bit-exactness checks between optimized and c implementations])
785 ])
786
787 AC_ARG_ENABLE([doc],
788 [AS_HELP_STRING([--disable-doc], [Do not build API documentation])],,
789 [enable_doc=yes])
790
791 AS_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
798 AM_CONDITIONAL([HAVE_DOXYGEN], [test "$HAVE_DOXYGEN" = "yes"])
799
800 AC_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
804 AM_CONDITIONAL([EXTRA_PROGRAMS], [test "$enable_extra_programs" = "yes"])
805
806
807 AC_ARG_ENABLE([rfc8251],
808 AS_HELP_STRING([--disable-rfc8251], [Disable bitstream fixes from RFC 8251]),,
809 [enable_rfc8251=yes])
810
811 AS_IF([test "$enable_rfc8251" = "no"], [
812 AC_DEFINE([DISABLE_UPDATE_DRAFT], [1], [Disable bitstream fixes from RFC 8251])
813 ])
814
815
816 saved_CFLAGS="$CFLAGS"
817 CFLAGS="$CFLAGS -fvisibility=hidden"
818 AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden])
819 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
820 [ AC_MSG_RESULT([yes]) ],
821 [ AC_MSG_RESULT([no])
822 CFLAGS="$saved_CFLAGS"
823 ])
824
825 on_x86=no
826 case "$host_cpu" in
827 i[[3456]]86 | x86_64)
828 on_x86=yes
829 ;;
830 esac
831
832 on_windows=no
833 case $host in
834 *cygwin*|*mingw*)
835 on_windows=yes
836 ;;
837 esac
838
839 dnl Enable stack-protector-all only on x86 where it's well supported.
840 dnl on some platforms it causes crashes. Hopefully the OS's default's
841 dnl include this on platforms that work but have been missed here.
842 AC_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
849 AS_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
863 AS_IF([test x$ac_cv_c_compiler_gnu = xyes],
864 [AX_ADD_FORTIFY_SOURCE]
865 )
866
867 CFLAGS="$CFLAGS -W"
868
869 warn_CFLAGS="-Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes"
870 saved_CFLAGS="$CFLAGS"
871 CFLAGS="$CFLAGS $warn_CFLAGS"
872 AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
873 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
874 [ AC_MSG_RESULT([yes]) ],
875 [ AC_MSG_RESULT([no])
876 CFLAGS="$saved_CFLAGS"
877 ])
878
879 saved_LIBS="$LIBS"
880 LIBS="$LIBS $LIBM"
881 AC_CHECK_FUNCS([lrintf])
882 AC_CHECK_FUNCS([lrint])
883 LIBS="$saved_LIBS"
884
885 AC_CHECK_FUNCS([__malloc_hook])
886
887 AC_SUBST([PC_BUILD])
888
889 AC_CONFIG_FILES([
890 Makefile
891 opus.pc
892 opus-uninstalled.pc
893 celt/arm/armopts.s
894 doc/Makefile
895 doc/Doxyfile
896 ])
897 AC_CONFIG_HEADERS([config.h])
898
899 AC_OUTPUT
900
901 AC_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