CMakeLists.txt

   1 # CMakeLists.txt for ALURE
   2 CMAKE_MINIMUM_REQUIRED(VERSION 2.4)
   3
   4 IF(COMMAND CMAKE_POLICY)
   5     CMAKE_POLICY(SET CMP0003 NEW)
   6 ENDIF(COMMAND CMAKE_POLICY)
   7
   8 SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
   9
  10 INCLUDE(CheckCCompilerFlag)
  11 INCLUDE(CheckCSourceCompiles)
  12 INCLUDE(CheckFunctionExists)
  13 INCLUDE(CheckIncludeFile)
  14 INCLUDE(CheckIncludeFiles)
  15 INCLUDE(CheckLibraryExists)
  16 INCLUDE(CheckSharedLibraryExists)
  17 INCLUDE(FindPkgConfig)
  18 INCLUDE(UsePkgConfig)
  19 INCLUDE(CheckFileOffsetBits)
  20
  21 PROJECT(ALURE)
  22
  23 IF(WIN32)
  24     SET(LIBNAME ALURE32)
  25 ELSE(WIN32)
  26     SET(LIBNAME alure)
  27 ENDIF(WIN32)
  28
  29 SET(LIB_MAJOR_VERSION "1")
  30 SET(LIB_MINOR_VERSION "1")
  31 SET(LIB_VERSION "${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION}")
  32
  33
  34 INCLUDE_DIRECTORIES(include "${ALURE_BINARY_DIR}")
  35
  36
  37 OPTION(BUILD_SHARED "Build the shared version of the library" ON)
  38 OPTION(BUILD_STATIC "Build the static version of the library" ON)
  39
  40 IF(NOT BUILD_SHARED AND NOT BUILD_STATIC)
  41     MESSAGE(FATAL_ERROR "No libtype being built!")
  42 ENDIF(NOT BUILD_SHARED AND NOT BUILD_STATIC)
  43
  44 IF(NOT CMAKE_BUILD_TYPE)
  45     SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
  46         "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel."
  47         FORCE)
  48 ENDIF(NOT CMAKE_BUILD_TYPE)
  49 IF(NOT DEFINED CMAKE_DEBUG_POSTFIX)
  50     SET(CMAKE_DEBUG_POSTFIX "" CACHE STRING
  51         "Library postfix for debug builds. Normally left blank."
  52         FORCE)
  53 ENDIF(NOT DEFINED CMAKE_DEBUG_POSTFIX)
  54
  55
  56 CHECK_SHARED_LIBRARY_EXISTS(stdc++ memset "" HAS_STDCXX)
  57 IF(HAS_STDCXX)
  58     SET(EXTRA_LIBS stdc++ ${EXTRA_LIBS})
  59 ENDIF(HAS_STDCXX)
  60
  61 CHECK_SHARED_LIBRARY_EXISTS(m pow "" HAS_LIBM)
  62 IF(HAS_LIBM)
  63     SET(EXTRA_LIBS m ${EXTRA_LIBS})
  64 ENDIF(HAS_LIBM)
  65
  66 CHECK_FILE_OFFSET_BITS()
  67 IF(_FILE_OFFSET_BITS)
  68     ADD_DEFINITIONS(-D_FILE_OFFSET_BITS=${_FILE_OFFSET_BITS})
  69     SET(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} -D_FILE_OFFSET_BITS=${_FILE_OFFSET_BITS})
  70 ENDIF(_FILE_OFFSET_BITS)
  71
  72 CHECK_FUNCTION_EXISTS(fseeko HAVE_FSEEKO)
  73 IF(NOT HAVE_FSEEKO)
  74     CHECK_FUNCTION_EXISTS(_fseeki64 HAVE__FSEEKI64)
  75 ENDIF(NOT HAVE_FSEEKO)
  76
  77 SET(STATIC_CFLAGS "${STATIC_CFLAGS} -DALURE_STATIC_LIBRARY")
  78
  79 IF(MSVC)
  80     # ???
  81 ELSE(MSVC)
  82     IF(NOT WIN32)
  83         CHECK_C_SOURCE_COMPILES("int foo() __attribute__((constructor));
  84                                  int main() {return 0;}" HAVE_GCC_CONSTRUCTOR)
  85
  86         CHECK_C_COMPILER_FLAG(-fvisibility=hidden HAVE_GCC_VISIBILITY)
  87         IF(HAVE_GCC_VISIBILITY)
  88             ADD_DEFINITIONS(-fvisibility=hidden)
  89         ENDIF(HAVE_GCC_VISIBILITY)
  90
  91         # Force -fPIC for the static lib, because it causes problems when the
  92         # static version is linked to a dynamic lib
  93         SET(STATIC_CFLAGS "${STATIC_CFLAGS} -fPIC")
  94     ENDIF(NOT WIN32)
  95
  96     CHECK_C_COMPILER_FLAG(-Wextra HAVE_WEXTRA)
  97     IF(HAVE_WEXTRA)
  98         ADD_DEFINITIONS(-Wextra)
  99     ENDIF(HAVE_WEXTRA)
 100     ADD_DEFINITIONS(-Wall)
 101
 102     CHECK_C_COMPILER_FLAG(-funswitch-loops HAVE_FUNSWITCH_LOOPS)
 103     IF(HAVE_FUNSWITCH_LOOPS)
 104         ADD_DEFINITIONS(-funswitch-loops)
 105     ENDIF(HAVE_FUNSWITCH_LOOPS)
 106 ENDIF(MSVC)
 107
 108
 109 CHECK_INCLUDE_FILE(windows.h HAVE_WINDOWS_H -D_WIN32_WINNT=0x0500)
 110 IF(HAVE_WINDOWS_H)
 111     CHECK_INCLUDE_FILE(ddk/ntddcdrm.h HAVE_DDK_NTDDCDRM_H)
 112 ELSE(HAVE_WINDOWS_H)
 113     CHECK_C_COMPILER_FLAG(-pthread HAVE_PTHREAD)
 114     IF(HAVE_PTHREAD)
 115         ADD_DEFINITIONS(-pthread)
 116         SET(EXTRA_LIBS ${EXTRA_LIBS} -pthread)
 117     ENDIF(HAVE_PTHREAD)
 118
 119     # We need pthreads outside of Windows
 120     CHECK_INCLUDE_FILE(pthread.h HAVE_PTHREAD_H)
 121     IF(NOT HAVE_PTHREAD_H)
 122         MESSAGE(FATAL_ERROR "PThreads is required for non-Windows builds!")
 123     ENDIF()
 124     # Some systems need pthread_np.h to get recursive mutexes
 125     CHECK_INCLUDE_FILES("pthread.h;pthread_np.h" HAVE_PTHREAD_NP_H)
 126
 127     # _GNU_SOURCE is needed on some systems for extra attributes, and
 128     # _REENTRANT is needed for libc thread-safety
 129     ADD_DEFINITIONS(-D_GNU_SOURCE=1)
 130     CHECK_FUNCTION_EXISTS(pthread_create HAS_PTHREAD_CREATE)
 131     IF(NOT HAS_PTHREAD_CREATE)
 132         CHECK_SHARED_LIBRARY_EXISTS(pthread pthread_create "" HAVE_LIBPTHREAD)
 133         IF(NOT HAVE_LIBPTHREAD)
 134             MESSAGE(FATAL_ERROR "pthread_create not found on non-Windows target!")
 135         ENDIF(NOT HAVE_LIBPTHREAD)
 136         SET(EXTRA_LIBS pthread ${EXTRA_LIBS})
 137     ENDIF(NOT HAS_PTHREAD_CREATE)
 138
 139     CHECK_FUNCTION_EXISTS(nanosleep HAVE_NANOSLEEP)
 140     IF(NOT HAVE_NANOSLEEP)
 141         MESSAGE(FATAL_ERROR "No sleep function found!")
 142     ENDIF(NOT HAVE_NANOSLEEP)
 143 ENDIF(HAVE_WINDOWS_H)
 144
 145 CHECK_INCLUDE_FILE(sys/types.h HAVE_SYS_TYPES_H)
 146 CHECK_INCLUDE_FILE(sys/wait.h HAVE_SYS_WAIT_H)
 147 CHECK_INCLUDE_FILE(signal.h HAVE_SIGNAL_H)
 148 CHECK_INCLUDE_FILE(dlfcn.h HAVE_DLFCN_H)
 149
 150 IF(HAVE_DLFCN_H)
 151     CHECK_SHARED_LIBRARY_EXISTS(dl dlopen "" HAVE_LIBDL)
 152     IF(HAVE_LIBDL)
 153         SET(EXTRA_LIBS dl ${EXTRA_LIBS})
 154     ENDIF(HAVE_LIBDL)
 155 ENDIF(HAVE_DLFCN_H)
 156
 157 OPTION(DYNLOAD    "Dynamically load support libs at run-time" ON)
 158 OPTION(SNDFILE    "SoundFile support (for various formats)" ON)
 159 OPTION(VORBIS     "VorbisFile support (for Ogg Vorbis)"  ON)
 160 OPTION(FLAC       "FLAC support (for FLAC and Ogg FLAC)" ON)
 161 OPTION(MPG123     "MPG123 support (for MP1/MP2/MP3)" ON)
 162 OPTION(DUMB       "DUMB support (for IT/XM/S3M/MOD)" ON)
 163 OPTION(MODPLUG    "ModPlug support (for IT/XM/S3M/MOD)" OFF)
 164 OPTION(FLUIDSYNTH "FluidSynth support (for MID)" ON)
 165
 166 IF(WIN32)
 167     ADD_DEFINITIONS(-D_WIN32)
 168 ELSE(WIN32)
 169     IF(NOT HAVE_DLFCN_H OR NOT HAVE_LIBDL)
 170         SET(DYNLOAD OFF)
 171     ENDIF(NOT HAVE_DLFCN_H OR NOT HAVE_LIBDL)
 172     PKG_CHECK_MODULES(OPENAL openal)
 173 ENDIF(WIN32)
 174
 175 IF(NOT OPENAL_FOUND)
 176     FIND_PACKAGE(OpenAL)
 177     IF(NOT OPENAL_FOUND)
 178         MESSAGE(FATAL_ERROR "OpenAL not found!\nPlease try setting the OPENALDIR environment variable and try again.")
 179     ENDIF(NOT OPENAL_FOUND)
 180
 181     MESSAGE(STATUS "OpenAL include: ${OPENAL_INCLUDE_DIR}")
 182     MESSAGE(STATUS "OpenAL lib: ${OPENAL_LIBRARY}")
 183
 184     INCLUDE_DIRECTORIES(${OPENAL_INCLUDE_DIR})
 185     SET(OPENAL_LIBRARIES ${OPENAL_LIBRARY})
 186 ELSE(NOT OPENAL_FOUND)
 187     INCLUDE_DIRECTORIES(${OPENAL_INCLUDE_DIRS})
 188     LINK_DIRECTORIES(${OPENAL_LIBRARY_DIRS})
 189 ENDIF(NOT OPENAL_FOUND)
 190
 191 # Base source files
 192 SET(ALURE_OBJS  src/alure.cpp
 193                 src/buffer.cpp
 194                 src/istream.cpp
 195                 src/stream.cpp
 196                 src/streamdec.cpp
 197                 src/streamplay.cpp
 198                 src/codec_wav.cpp
 199                 src/codec_aiff.cpp
 200 )
 201
 202 # SndFile support
 203 IF(SNDFILE)
 204     PKG_CHECK_MODULES(SNDFILE sndfile)
 205     IF(SNDFILE_FOUND)
 206         SET(HAS_SNDFILE 1)
 207         LINK_DIRECTORIES(${SNDFILE_LIBRARY_DIRS})
 208         SET_SOURCE_FILES_PROPERTIES(src/codec_sndfile.cpp PROPERTIES
 209                                     COMPILE_FLAGS "${SNDFILE_CFLAGS}")
 210     ELSE(SNDFILE_FOUND)
 211         FIND_PACKAGE(SndFile)
 212         IF(SNDFILE_FOUND)
 213             SET(HAS_SNDFILE 1)
 214             SET_SOURCE_FILES_PROPERTIES(src/codec_sndfile.cpp PROPERTIES
 215                                         INCLUDE_DIRECTORIES "${SNDFILE_INCLUDE_DIRS}")
 216         ENDIF(SNDFILE_FOUND)
 217     ENDIF(SNDFILE_FOUND)
 218     IF(HAS_SNDFILE)
 219         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_sndfile.cpp)
 220     ENDIF(HAS_SNDFILE)
 221 ELSE(SNDFILE)
 222     SET(SNDFILE_LIBRARIES "")
 223 ENDIF(SNDFILE)
 224
 225 # Vorbis support
 226 IF(VORBIS)
 227     PKG_CHECK_MODULES(VORBISFILE vorbisfile)
 228     IF(VORBISFILE_FOUND)
 229         SET(HAS_VORBISFILE 1)
 230         LINK_DIRECTORIES(${VORBISFILE_LIBRARY_DIRS})
 231         SET_SOURCE_FILES_PROPERTIES(src/codec_vorbisfile.cpp PROPERTIES
 232                                     COMPILE_FLAGS "${VORBISFILE_CFLAGS}")
 233     ELSE(VORBISFILE_FOUND)
 234         FIND_PACKAGE(OggVorbis)
 235         IF(OGGVORBIS_FOUND)
 236             SET(HAS_VORBISFILE 1)
 237             SET(VORBISFILE_LIBRARIES ${OGGVORBIS_LIBRARIES})
 238             SET_SOURCE_FILES_PROPERTIES(src/codec_vorbisfile.cpp PROPERTIES
 239                                         INCLUDE_DIRECTORIES "${OGGVORBIS_INCLUDE_DIRR}")
 240             SET(VORBISFILE_LIBRARIES ${OGGVORBIS_LIBRARIES})
 241         ENDIF(OGGVORBIS_FOUND)
 242     ENDIF(VORBISFILE_FOUND)
 243     IF(NOT HAS_VORBISFILE)
 244         PKG_CHECK_MODULES(VORBISIDEC vorbisidec)
 245         IF(NOT VORBISIDEC_FOUND)
 246             CHECK_INCLUDE_FILE(tremor/ivorbisfile.h HAVE_TREMOR_IVORBISFILE_H)
 247             IF(HAVE_TREMOR_IVORBISFILE_H)
 248                 CHECK_SHARED_LIBRARY_EXISTS(vorbisidec ov_open "" HAVE_LIBVORBISIDEC)
 249                 IF(DYNLOAD OR HAVE_LIBVORBISIDEC)
 250                     SET(HAS_VORBISFILE 1)
 251                     IF(HAVE_LIBVORBISIDEC)
 252                         SET(VORBISFILE_LIBRARIES "vorbisidec")
 253                     ENDIF(HAVE_LIBVORBISIDEC)
 254                     SET_SOURCE_FILES_PROPERTIES(src/codec_vorbisfile.cpp PROPERTIES
 255                                                 COMPILE_FLAGS "-DHAS_VORBISIDEC")
 256                 ENDIF(DYNLOAD OR HAVE_LIBVORBISIDEC)
 257             ENDIF(HAVE_TREMOR_IVORBISFILE_H)
 258         ELSE(NOT VORBISIDEC_FOUND)
 259             SET(HAS_VORBISFILE 1)
 260             LINK_DIRECTORIES(${VORBISIDEC_LIBRARY_DIRS})
 261             SET_SOURCE_FILES_PROPERTIES(src/codec_vorbisfile.cpp PROPERTIES
 262                                         COMPILE_FLAGS "${VORBISIDEC_CFLAGS} -DHAS_VORBISIDEC")
 263         ENDIF(NOT VORBISIDEC_FOUND)
 264     ENDIF(NOT HAS_VORBISFILE)
 265     IF(HAS_VORBISFILE)
 266         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_vorbisfile.cpp)
 267     ENDIF(HAS_VORBISFILE)
 268 ELSE(VORBIS)
 269     SET(VORBISFILE_LIBRARIES "")
 270 ENDIF(VORBIS)
 271
 272 # FLAC support
 273 IF(FLAC)
 274     #PKG_CHECK_MODULES(LIBFLAC flac)
 275     #IF(NOT LIBFLAC_FOUND)
 276         CHECK_INCLUDE_FILE(FLAC/all.h HAVE_FLAC_ALL_H)
 277         IF(HAVE_FLAC_ALL_H)
 278             CHECK_SHARED_LIBRARY_EXISTS(FLAC FLAC__stream_decoder_new "" HAVE_LIBFLAC)
 279             IF(DYNLOAD OR HAVE_LIBFLAC)
 280                 SET(HAS_FLAC 1)
 281                 IF(HAVE_LIBFLAC)
 282                     SET(LIBFLAC_LIBRARIES "FLAC")
 283                 ENDIF(HAVE_LIBFLAC)
 284             ENDIF(DYNLOAD OR HAVE_LIBFLAC)
 285         ENDIF(HAVE_FLAC_ALL_H)
 286     #ELSE(NOT LIBFLAC_FOUND)
 287     #    SET(HAS_FLAC 1)
 288     #    INCLUDE_DIRECTORIES(${LIBFLAC_INCLUDE_DIRS})
 289     #    LINK_DIRECTORIES(${LIBFLAC_LIBRARY_DIRS})
 290     #ENDIF(NOT LIBFLAC_FOUND)
 291     IF(HAS_FLAC)
 292         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_flac.cpp)
 293     ENDIF(HAS_FLAC)
 294 ELSE(FLAC)
 295     SET(LIBFLAC_LIBRARIES "")
 296 ENDIF(FLAC)
 297
 298 # MPG123 support
 299 IF(MPG123)
 300     PKG_CHECK_MODULES(MPG123 libmpg123)
 301     IF(NOT MPG123_FOUND)
 302         CHECK_INCLUDE_FILE(mpg123.h HAVE_MPG123_H)
 303         IF(HAVE_MPG123_H)
 304             CHECK_SHARED_LIBRARY_EXISTS(mpg123 mpg123_init "" HAVE_LIBMPG123)
 305             IF(DYNLOAD OR HAVE_LIBMPG123)
 306                 SET(HAS_MPG123 1)
 307                 IF(HAVE_LIBMPG123)
 308                     SET(MPG123_LIBRARIES "mpg123")
 309                 ENDIF(HAVE_LIBMPG123)
 310             ENDIF(DYNLOAD OR HAVE_LIBMPG123)
 311         ENDIF(HAVE_MPG123_H)
 312     ELSE(NOT MPG123_FOUND)
 313         SET(HAS_MPG123 1)
 314         LINK_DIRECTORIES(${MPG123_LIBRARY_DIRS})
 315         SET_SOURCE_FILES_PROPERTIES(src/codec_mpg123.cpp PROPERTIES
 316                                     COMPILE_FLAGS "${MPG123_CFLAGS}")
 317     ENDIF(NOT MPG123_FOUND)
 318     IF(HAS_MPG123)
 319         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_mpg123.cpp)
 320     ENDIF(HAS_MPG123)
 321 ELSE(MPG123)
 322     SET(MPG123_LIBRARIES "")
 323 ENDIF(MPG123)
 324
 325 # DUMB support
 326 IF(DUMB)
 327     CHECK_INCLUDE_FILE(dumb.h HAVE_DUMB_H)
 328     IF(HAVE_DUMB_H)
 329         IF(HAS_LIBM)
 330             CHECK_LIBRARY_EXISTS("dumb;m" dumbfile_open_ex "" HAVE_LIBDUMB)
 331         ELSE(HAS_LIBM)
 332             CHECK_LIBRARY_EXISTS(dumb dumbfile_open_ex "" HAVE_LIBDUMB)
 333         ENDIF(HAS_LIBM)
 334         IF(DYNLOAD OR HAVE_LIBDUMB)
 335             SET(HAS_DUMB 1)
 336             IF(HAVE_LIBDUMB)
 337                 SET(DUMB_LIBRARIES dumb)
 338             ENDIF(HAVE_LIBDUMB)
 339         ENDIF(DYNLOAD OR HAVE_LIBDUMB)
 340     ENDIF(HAVE_DUMB_H)
 341     IF(HAS_DUMB)
 342         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_dumb.cpp)
 343     ENDIF(HAS_DUMB)
 344 ELSE(DUMB)
 345     SET(DUMB_LIBRARIES "")
 346 ENDIF(DUMB)
 347
 348 # ModPlug support
 349 IF(MODPLUG)
 350     PKG_CHECK_MODULES(MODPLUG libmodplug)
 351     IF(NOT MODPLUG_FOUND)
 352         CHECK_INCLUDE_FILE(modplug.h HAVE_MODPLUG_H)
 353         IF(HAVE_MODPLUG_H)
 354             CHECK_SHARED_LIBRARY_EXISTS(modplug ModPlug_Load "" HAVE_LIBMODPLUG)
 355             IF(DYNLOAD OR HAVE_LIBMODPLUG)
 356                 SET(HAS_MODPLUG 1)
 357                 IF(HAVE_LIBMODPLUG)
 358                     SET(MODPLUG_LIBRARIES "modplug")
 359                 ENDIF(HAVE_LIBMODPLUG)
 360             ENDIF(DYNLOAD OR HAVE_LIBMODPLUG)
 361         ENDIF(HAVE_MODPLUG_H)
 362     ELSE(NOT MODPLUG_FOUND)
 363         SET(HAS_MODPLUG 1)
 364         LINK_DIRECTORIES(${MODPLUG_LIBRARY_DIRS})
 365         SET_SOURCE_FILES_PROPERTIES(src/codec_modplug.cpp PROPERTIES
 366                                     COMPILE_FLAGS "${MODPLUG_CFLAGS}")
 367     ENDIF(NOT MODPLUG_FOUND)
 368     IF(HAS_MODPLUG)
 369         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_modplug.cpp)
 370     ENDIF(HAS_MODPLUG)
 371 ELSE(MODPLUG)
 372     SET(MODPLUG_LIBRARIES "")
 373 ENDIF(MODPLUG)
 374
 375 # FluidSynth support
 376 IF(FLUIDSYNTH)
 377     PKG_CHECK_MODULES(FLUIDSYNTH fluidsynth>=1.1.1)
 378     IF(NOT FLUIDSYNTH_FOUND)
 379         CHECK_INCLUDE_FILE(fluidsynth.h HAVE_FLUIDSYNTH_H)
 380         IF(HAVE_FLUIDSYNTH_H)
 381             CHECK_SHARED_LIBRARY_EXISTS(fluidsynth new_fluid_synth "" HAVE_LIBFLUIDSYNTH)
 382             IF(DYNLOAD OR HAVE_LIBFLUIDSYNTH)
 383                 SET(HAS_FLUIDSYNTH 1)
 384                 IF(HAVE_LIBFLUIDSYNTH)
 385                     SET(FLUIDSYNTH_LIBRARIES "fluidsynth")
 386                 ENDIF(HAVE_LIBFLUIDSYNTH)
 387             ENDIF(DYNLOAD OR HAVE_LIBFLUIDSYNTH)
 388         ENDIF(HAVE_FLUIDSYNTH_H)
 389     ELSE(NOT FLUIDSYNTH_FOUND)
 390         SET(HAS_FLUIDSYNTH 1)
 391         LINK_DIRECTORIES(${FLUIDSYNTH_LIBRARY_DIRS})
 392         SET_SOURCE_FILES_PROPERTIES(src/codec_fluidsynth.cpp PROPERTIES
 393                                     COMPILE_FLAGS "${FLUIDSYNTH_CFLAGS}")
 394     ENDIF(NOT FLUIDSYNTH_FOUND)
 395     IF(HAS_FLUIDSYNTH)
 396         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_fluidsynth.cpp)
 397     ENDIF(HAS_FLUIDSYNTH)
 398 ELSE(FLUIDSYNTH)
 399     SET(FLUIDSYNTH_LIBRARIES "")
 400 ENDIF(FLUIDSYNTH)
 401
 402
 403 IF(NOT DYNLOAD)
 404     SET(EXTRA_LIBS ${SNDFILE_LIBRARIES} ${VORBISFILE_LIBRARIES} ${LIBFLAC_LIBRARIES} ${MPG123_LIBRARIES} ${DUMB_LIBRARIES} ${MODPLUG_LIBRARIES} ${FLUIDSYNTH_LIBRARIES} ${EXTRA_LIBS})
 405 ELSE(NOT DYNLOAD)
 406     ADD_DEFINITIONS(-DDYNLOAD=1)
 407 ENDIF(NOT DYNLOAD)
 408
 409 # For alure.pc.in
 410 SET(prefix ${CMAKE_INSTALL_PREFIX})
 411 SET(exec_prefix "\${prefix}")
 412 SET(libdir "\${exec_prefix}/lib${LIB_SUFFIX}")
 413 SET(bindir "\${exec_prefix}/bin")
 414 SET(includedir "\${prefix}/include")
 415 SET(PKG_CONFIG_REQUIRES openal)
 416 SET(PACKAGE_VERSION "${LIB_VERSION}")
 417
 418 # End configuration
 419 CONFIGURE_FILE(
 420     "${ALURE_SOURCE_DIR}/config.h.in"
 421     "${ALURE_BINARY_DIR}/config.h")
 422 IF(BUILD_SHARED)
 423     CONFIGURE_FILE(
 424         "${ALURE_SOURCE_DIR}/alure.pc.in"
 425         "${ALURE_BINARY_DIR}/alure.pc"
 426         @ONLY)
 427 ENDIF(BUILD_SHARED)
 428 IF(BUILD_STATIC)
 429     CONFIGURE_FILE(
 430         "${ALURE_SOURCE_DIR}/alure-static.pc.in"
 431         "${ALURE_BINARY_DIR}/alure-static.pc"
 432         @ONLY)
 433 ENDIF(BUILD_STATIC)
 434
 435 ADD_DEFINITIONS(-DHAVE_CONFIG_H)
 436
 437
 438 IF(BUILD_SHARED)
 439     #build a shared library
 440     ADD_LIBRARY(${LIBNAME} SHARED ${ALURE_OBJS})
 441     SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES DEFINE_SYMBOL ALURE_BUILD_LIBRARY
 442                                                 VERSION ${LIB_VERSION}.0
 443                                                 SOVERSION ${LIB_MAJOR_VERSION})
 444     IF(WIN32)
 445         SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES PREFIX "")
 446     ELSE(WIN32)
 447         SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES LINK_FLAGS "-Wl,--version-script=${ALURE_SOURCE_DIR}/libalure.map")
 448     ENDIF(WIN32)
 449     TARGET_LINK_LIBRARIES(${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 450
 451     INSTALL(TARGETS ${LIBNAME}
 452             RUNTIME DESTINATION bin
 453             LIBRARY DESTINATION lib${LIB_SUFFIX}
 454             ARCHIVE DESTINATION lib${LIB_SUFFIX}
 455 )
 456 ENDIF(BUILD_SHARED)
 457 IF(BUILD_STATIC)
 458     #build a static library
 459     ADD_LIBRARY(${LIBNAME}-static STATIC ${ALURE_OBJS})
 460     SET_TARGET_PROPERTIES(${LIBNAME}-static PROPERTIES DEFINE_SYMBOL ALURE_BUILD_LIBRARY
 461                                                        COMPILE_FLAGS ${STATIC_CFLAGS}
 462                                                        VERSION ${LIB_VERSION}.0)
 463     INSTALL(TARGETS ${LIBNAME}-static
 464             RUNTIME DESTINATION bin
 465             LIBRARY DESTINATION lib${LIB_SUFFIX}
 466             ARCHIVE DESTINATION lib${LIB_SUFFIX}
 467 )
 468 ENDIF(BUILD_STATIC)
 469
 470
 471 IF(HAVE_DDK_NTDDCDRM_H)
 472     SET_SOURCE_FILES_PROPERTIES(examples/alurecdplay.c PROPERTIES
 473                                 COMPILE_FLAGS "-DHAVE_DDK_NTDDCDRM_H")
 474 ENDIF(HAVE_DDK_NTDDCDRM_H)
 475 ADD_EXECUTABLE(alureplay examples/alureplay.c)
 476 ADD_EXECUTABLE(alurecdplay examples/alurecdplay.c)
 477 ADD_EXECUTABLE(alurestream examples/alurestream.c)
 478 IF(BUILD_SHARED)
 479     TARGET_LINK_LIBRARIES(alureplay ${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 480     TARGET_LINK_LIBRARIES(alurecdplay ${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 481     TARGET_LINK_LIBRARIES(alurestream ${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 482 ELSE(BUILD_SHARED)
 483     SET_TARGET_PROPERTIES(alureplay PROPERTIES COMPILE_FLAGS -DALURE_STATIC_LIBRARY)
 484     SET_TARGET_PROPERTIES(alurecdplay PROPERTIES COMPILE_FLAGS -DALURE_STATIC_LIBRARY)
 485     SET_TARGET_PROPERTIES(alurestream PROPERTIES COMPILE_FLAGS -DALURE_STATIC_LIBRARY)
 486     TARGET_LINK_LIBRARIES(alureplay ${LIBNAME}-static ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 487     TARGET_LINK_LIBRARIES(alurecdplay ${LIBNAME}-static ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 488     TARGET_LINK_LIBRARIES(alurestream ${LIBNAME}-static ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 489 ENDIF(BUILD_SHARED)
 490
 491
 492 FIND_PROGRAM(NATDOCS_BIN NaturalDocs)
 493 IF(NATDOCS_BIN)
 494     ADD_CUSTOM_TARGET(docs
 495                       "${NATDOCS_BIN}" -i "${ALURE_SOURCE_DIR}/src" -o HTML "${ALURE_SOURCE_DIR}/docs/html" -p "${ALURE_SOURCE_DIR}/docs/naturaldocs" -s Default CustomStyle
 496                       COMMENT "Building NaturalDocs documentation..." VERBATIM)
 497 ELSE(NATDOCS_BIN)
 498     MESSAGE(STATUS "\nNaturalDocs not found; building documentation is disabled")
 499 ENDIF(NATDOCS_BIN)
 500
 501
 502 #add an install target here
 503 IF(APPLE)
 504     SET(INCPATH OpenAL)
 505 ELSE(APPLE)
 506     SET(INCPATH AL)
 507 ENDIF(APPLE)
 508
 509 INSTALL(DIRECTORY "${ALURE_SOURCE_DIR}/docs/html"
 510         DESTINATION share/doc/alure
 511 )
 512 INSTALL(FILES include/AL/alure.h
 513         DESTINATION "include/${INCPATH}"
 514 )
 515 IF(BUILD_SHARED)
 516     INSTALL(FILES "${ALURE_BINARY_DIR}/alure.pc"
 517             DESTINATION "lib${LIB_SUFFIX}/pkgconfig"
 518     )
 519 ENDIF(BUILD_SHARED)
 520 IF(BUILD_STATIC)
 521     INSTALL(FILES "${ALURE_BINARY_DIR}/alure-static.pc"
 522             DESTINATION "lib${LIB_SUFFIX}/pkgconfig"
 523     )
 524 ENDIF(BUILD_STATIC)
 525
 526
 527 MESSAGE(STATUS "\n********************** Configured options **********************")
 528 IF(BUILD_SHARED AND BUILD_STATIC)
 529     MESSAGE(STATUS "Building shared, static library")
 530 ELSEIF(BUILD_SHARED)
 531     MESSAGE(STATUS "Building shared library")
 532 ELSE(BUILD_SHARED AND BUILD_STATIC)
 533     MESSAGE(STATUS "Building static library")
 534 ENDIF(BUILD_SHARED AND BUILD_STATIC)
 535 MESSAGE(STATUS "")
 536 IF(HAS_SNDFILE)
 537     MESSAGE(STATUS "SndFile support: enabled")
 538 ELSE(HAS_SNDFILE)
 539     MESSAGE(STATUS "SndFile support: disabled")
 540 ENDIF(HAS_SNDFILE)
 541 IF(HAS_VORBISFILE)
 542     MESSAGE(STATUS "VorbisFile support: enabled")
 543 ELSE(HAS_VORBISFILE)
 544     MESSAGE(STATUS "VorbisFile support: disabled")
 545 ENDIF(HAS_VORBISFILE)
 546 IF(HAS_FLAC)
 547     MESSAGE(STATUS "FLAC support: enabled")
 548 ELSE(HAS_FLAC)
 549     MESSAGE(STATUS "FLAC support: disabled")
 550 ENDIF(HAS_FLAC)
 551 IF(HAS_MPG123)
 552     MESSAGE(STATUS "MPG123 support: enabled")
 553 ELSE(HAS_MPG123)
 554     MESSAGE(STATUS "MPG123 support: disabled")
 555 ENDIF(HAS_MPG123)
 556 IF(HAS_DUMB)
 557     MESSAGE(STATUS "DUMB support: enabled")
 558 ELSE(HAS_DUMB)
 559     MESSAGE(STATUS "DUMB support: disabled")
 560 ENDIF(HAS_DUMB)
 561 IF(HAS_MODPLUG)
 562     MESSAGE(STATUS "ModPlug support: enabled")
 563 ELSE(HAS_MODPLUG)
 564     MESSAGE(STATUS "ModPlug support: disabled")
 565 ENDIF(HAS_MODPLUG)
 566 IF(HAS_FLUIDSYNTH)
 567     MESSAGE(STATUS "FluidSynth support: enabled")
 568 ELSE(HAS_FLUIDSYNTH)
 569     MESSAGE(STATUS "FluidSynth support: disabled")
 570 ENDIF(HAS_FLUIDSYNTH)
 571 MESSAGE(STATUS "")