CMakeLists.txt

CMAKE_MINIMUM_REQUIRED(VERSION 3.22.1)

PROJECT(lsmm)

SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules" ${CMAKE_MODULE_PATH})

IF(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
  MESSAGE(FATAL_ERROR "In-source builds not allowed. Please make a new directory (called a build directory) and run CMake from there. You may need to remove CMakeCache.txt.")
ENDIF()

IF(COMMAND CMAKE_POLICY)
	CMAKE_POLICY(SET CMP0003 NEW)
        CMAKE_POLICY(SET CMP0005 NEW)
	IF (CMAKE_MAJOR_VERSION GREATER 2)
		#CMAKE_POLICY(SET CMP0026 OLD)
		CMAKE_POLICY(SET CMP0045 NEW)
		#CMAKE_POLICY(SET CMP0050 OLD) # Add custom op
	    CMAKE_POLICY(SET CMP0072 NEW) # OpenGL
	ENDIF()
ENDIF(COMMAND CMAKE_POLICY)

INCLUDE(AddFileDependencies)
INCLUDE(CheckIncludeFiles)
INCLUDE(FindPkgConfig)

STRING(TOUPPER          "${CMAKE_PROJECT_NAME}" PROJECT_NAME_UCASE)

SET(PROJECT_YEAR 2018)

SET(PROJECT_AUTHOR      "LSMM Developers")
SET(PROJECT_URL         "https://lmms.io")
SET(PROJECT_EMAIL       "lmms-devel@lists.sourceforge.net")
SET(PROJECT_DESCRIPTION "${PROJECT_NAME_UCASE} - Free music production software")
SET(PROJECT_COPYRIGHT   "2008-${PROJECT_YEAR} ${PROJECT_AUTHOR}")
SET(VERSION_MAJOR       "1")
SET(VERSION_MINOR       "4")
SET(VERSION_RELEASE     "0")
SET(VERSION_STAGE       "alpha")
SET(VERSION_BUILD       "0")
SET(VERSION             "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_RELEASE}")
IF(VERSION_STAGE)
	SET(VERSION     "${VERSION}-${VERSION_STAGE}")
ENDIF()
IF(VERSION_BUILD)
	SET(VERSION     "${VERSION}.${VERSION_BUILD}")
ENDIF()

# Override version information for non-base builds
INCLUDE(VersionInfo)
INCLUDE(DetectMachine)


OPTION(WANT_ALSA	"Include ALSA (Advanced Linux Sound Architecture) support" ON)
OPTION(WANT_CALF	"Include CALF LADSPA plugins" ON)
OPTION(WANT_CAPS	"Include C* Audio Plugin Suite (LADSPA plugins)" ON)
OPTION(WANT_CARLA	"Include Carla plugin" ON)
OPTION(WANT_CMT		"Include Computer Music Toolkit LADSPA plugins" ON)
OPTION(WANT_JACK	"Include JACK (Jack Audio Connection Kit) support" ON)
OPTION(WANT_LV2	        "Include LV2 support" OFF)
OPTION(WANT_MPG123	"Include MP3/mpg123 support" ON)
OPTION(WANT_MP3LAME	"Include MP3/Lame support" ON)
OPTION(WANT_OGGVORBIS	"Include OGG/Vorbis support" ON)
OPTION(WANT_OSS		"Include OSS (Open Sound System) support" ON)
OPTION(WANT_PULSEAUDIO	"Include PulseAudio support" ON)
OPTION(WANT_PORTAUDIO	"Include PortAudio support" ON)
OPTION(WANT_SOUNDIO	"Include libsoundio support" ON)
OPTION(WANT_SDL		"Include SDL (Simple DirectMedia Layer) support" ON)
OPTION(WANT_SF2		"Include SoundFont2 player plugin" ON)
OPTION(WANT_GIG		"Include GIG player plugin" ON)
OPTION(WANT_STK		"Include Stk (Synthesis Toolkit) support" ON)
OPTION(WANT_SWH		"Include Steve Harris's LADSPA plugins" ON)
OPTION(WANT_TAP		"Include Tom's Audio Processing LADSPA plugins" ON)
OPTION(WANT_VST         "Include VST support" ON)
OPTION(WANT_WINE	"Include Wine support (for VST)" ON)
OPTION(WANT_WINMM	"Include WinMM MIDI support" OFF)
#OPTION(WANT_QT6		"Build with Qt6" ON)
OPTION(WANT_DEBUG_FPE	"Debug floating point exceptions" ON)
OPTION(WANT_DEBUG_PERFLOG "Log task performance" ON)


IF(LMMS_BUILD_APPLE)
	SET(WANT_ALSA OFF)
	SET(WANT_OSS OFF)
	SET(WANT_PULSEAUDIO OFF)
	SET(WANT_VST OFF)
	SET(WANT_WINE OFF)
	SET(STATUS_ALSA "   <not supported on this platform>")
	SET(STATUS_OSS "   <not supported on this platform>")
	SET(STATUS_PULSEAUDIO "   <not supported on this platform>")
	SET(STATUS_APPLEMIDI "OK")
ELSE(LMMS_BUILD_APPLE)
	SET(STATUS_APPLEMIDI "   <not supported on this platform>")
ENDIF(LMMS_BUILD_APPLE)


IF(LMMS_BUILD_WIN32)
	SET(WANT_ALSA OFF)
	SET(WANT_JACK OFF)
	SET(WANT_OSS OFF)
	SET(WANT_PULSEAUDIO OFF)
	SET(WANT_SOUNDIO OFF)
        SET(WANT_WINE OFF)
	SET(WANT_WINMM ON)
	SET(LMMS_HAVE_WINMM TRUE)
	SET(STATUS_ALSA "   <not supported on this platform>")
	SET(STATUS_OSS "   <not supported on this platform>")
	SET(STATUS_JACK "   <not supported on this platform>")
	SET(STATUS_PULSEAUDIO "   <not supported on this platform>")
	SET(STATUS_SOUNDIO "   <disabled in this release>")
	SET(STATUS_WINMM "OK")
	SET(STATUS_APPLEMIDI "   <not supported on this platform>")
ELSE(LMMS_BUILD_WIN32)
	SET(STATUS_WINMM "   <not supported on this platform>")
ENDIF(LMMS_BUILD_WIN32)


# TODO: Fix linking issues with msys debug builds
IF(LMMS_BUILD_MSYS AND CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
	SET(WANT_GIG OFF)
	SET(WANT_STK OFF)
	SET(WANT_SWH OFF)
	SET(STATUS_GIG "   <not built as requested>")
	SET(STATUS_STK "   <not built as requested>")
ENDIF()


CHECK_INCLUDE_FILES(stdint.h LMMS_HAVE_STDINT_H)
CHECK_INCLUDE_FILES(stdlib.h LMMS_HAVE_STDLIB_H)
CHECK_INCLUDE_FILES(pthread.h LMMS_HAVE_PTHREAD_H)
CHECK_INCLUDE_FILES(semaphore.h LMMS_HAVE_SEMAPHORE_H)
CHECK_INCLUDE_FILES(unistd.h LMMS_HAVE_UNISTD_H)
CHECK_INCLUDE_FILES(sys/types.h LMMS_HAVE_SYS_TYPES_H)
CHECK_INCLUDE_FILES(sys/ipc.h LMMS_HAVE_SYS_IPC_H)
CHECK_INCLUDE_FILES(sys/shm.h LMMS_HAVE_SYS_SHM_H)
CHECK_INCLUDE_FILES(sys/time.h LMMS_HAVE_SYS_TIME_H)
CHECK_INCLUDE_FILES(sched.h LMMS_HAVE_SCHED_H)
CHECK_INCLUDE_FILES(sys/soundcard.h LMMS_HAVE_SYS_SOUNDCARD_H)
CHECK_INCLUDE_FILES(soundcard.h LMMS_HAVE_SOUNDCARD_H)
CHECK_INCLUDE_FILES(fcntl.h LMMS_HAVE_FCNTL_H)
CHECK_INCLUDE_FILES(sys/ioctl.h LMMS_HAVE_SYS_IOCTL_H)
CHECK_INCLUDE_FILES(ctype.h LMMS_HAVE_CTYPE_H)
CHECK_INCLUDE_FILES(string.h LMMS_HAVE_STRING_H)
CHECK_INCLUDE_FILES(process.h LMMS_HAVE_PROCESS_H)
CHECK_INCLUDE_FILES(locale.h LMMS_HAVE_LOCALE_H)

LIST(APPEND CMAKE_PREFIX_PATH "${CMAKE_INSTALL_PREFIX}")


#SET(QT5 TRUE)

FIND_PACKAGE(Qt6Core REQUIRED)
FIND_PACKAGE(Qt6Core5Compat)
FIND_PACKAGE(Qt6Concurrent REQUIRED)
FIND_PACKAGE(Qt6Gui REQUIRED)
FIND_PACKAGE(Qt6Linguist)
FIND_PACKAGE(Qt6Widgets REQUIRED)
FIND_PACKAGE(Qt6Xml REQUIRED)

INCLUDE_DIRECTORIES(
  ${Qt6Core_INCLUDE_DIRS}
  ${Qt6Core5Compat_INCLUDE_DIRS}
  ${Qt6Concurrent_INCLUDE_DIRS}
  ${Qt6Gui_INCLUDE_DIRS}
  ${Qt6Linguist_INCLUDE_DIRS}
  ${Qt6Widgets_INCLUDE_DIRS}
  ${Qt6Xml_INCLUDE_DIRS}
  )

SET(QT_LIBRARIES
  Qt6::Core
  Qt6::Concurrent
  Qt6::Gui
  Qt6::Linguist
  Qt6::Widgets
  Qt6::Xml
  )

FIND_PACKAGE(Qt6Test)
SET(QT_QTTEST_LIBRARY Qt6::Test)


# check for libsndfile
PKG_CHECK_MODULES(SNDFILE REQUIRED sndfile>=1.0.18)
IF(NOT SNDFILE_FOUND)
	MESSAGE(FATAL_ERROR "LMMS requires libsndfile1 and libsndfile1-dev >= 1.0.18 - please install, remove CMakeCache.txt and try again!")
ENDIF()
# check if we can use SF_SET_COMPRESSION_LEVEL
IF(NOT SNDFILE_VERSION VERSION_LESS 1.0.26)
	SET(LMMS_HAVE_SF_COMPLEVEL TRUE)
ENDIF()

IF(WANT_CALF)
	SET(LMMS_HAVE_CALF TRUE)
	SET(STATUS_CALF "OK")
ELSE(WANT_CALF)
	SET(STATUS_CALF "   <not built as requested>")
ENDIF(WANT_CALF)

IF(WANT_CAPS)
	SET(LMMS_HAVE_CAPS TRUE)
	SET(STATUS_CAPS "OK")
ELSE(WANT_CAPS)
	SET(STATUS_CAPS "   <not built as requested>")
ENDIF(WANT_CAPS)

IF(WANT_CMT)
	SET(LMMS_HAVE_CMT TRUE)
	SET(STATUS_CMT "OK")
ELSE(WANT_CMT)
	SET(STATUS_CMT "   <not built as requested>")
ENDIF(WANT_CMT)

IF(WANT_SWH)
	SET(LMMS_HAVE_SWH TRUE)
	SET(STATUS_SWH "OK")
ELSE(WANT_SWH)
	SET(STATUS_SWH "   <not built as requested>")
ENDIF(WANT_SWH)

IF(WANT_TAP)
	SET(LMMS_HAVE_TAP TRUE)
	SET(STATUS_TAP "OK")
ELSE(WANT_TAP)
	SET(STATUS_TAP "   <not built as requested>")
ENDIF(WANT_TAP)


# check for CARLA
IF(WANT_CARLA)
	PKG_CHECK_MODULES(CARLA carla-standalone>=1.9.5)
	IF(CARLA_FOUND)
		SET(LMMS_HAVE_CARLA TRUE)
		SET(STATUS_CARLA "OK")
	ELSE(CARLA_FOUND)
		SET(STATUS_CARLA "?? <not found, please install the latest carla>")
	ENDIF(CARLA_FOUND)
ENDIF(WANT_CARLA)


# check for SDL2
IF(WANT_SDL)
	SET(SDL2_BUILDING_LIBRARY TRUE)
	FIND_PACKAGE(SDL2)
	IF(SDL2_FOUND)
		SET(LMMS_HAVE_SDL TRUE)
		SET(LMMS_HAVE_SDL2 TRUE)
		SET(STATUS_SDL "OK <using SDL2>")
		SET(SDL_INCLUDE_DIR "")
		SET(SDL_LIBRARY "")
	ELSE()
		SET(SDL2_INCLUDE_DIR "")
		SET(SDL2_LIBRARY "")
	ENDIF()
ENDIF()

# fallback to SDL1
IF(WANT_SDL AND NOT LMMS_HAVE_SDL2)
	# Fallback to SDL1.2
	SET(SDL_BUILDING_LIBRARY TRUE)
	FIND_PACKAGE(SDL)
	IF(SDL_FOUND)
		SET(LMMS_HAVE_SDL TRUE)
		SET(STATUS_SDL "OK <using SDL1.2>")
		# fix mingw since 53abd65
		IF(NOT SDL_INCLUDE_DIR)
			SET(SDL_INCLUDE_DIR "${CMAKE_FIND_ROOT_PATH}/include")
		ENDIF()
	ELSE()
	  SET(STATUS_SDL "?? <not found, please install libsdl2-dev "
            "(or similar) if you require SDL support>")
		SET(SDL_INCLUDE_DIR "")
		SET(SDL_LIBRARY "")
	ENDIF()
ENDIF()

# check for Stk
IF(WANT_STK)
	FIND_PACKAGE(STK)
	IF(STK_FOUND)
		SET(LMMS_HAVE_STK TRUE)
		SET(STATUS_STK "OK")
	ELSE(STK_FOUND)
		SET(STK_INCLUDE_DIR "")
		SET(STATUS_STK "?? <not found, please install libstk0-dev "
                  "(or similar) if you require the Mallets instrument>")
	ENDIF(STK_FOUND)
ENDIF(WANT_STK)


# check for PortAudio
IF(WANT_PORTAUDIO)
	FIND_PACKAGE(Portaudio)
	IF(PORTAUDIO_FOUND)
		SET(LMMS_HAVE_PORTAUDIO TRUE)
		SET(STATUS_PORTAUDIO "OK")
	ELSE(PORTAUDIO_FOUND)
	  SET(STATUS_PORTAUDIO "?? <not found, please install "
            "portaudio19-dev (or similar, version >= 1.9) "
	    "if you require PortAudio support>")
	ENDIF(PORTAUDIO_FOUND)
ENDIF(WANT_PORTAUDIO)


# check for libsoundio
IF(WANT_SOUNDIO)
  FIND_PACKAGE(SoundIo)
  IF(SOUNDIO_FOUND)
    SET(LMMS_HAVE_SOUNDIO TRUE)
    SET(STATUS_SOUNDIO "OK")
    INCLUDE_DIRECTORIES("${SOUNDIO_INCLUDE_DIR}")
  ELSE(SOUNDIO_FOUND)
    SET(SOUNDIO_INCLUDE_DIR "")
    SET(STATUS_SOUNDIO "?? <not found, please install libsoundio "
      "if you require libsoundio support>")
    SET(SOUNDIO_LIBRARY "")
  ENDIF(SOUNDIO_FOUND)
ENDIF(WANT_SOUNDIO)


# check for PulseAudio
IF(WANT_PULSEAUDIO)
	FIND_PACKAGE(PulseAudio)
	IF(PULSEAUDIO_FOUND)
		SET(LMMS_HAVE_PULSEAUDIO TRUE)
		SET(STATUS_PULSEAUDIO "OK")
	ELSE(PULSEAUDIO_FOUND)
	  SET(STATUS_PULSEAUDIO "?? <not found, please install "
            "libpulse-dev (or similar) "
	    "if you require PulseAudio support")
	ENDIF(PULSEAUDIO_FOUND)
ENDIF(WANT_PULSEAUDIO)
IF(NOT LMMS_HAVE_PULSEAUDIO)
	SET(PULSEAUDIO_INCLUDE_DIR "")
	SET(PULSEAUDIO_LIBRARIES "")
ENDIF(NOT LMMS_HAVE_PULSEAUDIO)


# check for libraries lilv, suil, ... needed for LV2
IF(WANT_LV2)
  FIND_PACKAGE(LILV)
  IF(LILV_FOUND)
    SET(LMMS_HAVE_LILV TRUE)
    SET(LMMS_SUPPORT_LV2 TRUE)
    SET(STATUS_LILV "OK")
  ELSE(LILV_FOUND)
    SET(STATUS_LILV "?? <not found, please install liblilv-dev, "
      "libserd-dev, libsratom-dev and libsord-0 "
      "(or similar) if you require LV2 support>")
    SET(LILV_LIBRARIES "")
    SET(LILV_INCLUDE_DIRS "")
    SET(WANT_LV2 FALSE)
  ENDIF(LILV_FOUND)
  FIND_PACKAGE(SUIL)
  IF(SUIL_FOUND)
    SET(LMMS_HAVE_SUIL TRUE)
    SET(STATUS_SUIL "OK")
  ELSE(SUIL_FOUND)
    SET(STATUS_SUIL "?? <not found, please install libsuil-dev (or similar) "
      "if you require LV2 support>")
    SET(SUIL_LIBRARIES "")
    SET(SUIL_INCLUDE_DIRS "")
    SET(WANT_LV2 FALSE)
  ENDIF(SUIL_FOUND)
ELSE(WANT_LV2)
  SET(STATUS_LILV "   <disabled as requested>")
  SET(STATUS_SUIL "   <disabled as requested>")
ENDIF(WANT_LV2)


# check for MP3/mpg123-library
IF(WANT_MPG123)
	FIND_PACKAGE(MPG123)
	IF(MPG123_FOUND)
		SET(LMMS_HAVE_MPG123 TRUE)
		SET(STATUS_MPG123 "OK")
	ELSE(MPG123_FOUND)
	  SET(STATUS_MPG123 "?? <not found, please install "
            "libmpg123-dev (or similar)>")
		SET(MPG123_LIBRARIES "")
		SET(MPG123_INCLUDE_DIRS "")
	ENDIF(MPG123_FOUND)
ELSE(WANT_MPG123)
	SET(STATUS_MPG123 "   <disabled as requested>")
ENDIF(WANT_MPG123)


# check for MP3/Lame-libraries
IF(WANT_MP3LAME)
	FIND_PACKAGE(Lame)
	IF(LAME_FOUND)
		SET(LMMS_HAVE_MP3LAME TRUE)
		SET(STATUS_MP3LAME "OK")
	ELSE(LAME_FOUND)
	  SET(STATUS_MP3LAME "?? <not found, please install "
            "libmp3lame-dev (or similar)>")
		SET(LAME_LIBRARIES "")
		SET(LAME_INCLUDE_DIRS "")
	ENDIF(LAME_FOUND)
ELSE(WANT_MP3LAME)
	SET(STATUS_MP3LAME "   <disabled as requested>")
ENDIF(WANT_MP3LAME)


# check for OGG/Vorbis-libraries
IF(WANT_OGGVORBIS)
	FIND_PACKAGE(OggVorbis)
	IF(OGGVORBIS_FOUND)
		SET(LMMS_HAVE_OGGVORBIS TRUE)
		SET(STATUS_OGGVORBIS "OK")
	ELSE(OGGVORBIS_FOUND)
	  SET(STATUS_OGGVORBIS "?? <not found, libogg-dev and "
            "libvorbis-dev (or similar) "
	    "is highly recommended>")
	ENDIF(OGGVORBIS_FOUND)
ELSE(WANT_OGGVORBIS)
	SET(STATUS_OGGVORBIS "   <disabled as requested>")
ENDIF(WANT_OGGVORBIS)


# check whether to enable OSS-support
IF(WANT_OSS)
	IF(LMMS_HAVE_SOUNDCARD_H OR LMMS_HAVE_SYS_SOUNDCARD_H)
		SET(LMMS_HAVE_OSS TRUE)
		SET(STATUS_OSS "OK")
	ELSE(LMMS_HAVE_SOUNDCARD_H OR LMMS_HAVE_SYS_SOUNDCARD_H)
		SET(STATUS_OSS "?? <not found or not supported on this platform>")
	ENDIF(LMMS_HAVE_SOUNDCARD_H OR LMMS_HAVE_SYS_SOUNDCARD_H)
ELSE(WANT_OSS)
	SET(STATUS_OSS "   <disabled as requested>")
ENDIF(WANT_OSS)


# check for ALSA
IF(WANT_ALSA)
	FIND_PACKAGE(Alsa)
	IF(ALSA_FOUND)
		SET(LMMS_HAVE_ALSA TRUE)
		SET(STATUS_ALSA "OK")
	ELSE(ALSA_FOUND)
	  SET(STATUS_ALSA "?? <not found, please install libasound2-dev "
            "(or similar) if you require ALSA support>")
	ENDIF(ALSA_FOUND)
ELSE(WANT_ALSA)
	SET(STATUS_ALSA "   <disabled as requested>")
ENDIF(WANT_ALSA)
IF(NOT LMMS_HAVE_ALSA)
	SET(ASOUND_LIBRARY "")
ENDIF(NOT LMMS_HAVE_ALSA)


# check for JACK
IF(WANT_JACK)
	PKG_CHECK_MODULES(JACK jack>=0.77)
	IF(JACK_FOUND)
		SET(LMMS_HAVE_JACK TRUE)
		SET(STATUS_JACK "OK")
	ELSE(JACK_FOUND)
	  SET(STATUS_JACK "?? <not found, please install "
            "libjack0.100.0-dev (or similar) "
	    "if you require JACK support>")
	ENDIF(JACK_FOUND)
ELSE(WANT_JACK)
	SET(STATUS_JACK "   <disabled as requested>")
ENDIF(WANT_JACK)


# check for FFTW3F-library
PKG_CHECK_MODULES(FFTW3F REQUIRED fftw3f>=3.0.0)


# check for FLTK
FIND_PACKAGE(FLTK)
IF(FLTK_FOUND)
	SET(STATUS_ZYN "OK")
ELSE()
	SET(STATUS_ZYN "?? <not found, please install fltk>")
ENDIF()


# check for Fluidsynth
IF(WANT_SF2)
	PKG_CHECK_MODULES(FLUIDSYNTH fluidsynth>=2.0.0) #1.0.7
	IF(FLUIDSYNTH_FOUND)
		SET(LMMS_HAVE_FLUIDSYNTH TRUE)
		SET(STATUS_FLUIDSYNTH "OK")
	ELSE(FLUIDSYNTH_FOUND)
	  SET(STATUS_FLUIDSYNTH "?? <not found, libfluidsynth-dev "
            "(or similar) is highly recommended")
	ENDIF(FLUIDSYNTH_FOUND)
ELSE(WANT_SF2)
	SET(STATUS_SF2 "   <disabled as requested>")
ENDIF(WANT_SF2)


# check for libgig
If(WANT_GIG)
	PKG_CHECK_MODULES(GIG gig)
	IF(GIG_FOUND)
		SET(LMMS_HAVE_GIG TRUE)
		SET(STATUS_GIG "OK")
	ELSE(GIG_FOUND)
	  SET(STATUS_GIG "?? <not found, libgig needed for decoding "
            ".gig files>")
	ENDIF(GIG_FOUND)
ELSE(WANT_GIG)
	SET(STATUS_GIG "   <disabled as requested>")
ENDIF(WANT_GIG)

# check for pthreads
IF(LMMS_BUILD_LINUX OR LMMS_BUILD_APPLE OR LMMS_BUILD_OPENBSD)
	FIND_PACKAGE(Threads)
ENDIF(LMMS_BUILD_LINUX OR LMMS_BUILD_APPLE OR LMMS_BUILD_OPENBSD)


# check for sndio (openbsd only, roaraudio won't work yet)
IF(WANT_SOUNDIO)
FIND_PACKAGE(Sndio)
IF(LMMS_BUILD_OPENBSD AND SNDIO_FOUND)
	SET(LMMS_HAVE_SNDIO TRUE)
	SET(STATUS_SNDIO "OK")
ELSE()
IF(LMMS_BUILD_LINUX AND SNDIO_FOUND)
	SET(LMMS_HAVE_SNDIO TRUE)
	SET(STATUS_SNDIO "OK <experimental>")
ELSE()
	SET(STATUS_SNDIO "-- <not found or not supported on this platform>")
	SET(SNDIO_LIBRARY "")
ENDIF()
ENDIF()
ELSE(WANT_SOUNDIO)
	SET(STATUS_SNDIO "   <disabled as requested>")
ENDIF(WANT_SOUNDIO)


# check for WINE
IF(WANT_WINE)
  FIND_PACKAGE(Wine)
  IF(WINE_FOUND)
    SET(LMMS_SUPPORT_WINE TRUE)
    SET(STATUS_WINE "OK")
  ELSE(WINE_FOUND)
    SET(STATUS_WINE "?? <not found, please install (lib)wine-dev "
      "(or similar) - 64 bit systems additionally need "
      "gcc-multilib and g++-multilib>")
  ENDIF(WINE_FOUND)
ENDIF(WANT_WINE)

IF(WANT_VST)
  IF(LMMS_BUILD_WIN32)
    SET(LMMS_SUPPORT_VST TRUE)
    SET(STATUS_VST "OK")
  ENDIF(LMMS_BUILD_WIN32)
  IF(LMMS_BUILD_LINUX)
    IF(LMMS_SUPPORT_WINE)
      SET(LMMS_SUPPORT_VST TRUE)
      SET(STATUS_VST "OK")
    ELSE(LMMS_SUPPORT_WINE)
          SET(STATUS_VST "?? <not available, wine is required>")
    ENDIF(LMMS_SUPPORT_WINE)
  ENDIF(LMMS_BUILD_LINUX)
ENDIF(WANT_VST)

IF(WANT_DEBUG_FPE)
	IF(LMMS_BUILD_LINUX)
		SET(LMMS_DEBUG_FPE TRUE)
		SET(STATUS_DEBUG_FPE "OK")
	ELSE()
	  SET(STATUS_DEBUG_FPE "?? <wanted but disabled due to "
            "unsupported platform>")
	ENDIF()
ELSE()
	SET(STATUS_DEBUG_FPE "   <disabled as requested>")
ENDIF(WANT_DEBUG_FPE)

IF(WANT_DEBUG_PERFLOG)
	IF(LMMS_BUILD_LINUX)
		SET(LMMS_DEBUG_PERFLOG TRUE)
		SET(STATUS_DEBUG_PERFLOG "OK")
	ELSE()
	  SET(STATUS_DEBUG_PERFLOG "?? <wanted but disabled due to "
            "unsupported platform>")
	ENDIF()
ELSE()
	SET(STATUS_DEBUG_PERFLOG "   <disabled as requested>")
ENDIF(WANT_DEBUG_PERFLOG)

# check for libsamplerate
PKG_CHECK_MODULES(SAMPLERATE REQUIRED samplerate>=0.1.8)

# set compiler flags
SET(WERROR_FLAGS "-Wall -Werror=unused-function -Wno-sign-compare -Wno-strict-overflow")
OPTION(USE_WERROR "Add -werror to the build flags. Stops the build on warnings" OFF)
IF(${USE_WERROR})
   SET(WERROR_FLAGS "${WERROR_FLAGS} -Werror")
ENDIF()

# Due to a regression in gcc-4.8.X, we need to disable array-bounds check
IF (CMAKE_COMPILER_IS_GNUCXX AND ((CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL "4.8.0") OR (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "4.8.0") OR LMMS_BUILD_WIN32))
   SET(WERROR_FLAGS "${WERROR_FLAGS} -Wno-array-bounds")
ENDIF()

IF(NOT CMAKE_BUILD_TYPE)
	message(STATUS "Setting build type to 'Debug' as none was specified.")
	set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
	# Set the possible values of build type for cmake-gui
	SET_PROPERTY(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
  		"MinSizeRel" "RelWithDebInfo")
ENDIF()

#SET(MY_FLAGS "-march=athlon64 -m64 -O9 -ggdb -ffast-math -fno-finite-math-only")
SET(MY_FLAGS "-march=native -m64 -O9 -ggdb -ffast-math -fno-finite-math-only -fassociative-math -ftree-vectorize -ftree-vectorizer-verbose=0 -fopenmp -fopenmp-simd")

SET(CMAKE_C_FLAGS "${WERROR_FLAGS} ${CMAKE_C_FLAGS} ${MY_FLAGS}")
SET(CMAKE_CXX_FLAGS "-fno-exceptions ${WERROR_FLAGS} ${CMAKE_CXX_FLAGS} ${MY_FLAGS}")
SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DLMMS_DEBUG")
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DLMMS_DEBUG")

SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -std=c++17")

# people simply updating git will still have this and mess up build with it
FILE(REMOVE include/lmmsconfig.h)

FILE(GLOB LMMS_INCLUDES "${CMAKE_SOURCE_DIR}/include/*.h")
LIST(SORT LMMS_INCLUDES)

# we somehow have to make LMMS-binary depend on MOC-files
ADD_FILE_DEPENDENCIES("${CMAKE_BINARY_DIR}/lmmsconfig.h")

IF(WIN32)
	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-attributes")
ELSE(WIN32)
	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -DPIC")
ENDIF(WIN32)

# use ccache
OPTION(USE_CCACHE "Use ccache for compilation" OFF)
IF(USE_CCACHE)
    FIND_PROGRAM(CCACHE ccache)
    IF (CCACHE)
        MESSAGE(STATUS "Using ccache found in PATH")
        SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE})
        SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE})
    ELSE()
        MESSAGE(WARNING "USE_CCACHE enabled, but no ccache found")
    ENDIF()
