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