diff options
author | Tim-Philipp Müller <tim@centricular.com> | 2016-03-19 15:40:22 +0000 |
---|---|---|
committer | Nirbheek Chauhan <nirbheek@centricular.com> | 2020-10-28 22:29:08 +0530 |
commit | c2b542b6c02bafbe7a83b2eeec6cb5a0bfa3ed0d (patch) | |
tree | d788ad2c57bd1ccaae6aa73dced21c83c59df1b1 /meson.build | |
parent | 034c1b61a250457649d788bbf983b3f0fb63f02e (diff) | |
download | libopus-c2b542b6c02bafbe7a83b2eeec6cb5a0bfa3ed0d.tar.gz |
Add support for Meson build system
Tested on:
- Linux/x86* with gcc
- Android armv7 arm64 x86 x86_64 with clang
- Windows x86 x86_64 with Visual Studio 2017
- Windows x86 x86_64 with MinGW
- macOS x86_64 with clang
- iOS arm64 x86_64 with clang
Co-authored by: Nirbheek Chauhan <nirbheek@centricular.com>
https://gitlab.xiph.org/xiph/opus/-/merge_requests/13
Diffstat (limited to 'meson.build')
-rw-r--r-- | meson.build | 673 |
1 files changed, 673 insertions, 0 deletions
diff --git a/meson.build b/meson.build new file mode 100644 index 00000000..45fff3f2 --- /dev/null +++ b/meson.build @@ -0,0 +1,673 @@ +project('opus', 'c', + version: run_command('meson/get-version.py', '--package-version', check: true).stdout().strip(), + meson_version: '>=0.54.0', + default_options: ['warning_level=2', + 'c_std=gnu99', + 'buildtype=debugoptimized']) + +libversion = run_command('meson/get-version.py', '--libtool-version', check: true).stdout().strip() +macosversion = run_command('meson/get-version.py', '--darwin-version', check: true).stdout().strip() + +cc = meson.get_compiler('c') +host_system = host_machine.system() +host_cpu_family = host_machine.cpu_family() + +opus_includes = include_directories('.', 'include', 'celt', 'silk') +opus_public_includes = include_directories('include') + +add_project_arguments('-DOPUS_BUILD', language: 'c') +add_project_arguments('-DHAVE_CONFIG_H', language: 'c') + +if host_system == 'windows' + if cc.get_argument_syntax() == 'msvc' + add_project_arguments('-D_CRT_SECURE_NO_WARNINGS', language: 'c') + endif +endif + +if cc.get_argument_syntax() == 'gnu' + add_project_arguments('-D_FORTIFY_SOURCE=2', language: 'c') +endif + +# Check for extra compiler args +additional_c_args = [] +if cc.get_argument_syntax() != 'msvc' + additional_c_args += [ + '-fvisibility=hidden', + '-Wcast-align', + '-Wnested-externs', + '-Wshadow', + '-Wstrict-prototypes', + ] + + # On Windows, -fstack-protector-strong adds a libssp-0.dll dependency and + # prevents static linking + if host_system != 'windows' + additional_c_args += ['-fstack-protector-strong'] + endif +endif + +foreach arg : additional_c_args + if cc.has_argument(arg) + add_project_arguments(arg, language: 'c') + endif +endforeach + +# Windows MSVC warnings +if cc.get_id() == 'msvc' + # Ignore several spurious warnings. + # If a warning is completely useless and spammy, use '/wdXXXX' to suppress it + # If a warning is harmless but hard to fix, use '/woXXXX' so it's shown once + # NOTE: Only add warnings here if you are sure they're spurious + add_project_arguments('/wd4035', '/wd4715', '/wd4116', '/wd4046', '/wd4068', + '/wd4820', '/wd4244', '/wd4255', '/wd4668', + language : 'c') +endif + +opus_version = meson.project_version() + +opus_conf = configuration_data() +opus_conf.set('PACKAGE_BUGREPORT', '"opus@xiph.org"') +opus_conf.set('PACKAGE_NAME', '"opus"') +opus_conf.set('PACKAGE_STRING', '"opus @0@"'.format(opus_version)) +opus_conf.set('PACKAGE_TARNAME', '"opus"') +opus_conf.set('PACKAGE_URL', '""') +opus_conf.set('PACKAGE_VERSION', '"@0@"'.format(opus_version)) + +# FIXME: optional Ne10 dependency +have_arm_ne10 = false + +libm = cc.find_library('m', required : false) + +opus_conf.set('HAVE_LRINTF', cc.has_function('lrintf', prefix: '#include <math.h>', dependencies: libm)) +opus_conf.set('HAVE_LRINT', cc.has_function('lrint', prefix: '#include <math.h>', dependencies: libm)) +opus_conf.set('HAVE___MALLOC_HOOK', cc.has_function('__malloc_hook', prefix: '#include <malloc.h>')) +opus_conf.set('HAVE_STDINT_H', cc.check_header('stdint.h')) + +# Check for restrict keyword +restrict_tmpl = ''' +typedef int * int_ptr; +int foo (int_ptr @0@ ip, int * @0@ baz[]) { + return ip[0]; +} +int main (int argc, char ** argv) { + int s[1]; + int * @0@ t = s; + t[0] = 0; + return foo(t, (void *)0); +}''' +# Define restrict to the equivalent of the C99 restrict keyword, or to +# nothing if this is not supported. Do not define if restrict is +# supported directly. +if not cc.compiles(restrict_tmpl.format('restrict'), name : 'restrict keyword') + if cc.compiles(restrict_tmpl.format('__restrict'), name : '__restrict') + opus_conf.set('restrict', '__restrict') + elif cc.compiles(restrict_tmpl.format('__restrict__'), name : '__restrict__') + opus_conf.set('restrict', '__restrict') + elif cc.compiles(restrict_tmpl.format('_Restrict'), name : '_Restrict') + opus_conf.set('restrict', '_Restrict') + else + opus_conf.set('restrict', '/**/') + endif +endif + +# Check for C99 variable-size arrays, or alloca() as fallback +msg_use_alloca = false +if cc.compiles('''static int x; + char some_func (void) { + char a[++x]; + a[sizeof a - 1] = 0; + int N; + return a[0]; + }''', name : 'C99 variable-size arrays') + opus_conf.set('VAR_ARRAYS', 1) + msg_use_alloca = 'NO (using C99 variable-size arrays instead)' +elif cc.compiles('''#include <alloca.h> + void some_func (void) { + int foo=10; + int * array = alloca(foo); + }''', name : 'alloca (alloca.h)') + opus_conf.set('USE_ALLOCA', true) + opus_conf.set('HAVE_ALLOCA_H', true) + msg_use_alloca = true +elif cc.compiles('''#include <malloc.h> + #include <stdlib.h> + void some_func (void) { + int foo=10; + int * array = alloca(foo); + }''', name : 'alloca (std)') + opus_conf.set('USE_ALLOCA', true) + msg_use_alloca = true +endif + +opts = [ + [ 'fixed-point', 'FIXED_POINT' ], + [ 'fixed-point-debug', 'FIXED_DEBUG' ], + [ 'custom-modes', 'CUSTOM_MODES' ], + [ 'float-approx', 'FLOAT_APPROX' ], + [ 'assertions', 'ENABLE_ASSERTIONS' ], + [ 'hardening', 'ENABLE_HARDENING' ], + [ 'fuzzing', 'FUZZING' ], + [ 'check-asm', 'OPUS_CHECK_ASM' ], +] + +foreach opt : opts + # we assume these are all boolean options + opt_foo = get_option(opt[0]) + if opt_foo + opus_conf.set(opt[1], 1) + endif + set_variable('opt_' + opt[0].underscorify(), opt_foo) +endforeach + +opt_asm = get_option('asm') +opt_rtcd = get_option('rtcd') +opt_intrinsics = get_option('intrinsics') +extra_programs = get_option('extra-programs') +opt_tests = get_option('tests') + +disable_float_api = not get_option('float-api') +if disable_float_api + opus_conf.set('DISABLE_FLOAT_API', 1) +endif + +# This is for the description in the pkg-config .pc file +if opt_fixed_point + pc_build = 'fixed-point' +else + pc_build = 'floating-point' +endif +if opt_custom_modes + pc_build = pc_build + ', custom modes' +endif + +rtcd_support = [] +# With GCC, Clang, ICC, etc, we differentiate between 'may support this SIMD' +# and 'presume we have this SIMD' by checking whether the SIMD / intrinsics can +# be compiled by the compiler as-is (presume) or with SIMD cflags (may have). +# With MSVC, the compiler will always build SIMD/intrinsics targeting all +# specific instruction sets supported by that version of the compiler. No +# special arguments are ever needed. If runtime CPU detection is not disabled, +# we must always assume that we only 'may have' it. +opus_can_presume_simd = true +if cc.get_argument_syntax() == 'msvc' + if opt_rtcd.disabled() + warning('Building with an MSVC-like compiler and runtime CPU detection is disabled. Outputs may not run on all @0@ CPUs.'.format(host_cpu_family)) + else + opus_can_presume_simd = false + endif +endif + +opus_arm_external_asm = false + +asm_tmpl = ''' +int main (int argc, char ** argv) { + __asm__("@0@"); + return 0; +}''' + +asm_optimization = [] +inline_optimization = [] +if not opt_asm.disabled() + # Currently we only have inline asm for fixed-point + if host_cpu_family == 'arm' and opt_fixed_point + opus_conf.set('OPUS_ARM_ASM', true) + + # Check if compiler supports gcc-style inline assembly + if cc.compiles('''#ifdef __GNUC_MINOR__ + #if (__GNUC__ * 1000 + __GNUC_MINOR__) < 3004 + #error GCC before 3.4 has critical bugs compiling inline assembly + #endif + #endif + __asm__ (""::)''', + name : 'compiler supports gcc-style inline assembly') + + opus_conf.set('OPUS_ARM_INLINE_ASM', 1) + + # AS_ASM_ARM_EDSP + if cc.compiles(asm_tmpl.format('qadd r3,r3,r3'), + name : 'assembler supports EDSP instructions on ARM') + opus_conf.set('OPUS_ARM_INLINE_EDSP', 1) + inline_optimization += ['ESDP'] + endif + + # AS_ASM_ARM_MEDIA + if cc.compiles(asm_tmpl.format('shadd8 r3,r3,r3'), + name : 'assembler supports ARMv6 media instructions on ARM') + opus_conf.set('OPUS_ARM_INLINE_MEDIA', 1) + inline_optimization += ['Media'] + endif + + # AS_ASM_ARM_NEON + if cc.compiles(asm_tmpl.format('vorr d0,d0,d0'), + name : 'assembler supports NEON instructions on ARM') + opus_conf.set('OPUS_ARM_INLINE_NEON', 1) + inline_optimization += ['NEON'] + endif + endif + + # We need Perl to translate RVCT-syntax asm to gas syntax + perl = find_program('perl', required: get_option('asm')) + if perl.found() + opus_arm_external_asm = true + # opus_arm_presume_* mean we can and will use those instructions + # directly without doing runtime CPU detection. + # opus_arm_may_have_* mean we can emit those instructions, but we can + # only use them after runtime detection. + # The same rules apply for x86 assembly and intrinsics. + + opus_arm_may_have_edsp = opus_conf.has('OPUS_ARM_INLINE_EDSP') + opus_arm_presume_edsp = opus_arm_may_have_edsp and opus_can_presume_simd + + opus_arm_may_have_media = opus_conf.has('OPUS_ARM_INLINE_MEDIA') + opus_arm_presume_media = opus_arm_may_have_media and opus_can_presume_simd + + opus_arm_may_have_neon = opus_conf.has('OPUS_ARM_INLINE_NEON') + opus_arm_presume_neon = opus_arm_may_have_neon and opus_can_presume_simd + + if not opt_rtcd.disabled() + if not opus_arm_may_have_edsp + message('Trying to force-enable armv5e EDSP instructions...') + # AS_ASM_ARM_EDSP_FORCE + opus_arm_may_have_edsp = cc.compiles(asm_tmpl.format('.arch armv5te\n.object_arch armv4t\nqadd r3,r3,r3'), + name : 'Assembler supports EDSP instructions on ARM (forced)') + endif + if not opus_arm_may_have_media + message('Trying to force-enable ARMv6 media instructions...') + opus_arm_may_have_media = cc.compiles(asm_tmpl.format('.arch armv6\n.object_arch armv4t\nshadd8 r3,r3,r3'), + name : 'Assembler supports ARMv6 media instructions on ARM (forced)') + endif + if not opus_arm_may_have_neon + message('Trying to force-enable NEON instructions...') + opus_arm_may_have_neon = cc.compiles(asm_tmpl.format('.arch armv7-a\n.fpu neon\n.object_arch armv4t\nvorr d0,d0,d0'), + name : 'Assembler supports NEON instructions on ARM (forced)') + endif + endif + + if opus_arm_may_have_edsp + opus_conf.set('OPUS_ARM_MAY_HAVE_EDSP', 1) + if opus_arm_presume_edsp + opus_conf.set('OPUS_ARM_PRESUME_EDSP', 1) + asm_optimization += ['EDSP'] + else + rtcd_support += ['EDSP'] + endif + endif + if opus_arm_may_have_media + opus_conf.set('OPUS_ARM_MAY_HAVE_MEDIA', 1) + if opus_arm_presume_media + opus_conf.set('OPUS_ARM_PRESUME_MEDIA', 1) + asm_optimization += ['Media'] + else + rtcd_support += ['Media'] + endif + endif + if opus_arm_may_have_neon + opus_conf.set('OPUS_ARM_MAY_HAVE_NEON', 1) + if opus_arm_presume_neon + opus_conf.set('OPUS_ARM_PRESUME_NEON', 1) + asm_optimization += ['NEON'] + else + rtcd_support += ['NEON'] + endif + endif + + if cc.get_define('__APPLE__') + arm2gnu_args = ['--apple'] + else + arm2gnu_args = [] + endif + endif # found perl + else # arm + enable fixed point + if opt_asm.enabled() + error('asm option is enabled, but no assembly support for ' + host_cpu_family) + endif + endif +endif # enable asm + +# Check whether we require assembly and we support assembly on this arch, +# but none were detected. Can happen because of incorrect compiler flags, such +# as missing -mfloat-abi=softfp on ARM32 softfp architectures. +if opt_asm.enabled() and (asm_optimization.length() + inline_optimization.length()) == 0 + error('asm option was enabled, but no assembly support was detected') +endif + +# XXX: NEON has hardfp vs softfp compiler configuration issues +# When targeting ARM32 softfp, we sometimes need to explicitly pass +# -mfloat-abi=softfp to enable NEON. F.ex., on Android. It should +# be set in the cross file. +arm_neon_intr_link_args = ['-mfpu=neon'] + +have_sse = false +have_sse2 = false +have_sse4_1 = false +have_avx = false # no avx opus code yet +have_neon_intr = false + +intrinsics_support = [] +if not opt_intrinsics.disabled() + if host_cpu_family in ['arm', 'aarch64'] + # Check for ARMv7/AArch64 neon intrinsics + intrin_check = ''' + #include <arm_neon.h> + int main (void) { + static float32x4_t A0, A1, SUMM; + SUMM = vmlaq_f32(SUMM, A0, A1); + return (int)vgetq_lane_f32(SUMM, 0); + }''' + intrin_name = 'ARMv7/AArch64 NEON' + if cc.links(intrin_check, + name: 'compiler supports @0@ intrinsics'.format(intrin_name)) + opus_arm_presume_neon_intr = opus_can_presume_simd + opus_arm_may_have_neon_intr = true + else + opus_arm_presume_neon_intr = false + if cc.links(intrin_check, + args: arm_neon_intr_link_args, + name: 'compiler supports @0@ intrinsics with @1@'.format(intrin_name, ' '.join(arm_neon_intr_link_args))) + opus_arm_may_have_neon_intr = true + else + opus_arm_may_have_neon_intr = false + endif + endif + + if opus_arm_may_have_neon_intr + have_neon_intr = true + intrinsics_support += [intrin_name] + opus_conf.set('OPUS_ARM_MAY_HAVE_NEON_INTR', 1) + if opus_arm_presume_neon_intr + opus_conf.set('OPUS_ARM_PRESUME_NEON_INTR', 1) + else + rtcd_support += [intrin_name] + opus_neon_intr_args = arm_neon_intr_link_args + endif + else + message('Compiler does not support @0@ intrinsics'.format(intrin_name)) + endif + + # Check for aarch64 neon intrinsics + intrin_check = ''' + #include <arm_neon.h> + int main (void) { + static int32_t IN; + static int16_t OUT; + OUT = vqmovns_s32(IN); + }''' + intrin_name = 'AArch64 NEON' + if cc.links(intrin_check, + name: 'compiler supports @0@ intrinsics'.format(intrin_name)) + opus_arm_presume_aarch64_neon_intr = opus_can_presume_simd + opus_arm_may_have_aarch64_neon_intr = true + else + opus_arm_presume_aarch64_neon_intr = false + if cc.links(intrin_check, + args: arm_neon_intr_link_args, + name: 'compiler supports @0@ intrinsics with @1@'.format(intrin_name, ' '.join(arm_neon_intr_link_args))) + opus_arm_may_have_aarch64_neon_intr = true + else + opus_arm_may_have_aarch64_neon_intr = false + endif + endif + + if opus_arm_may_have_aarch64_neon_intr + intrinsics_support += [intrin_name] + opus_conf.set('OPUS_X86_MAY_HAVE_AARCH64_NEON_INTR', 1) + if opus_arm_presume_aarch64_neon_intr + opus_conf.set('OPUS_X86_PRESUME_AARCH64_NEON_INTR', 1) + endif + else + message('Compiler does not support @0@ intrinsics'.format(intrin_name)) + endif + elif host_cpu_family in ['x86', 'x86_64'] + # XXX: allow external override/specification of the flags + x86_intrinsics = [ + [ 'SSE', 'xmmintrin.h', '__m128', '_mm_setzero_ps()', ['-msse'] ], + [ 'SSE2', 'emmintrin.h', '__m128i', '_mm_setzero_si128()', ['-msse2'] ], + [ 'SSE4.1', 'smmintrin.h', '__m128i', '_mm_setzero_si128(); mtest = _mm_cmpeq_epi64(mtest, mtest)', ['-msse4.1'] ], + [ 'AVX', 'immintrin.h', '__m256', '_mm256_setzero_ps()', ['-mavx'] ], + ] + + foreach intrin : x86_intrinsics + intrin_check = '''#include <@0@> + int main (int argc, char ** argv) { + static @1@ mtest; + mtest = @2@; + return *((unsigned char *) &mtest) != 0; + }'''.format(intrin[1],intrin[2],intrin[3]) + intrin_name = intrin[0] + # Intrinsics arguments are not available with MSVC-like compilers + intrin_args = cc.get_argument_syntax() == 'msvc' ? [] : intrin[4] + if cc.links(intrin_check, name : 'compiler supports @0@ intrinsics'.format(intrin_name)) + may_have_intrin = true + presume_intrin = opus_can_presume_simd + elif intrin_args.length() > 0 + presume_intrin = false + if cc.links(intrin_check, + args : intrin_args, + name : 'compiler supports @0@ intrinsics with @1@'.format(intrin_name, ' '.join(intrin_args))) + may_have_intrin = true + else + may_have_intrin = false + endif + endif + if may_have_intrin + intrinsics_support += [intrin_name] + intrin_lower_name = intrin_name.to_lower().underscorify() + set_variable('have_' + intrin_lower_name, true) + opus_conf.set('OPUS_X86_MAY_HAVE_' + intrin_name.underscorify(), 1) + if presume_intrin + opus_conf.set('OPUS_X86_PRESUME_' + intrin_name.underscorify(), 1) + else + rtcd_support += [intrin_name] + set_variable('opus_@0@_args'.format(intrin_lower_name), intrin_args) + endif + else + message('Compiler does not support @0@ intrinsics'.format(intrin_name)) + endif + endforeach + + if not opt_rtcd.disabled() + get_cpuid_by_asm = false + cpuid_asm_code = ''' + #include <stdio.h> + int main (int argc, char ** argv) { + unsigned int CPUInfo0; + unsigned int CPUInfo1; + unsigned int CPUInfo2; + unsigned int CPUInfo3; + unsigned int InfoType; + #if defined(__i386__) && defined(__PIC__) + __asm__ __volatile__ ( + "xchg %%ebx, %1\n" + "cpuid\n" + "xchg %%ebx, %1\n": + "=a" (CPUInfo0), + "=r" (CPUInfo1), + "=c" (CPUInfo2), + "=d" (CPUInfo3) : + "a" (InfoType), "c" (0) + ); + #else + __asm__ __volatile__ ( + "cpuid": + "=a" (CPUInfo0), + "=b" (CPUInfo1), + "=c" (CPUInfo2), + "=d" (CPUInfo3) : + "a" (InfoType), "c" (0) + ); + #endif + return 0; + }''' + cpuid_c_code = ''' + #include <cpuid.h> + int main (int argc, char ** argv) { + unsigned int CPUInfo0; + unsigned int CPUInfo1; + unsigned int CPUInfo2; + unsigned int CPUInfo3; + unsigned int InfoType; + __get_cpuid(InfoType, &CPUInfo0, &CPUInfo1, &CPUInfo2, &CPUInfo3); + return 0; + }''' + cpuid_msvc_code = ''' + #include <intrin.h> + int main (void) { + int CPUInfo, InfoType; + __cpuid(&CPUInfo, InfoType); + }''' + if cc.links(cpuid_asm_code, name : 'Get X86 CPU info via inline assembly') + opus_conf.set('CPU_INFO_BY_ASM', 1) + elif cc.links(cpuid_c_code, name : 'Get X86 CPU info via C method') + opus_conf.set('CPU_INFO_BY_C', 1) + elif cc.get_define('_MSC_VER') != '' and cc.links(cpuid_msvc_code) + message('Getting X86 CPU info via __cpuid') + else + if opt_intrinsics.enabled() and opt_rtcd.enabled() + error('intrinsics and rtcd options are enabled, but no Get CPU Info method detected') + endif + warning('Get CPU Info method not detected, no rtcd for intrinsics') + endif + endif # opt_rtcd + else + if opt_intrinsics.enabled() + error('intrinsics option enabled, but no intrinsics support for ' + host_machine.get_cpu()) + endif + warning('No intrinsics support for ' + host_machine.get_cpu()) + endif +endif + +# Check whether we require intrinsics and we support intrinsics on this arch, +# but none were detected. Can happen because of incorrect compiler flags, such +# as missing -mfloat-abi=softfp on ARM32 softfp architectures. +if opt_intrinsics.enabled() and intrinsics_support.length() == 0 + error('intrinsics option was enabled, but none were detected') +endif + +if opt_rtcd.disabled() + rtcd_support = 'disabled' +else + if rtcd_support.length() > 0 + opus_conf.set('OPUS_HAVE_RTCD', 1) + else + if intrinsics_support.length() == 0 + rtcd_support = 'none' + if opt_rtcd.enabled() + error('rtcd option is enabled, but no support for intrinsics or assembly is available') + endif + else + rtcd_support = 'not needed' + endif + endif +endif + +# extract source file lists from .mk files +mk_files = ['silk_sources.mk', 'opus_headers.mk', 'opus_sources.mk', 'silk_headers.mk', 'celt_sources.mk', 'celt_headers.mk'] +lines = run_command('meson/read-sources-list.py', mk_files, check: true).stdout().strip().split('\n') +sources = {} +foreach l : lines + a = l.split(' = ') + var_name = a[0] + file_list = a[1].split() + sources += {var_name: files(file_list)} +endforeach + +subdir('include') +subdir('silk') +subdir('celt') +subdir('src') + +configure_file(output: 'config.h', configuration: opus_conf) + +if not opt_tests.disabled() + subdir('celt/tests') + subdir('silk/tests') + subdir('tests') +endif + +# pkg-config files (not using pkg module so we can use the existing .pc.in file) +pkgconf = configuration_data() + +pkgconf.set('prefix', join_paths(get_option('prefix'))) +pkgconf.set('exec_prefix', '${prefix}') +pkgconf.set('libdir', '${prefix}/@0@'.format(get_option('libdir'))) +pkgconf.set('includedir', '${prefix}/@0@'.format(get_option('includedir'))) +pkgconf.set('VERSION', opus_version) +pkgconf.set('PC_BUILD', pc_build) +pkgconf.set('LIBM', libm.found() ? '-lm' : '') + +pkg_install_dir = '@0@/pkgconfig'.format(get_option('libdir')) + +configure_file(input : 'opus.pc.in', + output : 'opus.pc', + configuration : pkgconf, + install_dir : pkg_install_dir) + +# The uninstalled one has hardcoded libtool + static lib stuff, skip it for now +#configure_file(input : 'opus-uninstalled.pc.in', +# output : 'opus-uninstalled.pc', +# configuration : pkgconf, +# install : false) + +doxygen = find_program('doxygen', required: get_option('docs')) +if doxygen.found() + subdir('doc') +endif + +summary( + { + 'C99 var arrays': opus_conf.has('VAR_ARRAYS'), + 'C99 lrintf': opus_conf.has('HAVE_LRINTF'), + 'Use alloca': msg_use_alloca, + }, + section: 'Compiler support', + bool_yn: true, + list_sep: ', ', +) + +# Parse optimization status +foreach status : [['inline_optimization', opt_asm], + ['asm_optimization', opt_asm], + ['intrinsics_support', opt_intrinsics]] + res = status[0] + opt = status[1] + resval = get_variable(res) + if opt.disabled() + set_variable(res, 'disabled') + elif resval.length() == 0 + if host_cpu_family not in ['arm', 'aarch64', 'x86', 'x86_64'] + set_variable(res, 'No optimizations for your platform, please send patches') + else + set_variable(res, 'none') + endif + endif +endforeach + +summary( + { + 'Floating point support': not opt_fixed_point, + 'Fast float approximations': opt_float_approx, + 'Fixed point debugging': opt_fixed_point_debug, + 'Inline assembly optimizations': inline_optimization, + 'External assembly optimizations': asm_optimization, + 'Intrinsics optimizations': intrinsics_support, + 'Run-time CPU detection': rtcd_support, + }, + section: 'Optimizations', + bool_yn: true, + list_sep: ', ', +) +summary( + { + 'Custom modes': opt_custom_modes, + 'Assertions': opt_assertions, + 'Hardening': opt_hardening, + 'Fuzzing': opt_fuzzing, + 'Check ASM': opt_check_asm, + 'API documentation': doxygen.found(), + 'Extra programs': not extra_programs.disabled(), + 'Tests': not opt_tests.disabled(), + }, + section: 'General configuration', + bool_yn: true, + list_sep: ', ', +) |