ENDIF()

# make sub-directories
ADD_SUBDIRECTORY(cmake)
ADD_SUBDIRECTORY(src)
ADD_SUBDIRECTORY(plugins)
ADD_SUBDIRECTORY(tests)
ADD_SUBDIRECTORY(data)
ADD_SUBDIRECTORY(doc)

# post-install tasks
ADD_SUBDIRECTORY(cmake/postinstall)

ADD_CUSTOM_COMMAND(OUTPUT "${CMAKE_BINARY_DIR}/lmms.1.gz"
				COMMAND gzip -c ${CMAKE_SOURCE_DIR}/doc/lmms.1 > ${CMAKE_BINARY_DIR}/lmms.1.gz
				DEPENDS "${CMAKE_SOURCE_DIR}/doc/lmms.1"
				COMMENT "Generating lmms.1.gz"
				VERBATIM)


ADD_CUSTOM_TARGET(manpage ALL
				DEPENDS "${CMAKE_BINARY_DIR}/lmms.1.gz")

# install headers

IF(LMMS_BUILD_LINUX)
	INSTALL(FILES ${LMMS_INCLUDES}
		"${CMAKE_BINARY_DIR}/lmmsconfig.h"
		"${CMAKE_BINARY_DIR}/lmmsversion.h"
		"${CMAKE_SOURCE_DIR}/src/gui/embed.cpp"
		DESTINATION "${CMAKE_INSTALL_PREFIX}/include/lmms/")
