3bd683b3b7541ff4bf667fd810c5914f8a8dbae5
[opus.git] / configure.ac
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=6
26 OPUS_LT_REVISION=1
27 OPUS_LT_AGE=6
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([fuzzing],
763     [AS_HELP_STRING([--enable-fuzzing],[causes the encoder to make random decisions])],,
764     [enable_fuzzing=no])
765
766 AS_IF([test "$enable_fuzzing" = "yes"], [
767   AC_DEFINE([FUZZING], [1], [Fuzzing])
768 ])
769
770 AC_ARG_ENABLE([check-asm],
771     [AS_HELP_STRING([--enable-check-asm],
772                     [enable bit-exactness checks between optimized and c implementations])],,
773     [enable_check_asm=no])
774
775 AS_IF([test "$enable_check_asm" = "yes"], [
776   AC_DEFINE([OPUS_CHECK_ASM], [1], [Run bit-exactness checks between optimized and c implementations])
777 ])
778
779 AC_ARG_ENABLE([ambisonics],
780     [AS_HELP_STRING([--enable-ambisonics],[enable experimental ambisonic encoding and decoding support])],,
781     [enable_ambisonics=no])
782
783 AS_IF([test "$enable_ambisonics" = "yes"], [
784   AC_DEFINE([ENABLE_EXPERIMENTAL_AMBISONICS], [1], [Ambisonics Support])
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       Fuzzing: ....................... ${enable_fuzzing}
923       Check ASM: ..................... ${enable_check_asm}
924       Ambisonics support: ............ ${enable_ambisonics}
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