• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1dnl Process this file with autoconf to produce a configure script. -*-m4-*-
2
3dnl The package_version file will be automatically synced to the git revision
4dnl by the update_version script when configured in the repository, but will
5dnl remain constant in tarball releases unless it is manually edited.
6m4_define([CURRENT_VERSION],
7          m4_esyscmd([ ./update_version 2>/dev/null || true
8                       if test -e package_version; then
9                           . ./package_version
10                           printf "$PACKAGE_VERSION"
11                       else
12                           printf "unknown"
13                       fi ]))
14
15AC_INIT([opus],[CURRENT_VERSION],[opus@xiph.org])
16
17AC_CONFIG_SRCDIR(src/opus_encoder.c)
18AC_CONFIG_MACRO_DIR([m4])
19
20dnl enable silent rules on automake 1.11 and later
21m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
22
23# For libtool.
24dnl Please update these for releases.
25OPUS_LT_CURRENT=7
26OPUS_LT_REVISION=0
27OPUS_LT_AGE=7
28
29AC_SUBST(OPUS_LT_CURRENT)
30AC_SUBST(OPUS_LT_REVISION)
31AC_SUBST(OPUS_LT_AGE)
32
33AM_INIT_AUTOMAKE([no-define])
34AM_MAINTAINER_MODE([enable])
35
36AC_CANONICAL_HOST
37AC_MINGW32
38AM_PROG_LIBTOOL
39AM_PROG_CC_C_O
40
41AC_PROG_CC_C99
42AC_C_CONST
43AC_C_INLINE
44
45AM_PROG_AS
46
47AC_DEFINE([OPUS_BUILD], [], [This is a build of OPUS])
48
49#Use a hacked up version of autoconf's AC_C_RESTRICT because it's not
50#strong enough a test to detect old buggy versions of GCC (e.g. 2.95.3)
51#Note: Both this and the test for variable-size arrays below are also
52#      done by AC_PROG_CC_C99, but not thoroughly enough apparently.
53AC_CACHE_CHECK([for C/C++ restrict keyword], ac_cv_c_restrict,
54  [ac_cv_c_restrict=no
55   # The order here caters to the fact that C++ does not require restrict.
56   for ac_kw in __restrict __restrict__ _Restrict restrict; do
57     AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
58      [[typedef int * int_ptr;
59        int foo (int_ptr $ac_kw ip, int * $ac_kw baz[]) {
60        return ip[0];
61       }]],
62      [[int s[1];
63        int * $ac_kw t = s;
64        t[0] = 0;
65        return foo(t, (void *)0)]])],
66      [ac_cv_c_restrict=$ac_kw])
67     test "$ac_cv_c_restrict" != no && break
68   done
69  ])
70
71AH_VERBATIM([restrict],
72[/* Define to the equivalent of the C99 'restrict' keyword, or to
73   nothing if this is not supported.  Do not define if restrict is
74   supported directly.  */
75#undef restrict
76/* Work around a bug in Sun C++: it does not support _Restrict or
77   __restrict__, even though the corresponding Sun C compiler ends up with
78   "#define restrict _Restrict" or "#define restrict __restrict__" in the
79   previous line.  Perhaps some future version of Sun C++ will work with
80   restrict; if so, hopefully it defines __RESTRICT like Sun C does.  */
81#if defined __SUNPRO_CC && !defined __RESTRICT
82# define _Restrict
83# define __restrict__
84#endif])
85
86case $ac_cv_c_restrict in
87   restrict) ;;
88   no) AC_DEFINE([restrict], []) ;;
89   *)  AC_DEFINE_UNQUOTED([restrict], [$ac_cv_c_restrict]) ;;
90esac
91
92AC_MSG_CHECKING(for C99 variable-size arrays)
93AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
94                   [[static int x; char a[++x]; a[sizeof a - 1] = 0; int N; return a[0];]])],
95    [ has_var_arrays=yes
96      use_alloca="no (using var arrays)"
97      AC_DEFINE([VAR_ARRAYS], [1], [Use C99 variable-size arrays])
98    ],[
99      has_var_arrays=no
100    ])
101AC_MSG_RESULT([$has_var_arrays])
102
103AS_IF([test "$has_var_arrays" = "no"],
104  [
105   AC_CHECK_HEADERS([alloca.h])
106   AC_MSG_CHECKING(for alloca)
107   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <alloca.h>]],
108                                      [[int foo=10; int *array = alloca(foo);]])],
109     [ use_alloca=yes;
110       AC_DEFINE([USE_ALLOCA], [], [Make use of alloca])
111     ],[
112       use_alloca=no
113     ])
114   AC_MSG_RESULT([$use_alloca])
115  ])
116
117LT_LIB_M
118
119AC_ARG_ENABLE([fixed-point],
120    [AS_HELP_STRING([--enable-fixed-point],
121                    [compile without floating point (for machines without a fast enough FPU)])],,
122    [enable_fixed_point=no])
123
124AS_IF([test "$enable_fixed_point" = "yes"],[
125  enable_float="no"
126  AC_DEFINE([FIXED_POINT], [1], [Compile as fixed-point (for machines without a fast enough FPU)])
127  PC_BUILD="fixed-point"
128],[
129  enable_float="yes";
130  PC_BUILD="floating-point"
131])
132
133AM_CONDITIONAL([FIXED_POINT], [test "$enable_fixed_point" = "yes"])
134
135AC_ARG_ENABLE([fixed-point-debug],
136    [AS_HELP_STRING([--enable-fixed-point-debug], [debug fixed-point implementation])],,
137    [enable_fixed_point_debug=no])
138
139AS_IF([test "$enable_fixed_point_debug" = "yes"],[
140  AC_DEFINE([FIXED_DEBUG], [1], [Debug fixed-point implementation])
141])
142
143AC_ARG_ENABLE([float_api],
144    [AS_HELP_STRING([--disable-float-api],
145                    [compile without the floating point API (for machines with no float library)])],,
146    [enable_float_api=yes])
147
148AM_CONDITIONAL([DISABLE_FLOAT_API], [test "$enable_float_api" = "no"])
149
150AS_IF([test "$enable_float_api" = "no"],[
151  AC_DEFINE([DISABLE_FLOAT_API], [1], [Do not build the float API])
152])
153
154AC_ARG_ENABLE([custom-modes],
155    [AS_HELP_STRING([--enable-custom-modes], [enable non-Opus modes, e.g. 44.1 kHz & 2^n frames])],,
156    [enable_custom_modes=no])
157
158AS_IF([test "$enable_custom_modes" = "yes"],[
159  AC_DEFINE([CUSTOM_MODES], [1], [Custom modes])
160  PC_BUILD="$PC_BUILD, custom modes"
161])
162
163AM_CONDITIONAL([CUSTOM_MODES], [test "$enable_custom_modes" = "yes"])
164
165has_float_approx=no
166#case "$host_cpu" in
167#i[[3456]]86 | x86_64 | powerpc64 | powerpc32 | ia64)
168#  has_float_approx=yes
169#  ;;
170#esac
171
172AC_ARG_ENABLE([float-approx],
173    [AS_HELP_STRING([--enable-float-approx], [enable fast approximations for floating point])],
174    [if test "$enable_float_approx" = "yes"; then
175       AC_WARN([Floating point approximations are not supported on all platforms.])
176     fi
177    ],
178    [enable_float_approx=$has_float_approx])
179
180AS_IF([test "$enable_float_approx" = "yes"],[
181  AC_DEFINE([FLOAT_APPROX], [1], [Float approximations])
182])
183
184AC_ARG_ENABLE([asm],
185    [AS_HELP_STRING([--disable-asm], [Disable assembly optimizations])],,
186    [enable_asm=yes])
187
188AC_ARG_ENABLE([rtcd],
189    [AS_HELP_STRING([--disable-rtcd], [Disable run-time CPU capabilities detection])],,
190    [enable_rtcd=yes])
191
192AC_ARG_ENABLE([intrinsics],
193    [AS_HELP_STRING([--disable-intrinsics], [Disable intrinsics optimizations])],,
194    [enable_intrinsics=yes])
195
196rtcd_support=no
197cpu_arm=no
198
199AS_IF([test x"${enable_asm}" = x"yes"],[
200    inline_optimization="No inline ASM for your platform, please send patches"
201    case $host_cpu in
202      arm*)
203        dnl Currently we only have asm for fixed-point
204        AS_IF([test "$enable_float" != "yes"],[
205            cpu_arm=yes
206            AC_DEFINE([OPUS_ARM_ASM], [],  [Make use of ARM asm optimization])
207            AS_GCC_INLINE_ASSEMBLY(
208                [inline_optimization="ARM"],
209                [inline_optimization="disabled"]
210            )
211            AS_ASM_ARM_EDSP([OPUS_ARM_INLINE_EDSP=1],[OPUS_ARM_INLINE_EDSP=0])
212            AS_ASM_ARM_MEDIA([OPUS_ARM_INLINE_MEDIA=1],
213                [OPUS_ARM_INLINE_MEDIA=0])
214            AS_ASM_ARM_NEON([OPUS_ARM_INLINE_NEON=1],[OPUS_ARM_INLINE_NEON=0])
215            AS_IF([test x"$inline_optimization" = x"ARM"],[
216                AM_CONDITIONAL([OPUS_ARM_INLINE_ASM],[true])
217                AC_DEFINE([OPUS_ARM_INLINE_ASM], 1,
218                    [Use generic ARMv4 inline asm optimizations])
219                AS_IF([test x"$OPUS_ARM_INLINE_EDSP" = x"1"],[
220                    AC_DEFINE([OPUS_ARM_INLINE_EDSP], [1],
221                        [Use ARMv5E inline asm optimizations])
222                    inline_optimization="$inline_optimization (EDSP)"
223                ])
224                AS_IF([test x"$OPUS_ARM_INLINE_MEDIA" = x"1"],[
225                    AC_DEFINE([OPUS_ARM_INLINE_MEDIA], [1],
226                        [Use ARMv6 inline asm optimizations])
227                    inline_optimization="$inline_optimization (Media)"
228                ])
229                AS_IF([test x"$OPUS_ARM_INLINE_NEON" = x"1"],[
230                    AC_DEFINE([OPUS_ARM_INLINE_NEON], 1,
231                        [Use ARM NEON inline asm optimizations])
232                    inline_optimization="$inline_optimization (NEON)"
233                ])
234            ])
235            dnl We need Perl to translate RVCT-syntax asm to gas syntax.
236            AC_CHECK_PROG([HAVE_PERL], perl, yes, no)
237            AS_IF([test x"$HAVE_PERL" = x"yes"],[
238                AM_CONDITIONAL([OPUS_ARM_EXTERNAL_ASM],[true])
239                asm_optimization="ARM"
240                AS_IF([test x"$OPUS_ARM_INLINE_EDSP" = x"1"], [
241                    OPUS_ARM_PRESUME_EDSP=1
242                    OPUS_ARM_MAY_HAVE_EDSP=1
243                ],
244                [
245                    OPUS_ARM_PRESUME_EDSP=0
246                    OPUS_ARM_MAY_HAVE_EDSP=0
247                ])
248                AS_IF([test x"$OPUS_ARM_INLINE_MEDIA" = x"1"], [
249                    OPUS_ARM_PRESUME_MEDIA=1
250                    OPUS_ARM_MAY_HAVE_MEDIA=1
251                ],
252                [
253                    OPUS_ARM_PRESUME_MEDIA=0
254                    OPUS_ARM_MAY_HAVE_MEDIA=0
255                ])
256                AS_IF([test x"$OPUS_ARM_INLINE_NEON" = x"1"], [
257                    OPUS_ARM_PRESUME_NEON=1
258                    OPUS_ARM_MAY_HAVE_NEON=1
259                ],
260                [
261                    OPUS_ARM_PRESUME_NEON=0
262                    OPUS_ARM_MAY_HAVE_NEON=0
263                ])
264                AS_IF([test x"$enable_rtcd" = x"yes"],[
265                    AS_IF([test x"$OPUS_ARM_MAY_HAVE_EDSP" != x"1"],[
266                        AC_MSG_NOTICE(
267                          [Trying to force-enable armv5e EDSP instructions...])
268                        AS_ASM_ARM_EDSP_FORCE([OPUS_ARM_MAY_HAVE_EDSP=1])
269                    ])
270                    AS_IF([test x"$OPUS_ARM_MAY_HAVE_MEDIA" != x"1"],[
271                        AC_MSG_NOTICE(
272                          [Trying to force-enable ARMv6 media instructions...])
273                        AS_ASM_ARM_MEDIA_FORCE([OPUS_ARM_MAY_HAVE_MEDIA=1])
274                    ])
275                    AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON" != x"1"],[
276                        AC_MSG_NOTICE(
277                          [Trying to force-enable NEON instructions...])
278                        AS_ASM_ARM_NEON_FORCE([OPUS_ARM_MAY_HAVE_NEON=1])
279                    ])
280                ])
281                rtcd_support=
282                AS_IF([test x"$OPUS_ARM_MAY_HAVE_EDSP" = x"1"],[
283                    AC_DEFINE(OPUS_ARM_MAY_HAVE_EDSP, 1,
284                        [Define if assembler supports EDSP instructions])
285                    AS_IF([test x"$OPUS_ARM_PRESUME_EDSP" = x"1"],[
286                        AC_DEFINE(OPUS_ARM_PRESUME_EDSP, 1,
287                          [Define if binary requires EDSP instruction support])
288                        asm_optimization="$asm_optimization (EDSP)"
289                    ],
290                        [rtcd_support="$rtcd_support (EDSP)"]
291                    )
292                ])
293                AC_SUBST(OPUS_ARM_MAY_HAVE_EDSP)
294                AS_IF([test x"$OPUS_ARM_MAY_HAVE_MEDIA" = x"1"],[
295                    AC_DEFINE(OPUS_ARM_MAY_HAVE_MEDIA, 1,
296                      [Define if assembler supports ARMv6 media instructions])
297                    AS_IF([test x"$OPUS_ARM_PRESUME_MEDIA" = x"1"],[
298                        AC_DEFINE(OPUS_ARM_PRESUME_MEDIA, 1,
299                          [Define if binary requires ARMv6 media instruction support])
300                        asm_optimization="$asm_optimization (Media)"
301                    ],
302                        [rtcd_support="$rtcd_support (Media)"]
303                    )
304                ])
305                AC_SUBST(OPUS_ARM_MAY_HAVE_MEDIA)
306                AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON" = x"1"],[
307                    AC_DEFINE(OPUS_ARM_MAY_HAVE_NEON, 1,
308                      [Define if compiler supports NEON instructions])
309                    AS_IF([test x"$OPUS_ARM_PRESUME_NEON" = x"1"], [
310                        AC_DEFINE(OPUS_ARM_PRESUME_NEON, 1,
311                          [Define if binary requires NEON instruction support])
312                        asm_optimization="$asm_optimization (NEON)"
313                    ],
314                        [rtcd_support="$rtcd_support (NEON)"]
315                    )
316                ])
317                AC_SUBST(OPUS_ARM_MAY_HAVE_NEON)
318                dnl Make sure turning on RTCD gets us at least one
319                dnl instruction set.
320                AS_IF([test x"$rtcd_support" != x""],
321                    [rtcd_support=ARM"$rtcd_support"],
322                    [rtcd_support="no"]
323                )
324                AC_MSG_CHECKING([for apple style tools])
325                AC_PREPROC_IFELSE([AC_LANG_PROGRAM([
326#ifndef __APPLE__
327#error 1
328#endif],[])],
329                    [AC_MSG_RESULT([yes]); ARM2GNU_PARAMS="--apple"],
330                    [AC_MSG_RESULT([no]); ARM2GNU_PARAMS=""])
331                AC_SUBST(ARM2GNU_PARAMS)
332            ],
333            [
334                AC_MSG_WARN(
335                  [*** ARM assembly requires perl -- disabling optimizations])
336                asm_optimization="(missing perl dependency for ARM)"
337            ])
338        ])
339        ;;
340    esac
341],[
342   inline_optimization="disabled"
343   asm_optimization="disabled"
344])
345
346AM_CONDITIONAL([OPUS_ARM_INLINE_ASM],
347    [test x"${inline_optimization%% *}" = x"ARM"])
348AM_CONDITIONAL([OPUS_ARM_EXTERNAL_ASM],
349    [test x"${asm_optimization%% *}" = x"ARM"])
350
351AM_CONDITIONAL([HAVE_SSE], [false])
352AM_CONDITIONAL([HAVE_SSE2], [false])
353AM_CONDITIONAL([HAVE_SSE4_1], [false])
354AM_CONDITIONAL([HAVE_AVX], [false])
355
356m4_define([DEFAULT_X86_SSE_CFLAGS], [-msse])
357m4_define([DEFAULT_X86_SSE2_CFLAGS], [-msse2])
358m4_define([DEFAULT_X86_SSE4_1_CFLAGS], [-msse4.1])
359m4_define([DEFAULT_X86_AVX_CFLAGS], [-mavx])
360m4_define([DEFAULT_ARM_NEON_INTR_CFLAGS], [-mfpu=neon])
361# With GCC on ARM32 softfp architectures (e.g. Android, or older Ubuntu) you need to specify
362# -mfloat-abi=softfp for -mfpu=neon to work.  However, on ARM32 hardfp architectures (e.g. newer Ubuntu),
363# this option will break things.
364
365# As a heuristic, if host matches arm*eabi* but not arm*hf*, it's probably soft-float.
366m4_define([DEFAULT_ARM_NEON_SOFTFP_INTR_CFLAGS], [-mfpu=neon -mfloat-abi=softfp])
367
368AS_CASE([$host],
369        [arm*hf*], [AS_VAR_SET([RESOLVED_DEFAULT_ARM_NEON_INTR_CFLAGS], "DEFAULT_ARM_NEON_INTR_CFLAGS")],
370        [arm*eabi*], [AS_VAR_SET([RESOLVED_DEFAULT_ARM_NEON_INTR_CFLAGS], "DEFAULT_ARM_NEON_SOFTFP_INTR_CFLAGS")],
371        [AS_VAR_SET([RESOLVED_DEFAULT_ARM_NEON_INTR_CFLAGS], "DEFAULT_ARM_NEON_INTR_CFLAGS")])
372
373AC_ARG_VAR([X86_SSE_CFLAGS], [C compiler flags to compile SSE intrinsics @<:@default=]DEFAULT_X86_SSE_CFLAGS[@:>@])
374AC_ARG_VAR([X86_SSE2_CFLAGS], [C compiler flags to compile SSE2 intrinsics @<:@default=]DEFAULT_X86_SSE2_CFLAGS[@:>@])
375AC_ARG_VAR([X86_SSE4_1_CFLAGS], [C compiler flags to compile SSE4.1 intrinsics @<:@default=]DEFAULT_X86_SSE4_1_CFLAGS[@:>@])
376AC_ARG_VAR([X86_AVX_CFLAGS], [C compiler flags to compile AVX intrinsics @<:@default=]DEFAULT_X86_AVX_CFLAGS[@:>@])
377AC_ARG_VAR([ARM_NEON_INTR_CFLAGS], [C compiler flags to compile ARM NEON intrinsics @<:@default=]DEFAULT_ARM_NEON_INTR_CFLAGS / DEFAULT_ARM_NEON_SOFTFP_INTR_CFLAGS[@:>@])
378
379AS_VAR_SET_IF([X86_SSE_CFLAGS], [], [AS_VAR_SET([X86_SSE_CFLAGS], "DEFAULT_X86_SSE_CFLAGS")])
380AS_VAR_SET_IF([X86_SSE2_CFLAGS], [], [AS_VAR_SET([X86_SSE2_CFLAGS], "DEFAULT_X86_SSE2_CFLAGS")])
381AS_VAR_SET_IF([X86_SSE4_1_CFLAGS], [], [AS_VAR_SET([X86_SSE4_1_CFLAGS], "DEFAULT_X86_SSE4_1_CFLAGS")])
382AS_VAR_SET_IF([X86_AVX_CFLAGS], [], [AS_VAR_SET([X86_AVX_CFLAGS], "DEFAULT_X86_AVX_CFLAGS")])
383AS_VAR_SET_IF([ARM_NEON_INTR_CFLAGS], [], [AS_VAR_SET([ARM_NEON_INTR_CFLAGS], ["$RESOLVED_DEFAULT_ARM_NEON_INTR_CFLAGS"])])
384
385AC_DEFUN([OPUS_PATH_NE10],
386   [
387      AC_ARG_WITH(NE10,
388                  AC_HELP_STRING([--with-NE10=PFX],[Prefix where libNE10 is installed (optional)]),
389                  NE10_prefix="$withval", NE10_prefix="")
390      AC_ARG_WITH(NE10-libraries,
391                  AC_HELP_STRING([--with-NE10-libraries=DIR],
392                        [Directory where libNE10 library is installed (optional)]),
393                  NE10_libraries="$withval", NE10_libraries="")
394      AC_ARG_WITH(NE10-includes,
395                  AC_HELP_STRING([--with-NE10-includes=DIR],
396                                 [Directory where libNE10 header files are installed (optional)]),
397                  NE10_includes="$withval", NE10_includes="")
398
399      if test "x$NE10_libraries" != "x" ; then
400         NE10_LIBS="-L$NE10_libraries"
401      elif test "x$NE10_prefix" = "xno" || test "x$NE10_prefix" = "xyes" ; then
402         NE10_LIBS=""
403      elif test "x$NE10_prefix" != "x" ; then
404         NE10_LIBS="-L$NE10_prefix/lib"
405      elif test "x$prefix" != "xNONE" ; then
406         NE10_LIBS="-L$prefix/lib"
407      fi
408
409      if test "x$NE10_prefix" != "xno" ; then
410         NE10_LIBS="$NE10_LIBS -lNE10"
411      fi
412
413      if test "x$NE10_includes" != "x" ; then
414         NE10_CFLAGS="-I$NE10_includes"
415      elif test "x$NE10_prefix" = "xno" || test "x$NE10_prefix" = "xyes" ; then
416         NE10_CFLAGS=""
417      elif test "x$NE10_prefix" != "x" ; then
418         NE10_CFLAGS="-I$NE10_prefix/include"
419      elif test "x$prefix" != "xNONE"; then
420         NE10_CFLAGS="-I$prefix/include"
421      fi
422
423      AC_MSG_CHECKING(for NE10)
424      save_CFLAGS="$CFLAGS"; CFLAGS="$CFLAGS $NE10_CFLAGS"
425      save_LIBS="$LIBS"; LIBS="$LIBS $NE10_LIBS $LIBM"
426      AC_LINK_IFELSE(
427         [
428            AC_LANG_PROGRAM(
429               [[#include <NE10_dsp.h>
430               ]],
431               [[
432                  ne10_fft_cfg_float32_t cfg;
433                  cfg = ne10_fft_alloc_c2c_float32_neon(480);
434               ]]
435            )
436         ],[
437            HAVE_ARM_NE10=1
438            AC_MSG_RESULT([yes])
439         ],[
440            HAVE_ARM_NE10=0
441            AC_MSG_RESULT([no])
442            NE10_CFLAGS=""
443            NE10_LIBS=""
444         ]
445      )
446      CFLAGS="$save_CFLAGS"; LIBS="$save_LIBS"
447      #Now we know if libNE10 is installed or not
448      AS_IF([test x"$HAVE_ARM_NE10" = x"1"],
449         [
450            AC_DEFINE([HAVE_ARM_NE10], 1, [NE10 library is installed on host. Make sure it is on target!])
451            AC_SUBST(HAVE_ARM_NE10)
452            AC_SUBST(NE10_CFLAGS)
453            AC_SUBST(NE10_LIBS)
454         ]
455      )
456   ]
457)
458
459AS_IF([test x"$enable_intrinsics" = x"yes"],[
460   intrinsics_support=""
461   AS_CASE([$host_cpu],
462   [arm*|aarch64*],
463   [
464      cpu_arm=yes
465      OPUS_CHECK_INTRINSICS(
466         [ARM Neon],
467         [$ARM_NEON_INTR_CFLAGS],
468         [OPUS_ARM_MAY_HAVE_NEON_INTR],
469         [OPUS_ARM_PRESUME_NEON_INTR],
470         [[#include <arm_neon.h>
471         ]],
472         [[
473            static float32x4_t A0, A1, SUMM;
474            SUMM = vmlaq_f32(SUMM, A0, A1);
475            return (int)vgetq_lane_f32(SUMM, 0);
476         ]]
477      )
478      AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1" && test x"$OPUS_ARM_PRESUME_NEON_INTR" != x"1"],
479          [
480             OPUS_ARM_NEON_INTR_CFLAGS="$ARM_NEON_INTR_CFLAGS"
481             AC_SUBST([OPUS_ARM_NEON_INTR_CFLAGS])
482          ]
483      )
484
485      AS_IF([test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1"],
486      [
487         AC_DEFINE([OPUS_ARM_MAY_HAVE_NEON_INTR], 1, [Compiler supports ARMv7/Aarch64 Neon Intrinsics])
488         intrinsics_support="$intrinsics_support (NEON)"
489
490         AS_IF([test x"$enable_rtcd" != x"no" && test x"$OPUS_ARM_PRESUME_NEON_INTR" != x"1"],
491            [AS_IF([test x"$rtcd_support" = x"no"],
492               [rtcd_support="ARM (NEON Intrinsics)"],
493               [rtcd_support="$rtcd_support (NEON Intrinsics)"])])
494
495         AS_IF([test x"$OPUS_ARM_PRESUME_NEON_INTR" = x"1"],
496            [AC_DEFINE([OPUS_ARM_PRESUME_NEON_INTR], 1, [Define if binary requires NEON intrinsics support])])
497
498         OPUS_PATH_NE10()
499         AS_IF([test x"$NE10_LIBS" != x""],
500         [
501              intrinsics_support="$intrinsics_support (NE10)"
502              AS_IF([test x"enable_rtcd" != x"" \
503               && test x"$OPUS_ARM_PRESUME_NEON_INTR" != x"1"],
504                 [rtcd_support="$rtcd_support (NE10)"])
505         ])
506
507         OPUS_CHECK_INTRINSICS(
508            [Aarch64 Neon],
509            [$ARM_NEON_INTR_CFLAGS],
510            [OPUS_ARM_MAY_HAVE_AARCH64_NEON_INTR],
511            [OPUS_ARM_PRESUME_AARCH64_NEON_INTR],
512            [[#include <arm_neon.h>
513            ]],
514            [[
515               static int32_t IN;
516               static int16_t OUT;
517               OUT = vqmovns_s32(IN);
518            ]]
519         )
520
521         AS_IF([test x"$OPUS_ARM_PRESUME_AARCH64_NEON_INTR" = x"1"],
522         [
523            AC_DEFINE([OPUS_ARM_PRESUME_AARCH64_NEON_INTR], 1, [Define if binary requires Aarch64 Neon Intrinsics])
524            intrinsics_support="$intrinsics_support (NEON [Aarch64])"
525         ])
526
527         AS_IF([test x"$intrinsics_support" = x""],
528            [intrinsics_support=no],
529            [intrinsics_support="ARM$intrinsics_support"])
530      ],
531      [
532         AC_MSG_WARN([Compiler does not support ARM intrinsics])
533         intrinsics_support=no
534      ])
535   ],
536   [i?86|x86_64],
537   [
538      OPUS_CHECK_INTRINSICS(
539         [SSE],
540         [$X86_SSE_CFLAGS],
541         [OPUS_X86_MAY_HAVE_SSE],
542         [OPUS_X86_PRESUME_SSE],
543         [[#include <xmmintrin.h>
544           #include <time.h>
545         ]],
546         [[
547             __m128 mtest;
548             mtest = _mm_set1_ps((float)time(NULL));
549             mtest = _mm_mul_ps(mtest, mtest);
550             return _mm_cvtss_si32(mtest);
551         ]]
552      )
553      AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE" = x"1" && test x"$OPUS_X86_PRESUME_SSE" != x"1"],
554          [
555             OPUS_X86_SSE_CFLAGS="$X86_SSE_CFLAGS"
556             AC_SUBST([OPUS_X86_SSE_CFLAGS])
557          ]
558      )
559      OPUS_CHECK_INTRINSICS(
560         [SSE2],
561         [$X86_SSE2_CFLAGS],
562         [OPUS_X86_MAY_HAVE_SSE2],
563         [OPUS_X86_PRESUME_SSE2],
564         [[#include <emmintrin.h>
565           #include <time.h>
566         ]],
567         [[
568            __m128i mtest;
569            mtest = _mm_set1_epi32((int)time(NULL));
570            mtest = _mm_mul_epu32(mtest, mtest);
571            return _mm_cvtsi128_si32(mtest);
572         ]]
573      )
574      AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1" && test x"$OPUS_X86_PRESUME_SSE2" != x"1"],
575          [
576             OPUS_X86_SSE2_CFLAGS="$X86_SSE2_CFLAGS"
577             AC_SUBST([OPUS_X86_SSE2_CFLAGS])
578          ]
579      )
580      OPUS_CHECK_INTRINSICS(
581         [SSE4.1],
582         [$X86_SSE4_1_CFLAGS],
583         [OPUS_X86_MAY_HAVE_SSE4_1],
584         [OPUS_X86_PRESUME_SSE4_1],
585         [[#include <smmintrin.h>
586           #include <time.h>
587         ]],
588         [[
589            __m128i mtest;
590            mtest = _mm_set1_epi32((int)time(NULL));
591            mtest = _mm_mul_epi32(mtest, mtest);
592            return _mm_cvtsi128_si32(mtest);
593         ]]
594      )
595      AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1" && test x"$OPUS_X86_PRESUME_SSE4_1" != x"1"],
596          [
597             OPUS_X86_SSE4_1_CFLAGS="$X86_SSE4_1_CFLAGS"
598             AC_SUBST([OPUS_X86_SSE4_1_CFLAGS])
599          ]
600      )
601      OPUS_CHECK_INTRINSICS(
602         [AVX],
603         [$X86_AVX_CFLAGS],
604         [OPUS_X86_MAY_HAVE_AVX],
605         [OPUS_X86_PRESUME_AVX],
606         [[#include <immintrin.h>
607           #include <time.h>
608         ]],
609         [[
610             __m256 mtest;
611             mtest = _mm256_set1_ps((float)time(NULL));
612             mtest = _mm256_addsub_ps(mtest, mtest);
613             return _mm_cvtss_si32(_mm256_extractf128_ps(mtest, 0));
614         ]]
615      )
616      AS_IF([test x"$OPUS_X86_MAY_HAVE_AVX" = x"1" && test x"$OPUS_X86_PRESUME_AVX" != x"1"],
617          [
618             OPUS_X86_AVX_CFLAGS="$X86_AVX_CFLAGS"
619             AC_SUBST([OPUS_X86_AVX_CFLAGS])
620          ]
621      )
622         AS_IF([test x"$rtcd_support" = x"no"], [rtcd_support=""])
623         AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE" = x"1"],
624         [
625            AC_DEFINE([OPUS_X86_MAY_HAVE_SSE], 1, [Compiler supports X86 SSE Intrinsics])
626            intrinsics_support="$intrinsics_support SSE"
627
628            AS_IF([test x"$OPUS_X86_PRESUME_SSE" = x"1"],
629               [AC_DEFINE([OPUS_X86_PRESUME_SSE], 1, [Define if binary requires SSE intrinsics support])],
630               [rtcd_support="$rtcd_support SSE"])
631         ],
632         [
633            AC_MSG_WARN([Compiler does not support SSE intrinsics])
634         ])
635
636         AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1"],
637         [
638            AC_DEFINE([OPUS_X86_MAY_HAVE_SSE2], 1, [Compiler supports X86 SSE2 Intrinsics])
639            intrinsics_support="$intrinsics_support SSE2"
640
641            AS_IF([test x"$OPUS_X86_PRESUME_SSE2" = x"1"],
642               [AC_DEFINE([OPUS_X86_PRESUME_SSE2], 1, [Define if binary requires SSE2 intrinsics support])],
643               [rtcd_support="$rtcd_support SSE2"])
644         ],
645         [
646            AC_MSG_WARN([Compiler does not support SSE2 intrinsics])
647         ])
648
649         AS_IF([test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1"],
650         [
651            AC_DEFINE([OPUS_X86_MAY_HAVE_SSE4_1], 1, [Compiler supports X86 SSE4.1 Intrinsics])
652            intrinsics_support="$intrinsics_support SSE4.1"
653
654            AS_IF([test x"$OPUS_X86_PRESUME_SSE4_1" = x"1"],
655               [AC_DEFINE([OPUS_X86_PRESUME_SSE4_1], 1, [Define if binary requires SSE4.1 intrinsics support])],
656               [rtcd_support="$rtcd_support SSE4.1"])
657         ],
658         [
659            AC_MSG_WARN([Compiler does not support SSE4.1 intrinsics])
660         ])
661         AS_IF([test x"$OPUS_X86_MAY_HAVE_AVX" = x"1"],
662         [
663            AC_DEFINE([OPUS_X86_MAY_HAVE_AVX], 1, [Compiler supports X86 AVX Intrinsics])
664            intrinsics_support="$intrinsics_support AVX"
665
666            AS_IF([test x"$OPUS_X86_PRESUME_AVX" = x"1"],
667               [AC_DEFINE([OPUS_X86_PRESUME_AVX], 1, [Define if binary requires AVX intrinsics support])],
668               [rtcd_support="$rtcd_support AVX"])
669         ],
670         [
671            AC_MSG_WARN([Compiler does not support AVX intrinsics])
672         ])
673
674         AS_IF([test x"$intrinsics_support" = x""],
675            [intrinsics_support=no],
676            [intrinsics_support="x86$intrinsics_support"]
677         )
678         AS_IF([test x"$rtcd_support" = x""],
679            [rtcd_support=no],
680            [rtcd_support="x86$rtcd_support"],
681        )
682
683    AS_IF([test x"$enable_rtcd" = x"yes" && test x"$rtcd_support" != x""],[
684            get_cpuid_by_asm="no"
685            AC_MSG_CHECKING([How to get X86 CPU Info])
686            AC_LINK_IFELSE([AC_LANG_PROGRAM([[
687                 #include <stdio.h>
688            ]],[[
689                 unsigned int CPUInfo0;
690                 unsigned int CPUInfo1;
691                 unsigned int CPUInfo2;
692                 unsigned int CPUInfo3;
693                 unsigned int InfoType;
694                 __asm__ __volatile__ (
695                 "cpuid":
696                 "=a" (CPUInfo0),
697                 "=b" (CPUInfo1),
698                 "=c" (CPUInfo2),
699                 "=d" (CPUInfo3) :
700                 "a" (InfoType), "c" (0)
701                );
702            ]])],
703            [get_cpuid_by_asm="yes"
704             AC_MSG_RESULT([Inline Assembly])
705                 AC_DEFINE([CPU_INFO_BY_ASM], [1], [Get CPU Info by asm method])],
706             [AC_LINK_IFELSE([AC_LANG_PROGRAM([[
707                 #include <cpuid.h>
708            ]],[[
709                 unsigned int CPUInfo0;
710                 unsigned int CPUInfo1;
711                 unsigned int CPUInfo2;
712                 unsigned int CPUInfo3;
713                 unsigned int InfoType;
714                 __get_cpuid(InfoType, &CPUInfo0, &CPUInfo1, &CPUInfo2, &CPUInfo3);
715            ]])],
716            [AC_MSG_RESULT([C method])
717                 AC_DEFINE([CPU_INFO_BY_C], [1], [Get CPU Info by c method])],
718            [AC_MSG_ERROR([no supported Get CPU Info method, please disable run-time CPU capabilities detection or intrinsics])])])])
719   ],
720   [
721      AC_MSG_WARN([No intrinsics support for your architecture])
722      intrinsics_support="no"
723   ])
724],
725[
726   intrinsics_support="no"
727])
728
729AM_CONDITIONAL([CPU_ARM], [test "$cpu_arm" = "yes"])
730AM_CONDITIONAL([HAVE_ARM_NEON_INTR],
731    [test x"$OPUS_ARM_MAY_HAVE_NEON_INTR" = x"1"])
732AM_CONDITIONAL([HAVE_ARM_NE10],
733    [test x"$HAVE_ARM_NE10" = x"1"])
734AM_CONDITIONAL([HAVE_SSE],
735    [test x"$OPUS_X86_MAY_HAVE_SSE" = x"1"])
736AM_CONDITIONAL([HAVE_SSE2],
737    [test x"$OPUS_X86_MAY_HAVE_SSE2" = x"1"])
738AM_CONDITIONAL([HAVE_SSE4_1],
739    [test x"$OPUS_X86_MAY_HAVE_SSE4_1" = x"1"])
740AM_CONDITIONAL([HAVE_AVX],
741    [test x"$OPUS_X86_MAY_HAVE_AVX" = x"1"])
742
743AS_IF([test x"$enable_rtcd" = x"yes"],[
744    AS_IF([test x"$rtcd_support" != x"no"],[
745        AC_DEFINE([OPUS_HAVE_RTCD], [1],
746            [Use run-time CPU capabilities detection])
747        OPUS_HAVE_RTCD=1
748        AC_SUBST(OPUS_HAVE_RTCD)
749    ])
750],[
751    rtcd_support="disabled"
752])
753
754AC_ARG_ENABLE([assertions],
755    [AS_HELP_STRING([--enable-assertions],[enable additional software error checking])],,
756    [enable_assertions=no])
757
758AS_IF([test "$enable_assertions" = "yes"], [
759  AC_DEFINE([ENABLE_ASSERTIONS], [1], [Assertions])
760])
761
762AC_ARG_ENABLE([hardening],
763    [AS_HELP_STRING([--disable-hardening],[disable run-time checks that are cheap and safe for use in production])],,
764    [enable_hardening=yes])
765
766AS_IF([test "$enable_hardening" = "yes"], [
767  AC_DEFINE([ENABLE_HARDENING], [1], [Hardening])
768])
769
770AC_ARG_ENABLE([fuzzing],
771	      [AS_HELP_STRING([--enable-fuzzing],[causes the encoder to make random decisions (do not use in production)])],,
772    [enable_fuzzing=no])
773
774AS_IF([test "$enable_fuzzing" = "yes"], [
775  AC_DEFINE([FUZZING], [1], [Fuzzing])
776])
777
778AC_ARG_ENABLE([check-asm],
779    [AS_HELP_STRING([--enable-check-asm],
780                    [enable bit-exactness checks between optimized and c implementations])],,
781    [enable_check_asm=no])
782
783AS_IF([test "$enable_check_asm" = "yes"], [
784  AC_DEFINE([OPUS_CHECK_ASM], [1], [Run bit-exactness checks between optimized and c implementations])
785])
786
787AC_ARG_ENABLE([doc],
788    [AS_HELP_STRING([--disable-doc], [Do not build API documentation])],,
789    [enable_doc=yes])
790
791AS_IF([test "$enable_doc" = "yes"], [
792  AC_CHECK_PROG(HAVE_DOXYGEN, [doxygen], [yes], [no])
793  AC_CHECK_PROG(HAVE_DOT, [dot], [yes], [no])
794],[
795  HAVE_DOXYGEN=no
796])
797
798AM_CONDITIONAL([HAVE_DOXYGEN], [test "$HAVE_DOXYGEN" = "yes"])
799
800AC_ARG_ENABLE([extra-programs],
801    [AS_HELP_STRING([--disable-extra-programs], [Do not build extra programs (demo and tests)])],,
802    [enable_extra_programs=yes])
803
804AM_CONDITIONAL([EXTRA_PROGRAMS], [test "$enable_extra_programs" = "yes"])
805
806
807AC_ARG_ENABLE([rfc8251],
808	      AS_HELP_STRING([--disable-rfc8251], [Disable bitstream fixes from RFC 8251]),,
809  [enable_rfc8251=yes])
810
811AS_IF([test "$enable_rfc8251" = "no"], [
812       AC_DEFINE([DISABLE_UPDATE_DRAFT], [1], [Disable bitstream fixes from RFC 8251])
813])
814
815
816saved_CFLAGS="$CFLAGS"
817CFLAGS="$CFLAGS -fvisibility=hidden"
818AC_MSG_CHECKING([if ${CC} supports -fvisibility=hidden])
819AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
820    [ AC_MSG_RESULT([yes]) ],
821    [ AC_MSG_RESULT([no])
822      CFLAGS="$saved_CFLAGS"
823    ])
824
825on_x86=no
826case "$host_cpu" in
827i[[3456]]86 | x86_64)
828  on_x86=yes
829  ;;
830esac
831
832on_windows=no
833case $host in
834*cygwin*|*mingw*)
835  on_windows=yes
836  ;;
837esac
838
839dnl Enable stack-protector-all only on x86 where it's well supported.
840dnl on some platforms it causes crashes. Hopefully the OS's default's
841dnl include this on platforms that work but have been missed here.
842AC_ARG_ENABLE([stack-protector],
843    [AS_HELP_STRING([--disable-stack-protector],[Disable compiler stack hardening])],,
844    [
845      AS_IF([test "$ac_cv_c_compiler_gnu" = "yes" && test "$on_x86" = "yes" && test "$on_windows" = "no"],
846            [enable_stack_protector=yes],[enable_stack_protector=no])
847    ])
848
849AS_IF([test "$enable_stack_protector" = "yes"],
850 [
851  saved_CFLAGS="$CFLAGS"
852  CFLAGS="$CFLAGS -fstack-protector-strong"
853  AC_MSG_CHECKING([if ${CC} supports -fstack-protector-strong])
854  AC_LINK_IFELSE([AC_LANG_PROGRAM([],[[char foo;]])],
855    [ AC_MSG_RESULT([yes]) ],
856    [
857      AC_MSG_RESULT([no])
858      enable_stack_protector=no
859      CFLAGS="$saved_CFLAGS"
860    ])
861 ])
862
863AS_IF([test x$ac_cv_c_compiler_gnu = xyes],
864    [AX_ADD_FORTIFY_SOURCE]
865)
866
867CFLAGS="$CFLAGS -W"
868
869warn_CFLAGS="-Wall -Wextra -Wcast-align -Wnested-externs -Wshadow -Wstrict-prototypes"
870saved_CFLAGS="$CFLAGS"
871CFLAGS="$CFLAGS $warn_CFLAGS"
872AC_MSG_CHECKING([if ${CC} supports ${warn_CFLAGS}])
873AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
874    [ AC_MSG_RESULT([yes]) ],
875    [ AC_MSG_RESULT([no])
876      CFLAGS="$saved_CFLAGS"
877    ])
878
879saved_LIBS="$LIBS"
880LIBS="$LIBS $LIBM"
881AC_CHECK_FUNCS([lrintf])
882AC_CHECK_FUNCS([lrint])
883LIBS="$saved_LIBS"
884
885AC_CHECK_FUNCS([__malloc_hook])
886
887AC_SUBST([PC_BUILD])
888
889AC_CONFIG_FILES([
890    Makefile
891    opus.pc
892    opus-uninstalled.pc
893    celt/arm/armopts.s
894    doc/Makefile
895    doc/Doxyfile
896])
897AC_CONFIG_HEADERS([config.h])
898
899AC_OUTPUT
900
901AC_MSG_NOTICE([
902------------------------------------------------------------------------
903  $PACKAGE_NAME $PACKAGE_VERSION:  Automatic configuration OK.
904
905    Compiler support:
906
907      C99 var arrays: ................ ${has_var_arrays}
908      C99 lrintf: .................... ${ac_cv_func_lrintf}
909      Use alloca: .................... ${use_alloca}
910
911    General configuration:
912
913      Floating point support: ........ ${enable_float}
914      Fast float approximations: ..... ${enable_float_approx}
915      Fixed point debugging: ......... ${enable_fixed_point_debug}
916      Inline Assembly Optimizations: . ${inline_optimization}
917      External Assembly Optimizations: ${asm_optimization}
918      Intrinsics Optimizations: ...... ${intrinsics_support}
919      Run-time CPU detection: ........ ${rtcd_support}
920      Custom modes: .................. ${enable_custom_modes}
921      Assertion checking: ............ ${enable_assertions}
922      Hardening: ..................... ${enable_hardening}
923      Fuzzing: ....................... ${enable_fuzzing}
924      Check ASM: ..................... ${enable_check_asm}
925
926      API documentation: ............. ${enable_doc}
927      Extra programs: ................ ${enable_extra_programs}
928------------------------------------------------------------------------
929
930 Type "make; make install" to compile and install
931 Type "make check" to run the test suite
932])
933
934