ENDIF(LMMS_BUILD_LINUX)

# package ZynAddSubFX into win32 build
IF(LMMS_BUILD_WIN32)
	IF(EXISTS "${CMAKE_SOURCE_DIR}/extras")
		ADD_SUBDIRECTORY("${CMAKE_SOURCE_DIR}/extras/data/presets")
		FILE(GLOB ZASF_BINARIES
			"${CMAKE_SOURCE_DIR}/extras/plugins/zynaddsubfx/zynaddsubfx.dll"
			"${CMAKE_SOURCE_DIR}/extras/plugins/zynaddsubfx/remote_zynaddsubfx.exe")
		LIST(SORT ZASF_BINARIES)
		INSTALL(FILES "${ZASF_BINARIES}" DESTINATION "${PLUGIN_DIR}")
	ENDIF(EXISTS "${CMAKE_SOURCE_DIR}/extras")
ENDIF(LMMS_BUILD_WIN32)

#
# add distclean-target
#
ADD_CUSTOM_TARGET(distclean
			COMMAND make clean
			COMMAND rm -rf `find -name cmake_install.cmake` `find -name Makefile` `find -type d -name CMakeFiles` CMakeCache.txt lmmsconfig.h lmms.1.gz)

#
# add tarball-target
#
SET(TMP "lmms-${VERSION}")
ADD_CUSTOM_TARGET(dist
			COMMAND make clean
			COMMAND rm -rf "${TMP}"
			COMMAND mkdir -p "${TMP}"
			COMMAND cp CMakeLists.txt LICENSE.txt INSTALL.txt README.md "${TMP}"
			COMMAND cp -r buildtools cmake data doc include plugins src "${TMP}"
			COMMAND rm -rf `find "${TMP}" -name cmake_install.cmake` `find "${TMP}" -name Makefile` `find "${TMP}" -type d -name CMakeFiles` "${TMP}/CMakeCache.txt"
			COMMAND tar cjf lmms-${VERSION}-src.tar.bz2 "${TMP}"
			COMMAND rm -rf "${TMP}")

