XLDS Git

Status: Alpha
Brought to you by: kvd_wallner
[15e85e]: / CMakeLists.txt Maximize Restore History

718 lines (649 with data), 25.6 kB

cmake_minimum_required(VERSION 3.0.2)
project(XLDS)

cmake_policy(SET CMP0003 NEW)
if(POLICY CMP0075)
  cmake_policy(SET CMP0075 NEW)
endif()

set(SOURCEFORGE_MIRROR https://sourceforge.net/projects)

option(DOWNLOAD_TO_BUILD "Download to build dir." OFF)
if(DOWNLOAD_TO_BUILD)
  set(DOWNLOAD_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty/packages)
else(DOWNLOAD_TO_BUILD)
  set(DOWNLOAD_DIRECTORY ${CMAKE_SOURCE_DIR}/../cmake-downloads)
endif(DOWNLOAD_TO_BUILD)

enable_testing()

option(INSTALL_HEADERS "Install header files." OFF)
option(CMAKE_VERBOSE_MAKEFILE "Verbose makefile" OFF)

#
# OS Specifics
#

if(UNIX AND NOT APPLE)
  set(LINUX TRUE)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
endif(UNIX AND NOT APPLE)

if(APPLE)
  if(iPhone)
    set(CMAKE_OSX_ARCHITECTURES "$(ARCHS_UNIVERSAL_IPHONE_OS)" CACHE STRING "Build architectures for OSX" FORCE)
    set(CMAKE_OSX_SYSROOT /Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS4.2.sdk CACHE PATH "The product will be built against the headers and libraries located inside the indicated SDK." FORCE)
  else(iPhone)
    option(OSX_10_4_UNIVERSAL_BUILD "Build 10.4 universal binary." OFF)
    if(OSX_10_4_UNIVERSAL_BUILD)
      # Only works for Xcode builds at the moment
      set(CMAKE_CXX_COMPILER "${DEVROOT}/usr/bin/g++-4.0" CACHE FILEPATH "C compiler" FORCE)
      set(CMAKE_C_COMPILER "${DEVROOT}/usr/bin/gcc-4.0" CACHE FILEPATH "C++ compiler" FORCE)
      set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.gcc.4_0")
      set(CMAKE_OSX_ARCHITECTURES "i386;ppc" CACHE STRING "Build architectures for OSX" FORCE)
      set(CMAKE_MACOSX_DEPLOYMENT_TARGET "10.4" CACHE STRING "Minimum OS X version to target for deployment (at runtime); newer APIs weak linked. Set to empty string for default value." FORCE)
      set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX10.4u.sdk CACHE PATH "The product will be built against the headers and libraries located inside the indicated SDK." FORCE)

    else(OSX_10_4_UNIVERSAL_BUILD)
#      set(CMAKE_OSX_ARCHITECTURES "ppc;i386;ppc64;x86_64" CACHE STRING "Build architectures for OSX" FORCE)
    endif(OSX_10_4_UNIVERSAL_BUILD)
  endif(iPhone)
endif(APPLE)

if(WIN32)
  if(MINGW)
    set(PA_USE_DS OFF CACHE BOOL "Enable support for DirectSound" FORCE)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
  endif()

  if(MSVC)
    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
    add_definitions(-wd4290)
    add_definitions(-we4013 -we4715)
    add_definitions(-wd4244)
  endif(MSVC)

# _USE_MATH_DEFINES enables math.h M_PI and friends
  add_definitions(-D_USE_MATH_DEFINES)
endif(WIN32)

#
# Output directories
#

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
if(NOT OSX_10_4_UNIVERSAL_BUILD)
  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
endif(NOT OSX_10_4_UNIVERSAL_BUILD)
set(DOCUMENTATION_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/doc)

#
# Include checks
#

include(CheckIncludeFile)
check_include_file(getopt.h HAVE_GETOPT_H)
if(HAVE_GETOPT_H)
  add_definitions(-DHAVE_GETOPT_H=1)
endif(HAVE_GETOPT_H)
check_include_file(curses.h HAVE_CURSES_H)
if(HAVE_CURSES_H)
  add_definitions(-DHAVE_CURSES_H=1)
endif(HAVE_CURSES_H)
check_include_file(termios.h HAVE_TERMIOS_H)
if(HAVE_TERMIOS_H)
  add_definitions(-DHAVE_TERMIOS_H=1)
endif(HAVE_TERMIOS_H)

#
# Function checks
#

include(CheckFunctionExists)
set(CMAKE_REQUIRED_INCLUDES math.h)
if(NOT MSVC)
  set(CMAKE_REQUIRED_LIBRARIES m)
endif()
check_function_exists(lrint HAVE_LRINT)
if(HAVE_LRINT)
  add_definitions(-DHAVE_LRINT=1)
