Unverified Commit f9d3d432 authored by Marcus Asteborg's avatar Marcus Asteborg Committed by Jean-Marc Valin
Browse files

Adding CMake support for Windows, Mac, Linux and Android Co-Authored-By: evpobr


Signed-off-by: Jean-Marc Valin's avatarJean-Marc Valin <jmvalin@jmvalin.ca>
parent 3765a248
......@@ -83,3 +83,7 @@ silk/tests/test_unit_LPC_inv_pred_gain
src/Debug
src/Release
src/x64
/*[Bb]uild*/
.vs/
.vscode/
CMakeSettings.json
cmake_minimum_required(VERSION 3.1)
include(opus_functions.cmake)
get_library_version(OPUS_LIBRARY_VERSION OPUS_LIBRARY_VERSION_MAJOR)
message(STATUS "Opus library version: ${OPUS_LIBRARY_VERSION}")
get_package_version(PACKAGE_VERSION)
message(STATUS "Opus package version: ${PACKAGE_VERSION}")
string(REGEX
REPLACE "^([0-9]+.[0-9]+\\.?([0-9]+)?).*"
"\\1"
PROJECT_VERSION
${PACKAGE_VERSION})
message(STATUS "Opus project version: ${PROJECT_VERSION}")
project(Opus LANGUAGES C VERSION ${PROJECT_VERSION})
option(OPUS_FIXED_POINT
"Compile as fixed-point (for machines without a fast enough FPU)" OFF)
option(OPUS_ENABLE_FLOAT_API
"Compile with the floating point API (for machines with float library"
ON)
option(OPUS_INSTALL_PKG_CONFIG_MODULE "Install PkgConfig module" ON)
option(OPUS_INSTALL_CMAKE_CONFIG_MODULE "Install CMake package config module"
ON)
include(opus_config.cmake)
include(opus_sources.cmake)
include(GNUInstallDirs)
include(CMakeDependentOption)
include(FeatureSummary)
if(OPUS_CPU_X86 OR OPUS_CPU_X64)
cmake_dependent_option(OPUS_X86_MAY_HAVE_SSE
"Does runtime check for SSE1 support"
ON
"SSE1_SUPPORTED"
OFF)
cmake_dependent_option(OPUS_X86_MAY_HAVE_SSE2
"Does runtime check for SSE2 support"
ON
"SSE2_SUPPORTED"
OFF)
cmake_dependent_option(OPUS_X86_MAY_HAVE_SSE4_1
"Does runtime check for SSE4.1 support"
ON
"SSE4_1_SUPPORTED"
OFF)
cmake_dependent_option(OPUS_X86_MAY_HAVE_AVX
"Does runtime check for AVX support"
ON
"AVX_SUPPORTED"
OFF)
if(OPUS_CPU_X64) # Assume 64 bit has SSE2 support
cmake_dependent_option(OPUS_X86_PRESUME_SSE
"Assume target CPU has SSE1 support"
ON
"OPUS_X86_MAY_HAVE_SSE"
OFF)
cmake_dependent_option(OPUS_X86_PRESUME_SSE2
"Assume target CPU has SSE2 support"
ON
"OPUS_X86_MAY_HAVE_SSE2"
OFF)
else()
cmake_dependent_option(OPUS_X86_PRESUME_SSE
"Assume target CPU has SSE1 support"
OFF
"OPUS_X86_MAY_HAVE_SSE"
OFF)
cmake_dependent_option(OPUS_X86_PRESUME_SSE2
"Assume target CPU has SSE2 support"
OFF
"OPUS_X86_MAY_HAVE_SSE2"
OFF)
endif()
cmake_dependent_option(OPUS_X86_PRESUME_SSE4_1
"Assume target CPU has SSE4.1 support"
OFF
"OPUS_X86_MAY_HAVE_SSE4_1"
OFF)
cmake_dependent_option(OPUS_X86_PRESUME_AVX
"Assume target CPU has AVX support"
OFF
"OPUS_X86_MAY_HAVE_AVX"
OFF)
endif()
set_package_properties(Git
PROPERTIES
TYPE
REQUIRED
DESCRIPTION
"fast, scalable, distributed revision control system"
URL
"https://git-scm.com/"
PURPOSE
"required to set up package version")
add_feature_info(
FIXED_POINT OPUS_FIXED_POINT
"compile as fixed-point (for machines without a fast enough FPU)")
add_feature_info(
FLOAT_API OPUS_ENABLE_FLOAT_API
"compile with the floating point API (for machines with float library)")
add_feature_info(INSTALL_PKG_CONFIG_MODULE OPUS_INSTALL_PKG_CONFIG_MODULE
"install PkgConfig module")
add_feature_info(INSTALL_CMAKE_CONFIG_MODULE OPUS_INSTALL_CMAKE_CONFIG_MODULE
"install CMake package config module")
if(OPUS_CPU_X86 OR OPUS_CPU_X64)
add_feature_info(X86_MAY_HAVE_SSE OPUS_X86_MAY_HAVE_SSE
"does runtime check for SSE1 support")
add_feature_info(X86_MAY_HAVE_SSE2 OPUS_X86_MAY_HAVE_SSE2
"does runtime check for SSE2 support")
add_feature_info(X86_MAY_HAVE_SSE4_1 OPUS_X86_MAY_HAVE_SSE4_1
"does runtime check for SSE4_1 support")
add_feature_info(X86_MAY_HAVE_AVX OPUS_X86_MAY_HAVE_AVX
"does runtime check for AVX support")
add_feature_info(X86_PRESUME_SSE OPUS_X86_PRESUME_SSE
"assume target CPU has SSE1 support")
add_feature_info(X86_PRESUME_SSE2 OPUS_X86_PRESUME_SSE2
"assume target CPU has SSE2 support")
add_feature_info(X86_PRESUME_SSE4_1 OPUS_X86_PRESUME_SSE4_1
"assume target CPU has SSE4_1 support")
add_feature_info(X86_PRESUME_AVX OPUS_X86_PRESUME_AVX
"assume target CPU has AVX support")
endif()
feature_summary(WHAT ALL)
add_library(opus ${opus_sources} ${opus_sources_float})
set(Opus_PUBLIC_HEADER
${CMAKE_CURRENT_SOURCE_DIR}/include/opus.h
${CMAKE_CURRENT_SOURCE_DIR}/include/opus_custom.h
${CMAKE_CURRENT_SOURCE_DIR}/include/opus_defines.h
${CMAKE_CURRENT_SOURCE_DIR}/include/opus_multistream.h
${CMAKE_CURRENT_SOURCE_DIR}/include/opus_projection.h
${CMAKE_CURRENT_SOURCE_DIR}/include/opus_types.h)
set_target_properties(opus
PROPERTIES SOVERSION
${OPUS_LIBRARY_VERSION_MAJOR}
VERSION
${OPUS_LIBRARY_VERSION}
PUBLIC_HEADER
"${Opus_PUBLIC_HEADER}")
target_include_directories(
opus
PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}
celt
silk)
target_link_libraries(opus PRIVATE ${OPUS_REQUIRED_LIBRARIES})
target_compile_definitions(opus PRIVATE CUSTOM_MODES OPUS_BUILD)
if(BUILD_SHARED_LIBS)
if(WIN32)
target_compile_definitions(opus PRIVATE DLL_EXPORT)
else()
include(CheckCCompilerFlag)
check_c_compiler_flag(-fvisibility=hidden COMPILER_HAS_HIDDEN_VISIBILITY)
if(COMPILER_HAS_HIDDEN_VISIBILITY)
set_target_properties(opus PROPERTIES C_VISIBILITY_PRESET hidden)
endif()
endif()
endif()
add_sources_group(opus silk ${silk_sources})
add_sources_group(opus celt ${celt_sources})
if(OPUS_FIXED_POINT)
add_sources_group(opus silk ${silk_sources_fixed})
target_include_directories(opus PRIVATE silk/fixed)
target_compile_definitions(opus PRIVATE FIXED_POINT=1)
else()
add_sources_group(opus silk ${silk_sources_float})
target_include_directories(opus PRIVATE silk/float)
endif()
if(NOT OPUS_ENABLE_FLOAT_API)
target_compile_definitions(opus PRIVATE DISABLE_FLOAT_API)
endif()
if(OPUS_X86_MAY_HAVE_SSE
OR OPUS_X86_MAY_HAVE_SSE2
OR OPUS_X86_MAY_HAVE_SSE4_1
OR OPUS_X86_MAY_HAVE_AVX)
target_compile_definitions(opus PRIVATE OPUS_HAVE_RTCD)
endif()
if(OPUS_X86_MAY_HAVE_SSE)
add_sources_group(opus celt ${celt_sources_sse})
target_compile_definitions(opus PRIVATE OPUS_X86_MAY_HAVE_SSE)
endif()
if(OPUS_X86_PRESUME_SSE)
target_compile_definitions(opus PRIVATE OPUS_X86_PRESUME_SSE)
endif()
if(OPUS_X86_MAY_HAVE_SSE2)
add_sources_group(opus celt ${celt_sources_sse2})
target_compile_definitions(opus PRIVATE OPUS_X86_MAY_HAVE_SSE2)
endif()
if(OPUS_X86_PRESUME_SSE2)
target_compile_definitions(opus PRIVATE OPUS_X86_PRESUME_SSE2)
endif()
if(OPUS_X86_MAY_HAVE_SSE)
add_sources_group(opus celt ${celt_sources_sse4_1})
add_sources_group(opus silk ${silk_sources_sse4_1})
if(OPUS_FIXED_POINT)
add_sources_group(opus silk ${silk_sources_fixed_sse4_1})
endif()
target_compile_definitions(opus PRIVATE OPUS_X86_MAY_HAVE_SSE4_1)
endif()
if(OPUS_X86_PRESUME_SSE4_1)
target_compile_definitions(opus PRIVATE OPUS_X86_PRESUME_SSE4_1)
endif()
if(CMAKE_SYSTEM_PROCESSOR MATCHES "(armv7-a)")
add_sources_group(opus celt ${celt_sources_arm})
endif()
if(COMPILER_SUPPORT_NEON AND OPUS_USE_NEON)
if(OPUS_MAY_HAVE_NEON)
if(RUNTIME_CPU_CAPABILITY_DETECTION)
message(STATUS "OPUS_MAY_HAVE_NEON enabling runtime detection")
target_compile_definitions(opus PRIVATE OPUS_HAVE_RTCD)
else()
message(ERROR "Runtime cpu capability detection needed for MAY_HAVE_NEON")
endif()
# Do runtime check for NEON
target_compile_definitions(opus
PRIVATE
OPUS_ARM_MAY_HAVE_NEON
OPUS_ARM_MAY_HAVE_NEON_INTR)
endif()
add_sources_group(opus celt ${celt_sources_arm_neon_intr})
add_sources_group(opus silk ${silk_sources_arm_neon_intr})
# silk arm neon depends on main_Fix.h
target_include_directories(opus PRIVATE silk/fixed)
if(OPUS_FIXED_POINT)
add_sources_group(opus silk ${silk_sources_fixed_arm_neon_intr})
endif()
if(OPUS_PRESUME_NEON)
target_compile_definitions(opus
PRIVATE
OPUS_ARM_PRESUME_NEON
OPUS_ARM_PRESUME_NEON_INTR)
endif()
endif()
install(TARGETS opus
EXPORT OpusTargets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/opus)
if(OPUS_INSTALL_PKG_CONFIG_MODULE)
set(prefix ${CMAKE_INSTALL_PREFIX})
set(exec_prefix ${CMAKE_INSTALL_PREFIX})
set(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
set(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
set(VERSION ${OPUS_LIBRARY_VERSION})
set(VERSION ${OPUS_LIBRARY_VERSION})
if(HAVE_LIBM)
set(LIBM "-lm")
endif()
configure_file(opus.pc.in opus.pc)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/opus.pc
DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
endif()
if(OPUS_INSTALL_CMAKE_CONFIG_MODULE)
set(CMAKE_INSTALL_PACKAGEDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME})
install(EXPORT OpusTargets
NAMESPACE Opus::
DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
include(CMakePackageConfigHelpers)
set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR})
configure_package_config_file(OpusConfig.cmake.in
OpusConfig.cmake
INSTALL_DESTINATION
${CMAKE_INSTALL_PACKAGEDIR}
PATH_VARS
INCLUDE_INSTALL_DIR
INSTALL_PREFIX
${CMAKE_INSTALL_PREFIX})
write_basic_package_version_file(OpusConfigVersion.cmake
VERSION ${PROJECT_VERSION}
COMPATIBILITY SameMajorVersion)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/OpusConfig.cmake
${CMAKE_CURRENT_BINARY_DIR}/OpusConfigVersion.cmake
DESTINATION ${CMAKE_INSTALL_PACKAGEDIR})
endif()
if(BUILD_PROGRAMS)
# demo
add_executable(opus_demo ${opus_demo_sources})
target_include_directories(opus_demo PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_link_libraries(opus_demo PRIVATE opus)
# compare
add_executable(opus_compare ${opus_compare_sources})
target_include_directories(opus_compare PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_link_libraries(opus_compare PRIVATE opus)
endif()
if(BUILD_TESTING)
enable_testing()
# tests
add_executable(test_opus_decode ${test_opus_decode_sources})
target_include_directories(test_opus_decode
PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_link_libraries(test_opus_decode PRIVATE opus)
if(OPUS_FIXED_POINT)
target_compile_definitions(test_opus_decode PRIVATE DISABLE_FLOAT_API)
endif()
add_test(test_opus_decode test_opus_decode)
add_executable(test_opus_padding ${test_opus_padding_sources})
target_include_directories(test_opus_padding
PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_link_libraries(test_opus_padding PRIVATE opus)
add_test(test_opus_padding test_opus_padding)
if(NOT BUILD_SHARED_LIBS)
# disable tests that depends on private API when building shared lib
add_executable(test_opus_api ${test_opus_api_sources})
target_include_directories(test_opus_api
PRIVATE ${CMAKE_CURRENT_BINARY_DIR} celt)
target_link_libraries(test_opus_api PRIVATE opus)
if(OPUS_FIXED_POINT)
target_compile_definitions(test_opus_api PRIVATE DISABLE_FLOAT_API)
endif()
add_test(test_opus_api test_opus_api)
add_executable(test_opus_encode ${test_opus_encode_sources})
target_include_directories(test_opus_encode
PRIVATE ${CMAKE_CURRENT_BINARY_DIR} celt)
target_link_libraries(test_opus_encode PRIVATE opus)
add_test(test_opus_encode test_opus_encode)
endif()
endif()
......@@ -210,6 +210,12 @@ EXTRA_DIST = opus.pc.in \
opus.m4 \
Makefile.mips \
Makefile.unix \
CMakeLists.txt \
config.h.cmake.in \
opus_config.cmake \
opus_functions.cmake \
opus_sources.cmake \
OpusConfig.cmake.in \
tests/run_vectors.sh \
celt/arm/arm2gnu.pl \
celt/arm/celt_pitch_xcorr_arm.s \
......
set(OPUS_VERSION @PROJECT_VERSION@)
set(OPUS_VERSION_STRING @PROJECT_VERSION@)
set(OPUS_VERSION_MAJOR @PROJECT_VERSION_MAJOR@)
set(OPUS_VERSION_MINOR @PROJECT_VERSION_MINOR@)
set(OPUS_VERSION_PATCH @PROJECT_VERSION_PATCH@)
@PACKAGE_INIT@
set_and_check(OPUS_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
set_and_check(OPUS_INCLUDE_DIRS "@PACKAGE_INCLUDE_INSTALL_DIR@")
include(${CMAKE_CURRENT_LIST_DIR}/OpusTargets.cmake)
set(OPUS_LIBRARY Opus::opus)
set(OPUS_LIBRARIES Opus::opus)
check_required_components(Opus)
set(OPUS_FOUND 1)
CELT_SOURCES = celt/bands.c \
CELT_SOURCES = \
celt/bands.c \
celt/celt.c \
celt/celt_encoder.c \
celt/celt_decoder.c \
......
#cmakedefine PACKAGE_VERSION "@PACKAGE_VERSION@"
\ No newline at end of file
include(opus_functions.cmake)
configure_file(config.h.cmake.in config.h @ONLY)
add_definitions(-DHAVE_CONFIG_H)
option(FIXED_POINT "Use fixed-point code (for devices with less powerful FPU)"
OFF)
option(USE_ALLOCA "Use alloca for stack arrays (on non-C99 compilers)" OFF)
option(BUILD_PROGRAMS "Build programs" OFF)
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
set_property(GLOBAL PROPERTY C_STANDARD 99)
if(MSVC)
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
endif()
# It is strongly recommended to uncomment one of these VAR_ARRAYS: Use C99
# variable-length arrays for stack allocation USE_ALLOCA: Use alloca() for stack
# allocation If none is defined, then the fallback is a non-threadsafe global
# array
if(USE_ALLOCA OR MSVC)
add_definitions(-DUSE_ALLOCA)
else()
add_definitions(-DVAR_ARRAYS)
endif()
include(CheckLibraryExists)
check_library_exists(m floor "" HAVE_LIBM)
if(HAVE_LIBM)
list(APPEND OPUS_REQUIRED_LIBRARIES m)
endif()
if(CMAKE_SYSTEM_PROCESSOR MATCHES "(i[0-9]86|x86|X86|amd64|AMD64|x86_64)")
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
set(OPUS_CPU_X64 1)
else()
set(OPUS_CPU_X86 1)
endif()
elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
set(OPUS_CPU_ARM 1)
endif()
opus_supports_cpu_detection(RUNTIME_CPU_CAPABILITY_DETECTION)
if(OPUS_CPU_X86 OR OPUS_CPU_X64)
opus_detect_sse(COMPILER_SUPPORT_SIMD)
elseif(OPUS_CPU_ARM)
opus_detect_neon(COMPILER_SUPPORT_NEON)
if(COMPILER_SUPPORT_NEON)
option(OPUS_USE_NEON "Option to turn off SSE" ON)
option(OPUS_MAY_SUPPORT_NEON "Does runtime check for neon support" ON)
option(OPUS_PRESUME_NEON "Assume target CPU has NEON support" OFF)
if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
set(OPUS_PRESUME_NEON ON)
endif()
endif()
endif()
#[[Cmake helper function to parse source files from make files
this is to avoid breaking existing make and auto make support
but still have the option to use CMake with only lists at one place]]
cmake_minimum_required(VERSION 3.1)
function(get_library_version OPUS_LIBRARY_VERSION OPUS_LIBRARY_VERSION_MAJOR)
file(STRINGS configure.ac opus_lt_current_string
LIMIT_COUNT 1
REGEX "OPUS_LT_CURRENT=")
string(REGEX MATCH
"OPUS_LT_CURRENT=([0-9]*)"
_
${opus_lt_current_string})
set(OPUS_LT_CURRENT ${CMAKE_MATCH_1})
file(STRINGS configure.ac opus_lt_revision_string
LIMIT_COUNT 1
REGEX "OPUS_LT_REVISION=")
string(REGEX MATCH
"OPUS_LT_REVISION=([0-9]*)"
_
${opus_lt_revision_string})
set(OPUS_LT_REVISION ${CMAKE_MATCH_1})
file(STRINGS configure.ac opus_lt_age_string
LIMIT_COUNT 1
REGEX "OPUS_LT_AGE=")
string(REGEX MATCH
"OPUS_LT_AGE=([0-9]*)"
_
${opus_lt_age_string})
set(OPUS_LT_AGE ${CMAKE_MATCH_1})
math(EXPR OPUS_LIBRARY_VERSION_MAJOR "${OPUS_LT_CURRENT} - ${OPUS_LT_AGE}")
set(OPUS_LIBRARY_VERSION_MINOR ${OPUS_LT_AGE})
set(OPUS_LIBRARY_VERSION_PATCH ${OPUS_LT_REVISION})
set(
OPUS_LIBRARY_VERSION
"${OPUS_LIBRARY_VERSION_MAJOR}.${OPUS_LIBRARY_VERSION_MINOR}.${OPUS_LIBRARY_VERSION_PATCH}"
PARENT_SCOPE)
set(OPUS_LIBRARY_VERSION_MAJOR ${OPUS_LIBRARY_VERSION_MAJOR} PARENT_SCOPE)
endfunction()
function(get_package_version PACKAGE_VERSION)
find_package(Git)
if(GIT_FOUND)
execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags --match "v*"
OUTPUT_VARIABLE OPUS_PACKAGE_VERSION)
if(OPUS_PACKAGE_VERSION)
string(STRIP ${OPUS_PACKAGE_VERSION}, OPUS_PACKAGE_VERSION)
string(REPLACE \n
""
OPUS_PACKAGE_VERSION
${OPUS_PACKAGE_VERSION})
string(REPLACE ,
""
OPUS_PACKAGE_VERSION
${OPUS_PACKAGE_VERSION})
string(SUBSTRING ${OPUS_PACKAGE_VERSION}
1
-1
OPUS_PACKAGE_VERSION)
set(PACKAGE_VERSION ${OPUS_PACKAGE_VERSION} PARENT_SCOPE)
return()
endif()
endif()
if(EXISTS "${CMAKE_SOURCE_DIR}/package_version")
# Not a git repo, lets' try to parse it from package_version file if exists
file(STRINGS package_version opus_package_version_string
LIMIT_COUNT 1
REGEX "PACKAGE_VERSION=")
string(REPLACE "PACKAGE_VERSION="
""
opus_package_version_string
${opus_package_version_string})
string(REPLACE "\""
""
opus_package_version_string
${opus_package_version_string})
set(PACKAGE_VERSION ${opus_package_version_string} PARENT_SCOPE)
return()
endif()
# if all else fails set to 0
set(PACKAGE_VERSION 0 PARENT_SCOPE)
endfunction()
function(check_and_set_flag NAME FLAG)
include(CheckCCompilerFlag)
check_c_compiler_flag(${FLAG} ${NAME}_SUPPORTED)
if(${NAME}_SUPPORTED)
add_definitions(${FLAG})
endif()
endfunction()
function(check_flag NAME FLAG)
include(CheckCCompilerFlag)
check_c_compiler_flag(${FLAG} ${NAME}_SUPPORTED)
endfunction()
include(CheckIncludeFile)
# function to check if compiler supports SSE, SSE2, SSE4.1 and AVX if target
# systems may not have SSE support then use OPUS_MAY_HAVE_SSE option if target
# system is guaranteed to have SSE support then OPUS_PRESUME_SSE can be used to
# skip SSE runtime check
function(opus_detect_sse COMPILER_SUPPORT_SIMD)
message(STATUS "Check SIMD support by compiler")
check_include_file(xmmintrin.h HAVE_XMMINTRIN_H) # SSE1
if(HAVE_XMMINTRIN_H)
if(MSVC)
# different arch options for 32 and 64 bit target for MSVC
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
check_flag(SSE1 /arch:SSE)
else()
set(SSE1_SUPPORTED 1 PARENT_SCOPE)
endif()
else()
check_and_set_flag(SSE1 -msse)
endif()
else()
set(SSE1_SUPPORTED 0 PARENT_SCOPE)
endif()
check_include_file(emmintrin.h HAVE_EMMINTRIN_H) # SSE2
if(HAVE_EMMINTRIN_H)
if(MSVC)
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
check_flag(SSE2 /arch:SSE2)
else()
set(SSE2_SUPPORTED 1 PARENT_SCOPE)
endif()
else()
check_and_set_flag(SSE2 -msse2)
endif()
else()
set(SSE2_SUPPORTED 0 PARENT_SCOPE)
endif()
check_include_file(smmintrin.h HAVE_SMMINTRIN_H) # SSE4.1
if(HAVE_SMMINTRIN_H)
if(MSVC)
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
check_flag(SSE4_1 /arch:SSE2) # SSE2 and above
else()
set(SSE4_1_SUPPORTED 1 PARENT_SCOPE)
endif()
else()
check_and_set_flag(SSE4_1 -msse4.1)
endif()
else()
set(SSE4_1_SUPPORTED 0 PARENT_SCOPE)
endif()
check_include_file(immintrin.h HAVE_IMMINTRIN_H) # AVX
if(HAVE_IMMINTRIN_H)
if(MSVC)
check_flag(AVX /arch:AVX)