#
# display configuration information
#

MESSAGE("\n"
"Installation Summary\n"
"--------------------\n"
"* Install Directory           : ${CMAKE_INSTALL_PREFIX}\n"
)

MESSAGE(
"Supported audio interfaces\n"
"--------------------------\n"
"* ALSA                        : ${STATUS_ALSA}\n"
"* JACK                        : ${STATUS_JACK}\n"
"* OSS                         : ${STATUS_OSS}\n"
"* Sndio                       : ${STATUS_SNDIO}\n"
"* PortAudio                   : ${STATUS_PORTAUDIO}\n"
"* libsoundio                  : ${STATUS_SOUNDIO}\n"
"* PulseAudio                  : ${STATUS_PULSEAUDIO}\n"
"* SDL                         : ${STATUS_SDL}\n"
)

MESSAGE(
"Supported MIDI interfaces\n"
"-------------------------\n"
"* ALSA                        : ${STATUS_ALSA}\n"
"* OSS                         : ${STATUS_OSS}\n"
"* Sndio                       : ${STATUS_SNDIO}\n"
"* JACK                        : ${STATUS_JACK}\n"
"* WinMM                       : ${STATUS_WINMM}\n"
"* AppleMidi                   : ${STATUS_APPLEMIDI}\n"
)

MESSAGE(
"Supported file formats for project import\n"
"-----------------------------------------\n"
"* libsndfile                  : OK\n"
"* libmpg123                   : ${STATUS_MPG123}\n"
)

