mirror of
https://github.com/ggerganov/whisper.cpp.git
synced 2024-12-21 05:33:06 +00:00
514 lines
16 KiB
CMake
514 lines
16 KiB
CMake
cmake_minimum_required (VERSION 3.0)
|
|
|
|
project(whisper.cpp VERSION 1.4.2)
|
|
|
|
# Add path to modules
|
|
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
|
|
|
|
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
|
|
|
|
if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
|
|
set(WHISPER_STANDALONE ON)
|
|
include(GitVars)
|
|
include(BuildTypes)
|
|
|
|
# configure project version
|
|
if (EXISTS "${CMAKE_SOURCE_DIR}/bindings/ios/Makefile-tmpl")
|
|
configure_file(${CMAKE_SOURCE_DIR}/bindings/ios/Makefile-tmpl ${CMAKE_SOURCE_DIR}/bindings/ios/Makefile @ONLY)
|
|
endif()
|
|
configure_file(${CMAKE_SOURCE_DIR}/bindings/javascript/package-tmpl.json ${CMAKE_SOURCE_DIR}/bindings/javascript/package.json @ONLY)
|
|
else()
|
|
set(WHISPER_STANDALONE OFF)
|
|
endif()
|
|
|
|
if (EMSCRIPTEN)
|
|
set(BUILD_SHARED_LIBS_DEFAULT OFF)
|
|
|
|
option(WHISPER_WASM_SINGLE_FILE "whisper: embed WASM inside the generated whisper.js" ON)
|
|
else()
|
|
if (MINGW)
|
|
set(BUILD_SHARED_LIBS_DEFAULT OFF)
|
|
else()
|
|
set(BUILD_SHARED_LIBS_DEFAULT ON)
|
|
endif()
|
|
endif()
|
|
|
|
# options
|
|
|
|
option(BUILD_SHARED_LIBS "whisper: build shared libs" ${BUILD_SHARED_LIBS_DEFAULT})
|
|
|
|
option(WHISPER_ALL_WARNINGS "whisper: enable all compiler warnings" ON)
|
|
option(WHISPER_ALL_WARNINGS_3RD_PARTY "whisper: enable all compiler warnings in 3rd party libs" OFF)
|
|
|
|
option(WHISPER_SANITIZE_THREAD "whisper: enable thread sanitizer" OFF)
|
|
option(WHISPER_SANITIZE_ADDRESS "whisper: enable address sanitizer" OFF)
|
|
option(WHISPER_SANITIZE_UNDEFINED "whisper: enable undefined sanitizer" OFF)
|
|
|
|
option(WHISPER_BUILD_TESTS "whisper: build tests" ${WHISPER_STANDALONE})
|
|
option(WHISPER_BUILD_EXAMPLES "whisper: build examples" ${WHISPER_STANDALONE})
|
|
|
|
option(WHISPER_SDL2 "whisper: support for libSDL2" OFF)
|
|
|
|
option(WHISPER_NO_AVX "whisper: disable AVX" OFF)
|
|
option(WHISPER_NO_AVX2 "whisper: disable AVX2" OFF)
|
|
option(WHISPER_NO_FMA "whisper: disable FMA" OFF)
|
|
option(WHISPER_NO_F16C "whisper: disable F16c" OFF)
|
|
|
|
option(WHISPER_OPENVINO "whisper: support for OpenVINO" OFF)
|
|
|
|
if (APPLE)
|
|
option(WHISPER_NO_ACCELERATE "whisper: disable Accelerate framework" OFF)
|
|
option(WHISPER_COREML "whisper: enable Core ML framework" OFF)
|
|
option(WHISPER_COREML_ALLOW_FALLBACK "whisper: allow non-CoreML fallback" OFF)
|
|
else()
|
|
option(WHISPER_BLAS "whisper: use BLAS libraries" OFF)
|
|
option(WHISPER_BLAS_VENDOR "whisper: BLAS library vendor" Generic)
|
|
option(WHISPER_OPENBLAS "whisper: prefer OpenBLAS" OFF)
|
|
option(WHISPER_CUBLAS "whisper: support for cuBLAS" OFF)
|
|
option(WHISPER_HIPBLAS "whisper: support for hipBLAS" OFF)
|
|
option(WHISPER_CLBLAST "whisper: use CLBlast" OFF)
|
|
endif()
|
|
|
|
option(WHISPER_PERF "whisper: enable perf timings" OFF)
|
|
|
|
# sanitizers
|
|
|
|
if (NOT MSVC)
|
|
if (WHISPER_SANITIZE_THREAD)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=thread")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
|
|
endif()
|
|
|
|
if (WHISPER_SANITIZE_ADDRESS)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
|
|
endif()
|
|
|
|
if (WHISPER_SANITIZE_UNDEFINED)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=undefined")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined")
|
|
endif()
|
|
endif()
|
|
|
|
#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ffast-math")
|
|
#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=native")
|
|
|
|
# dependencies
|
|
|
|
find_package(Threads REQUIRED)
|
|
|
|
# on APPLE
|
|
if (APPLE)
|
|
# include Accelerate framework
|
|
if (NOT WHISPER_NO_ACCELERATE)
|
|
find_library(ACCELERATE_FRAMEWORK Accelerate)
|
|
|
|
if (ACCELERATE_FRAMEWORK)
|
|
message(STATUS "Accelerate framework found")
|
|
|
|
set(WHISPER_EXTRA_LIBS ${WHISPER_EXTRA_LIBS} ${ACCELERATE_FRAMEWORK})
|
|
set(WHISPER_EXTRA_FLAGS ${WHISPER_EXTRA_FLAGS} -DGGML_USE_ACCELERATE)
|
|
else()
|
|
message(WARNING "Accelerate framework not found")
|
|
endif()
|
|
endif()
|
|
|
|
if (WHISPER_COREML)
|
|
find_library(FOUNDATION_FRAMEWORK Foundation)
|
|
find_library(COREML_FRAMEWORK CoreML)
|
|
|
|
if (COREML_FRAMEWORK)
|
|
message(STATUS "CoreML framework found")
|
|
|
|
set(WHISPER_EXTRA_FLAGS ${WHISPER_EXTRA_FLAGS} -DWHISPER_USE_COREML)
|
|
else()
|
|
message(WARNING "CoreML framework not found")
|
|
endif()
|
|
|
|
if (WHISPER_COREML_ALLOW_FALLBACK)
|
|
set(WHISPER_EXTRA_FLAGS ${WHISPER_EXTRA_FLAGS} -DWHISPER_COREML_ALLOW_FALLBACK)
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if (WHISPER_OPENBLAS)
|
|
set(WHISPER_BLAS_VENDOR "OpenBLAS")
|
|
set(WHISPER_BLAS ON)
|
|
endif()
|
|
|
|
if (WHISPER_BLAS)
|
|
if (WIN32)
|
|
if(DEFINED ENV{OPENBLAS_PATH})
|
|
set(BLAS_LIBRARIES $ENV{OPENBLAS_PATH}/lib/libopenblas.dll.a)
|
|
message(STATUS "Libraries ${BLAS_LIBRARIES}")
|
|
set(WHISPER_EXTRA_FLAGS ${WHISPER_EXTRA_FLAGS} -DGGML_USE_OPENBLAS)
|
|
include_directories($ENV{OPENBLAS_PATH}/include)
|
|
set(WHISPER_EXTRA_LIBS ${WHISPER_EXTRA_LIBS} ${BLAS_LIBRARIES})
|
|
else ()
|
|
message(WARNING "BLAS library was not found. Environment variable OPENBLAS_PATH not defined.")
|
|
endif ()
|
|
else ()
|
|
set(BLA_STATIC 1)
|
|
set(BLA_VENDOR ${WHISPER_BLAS_VENDOR})
|
|
# set(BLA_PREFER_PKGCONFIG 1)
|
|
set(BLA_SIZEOF_INTEGER 8)
|
|
find_package(BLAS)
|
|
|
|
if(BLAS_FOUND)
|
|
message(STATUS "BLAS compatible library found")
|
|
message(STATUS "Libraries ${BLAS_LIBRARIES}")
|
|
find_path(BLAS_INCLUDE_DIRS cblas.h /usr/include/openblas /usr/local/include/openblas $ENV{BLAS_HOME}/include)
|
|
set(WHISPER_EXTRA_FLAGS ${WHISPER_EXTRA_FLAGS} -DGGML_USE_OPENBLAS)
|
|
include_directories(${BLAS_INCLUDE_DIRS})
|
|
set(WHISPER_EXTRA_LIBS ${WHISPER_EXTRA_LIBS} ${BLAS_LIBRARIES})
|
|
else()
|
|
message(WARNING "BLAS library was not found")
|
|
endif()
|
|
endif ()
|
|
endif ()
|
|
|
|
if (WHISPER_CUBLAS)
|
|
cmake_minimum_required(VERSION 3.17)
|
|
|
|
find_package(CUDAToolkit)
|
|
|
|
if (CUDAToolkit_FOUND)
|
|
message(STATUS "cuBLAS found")
|
|
|
|
enable_language(CUDA)
|
|
|
|
set(GGML_CUDA_SOURCES ggml-cuda.cu ggml-cuda.h)
|
|
|
|
add_compile_definitions(GGML_USE_CUBLAS)
|
|
|
|
if (WHISPER_STATIC)
|
|
set(WHISPER_EXTRA_LIBS ${WHISPER_EXTRA_LIBS} CUDA::cudart_static CUDA::cublas_static CUDA::cublasLt_static)
|
|
else()
|
|
set(WHISPER_EXTRA_LIBS ${WHISPER_EXTRA_LIBS} CUDA::cudart CUDA::cublas CUDA::cublasLt)
|
|
endif()
|
|
|
|
else()
|
|
message(WARNING "cuBLAS not found")
|
|
endif()
|
|
endif()
|
|
|
|
|
|
if (WHISPER_HIPBLAS)
|
|
list(APPEND CMAKE_PREFIX_PATH /opt/rocm)
|
|
if (NOT ${CMAKE_C_COMPILER_ID} MATCHES "Clang")
|
|
message(WARNING "Only LLVM is supported for HIP, hint: CC=/opt/rocm/llvm/bin/clang")
|
|
endif()
|
|
if (NOT ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
|
|
message(WARNING "Only LLVM is supported for HIP, hint: CXX=/opt/rocm/llvm/bin/clang++")
|
|
endif()
|
|
|
|
find_package(hip)
|
|
find_package(hipblas)
|
|
find_package(rocblas)
|
|
|
|
if (${hipblas_FOUND} AND ${hip_FOUND})
|
|
message(STATUS "HIP and hipBLAS found")
|
|
add_compile_definitions(GGML_USE_HIPBLAS GGML_USE_CUBLAS)
|
|
add_library(ggml-rocm OBJECT ggml-cuda.cu ggml-cuda.h)
|
|
set_property(TARGET ggml-rocm PROPERTY POSITION_INDEPENDENT_CODE ON)
|
|
set_source_files_properties(ggml-cuda.cu PROPERTIES LANGUAGE CXX)
|
|
target_link_libraries(ggml-rocm PRIVATE hip::device PUBLIC hip::host roc::rocblas roc::hipblas)
|
|
|
|
if (WHISPER_STATIC)
|
|
message(FATAL_ERROR "Static linking not supported for HIP/ROCm")
|
|
endif()
|
|
set(WHISPER_EXTRA_LIBS ${WHISPER_EXTRA_LIBS} ggml-rocm)
|
|
else()
|
|
message(WARNING "hipBLAS or HIP not found. Try setting CMAKE_PREFIX_PATH=/opt/rocm")
|
|
endif()
|
|
endif()
|
|
|
|
if (WHISPER_CLBLAST)
|
|
find_package(CLBlast)
|
|
if (CLBlast_FOUND)
|
|
message(STATUS "CLBlast found")
|
|
|
|
set(GGML_OPENCL_SOURCES ggml-opencl.cpp ggml-opencl.h)
|
|
|
|
add_compile_definitions(GGML_USE_CLBLAST)
|
|
|
|
set(WHISPER_EXTRA_LIBS ${WHISPER_EXTRA_LIBS} clblast)
|
|
else()
|
|
message(WARNING "CLBlast not found")
|
|
endif()
|
|
endif()
|
|
|
|
if( WHISPER_OPENVINO )
|
|
find_package(OpenVINO REQUIRED COMPONENTS Runtime)
|
|
endif()
|
|
|
|
# compiler flags
|
|
|
|
if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
|
|
set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
|
|
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "RelWithDebInfo")
|
|
endif ()
|
|
|
|
if (WHISPER_ALL_WARNINGS)
|
|
if (NOT MSVC)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} \
|
|
-Wall \
|
|
-Wextra \
|
|
-Wpedantic \
|
|
-Wshadow \
|
|
-Wcast-qual \
|
|
-Wstrict-prototypes \
|
|
-Wpointer-arith \
|
|
-Wno-unused-function \
|
|
")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} \
|
|
-Wall \
|
|
-Wextra \
|
|
-Wpedantic \
|
|
-Wcast-qual \
|
|
")
|
|
else()
|
|
# todo : msvc
|
|
endif()
|
|
endif()
|
|
|
|
if (NOT MSVC)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=vla")
|
|
#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-math-errno -ffinite-math-only -funsafe-math-optimizations")
|
|
endif()
|
|
|
|
message(STATUS "CMAKE_SYSTEM_PROCESSOR: ${CMAKE_SYSTEM_PROCESSOR}")
|
|
|
|
if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "arm" OR ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
|
|
message(STATUS "ARM detected")
|
|
elseif(${CMAKE_SYSTEM_PROCESSOR} MATCHES "ppc64le")
|
|
message(STATUS "PowerPC detected")
|
|
else()
|
|
message(STATUS "x86 detected")
|
|
if (MSVC)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /utf-8")
|
|
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /utf-8")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /utf-8")
|
|
if(NOT WHISPER_NO_AVX2)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX2")
|
|
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /arch:AVX2")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:AVX2")
|
|
else()
|
|
if(NOT WHISPER_NO_AVX)
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /arch:AVX")
|
|
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /arch:AVX")
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /arch:AVX")
|
|
endif()
|
|
endif()
|
|
else()
|
|
if (EMSCRIPTEN)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread")
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
|
|
else()
|
|
if(NOT WHISPER_NO_AVX)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx")
|
|
endif()
|
|
if(NOT WHISPER_NO_AVX2)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mavx2")
|
|
endif()
|
|
if(NOT WHISPER_NO_FMA)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfma")
|
|
endif()
|
|
if(NOT WHISPER_NO_F16C)
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mf16c")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
#
|
|
# POSIX conformance
|
|
#
|
|
|
|
# clock_gettime came in POSIX.1b (1993)
|
|
# CLOCK_MONOTONIC came in POSIX.1-2001 / SUSv3 as optional
|
|
# posix_memalign came in POSIX.1-2001 / SUSv3
|
|
# M_PI is an XSI extension since POSIX.1-2001 / SUSv3, came in XPG1 (1985)
|
|
add_compile_definitions(_XOPEN_SOURCE=600)
|
|
|
|
# Somehow in OpenBSD whenever POSIX conformance is specified
|
|
# some string functions rely on locale_t availability,
|
|
# which was introduced in POSIX.1-2008, forcing us to go higher
|
|
if (CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
|
|
remove_definitions(-D_XOPEN_SOURCE=600)
|
|
add_compile_definitions(_XOPEN_SOURCE=700)
|
|
endif()
|
|
|
|
# Data types, macros and functions related to controlling CPU affinity
|
|
# are available on Linux through GNU extensions in libc
|
|
if (CMAKE_SYSTEM_NAME MATCHES "Linux")
|
|
add_compile_definitions(_GNU_SOURCE)
|
|
endif()
|
|
|
|
# RLIMIT_MEMLOCK came in BSD, is not specified in POSIX.1,
|
|
# and on macOS its availability depends on enabling Darwin extensions
|
|
# similarly on DragonFly, enabling BSD extensions is necessary
|
|
if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
|
|
add_compile_definitions(_DARWIN_C_SOURCE)
|
|
endif()
|
|
if (CMAKE_SYSTEM_NAME MATCHES "DragonFly")
|
|
add_compile_definitions(_DARWIN_C_SOURCE)
|
|
endif()
|
|
|
|
# alloca is a non-standard interface that is not visible on BSDs when
|
|
# POSIX conformance is specified, but not all of them provide a clean way
|
|
# to enable it in such cases
|
|
if (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
|
|
add_compile_definitions(__BSD_VISIBLE)
|
|
endif()
|
|
if (CMAKE_SYSTEM_NAME MATCHES "NetBSD")
|
|
add_compile_definitions(_NETBSD_SOURCE)
|
|
endif()
|
|
if (CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
|
|
add_compile_definitions(_BSD_SOURCE)
|
|
endif()
|
|
|
|
if (WHISPER_PERF)
|
|
set(WHISPER_EXTRA_FLAGS ${WHISPER_EXTRA_FLAGS} -DGGML_PERF)
|
|
endif()
|
|
|
|
#
|
|
# whisper.coreml - Core ML support
|
|
#
|
|
|
|
if (WHISPER_COREML)
|
|
set(TARGET whisper.coreml)
|
|
|
|
add_library(${TARGET}
|
|
coreml/whisper-encoder.h
|
|
coreml/whisper-encoder.mm
|
|
coreml/whisper-encoder-impl.h
|
|
coreml/whisper-encoder-impl.m
|
|
)
|
|
|
|
include(DefaultTargetOptions)
|
|
|
|
target_include_directories(${TARGET} PUBLIC
|
|
.
|
|
)
|
|
|
|
target_link_libraries(${TARGET} PRIVATE ${FOUNDATION_FRAMEWORK} ${COREML_FRAMEWORK})
|
|
|
|
set_target_properties(${TARGET} PROPERTIES
|
|
COMPILE_FLAGS "-fobjc-arc"
|
|
)
|
|
endif()
|
|
|
|
if (WHISPER_OPENVINO)
|
|
set(TARGET whisper.openvino)
|
|
|
|
add_library(${TARGET} OBJECT
|
|
openvino/whisper-openvino-encoder.h
|
|
openvino/whisper-openvino-encoder.cpp
|
|
)
|
|
|
|
target_include_directories(${TARGET} PUBLIC
|
|
.
|
|
)
|
|
|
|
set_property(TARGET ${TARGET} PROPERTY POSITION_INDEPENDENT_CODE ON)
|
|
set(WHISPER_EXTRA_FLAGS ${WHISPER_EXTRA_FLAGS} -DWHISPER_USE_OPENVINO)
|
|
|
|
target_link_libraries(${TARGET} PRIVATE openvino::runtime)
|
|
endif()
|
|
|
|
#
|
|
# whisper - this is the main library of the project
|
|
#
|
|
|
|
set(TARGET whisper)
|
|
|
|
add_library(${TARGET}
|
|
ggml.h
|
|
ggml.c
|
|
${GGML_CUDA_SOURCES}
|
|
${GGML_OPENCL_SOURCES}
|
|
whisper.h
|
|
whisper.cpp
|
|
)
|
|
|
|
include(DefaultTargetOptions)
|
|
|
|
target_include_directories(${TARGET} PUBLIC
|
|
.
|
|
)
|
|
|
|
if (WHISPER_COREML)
|
|
target_link_libraries(${TARGET} PRIVATE whisper.coreml)
|
|
endif()
|
|
|
|
if (WHISPER_OPENVINO)
|
|
target_link_libraries(${TARGET} PRIVATE whisper.openvino)
|
|
endif()
|
|
|
|
if (MSVC)
|
|
target_link_libraries(${TARGET} PRIVATE ${WHISPER_EXTRA_LIBS} ${CMAKE_THREAD_LIBS_INIT})
|
|
|
|
set(WHISPER_EXTRA_FLAGS ${WHISPER_EXTRA_FLAGS} -D_CRT_SECURE_NO_WARNINGS)
|
|
else()
|
|
target_link_libraries(${TARGET} PRIVATE m ${WHISPER_EXTRA_LIBS} ${CMAKE_THREAD_LIBS_INIT})
|
|
endif()
|
|
|
|
if (BUILD_SHARED_LIBS)
|
|
target_link_libraries(${TARGET} PUBLIC
|
|
${CMAKE_DL_LIBS}
|
|
)
|
|
|
|
target_compile_definitions(${TARGET} PUBLIC
|
|
WHISPER_SHARED
|
|
GGML_SHARED
|
|
)
|
|
|
|
target_compile_definitions(${TARGET} PRIVATE
|
|
WHISPER_BUILD
|
|
GGML_BUILD
|
|
)
|
|
endif()
|
|
|
|
if (GGML_CUDA_SOURCES)
|
|
message(STATUS "GGML CUDA sources found, configuring CUDA architecture")
|
|
set_property(TARGET whisper PROPERTY CUDA_ARCHITECTURES OFF)
|
|
set_property(TARGET whisper PROPERTY CUDA_SELECT_NVCC_ARCH_FLAGS "Auto")
|
|
endif()
|
|
|
|
if (EMSCRIPTEN)
|
|
set_target_properties(${TARGET} PROPERTIES COMPILE_FLAGS "-msimd128")
|
|
endif()
|
|
|
|
target_compile_definitions(${TARGET} PUBLIC
|
|
${WHISPER_EXTRA_FLAGS}
|
|
)
|
|
|
|
set_target_properties(${TARGET} PROPERTIES PUBLIC_HEADER "whisper.h")
|
|
|
|
install(TARGETS ${TARGET}
|
|
LIBRARY DESTINATION lib
|
|
ARCHIVE DESTINATION lib/static
|
|
RUNTIME DESTINATION bin
|
|
PUBLIC_HEADER DESTINATION include
|
|
)
|
|
|
|
#
|
|
# bindings
|
|
#
|
|
|
|
add_subdirectory(bindings)
|
|
|
|
#
|
|
# programs, examples and tests
|
|
#
|
|
|
|
if (WHISPER_BUILD_TESTS AND NOT CMAKE_JS_VERSION)
|
|
enable_testing()
|
|
add_subdirectory(tests)
|
|
endif ()
|
|
|
|
if (WHISPER_BUILD_EXAMPLES)
|
|
add_subdirectory(examples)
|
|
endif()
|