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(DYNLOAD    "Dynamically load support libs at run-time" ON)
 167 OPTION(SNDFILE    "SoundFile support (for various formats)" ON)
 168 OPTION(VORBIS     "VorbisFile support (for Ogg Vorbis)"  ON)
 169 OPTION(FLAC       "FLAC support (for FLAC and Ogg FLAC)" ON)
 170 OPTION(MPG123     "MPG123 support (for MP1/MP2/MP3)" ON)
 171 OPTION(DUMB       "DUMB support (for IT/XM/S3M/MOD)" ON)
 172 OPTION(MODPLUG    "ModPlug support (for IT/XM/S3M/MOD)" OFF)
 173 OPTION(FLUIDSYNTH "FluidSynth support (for MID)" ON)
 174
 175 IF(WIN32)
 176     ADD_DEFINITIONS(-D_WIN32)
 177 ELSE(WIN32)
 178     IF(NOT HAVE_DLFCN_H OR NOT HAVE_LIBDL)
 179         SET(DYNLOAD OFF)
 180     ENDIF(NOT HAVE_DLFCN_H OR NOT HAVE_LIBDL)
 181     PKG_CHECK_MODULES(OPENAL openal)
 182 ENDIF(WIN32)
 183
 184 IF(NOT OPENAL_FOUND)
 185     FIND_PACKAGE(OpenAL)
 186     IF(NOT OPENAL_FOUND)
 187         MESSAGE(FATAL_ERROR "OpenAL not found!\nPlease try setting the OPENALDIR environment variable and try again.")
 188     ENDIF(NOT OPENAL_FOUND)
 189
 190     MESSAGE(STATUS "OpenAL include: ${OPENAL_INCLUDE_DIR}")
 191     MESSAGE(STATUS "OpenAL lib: ${OPENAL_LIBRARY}")
 192
 193     INCLUDE_DIRECTORIES(${OPENAL_INCLUDE_DIR})
 194     SET(OPENAL_LIBRARIES ${OPENAL_LIBRARY})
 195 ELSE(NOT OPENAL_FOUND)
 196     INCLUDE_DIRECTORIES(${OPENAL_INCLUDE_DIRS})
 197     LINK_DIRECTORIES(${OPENAL_LIBRARY_DIRS})
 198 ENDIF(NOT OPENAL_FOUND)
 199
 200 # Base source files
 201 SET(ALURE_OBJS  src/alure.cpp
 202                 src/buffer.cpp
 203                 src/istream.cpp
 204                 src/stream.cpp
 205                 src/streamdec.cpp
 206                 src/streamplay.cpp
 207                 src/codec_wav.cpp
 208                 src/codec_aiff.cpp
 209 )
 210
 211 # SndFile support
 212 IF(SNDFILE)
 213     PKG_CHECK_MODULES(SNDFILE sndfile)
 214     IF(SNDFILE_FOUND)
 215         SET(HAS_SNDFILE 1)
 216         LINK_DIRECTORIES(${SNDFILE_LIBRARY_DIRS})
 217         SET_SOURCE_FILES_PROPERTIES(src/codec_sndfile.cpp PROPERTIES
 218                                     COMPILE_FLAGS "${SNDFILE_CFLAGS}")
 219     ELSE(SNDFILE_FOUND)
 220         FIND_PACKAGE(SndFile)
 221         IF(SNDFILE_FOUND)
 222             SET(HAS_SNDFILE 1)
 223             INCLUDE_DIRECTORIES(${SNDFILE_INCLUDE_DIRS})
 224         ENDIF(SNDFILE_FOUND)
 225     ENDIF(SNDFILE_FOUND)
 226     IF(HAS_SNDFILE)
 227         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_sndfile.cpp)
 228     ENDIF(HAS_SNDFILE)
 229 ELSE(SNDFILE)
 230     SET(SNDFILE_LIBRARIES "")
 231 ENDIF(SNDFILE)
 232
 233 # Vorbis support
 234 IF(VORBIS)
 235     PKG_CHECK_MODULES(VORBISFILE vorbisfile)
 236     IF(VORBISFILE_FOUND)
 237         SET(HAS_VORBISFILE 1)
 238         LINK_DIRECTORIES(${VORBISFILE_LIBRARY_DIRS})
 239         SET_SOURCE_FILES_PROPERTIES(src/codec_vorbisfile.cpp PROPERTIES
 240                                     COMPILE_FLAGS "${VORBISFILE_CFLAGS}")
 241     ELSE(VORBISFILE_FOUND)
 242         FIND_PACKAGE(OggVorbis)
 243         IF(OGGVORBIS_FOUND)
 244             SET(HAS_VORBISFILE 1)
 245             INCLUDE_DIRECTORIES(${OGGVORBIS_INCLUDE_DIRS})
 246             SET(VORBISFILE_LIBRARIES ${OGGVORBIS_LIBRARIES})
 247         ENDIF(OGGVORBIS_FOUND)
 248     ENDIF(VORBISFILE_FOUND)
 249     IF(NOT HAS_VORBISFILE)
 250         PKG_CHECK_MODULES(VORBISIDEC vorbisidec)
 251         IF(NOT VORBISIDEC_FOUND)
 252             CHECK_INCLUDE_FILE(tremor/ivorbisfile.h HAVE_TREMOR_IVORBISFILE_H)
 253             IF(HAVE_TREMOR_IVORBISFILE_H)
 254                 CHECK_SHARED_FUNCTION_EXISTS(ov_open "tremor/ivorbisfile.h" vorbisidec "" HAVE_LIBVORBISIDEC)
 255                 IF(DYNLOAD OR HAVE_LIBVORBISIDEC)
 256                     SET(HAS_VORBISFILE 1)
 257                     IF(HAVE_LIBVORBISIDEC)
 258                         SET(VORBISFILE_LIBRARIES "vorbisidec")
 259                     ENDIF(HAVE_LIBVORBISIDEC)
 260                     SET_SOURCE_FILES_PROPERTIES(src/codec_vorbisfile.cpp PROPERTIES
 261                                                 COMPILE_FLAGS "-DHAS_VORBISIDEC")
 262                 ENDIF(DYNLOAD OR HAVE_LIBVORBISIDEC)
 263             ENDIF(HAVE_TREMOR_IVORBISFILE_H)
 264         ELSE(NOT VORBISIDEC_FOUND)
 265             SET(HAS_VORBISFILE 1)
 266             LINK_DIRECTORIES(${VORBISIDEC_LIBRARY_DIRS})
 267             SET_SOURCE_FILES_PROPERTIES(src/codec_vorbisfile.cpp PROPERTIES
 268                                         COMPILE_FLAGS "${VORBISIDEC_CFLAGS} -DHAS_VORBISIDEC")
 269         ENDIF(NOT VORBISIDEC_FOUND)
 270     ENDIF(NOT HAS_VORBISFILE)
 271     IF(HAS_VORBISFILE)
 272         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_vorbisfile.cpp)
 273     ENDIF(HAS_VORBISFILE)
 274 ELSE(VORBIS)
 275     SET(VORBISFILE_LIBRARIES "")
 276 ENDIF(VORBIS)
 277
 278 # FLAC support
 279 IF(FLAC)
 280     FIND_PACKAGE(FLAC)
 281     IF(FLAC_FOUND)
 282         INCLUDE_DIRECTORIES(${FLAC_INCLUDE_DIR})
 283         SET(HAS_FLAC 1)
 284     ENDIF(FLAC_FOUND)
 285     IF(HAS_FLAC)
 286         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_flac.cpp)
 287     ENDIF(HAS_FLAC)
 288 ELSE(FLAC)
 289     SET(LIBFLAC_LIBRARIES "")
 290 ENDIF(FLAC)
 291
 292 # MPG123 support
 293 IF(MPG123)
 294     PKG_CHECK_MODULES(MPG123 libmpg123)
 295     IF(NOT MPG123_FOUND)
 296         CHECK_INCLUDE_FILE(mpg123.h HAVE_MPG123_H)
 297         IF(HAVE_MPG123_H)
 298             CHECK_SHARED_FUNCTION_EXISTS(mpg123_init "mpg123.h" mpg123 "" HAVE_LIBMPG123)
 299             IF(NOT HAVE_LIBMPG123)
 300                 CHECK_SHARED_FUNCTION_EXISTS(mpg123_init "mpg123.h" mpg123-0 "" HAVE_LIBMPG123_0)
 301             ENDIF(NOT HAVE_LIBMPG123)
 302             IF(DYNLOAD OR HAVE_LIBMPG123 OR HAVE_LIBMPG123_0)
 303                 SET(HAS_MPG123 1)
 304                 IF(HAVE_LIBMPG123)
 305                     SET(MPG123_LIBRARIES "mpg123")
 306                 ELSEIF(HAVE_LIBMPG123_0)
 307                     SET(MPG123_LIBRARIES "mpg123-0")
 308                 ENDIF(HAVE_LIBMPG123)
 309             ENDIF(DYNLOAD OR HAVE_LIBMPG123 OR HAVE_LIBMPG123_0)
 310         ENDIF(HAVE_MPG123_H)
 311     ELSE(NOT MPG123_FOUND)
 312         SET(HAS_MPG123 1)
 313         LINK_DIRECTORIES(${MPG123_LIBRARY_DIRS})
 314         SET_SOURCE_FILES_PROPERTIES(src/codec_mpg123.cpp PROPERTIES
 315                                     COMPILE_FLAGS "${MPG123_CFLAGS}")
 316     ENDIF(NOT MPG123_FOUND)
 317     IF(HAS_MPG123)
 318         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_mpg123.cpp)
 319     ENDIF(HAS_MPG123)
 320 ELSE(MPG123)
 321     SET(MPG123_LIBRARIES "")
 322 ENDIF(MPG123)
 323
 324 # DUMB support
 325 IF(DUMB)
 326     CHECK_INCLUDE_FILE(dumb.h HAVE_DUMB_H)
 327     IF(HAVE_DUMB_H)
 328         IF(HAS_LIBM)
 329             CHECK_LIBRARY_EXISTS("dumb;m" dumbfile_open_ex "" HAVE_LIBDUMB)
 330         ELSE(HAS_LIBM)
 331             CHECK_LIBRARY_EXISTS(dumb dumbfile_open_ex "" HAVE_LIBDUMB)
 332         ENDIF(HAS_LIBM)
 333         IF(DYNLOAD OR HAVE_LIBDUMB)
 334             SET(HAS_DUMB 1)
 335             IF(HAVE_LIBDUMB)
 336                 SET(DUMB_LIBRARIES dumb)
 337             ENDIF(HAVE_LIBDUMB)
 338         ENDIF(DYNLOAD OR HAVE_LIBDUMB)
 339     ENDIF(HAVE_DUMB_H)
 340     IF(HAS_DUMB)
 341         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_dumb.cpp)
 342     ENDIF(HAS_DUMB)
 343 ELSE(DUMB)
 344     SET(DUMB_LIBRARIES "")
 345 ENDIF(DUMB)
 346
 347 # ModPlug support
 348 IF(MODPLUG)
 349     CHECK_INCLUDE_FILE(libmodplug/modplug.h HAVE_LIBMODPLUG_MODPLUG_H)
 350     IF(HAVE_LIBMODPLUG_MODPLUG_H)
 351         CHECK_SHARED_FUNCTION_EXISTS(ModPlug_Load "libmodplug/modplug.h" modplug "" HAVE_LIBMODPLUG)
 352         IF(DYNLOAD OR HAVE_LIBMODPLUG)
 353             SET(HAS_MODPLUG 1)
 354             IF(HAVE_LIBMODPLUG)
 355                 SET(MODPLUG_LIBRARIES "modplug")
 356             ENDIF(HAVE_LIBMODPLUG)
 357         ENDIF(DYNLOAD OR HAVE_LIBMODPLUG)
 358     ENDIF(HAVE_LIBMODPLUG_MODPLUG_H)
 359     IF(HAS_MODPLUG)
 360         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_modplug.cpp)
 361     ENDIF(HAS_MODPLUG)
 362 ELSE(MODPLUG)
 363     SET(MODPLUG_LIBRARIES "")
 364 ENDIF(MODPLUG)
 365
 366 # FluidSynth support
 367 IF(FLUIDSYNTH)
 368     PKG_CHECK_MODULES(FLUIDSYNTH fluidsynth>=1.1.1)
 369     IF(NOT FLUIDSYNTH_FOUND)
 370         CHECK_INCLUDE_FILE(fluidsynth.h HAVE_FLUIDSYNTH_H)
 371         IF(HAVE_FLUIDSYNTH_H)
 372             CHECK_SHARED_FUNCTION_EXISTS(new_fluid_synth "fluidsynth.h" fluidsynth "" HAVE_LIBFLUIDSYNTH)
 373             IF(DYNLOAD OR HAVE_LIBFLUIDSYNTH)
 374                 SET(HAS_FLUIDSYNTH 1)
 375                 IF(HAVE_LIBFLUIDSYNTH)
 376                     SET(FLUIDSYNTH_LIBRARIES "fluidsynth")
 377                 ENDIF(HAVE_LIBFLUIDSYNTH)
 378             ENDIF(DYNLOAD OR HAVE_LIBFLUIDSYNTH)
 379         ENDIF(HAVE_FLUIDSYNTH_H)
 380     ELSE(NOT FLUIDSYNTH_FOUND)
 381         SET(HAS_FLUIDSYNTH 1)
 382         LINK_DIRECTORIES(${FLUIDSYNTH_LIBRARY_DIRS})
 383         SET_SOURCE_FILES_PROPERTIES(src/codec_fluidsynth.cpp PROPERTIES
 384                                     COMPILE_FLAGS "${FLUIDSYNTH_CFLAGS}")
 385     ENDIF(NOT FLUIDSYNTH_FOUND)
 386     IF(HAS_FLUIDSYNTH)
 387         SET(ALURE_OBJS ${ALURE_OBJS} src/codec_fluidsynth.cpp)
 388     ENDIF(HAS_FLUIDSYNTH)
 389 ELSE(FLUIDSYNTH)
 390     SET(FLUIDSYNTH_LIBRARIES "")
 391 ENDIF(FLUIDSYNTH)
 392
 393
 394 IF(NOT DYNLOAD)
 395     SET(EXTRA_LIBS ${SNDFILE_LIBRARIES} ${VORBISFILE_LIBRARIES} ${LIBFLAC_LIBRARIES} ${MPG123_LIBRARIES} ${DUMB_LIBRARIES} ${MODPLUG_LIBRARIES} ${FLUIDSYNTH_LIBRARIES} ${EXTRA_LIBS})
 396 ELSE(NOT DYNLOAD)
 397     ADD_DEFINITIONS(-DDYNLOAD=1)
 398 ENDIF(NOT DYNLOAD)
 399
 400 # For alure.pc.in
 401 SET(prefix ${CMAKE_INSTALL_PREFIX})
 402 SET(exec_prefix "\${prefix}")
 403 SET(libdir "\${exec_prefix}/lib${LIB_SUFFIX}")
 404 SET(bindir "\${exec_prefix}/bin")
 405 SET(includedir "\${prefix}/include")
 406 SET(PKG_CONFIG_REQUIRES openal)
 407 SET(PACKAGE_VERSION "${LIB_VERSION}")
 408
 409 # End configuration
 410 CONFIGURE_FILE(
 411     "${ALURE_SOURCE_DIR}/config.h.in"
 412     "${ALURE_BINARY_DIR}/config.h")
 413 IF(BUILD_SHARED)
 414     CONFIGURE_FILE(
 415         "${ALURE_SOURCE_DIR}/alure.pc.in"
 416         "${ALURE_BINARY_DIR}/alure.pc"
 417         @ONLY)
 418 ENDIF(BUILD_SHARED)
 419 IF(BUILD_STATIC)
 420     CONFIGURE_FILE(
 421         "${ALURE_SOURCE_DIR}/alure-static.pc.in"
 422         "${ALURE_BINARY_DIR}/alure-static.pc"
 423         @ONLY)
 424 ENDIF(BUILD_STATIC)
 425
 426 ADD_DEFINITIONS(-DHAVE_CONFIG_H)
 427
 428
 429 IF(BUILD_SHARED)
 430     #build a shared library
 431     ADD_LIBRARY(${LIBNAME} SHARED ${ALURE_OBJS})
 432     SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES DEFINE_SYMBOL ALURE_BUILD_LIBRARY
 433                                                 VERSION ${LIB_VERSION}.0
 434                                                 SOVERSION ${LIB_MAJOR_VERSION})
 435     IF(WIN32)
 436         SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES PREFIX "")
 437     ELSEIF(NOT APPLE)
 438         SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES LINK_FLAGS "-Wl,--version-script=${ALURE_SOURCE_DIR}/libalure.map")
 439     ENDIF(WIN32)
 440     TARGET_LINK_LIBRARIES(${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 441
 442     INSTALL(TARGETS ${LIBNAME}
 443             RUNTIME DESTINATION bin
 444             LIBRARY DESTINATION lib${LIB_SUFFIX}
 445             ARCHIVE DESTINATION lib${LIB_SUFFIX}
 446 )
 447 ENDIF(BUILD_SHARED)
 448 IF(BUILD_STATIC)
 449     #build a static library
 450     ADD_LIBRARY(${LIBNAME}-static STATIC ${ALURE_OBJS})
 451     SET_TARGET_PROPERTIES(${LIBNAME}-static PROPERTIES DEFINE_SYMBOL ALURE_BUILD_LIBRARY
 452                                                        COMPILE_FLAGS ${STATIC_CFLAGS}
 453                                                        VERSION ${LIB_VERSION}.0)
 454     INSTALL(TARGETS ${LIBNAME}-static
 455             RUNTIME DESTINATION bin
 456             LIBRARY DESTINATION lib${LIB_SUFFIX}
 457             ARCHIVE DESTINATION lib${LIB_SUFFIX}
 458 )
 459 ENDIF(BUILD_STATIC)
 460
 461
 462 OPTION(BUILD_EXAMPLES   "Build example programs"   ON)
 463 OPTION(INSTALL_EXAMPLES "Install example programs" ON)
 464
 465 IF(BUILD_EXAMPLES)
 466     IF(HAVE_DDK_NTDDCDRM_H)
 467         SET_SOURCE_FILES_PROPERTIES(examples/alurecdplay.c PROPERTIES
 468                                     COMPILE_FLAGS "-DHAVE_DDK_NTDDCDRM_H")
 469     ENDIF(HAVE_DDK_NTDDCDRM_H)
 470     ADD_EXECUTABLE(alureplay examples/alureplay.c)
 471     ADD_EXECUTABLE(alurecdplay examples/alurecdplay.c)
 472     ADD_EXECUTABLE(alurestream examples/alurestream.c)
 473     IF(BUILD_SHARED)
 474         TARGET_LINK_LIBRARIES(alureplay ${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 475         TARGET_LINK_LIBRARIES(alurecdplay ${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 476         TARGET_LINK_LIBRARIES(alurestream ${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 477     ELSE(BUILD_SHARED)
 478         SET_TARGET_PROPERTIES(alureplay PROPERTIES COMPILE_FLAGS -DALURE_STATIC_LIBRARY)
 479         SET_TARGET_PROPERTIES(alurecdplay PROPERTIES COMPILE_FLAGS -DALURE_STATIC_LIBRARY)
 480         SET_TARGET_PROPERTIES(alurestream PROPERTIES COMPILE_FLAGS -DALURE_STATIC_LIBRARY)
 481         TARGET_LINK_LIBRARIES(alureplay ${LIBNAME}-static ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 482         TARGET_LINK_LIBRARIES(alurecdplay ${LIBNAME}-static ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 483         TARGET_LINK_LIBRARIES(alurestream ${LIBNAME}-static ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 484     ENDIF(BUILD_SHARED)
 485 ENDIF(BUILD_EXAMPLES)
 486
 487
 488 FIND_PROGRAM(NATDOCS_BIN NaturalDocs)
 489 IF(NATDOCS_BIN)
 490     ADD_CUSTOM_TARGET(docs
 491                       "${NATDOCS_BIN}" -i "${ALURE_SOURCE_DIR}/src" -o HTML "${ALURE_SOURCE_DIR}/docs/html" -p "${ALURE_SOURCE_DIR}/docs/naturaldocs" -s Default CustomStyle
 492                       COMMENT "Building NaturalDocs documentation..." VERBATIM)
 493 ELSE(NATDOCS_BIN)
 494     MESSAGE(STATUS "\nNaturalDocs not found; building documentation is disabled")
 495 ENDIF(NATDOCS_BIN)
 496
 497
 498 #add an install target here
 499 IF(APPLE)
 500     SET(INCPATH OpenAL)
 501 ELSE(APPLE)
 502     SET(INCPATH AL)
 503 ENDIF(APPLE)
 504
 505 INSTALL(DIRECTORY "${ALURE_SOURCE_DIR}/docs/html"
 506         DESTINATION share/doc/alure
 507 )
 508 INSTALL(FILES include/AL/alure.h
 509         DESTINATION "include/${INCPATH}"
 510 )
 511 IF(BUILD_SHARED)
 512     INSTALL(FILES "${ALURE_BINARY_DIR}/alure.pc"
 513             DESTINATION "lib${LIB_SUFFIX}/pkgconfig"
 514     )
 515 ENDIF(BUILD_SHARED)
 516 IF(BUILD_STATIC)
 517     INSTALL(FILES "${ALURE_BINARY_DIR}/alure-static.pc"
 518             DESTINATION "lib${LIB_SUFFIX}/pkgconfig"
 519     )
 520 ENDIF(BUILD_STATIC)
 521 IF(BUILD_EXAMPLES AND INSTALL_EXAMPLES)
 522     INSTALL(TARGETS alureplay alurestream alurecdplay
 523             RUNTIME DESTINATION bin)
 524 ENDIF(BUILD_EXAMPLES AND INSTALL_EXAMPLES)
 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 IF(BUILD_EXAMPLES AND INSTALL_EXAMPLES)
 536     MESSAGE(STATUS "Building and installing examples")
 537 ELSEIF(BUILD_EXAMPLES)
 538     MESSAGE(STATUS "Building (not installing) examples")
 539 ELSE(BUILD_EXAMPLES AND INSTALL_EXAMPLES)
 540     MESSAGE(STATUS "Not building examples")
 541 ENDIF(BUILD_EXAMPLES AND INSTALL_EXAMPLES)
 542 MESSAGE(STATUS "")
 543 IF(HAS_SNDFILE)
 544     MESSAGE(STATUS "SndFile support: enabled")
 545 ELSE(HAS_SNDFILE)
 546     MESSAGE(STATUS "SndFile support: disabled")
 547 ENDIF(HAS_SNDFILE)
 548 IF(HAS_VORBISFILE)
 549     MESSAGE(STATUS "VorbisFile support: enabled")
 550 ELSE(HAS_VORBISFILE)
 551     MESSAGE(STATUS "VorbisFile support: disabled")
 552 ENDIF(HAS_VORBISFILE)
 553 IF(HAS_FLAC)
 554     MESSAGE(STATUS "FLAC support: enabled")
 555 ELSE(HAS_FLAC)
 556     MESSAGE(STATUS "FLAC support: disabled")
 557 ENDIF(HAS_FLAC)
 558 IF(HAS_MPG123)
 559     MESSAGE(STATUS "MPG123 support: enabled")
 560 ELSE(HAS_MPG123)
 561     MESSAGE(STATUS "MPG123 support: disabled")
 562 ENDIF(HAS_MPG123)
 563 IF(HAS_DUMB)
 564     MESSAGE(STATUS "DUMB support: enabled")
 565 ELSE(HAS_DUMB)
 566     MESSAGE(STATUS "DUMB support: disabled")
 567 ENDIF(HAS_DUMB)
 568 IF(HAS_MODPLUG)
 569     MESSAGE(STATUS "ModPlug support: enabled")
 570 ELSE(HAS_MODPLUG)
 571     MESSAGE(STATUS "ModPlug support: disabled")
 572 ENDIF(HAS_MODPLUG)
 573 IF(HAS_FLUIDSYNTH)
 574     MESSAGE(STATUS "FluidSynth support: enabled")
 575 ELSE(HAS_FLUIDSYNTH)
 576     MESSAGE(STATUS "FluidSynth support: disabled")
 577 ENDIF(HAS_FLUIDSYNTH)
 578 MESSAGE(STATUS "")