MESSAGE(
"Supported file formats for project export\n"
"-----------------------------------------\n"
"* WAVE                        : OK\n"
"* FLAC                        : OK\n"
"* OGG/VORBIS                  : ${STATUS_OGGVORBIS}\n"
"* MP3/Lame                    : ${STATUS_MP3LAME}\n"
)

MESSAGE(
"Optional plugins\n"
"----------------\n"
"* ZynAddSubFX instrument      : ${STATUS_ZYN}\n"
"* Carla Patchbay & Rack       : ${STATUS_CARLA}\n"
"* SoundFont2 player           : ${STATUS_FLUIDSYNTH}\n"
"* GIG player                  : ${STATUS_GIG}\n"
"* Stk Mallets                 : ${STATUS_STK}\n"
"* Wine                        : ${STATUS_WINE}\n"
"* VST host                    : ${STATUS_VST}\n"
"* CALF LADSPA plugins         : ${STATUS_CALF}\n"
"* CAPS LADSPA plugins         : ${STATUS_CAPS}\n"
"* CMT LADSPA plugins          : ${STATUS_CMT}\n"
"* TAP LADSPA plugins          : ${STATUS_TAP}\n"
"* SWH LADSPA plugins          : ${STATUS_SWH}\n"
"* LV2 plugins            lilv : ${STATUS_LILV}\n"
"*                        suil : ${STATUS_SUIL}\n"
)

MESSAGE(
"Developer options\n"
"-----------------------------------------\n"
"* Debug FP exceptions         : ${STATUS_DEBUG_FPE}\n"
"* Performance log             : ${STATUS_DEBUG_PERFLOG}\n"
)

MESSAGE(
"\n"
"-----------------------------------------------------------------\n"
"IMPORTANT:\n"
"after installing missing packages, remove CMakeCache.txt before\n"
"running cmake again!\n"
"-----------------------------------------------------------------\n"
"\n\n")

INCLUDE(InstallRequiredSystemLibraries)