endif(HAVE_LRINT)
check_function_exists(lrintf HAVE_LRINTF)
if(HAVE_LRINTF)
  add_definitions(-DHAVE_LRINTF=1)
endif(HAVE_LRINTF)
check_function_exists(llrint HAVE_LLRINT)
if(HAVE_LLRINT)
  add_definitions(-DHAVE_LLRINT=1)
endif(HAVE_LLRINT)
check_function_exists(llrintf HAVE_LLRINTF)
if(HAVE_LLRINTF)
  add_definitions(-DHAVE_LLRINTF=1)
endif(HAVE_LLRINTF)

#
# 3rd Party Libraries
#

include(cmake/getfiles.cmake)

include(FindPkgConfig)

#
# Dependencies with optional download
#

# ASIO

option(INTERNAL_ASIO "Use internal ASIO library" OFF)
if(INTERNAL_ASIO)
  set(ASIO_FOUND true)
  set(ASIO_NAME ASIOSDK2.3.2)
  set(INSTALLED_ASIO INSTALLED_ASIO-NOTFOUND CACHE FILEPATH "Path to a file." FORCE)
  set(ASIO_SDK_ROOT_DIR ${CMAKE_BINARY_DIR}/3rdparty/${ASIO_NAME})
  set(ASIO_SDK_INCLUDE_DIR ${CMAKE_BINARY_DIR}/3rdparty/${ASIO_NAME}/host)
  find_file(
    INSTALLED_ASIO ${ASIO_NAME}/readme.txt ${CMAKE_BINARY_DIR}/3rdparty
    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
  if(NOT INSTALLED_ASIO)
    get_package(http://www.steinberg.net/sdk_downloads/${ASIO_NAME}.zip ${ASIO_NAME} ${ASIO_NAME}.zip)
    message(STATUS "Extracting ASIO SDK")
    message(STATUS "${UNZIP_EXE} -o ${DOWNLOAD_DIRECTORY}/${ASIO_NAME}.zip")
    execute_process(COMMAND ${UNZIP_EXE} -o ${DOWNLOAD_DIRECTORY}/${ASIO_NAME}.zip
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty
      RESULT_VARIABLE COMMAND_RESULT
      OUTPUT_VARIABLE COMMAND_OUTPUT
      ERROR_VARIABLE COMMAND_ERROR)
    if(COMMAND_RESULT)
      message(STATUS ${COMMAND_OUTPUT})
      message(FATAL_ERROR ${COMMAND_ERROR})
    endif(COMMAND_RESULT)
  endif(NOT INSTALLED_ASIO)
endif(INTERNAL_ASIO)

# The C Container Library

option(INTERNAL_CCL "Use internal C container library" ON)
if(INTERNAL_CCL)
  set(CCL_FOUND true)
  set(CCL_NAME ccl-b94d6d8abe493798065683935a73044cb3fff3a0)
  set(CCL_PACKAGE_NAME b94d6d8)
  set(INSTALLED_CCL INSTALLED_CCL-NOTFOUND CACHE FILEPATH "Path to a file." FORCE)
  find_file(
    INSTALLED_CCL ${CCL_NAME}/ccl/containers.h ${CMAKE_BINARY_DIR}/3rdparty
    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
  if(NOT INSTALLED_CCL)
    get_package(https://github.com/danielwallner/ccl/archive/${CCL_PACKAGE_NAME}.zip ${CCL_PACKAGE_NAME} ${CCL_PACKAGE_NAME}.zip)
    message(STATUS "Extracting The C Container Library")
    message(STATUS "${UNZIP_EXE} -o -d ${CCL_NAME} ${DOWNLOAD_DIRECTORY}/${CCL_PACKAGE_NAME}.zip")
    execute_process(COMMAND ${UNZIP_EXE} -o -d ${CCL_NAME} ${DOWNLOAD_DIRECTORY}/${CCL_PACKAGE_NAME}.zip
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty
      RESULT_VARIABLE COMMAND_RESULT
      OUTPUT_VARIABLE COMMAND_OUTPUT
      ERROR_VARIABLE COMMAND_ERROR)
    if(COMMAND_RESULT)
      message(STATUS ${COMMAND_OUTPUT})
      message(FATAL_ERROR ${COMMAND_ERROR})
    endif(COMMAND_RESULT)
	file(RENAME ${CMAKE_BINARY_DIR}/3rdparty/${CCL_NAME}/${CCL_NAME} ${CMAKE_BINARY_DIR}/3rdparty/${CCL_NAME}/ccl)
  endif()
  find_file(
    INSTALLED_CCL ${CCL_NAME}/ccl/containers.h ${CMAKE_BINARY_DIR}/3rdparty
    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
  if(INSTALLED_CCL)
    configure_file(${CMAKE_SOURCE_DIR}/3rdparty/${CCL_NAME}.CMakeLists.txt ${CMAKE_BINARY_DIR}/3rdparty/${CCL_NAME}/ccl/CMakeLists.txt COPYONLY)
  endif()
  add_subdirectory(${CMAKE_BINARY_DIR}/3rdparty/${CCL_NAME}/ccl 3rdparty/${CCL_NAME}-binary)
  include_directories(${CMAKE_BINARY_DIR}/3rdparty/${CCL_NAME})
else(INTERNAL_CCL)
# No support yet
endif(INTERNAL_CCL)


# fftw3

option(INTERNAL_FFTW3 "Use internal fftw3 library" OFF)
pkg_search_module(FFTW3 fftw3)
if(PKG_CONFIG_FOUND AND FFTW3_FOUND AND NOT INTERNAL_FFTW3)
  include_directories(${FFTW3_INCLUDE_DIRS})
  link_directories(${FFTW3_LIBRARY_DIRS})
else(PKG_CONFIG_FOUND AND FFTW3_FOUND AND NOT INTERNAL_FFTW3)
  if(INTERNAL_FFTW3)
    set(FFTW_NAME fftw-3.2.2)
    if(WIN32)
      set(FFTW3_FOUND true)
      include_directories(${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll)
      link_directories(${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll)
      if(MSVC)
        set(FFTW3_LIBRARIES libfftw3-3)
      else(MSVC)
        set(FFTW3_LIBRARIES fftw3-3)
      endif(MSVC)
      set(FFTW3_DLL_SUFFIX .pl1-dll32)
      set(INSTALLED_${FFTW_NAME}-dll INSTALLED_${FFTW_NAME}-dll-NOTFOUND CACHE FILEPATH "Path to a file." FORCE)
      find_file(
        INSTALLED_${FFTW_NAME}-dll ${FFTW_NAME}-dll/COPYING ${CMAKE_BINARY_DIR}/3rdparty
        NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
      if(NOT INSTALLED_${FFTW_NAME}-dll)
        get_package("ftp://ftp.fftw.org/pub/fftw/${FFTW_NAME}${FFTW3_DLL_SUFFIX}.zip" ${FFTW_NAME}${FFTW3_DLL_SUFFIX} ${FFTW_NAME}${FFTW3_DLL_SUFFIX}.zip)
        message(STATUS "Extracting ${FFTW_NAME}${FFTW3_DLL_SUFFIX}.zip")
        execute_process(COMMAND ${UNZIP_EXE} -o ${DOWNLOAD_DIRECTORY}/${FFTW_NAME}${FFTW3_DLL_SUFFIX}.zip -d ${FFTW_NAME}-dll
          WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty
          RESULT_VARIABLE COMMAND_RESULT
          OUTPUT_VARIABLE COMMAND_OUTPUT
          ERROR_VARIABLE COMMAND_ERROR)
        if(COMMAND_RESULT)
          message(STATUS ${COMMAND_OUTPUT})
          message(FATAL_ERROR ${COMMAND_ERROR})
        endif(COMMAND_RESULT)
        if(MSVC)
          message("Creating fftw lib maker batch file in ${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll")
          file(WRITE "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/makelibs.bat" "lib /machine:i386 /def:libfftw3-3.def\n")
          file(APPEND "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/makelibs.bat" "lib /machine:i386 /def:libfftw3f-3.def\n")
          file(APPEND "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/makelibs.bat" "lib /machine:i386 /def:libfftw3l-3.def\n")
          file(COPY
            "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/libfftw3-3.dll"
            DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Debug")
          file(COPY
            "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/libfftw3f-3.dll"
            DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Debug")
          file(COPY
            "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/libfftw3l-3.dll"
            DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Debug")
          file(COPY
            "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/libfftw3-3.dll"
            DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Release")
          file(COPY
            "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/libfftw3f-3.dll"
            DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Release")
          file(COPY
            "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/libfftw3l-3.dll"
            DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/Release")
        else(MSVC)
          file(COPY
            "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/libfftw3-3.dll"
            DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
          file(COPY
            "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/libfftw3f-3.dll"
            DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
          file(COPY
            "${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}-dll/libfftw3l-3.dll"
            DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
        endif(MSVC)
      endif(NOT INSTALLED_${FFTW_NAME}-dll)
      message(STATUS "Using internal ${FFTW_NAME}")
    else(WIN32)
      if(INTERNAL_FFTW3)
        set(FFTW3_FOUND true)
        include_directories(${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}/api)
        set(FFTW3_LIBRARIES ${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}/libs/libfftw3.a ${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME}/libs/libfftw3f.a)
        get_gz_package(http://www.fftw.org/${FFTW_NAME}.tar.gz ${FFTW_NAME} ${FFTW_NAME}.tar.gz COPYING TRUE)
        add_subdirectory(${CMAKE_BINARY_DIR}/3rdparty/${FFTW_NAME} 3rdparty/${FFTW_NAME}-binary)
        message(STATUS "Using internal ${FFTW_NAME}")
      endif(INTERNAL_FFTW3)
    endif(WIN32)
  endif(INTERNAL_FFTW3)
endif(PKG_CONFIG_FOUND AND FFTW3_FOUND AND NOT INTERNAL_FFTW3)
if(FFTW3_FOUND)
  add_definitions(-DHAVE_FFTW3=1)
else(FFTW3_FOUND)
  message(STATUS "Warning: Not using FFTW")
endif(FFTW3_FOUND)

# Kiss FFT

if(FALSE)
  set(KISSFFT_FOUND true)
  set(KISSFFT_NAME kissfft-131.1.0)
  set(KISSFFT_LIBRARIES trd_kissfft)
  set(INSTALLED_KISSFFT INSTALLED_KISSFFT-NOTFOUND CACHE FILEPATH "Path to a file." FORCE)
  find_file(
    INSTALLED_KISSFFT kiss_fft.c ${CMAKE_BINARY_DIR}/3rdparty/${KISSFFT_NAME}
    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
  if(NOT INSTALLED_KISSFFT)
    get_package(https://github.com/mborgerding/kissfft/archive/refs/tags/131.1.0.zip ${KISSFFT_NAME} ${KISSFFT_NAME}.zip)
    message(STATUS "Extracting Kiss FFT")
    message(STATUS "${UNZIP_EXE} -o fft.zip")
    execute_process(COMMAND ${UNZIP_EXE} -o ${DOWNLOAD_DIRECTORY}/${KISSFFT_NAME}.zip
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty
      RESULT_VARIABLE COMMAND_RESULT
      OUTPUT_VARIABLE COMMAND_OUTPUT
      ERROR_VARIABLE COMMAND_ERROR)
    if(COMMAND_RESULT)
      message(STATUS ${COMMAND_OUTPUT})
      message(FATAL_ERROR ${COMMAND_ERROR})
    endif(COMMAND_RESULT)
  endif(NOT INSTALLED_KISSFFT)
  configure_file(${CMAKE_SOURCE_DIR}/3rdparty/${KISSFFT_NAME}.CMakeLists.txt ${CMAKE_BINARY_DIR}/3rdparty/${KISSFFT_NAME}/CMakeLists.txt COPYONLY)
  add_subdirectory(${CMAKE_BINARY_DIR}/3rdparty/${KISSFFT_NAME} 3rdparty/${KISSFFT_NAME}-binary)
  include_directories(${CMAKE_BINARY_DIR}/3rdparty/${KISSFFT_NAME})
  add_definitions(-Dkiss_fft_scalar=double)
endif()
if(KISSFFT_FOUND)
  add_definitions(-DHAVE_KISSFFT=1)
endif(KISSFFT_FOUND)

# libsndfile

option(INTERNAL_LIBSNDFILE "Use internal libsndfile library" ${WIN32})
if(NOT INTERNAL_LIBSNDFILE)
  pkg_search_module(LIBSNDFILE sndfile)
  if(PKG_CONFIG_FOUND AND LIBSNDFILE_FOUND)
    include_directories(${LIBSNDFILE_INCLUDE_DIRS})
    link_directories(${LIBSNDFILE_LIBRARY_DIRS})
  endif()
  if(NOT LIBSNDFILE_FOUND)
    message(WARNING "libsndfile not found. Downloading project local copy.")
    set(INTERNAL_LIBSNDFILE TRUE)
  endif()
endif()
if(INTERNAL_LIBSNDFILE)
  set(LIBSNDFILE_NAME libsndfile-1.0.23)
  set(LIBSNDFILE_LIBRARIES trd_libsndfile)
  get_gz_package(http://www.mega-nerd.com/libsndfile/files/${LIBSNDFILE_NAME}.tar.gz ${LIBSNDFILE_NAME} ${LIBSNDFILE_NAME}.tar.gz COPYING TRUE)
  configure_file(${CMAKE_SOURCE_DIR}/3rdparty/${LIBSNDFILE_NAME}.sndfile.h ${CMAKE_BINARY_DIR}/3rdparty/${LIBSNDFILE_NAME}/src/sndfile.h COPYONLY)
  configure_file(${CMAKE_SOURCE_DIR}/3rdparty/${LIBSNDFILE_NAME}.config.h.cmake ${CMAKE_BINARY_DIR}/3rdparty/${LIBSNDFILE_NAME}/src/config.h.cmake COPYONLY)
  add_subdirectory(${CMAKE_BINARY_DIR}/3rdparty/${LIBSNDFILE_NAME} 3rdparty/${LIBSNDFILE_NAME}-binary)
  include_directories(${CMAKE_BINARY_DIR}/3rdparty/${LIBSNDFILE_NAME}/src)
endif()

# my_getopt

if(MSVC)
  set(MY_GETOPT_NAME my_getopt-1.5)
  get_gz_package(http://xent.com/~bsittler/geocities/${MY_GETOPT_NAME}.tgz ${MY_GETOPT_NAME} ${MY_GETOPT_NAME}.tgz LICENSE FALSE)
  include_directories(SYSTEM "${CMAKE_BINARY_DIR}/3rdparty/${MY_GETOPT_NAME}")
  set(NEED_MY_GETOPT_C "${CMAKE_BINARY_DIR}/3rdparty/${MY_GETOPT_NAME}/my_getopt.c")
endif(MSVC)

# ooura fft

if(NOT FFTW3_FOUND)
  set(FFTSG_FOUND true)
  set(FFTSG_NAME fft)
  set(FFTSG_LIBRARIES trd_fftsg)
  set(INSTALLED_FFTSG INSTALLED_FFTSG-NOTFOUND CACHE FILEPATH "Path to a file." FORCE)
  find_file(
    INSTALLED_FFTSG fftsg.c ${CMAKE_BINARY_DIR}/3rdparty/fft
    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
  configure_file(${CMAKE_SOURCE_DIR}/3rdparty/${FFTSG_NAME}.CMakeLists.txt ${CMAKE_BINARY_DIR}/3rdparty/${FFTSG_NAME}/CMakeLists.txt COPYONLY)
  if(NOT INSTALLED_FFTSG)
    get_package(http://www.kurims.kyoto-u.ac.jp/~ooura/${FFTSG_NAME}.zip fftsg ${FFTSG_NAME}.zip)
    message(STATUS "Extracting ooura fft")
    message(STATUS "${UNZIP_EXE} -o fft.zip")
    execute_process(COMMAND ${UNZIP_EXE} -o ${DOWNLOAD_DIRECTORY}/${FFTSG_NAME}.zip
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty
      RESULT_VARIABLE COMMAND_RESULT
      OUTPUT_VARIABLE COMMAND_OUTPUT
      ERROR_VARIABLE COMMAND_ERROR)
    if(COMMAND_RESULT)
      message(STATUS ${COMMAND_OUTPUT})
      message(FATAL_ERROR ${COMMAND_ERROR})
    endif(COMMAND_RESULT)
  endif(NOT INSTALLED_FFTSG)
  add_subdirectory(${CMAKE_BINARY_DIR}/3rdparty/${FFTSG_NAME} 3rdparty/${FFTSG_NAME}-binary)
endif()
if(FFTSG_FOUND)
  add_definitions(-DHAVE_FFTSG=1)
endif(FFTSG_FOUND)

# pocketfft

if(NOT FFTW3_FOUND)
  set(POCKETFFT_FOUND true)
  set(POCKETFFT_NAME pocketfft-master-81d171a6d5562e3aaa2c73489b70f564c633ff81)
  set(POCKETFFT_LIBRARIES trd_pocketfft)
  set(INSTALLED_POCKETFFT INSTALLED_POCKETFFT-NOTFOUND CACHE FILEPATH "Path to a file." FORCE)
  find_file(
    INSTALLED_POCKETFFT pocketfft.c ${CMAKE_BINARY_DIR}/3rdparty/${POCKETFFT_NAME}
    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
  if(NOT INSTALLED_POCKETFFT)
    get_gz_package(https://gitlab.mpcdf.mpg.de/mtr/pocketfft/-/archive/master/${POCKETFFT_NAME}.tar.gz ${POCKETFFT_NAME} ${POCKETFFT_NAME}.tar.gz README.md TRUE)
    message(STATUS "Extracting pocketfft")
    message(STATUS "${TAR_EXE} xzf ${POCKETFFT_NAME}.tar.gz")
    execute_process(COMMAND ${TAR_EXE} xzf "${DOWNLOAD_DIRECTORY}/${POCKETFFT_NAME}.tar.gz"
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty
      RESULT_VARIABLE COMMAND_RESULT
      OUTPUT_VARIABLE COMMAND_OUTPUT
      ERROR_VARIABLE COMMAND_ERROR)
    if(COMMAND_RESULT)
      message(STATUS ${COMMAND_OUTPUT})
      message(FATAL_ERROR ${COMMAND_ERROR})
    endif(COMMAND_RESULT)
  endif(NOT INSTALLED_POCKETFFT)
  configure_file(${CMAKE_SOURCE_DIR}/3rdparty/${POCKETFFT_NAME}.CMakeLists.txt ${CMAKE_BINARY_DIR}/3rdparty/${POCKETFFT_NAME}/CMakeLists.txt COPYONLY)
  add_subdirectory(${CMAKE_BINARY_DIR}/3rdparty/${POCKETFFT_NAME} 3rdparty/${POCKETFFT_NAME}-binary)
  include_directories(${CMAKE_BINARY_DIR}/3rdparty/${POCKETFFT_NAME})
endif()
if(POCKETFFT_FOUND)
  add_definitions(-DHAVE_POCKETFFT=1)
endif(POCKETFFT_FOUND)

# portaudio

option(INTERNAL_PORTAUDIO "Use internal portaudio library" ON)
if(NOT INTERNAL_PORTAUDIO)
  pkg_search_module(PORTAUDIO portaudio)
  if(PKG_CONFIG_FOUND AND PORTAUDIO_FOUND)
    include_directories(${PORTAUDIO_INCLUDE_DIRS})
    link_directories(${PORTAUDIO_LIBRARY_DIRS})
  endif()
  if(NOT PORTAUDIO_FOUND)
    message(WARNING "portaudio not found. Downloading project local copy.")
    set(INTERNAL_PORTAUDIO TRUE)
  endif()
endif()
if(INTERNAL_PORTAUDIO)
  set(PORTAUDIO_FOUND true)
  set(PORTAUDIO_NAME pa_stable_v190700_20210406)
  set(PORTAUDIO_ORIG_NAME portaudio)
  if(BUILD_SHARED_LIBS)
    set(PORTAUDIO_LIBRARIES portaudio)
  else(BUILD_SHARED_LIBS)
    set(PORTAUDIO_LIBRARIES portaudio_static)
  endif(BUILD_SHARED_LIBS)
  if(APPLE)
    #set(PORTAUDIO_LIBRARIES ${PORTAUDIO_LIBRARIES} "-framework CoreAudio" "-framework AudioToolbox" "-framework AudioUnit")
  endif()
  if(LINUX)
    set(PORTAUDIO_LIBRARIES ${PORTAUDIO_LIBRARIES} asound)
  endif()
  if(WIN32)
    set(PORTAUDIO_LIBRARIES ${PORTAUDIO_LIBRARIES} ole32 uuid strmiids)
    if(PA_USE_WDMKS)
      set(PORTAUDIO_LIBRARIES ${PORTAUDIO_LIBRARIES} setupapi)
    endif()
  endif()
  set(INSTALLED_PORTAUDIO INSTALLED_PORTAUDIO-NOTFOUND CACHE FILEPATH "Path to a file." FORCE)
  find_file(
    INSTALLED_PORTAUDIO ${PORTAUDIO_NAME}/LICENSE.txt ${CMAKE_BINARY_DIR}/3rdparty
    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
  if(NOT INSTALLED_PORTAUDIO)
    get_package(http://files.portaudio.com/archives/${PORTAUDIO_NAME}.tgz ${PORTAUDIO_NAME} ${PORTAUDIO_NAME}.tgz)
    message(STATUS "Extracting portaudio")
    message(STATUS "${TAR_EXE} xzf ${CMAKE_SOURCE_DIR}/3rdparty/${PORTAUDIO_NAME}")
    execute_process(COMMAND ${TAR_EXE} xzf "${DOWNLOAD_DIRECTORY}/${PORTAUDIO_NAME}.tgz"
      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/3rdparty
      RESULT_VARIABLE COMMAND_RESULT
      OUTPUT_VARIABLE COMMAND_OUTPUT
      ERROR_VARIABLE COMMAND_ERROR)
    if(COMMAND_RESULT)
      message(STATUS ${COMMAND_OUTPUT})
      message(FATAL_ERROR ${COMMAND_ERROR})
    endif(COMMAND_RESULT)
    file(RENAME "${CMAKE_BINARY_DIR}/3rdparty/${PORTAUDIO_ORIG_NAME}" "${CMAKE_BINARY_DIR}/3rdparty/${PORTAUDIO_NAME}")
  endif()
  configure_file(${CMAKE_SOURCE_DIR}/3rdparty/${PORTAUDIO_NAME}.CMakeLists.txt ${CMAKE_BINARY_DIR}/3rdparty/${PORTAUDIO_NAME}/CMakeLists.txt COPYONLY)
  add_subdirectory(${CMAKE_BINARY_DIR}/3rdparty/${PORTAUDIO_NAME} 3rdparty/${PORTAUDIO_NAME}-binary)
  include_directories(${CMAKE_BINARY_DIR}/3rdparty/${PORTAUDIO_NAME}/include)
endif()

#
# Libraries that are only searched for
#

if(UNIX)
  pkg_search_module(ALSA alsa)
  if(PKG_CONFIG_FOUND AND ALSA_FOUND)
    include_directories(${ALSA_INCLUDE_DIRS})
    link_directories(${ALSA_LIBRARY_DIRS})
    message(STATUS "Found ALSA")
  endif(PKG_CONFIG_FOUND AND ALSA_FOUND)
endif(UNIX)

# plotutils/libplot

option(ENABLE_LIBPLOT "GNU plotutils/libplot plot driver" ON)
if(ENABLE_LIBPLOT)
  find_library(PLOT_FOUND NAMES plot PATHS /usr/lib /usr/local/lib)
  if(PLOT_FOUND)
    add_definitions(-DHAVE_LIBPLOT)
    set(PLOT_LIBRARIES ${PLOT_FOUND} png z)
    message(STATUS "Found plotutils")
  endif(PLOT_FOUND)
endif(ENABLE_LIBPLOT)
if(NOT ENABLE_LIBPLOT)
  set(LIBPLOT_FOUND 0)
endif(NOT ENABLE_LIBPLOT)

# gtk

if(UNIX)
  option(ENABLE_GTK "GTK plot driver" ON)
  if(ENABLE_GTK)
    pkg_search_module(GTK gtk+-2.0)
    if(PKG_CONFIG_FOUND AND GTK_FOUND)
      include_directories(${GTK_INCLUDE_DIRS})
      link_directories(${GTK_LIBRARY_DIRS})
    endif(PKG_CONFIG_FOUND AND GTK_FOUND)
    if(GTK_FOUND)
      add_definitions(-DHAVE_GTK=1)
      message(STATUS "Found GTK+")
    endif(GTK_FOUND)
  endif(ENABLE_GTK)
  if(ENABLE_GTK AND NOT GTK_FOUND)
    message(MESSAGE "GTK+ not found")
  endif(ENABLE_GTK AND NOT GTK_FOUND)
endif(UNIX)
if(NOT ENABLE_GTK)
  set(GTK_FOUND 0)
  set(GTK_LIBRARIES "")
endif(NOT ENABLE_GTK)

# qt

option(ENABLE_QT "Qt plot driver" OFF)
set(DESIRED_QT_VERSION 5 CACHE STRING "Desired Qt Version")
if(ENABLE_QT)
  if(DESIRED_QT_VERSION MATCHES 5)
    find_package(Qt5 COMPONENTS Core Widgets REQUIRED)
    include_directories(/usr/include/qt5)
    include_directories(/usr/include/qt5/QtWidgets)
    set(QT5_LIBRARIES Qt5::Widgets)
  elseif(DESIRED_QT_VERSION MATCHES 4)
    find_package(Qt4 REQUIRED)
    add_definitions(-DUSE_QT_4=1)
  elseif(DESIRED_QT_VERSION MATCHES 3)
    find_package(Qt4 REQUIRED)
    add_definitions(-DUSE_QT_4=1)
  else()
    message(FATAL_ERROR "Unknown Qt version")
  endif()
  set(QT_FOUND TRUE)
  add_definitions(-DHAVE_QT=1)
  message(STATUS "Found Qt")
endif(ENABLE_QT)
if(NOT ENABLE_QT)
  set(QT_FOUND 0)
  set(QT_LIBRARIES "")
endif(NOT ENABLE_QT)

# x

if(UNIX)
  option(ENABLE_X11 "X11 plot driver" ON)
  if(ENABLE_X11)
    include(FindX11)
    if(X11_FOUND)
      add_definitions(-DHAVE_X11=1)
      message(STATUS "Found X")
    endif(X11_FOUND)
  endif(ENABLE_X11)
endif(UNIX)
if(NOT ENABLE_X11)
  set(X11_FOUND 0)
  set(X11_LIBRARIES "")
endif(NOT ENABLE_X11)

#
# Utility macros
#

if(APPLE)
  macro(add_link BUNDLE_TARGET)
    set(LINK_SOURCE "${BUNDLE_TARGET}.app/Contents/MacOS/${BUNDLE_TARGET}")
    add_custom_command(TARGET ${BUNDLE_TARGET} POST_BUILD
      COMMAND ln -sf "${LINK_SOURCE}" "${BUNDLE_TARGET}"
      WORKING_DIRECTORY "$<TARGET_FILE_DIR:${BUNDLE_TARGET}>/../../..")
  endmacro(add_link)
endif(APPLE)

#
#
#

if(WIN32 AND BUILD_SHARED_LIBS)
  add_definitions(-DCPPUNIT_DLL_EXPORTS)
  add_definitions(-DARP_DLL)
  add_definitions(-DBURY_DLL)
  add_definitions(-DSIGNALKIT_DLL)
  add_definitions(-DPLOTKIT_DLL)
  add_definitions(-DLSPKIT_DLL)
  add_definitions(-DPROBEKIT_DLL)
  add_definitions(-DNAFF_DLL)
endif(WIN32 AND BUILD_SHARED_LIBS)

include_directories(.)

if(CPPUTEST_LEAK_DETECTION)
  include_directories(${CPPUTEST_INCLUDE_DIR})
  add_definitions(-DCPPUTEST_USE_MEM_LEAK_DETECTION)
endif(CPPUTEST_LEAK_DETECTION)

set(BURY_DEPENDENCIES
  int_arp
  trd_ccl)
if(UNIX)
  set(BURY_DEPENDENCIES ${BURY_DEPENDENCIES} m)
endif(UNIX)
if(CPPUTEST_LEAK_DETECTION)
  set(BURY_DEPENDENCIES ${BURY_DEPENDENCIES} ${CPPUTEST_LIBRARIES})
endif(CPPUTEST_LEAK_DETECTION)
if(HAVE_CURSES_H)
  set(BURY_DEPENDENCIES ${BURY_DEPENDENCIES} curses)
endif(HAVE_CURSES_H)
set(BURY_LIBRARIES
  int_bury
  ${BURY_DEPENDENCIES})

set(SIGNALKIT_DEPENDENCIES
  ${PORTAUDIO_LIBRARIES}
  ${BURY_LIBRARIES}
  ${LIBSAMPLERATE_LIBRARIES}
  ${LIBSNDFILE_LIBRARIES})
if(APPLE)
  set(SIGNALKIT_DEPENDENCIES
    ${SIGNALKIT_DEPENDENCIES}
    "-framework Accelerate"
    "-framework Foundation")
endif(APPLE)
if(WIN32)
  set(SIGNALKIT_DEPENDENCIES
    ${SIGNALKIT_DEPENDENCIES}
    winmm)
endif(WIN32)
if(FFTW3_FOUND)
  set(SIGNALKIT_DEPENDENCIES
    ${SIGNALKIT_DEPENDENCIES}
    ${FFTW3_LIBRARIES})
else(FFTW3_FOUND)
  set(SIGNALKIT_DEPENDENCIES
    ${SIGNALKIT_DEPENDENCIES}
    ${FFTPACK_LIBRARIES}
    ${KISSFFT_LIBRARIES}
    ${FFTSG_LIBRARIES}
    ${POCKETFFT_LIBRARIES})
endif(FFTW3_FOUND)
set(SIGNALKIT_LIBRARIES
  int_signalkit
  ${SIGNALKIT_DEPENDENCIES})

set(PLOTKIT_DEPENDENCIES
  ${SIGNALKIT_LIBRARIES}
  ${PLOT_LIBRARIES}
  ${GTK_LIBRARIES}
  ${QT5_LIBRARIES}
  ${QT4_LIBRARIES}
  ${X11_LIBRARIES})
if(APPLE)
  set(PLOTKIT_DEPENDENCIES
    ${PLOTKIT_DEPENDENCIES}
    "-framework AppKit"
    "-framework ApplicationServices")
endif(APPLE)
set(PLOTKIT_LIBRARIES
  int_plotkit
  ${PLOTKIT_DEPENDENCIES})

set(LSPKIT_DEPENDENCIES
  ${PLOTKIT_LIBRARIES})
set(LSPKIT_LIBRARIES
  int_lspkit
  ${LSPKIT_DEPENDENCIES})

set(PROBEKIT_DEPENDENCIES
  ${LSPKIT_LIBRARIES})
set(PROBEKIT_LIBRARIES
  int_probekit
  ${PROBEKIT_DEPENDENCIES})

set(NAFF_DEPENDENCIES
  ${PROBEKIT_LIBRARIES})
set(NAFF_LIBRARIES
  int_naff
  ${NAFF_DEPENDENCIES})

# Base abstract runtime library
add_subdirectory(arp)

# Base concrete runtime and generic support library (only depends on crt)
add_subdirectory(bury)
# Signal processing support kit
add_subdirectory(signalkit)
# Loudspeaker design support kit
add_subdirectory(lspkit)
# Plotting support kit
add_subdirectory(plotkit)
# Audio measurement support kit
add_subdirectory(probekit)

# More complete file support
add_subdirectory(naff)

# Loudspeaker design utilities
add_subdirectory(xldsutils)

# Loudspeaker design applications
add_subdirectory(xldsapps)
XLDS Git

Branches

[15e85e]: / CMakeLists.txt Maximize Restore History

718 lines (649 with data), 25.6 kB
