bump LT revision
[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$ogg_prefix" != "x" ; then
418          NE10_CFLAGS="-I$NE10_prefix/include"
419       elif test "x$prefix" != "xNONE"; then
420          NE10_CFLAGS="-I$prefix/include"
421       fi
422
423       AC_MSG_CHECKING(for NE10)
424       save_CFLAGS="$CFLAGS"; CFLAGS="$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([update-draft],
808   AS_HELP_STRING([--enable-update-draft], [Enable bitstream changes from draft-ietf-codec-opus-update]),,
809   [enable_update_draft=no])
810
811 AS_IF([test "$enable_update_draft" = "yes"], [
812   AC_DEFINE([ENABLE_UPDATE_DRAFT], [1], [Enable bitstream changes from draft-ietf-codec-opus-update])
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 CFLAGS="$CFLAGS -W"
826
827 warn_CFLAGS="-Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes"
828 saved_CFLAGS="$CFLAGS"
829 CFLAGS="$CFLAGS $warn_CFLAGS"
830 AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
831 AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
832     [ AC_MSG_RESULT([yes]) ],
833     [ AC_MSG_RESULT([no])
834       CFLAGS="$saved_CFLAGS"
835     ])
836
837 saved_LIBS="$LIBS"
838 LIBS="$LIBS $LIBM"
839 AC_CHECK_FUNCS([lrintf])
840 AC_CHECK_FUNCS([lrint])
841 LIBS="$saved_LIBS"
842
843 AC_CHECK_FUNCS([__malloc_hook])
844
845 AC_SUBST([PC_BUILD])
846
847 AC_CONFIG_FILES([
848     Makefile
849     opus.pc
850     opus-uninstalled.pc
851     celt/arm/armopts.s
852     doc/Makefile
853     doc/Doxyfile
854 ])
855 AC_CONFIG_HEADERS([config.h])
856
857 AC_OUTPUT
858
859 AC_MSG_NOTICE([
860 ------------------------------------------------------------------------
861   $PACKAGE_NAME $PACKAGE_VERSION:  Automatic configuration OK.
862
863     Compiler support:
864
865       C99 var arrays: ................ ${has_var_arrays}
866       C99 lrintf: .................... ${ac_cv_func_lrintf}
867       Use alloca: .................... ${use_alloca}
868
869     General configuration:
870
871       Floating point support: ........ ${enable_float}
872       Fast float approximations: ..... ${enable_float_approx}
873       Fixed point debugging: ......... ${enable_fixed_point_debug}
874       Inline Assembly Optimizations: . ${inline_optimization}
875       External Assembly Optimizations: ${asm_optimization}
876       Intrinsics Optimizations.......: ${intrinsics_support}
877       Run-time CPU detection: ........ ${rtcd_support}
878       Custom modes: .................. ${enable_custom_modes}
879       Assertion checking: ............ ${enable_assertions}
880       Fuzzing: ....................... ${enable_fuzzing}
881       Check ASM: ..................... ${enable_check_asm}
882       Ambisonics support: ............ ${enable_ambisonics}
883
884       API documentation: ............. ${enable_doc}
885       Extra programs: ................ ${enable_extra_programs}
886 ------------------------------------------------------------------------
887
888  Type "make; make install" to compile and install
889  Type "make check" to run the test suite
890 ])
891