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(NOT HAVE_WINDOWS_H)
 111     CHECK_C_COMPILER_FLAG(-pthread HAVE_PTHREAD)
 112     IF(HAVE_PTHREAD)
 113         ADD_DEFINITIONS(-pthread)
 114         SET(EXTRA_LIBS ${EXTRA_LIBS} -pthread)
 115     ENDIF(HAVE_PTHREAD)
 116
 117     # We need pthreads outside of Windows
 118     CHECK_INCLUDE_FILE(pthread.h HAVE_PTHREAD_H)
 119     IF(NOT HAVE_PTHREAD_H)
 120         MESSAGE(FATAL_ERROR "PThreads is required for non-Windows builds!")
 121     ENDIF()
 122     # Some systems need pthread_np.h to get recursive mutexes
 123     CHECK_INCLUDE_FILES("pthread.h;pthread_np.h" HAVE_PTHREAD_NP_H)
 124
 125     # _GNU_SOURCE is needed on some systems for extra attributes, and
 126     # _REENTRANT is needed for libc thread-safety
 127     ADD_DEFINITIONS(-D_GNU_SOURCE=1)
 128     CHECK_FUNCTION_EXISTS(pthread_create HAS_PTHREAD_CREATE)
 129     IF(NOT HAS_PTHREAD_CREATE)
 130         CHECK_SHARED_LIBRARY_EXISTS(pthread pthread_create "" HAVE_LIBPTHREAD)
 131         IF(NOT HAVE_LIBPTHREAD)
 132             MESSAGE(FATAL_ERROR "pthread_create not found on non-Windows target!")
 133         ENDIF(NOT HAVE_LIBPTHREAD)
 134         SET(EXTRA_LIBS pthread ${EXTRA_LIBS})
 135     ENDIF(NOT HAS_PTHREAD_CREATE)
 136
 137     CHECK_FUNCTION_EXISTS(nanosleep HAVE_NANOSLEEP)
 138     IF(NOT HAVE_NANOSLEEP)
 139         MESSAGE(FATAL_ERROR "No sleep function found!")
 140     ENDIF(NOT HAVE_NANOSLEEP)
 141 ENDIF(NOT HAVE_WINDOWS_H)
 142
 143 CHECK_INCLUDE_FILE(sys/types.h HAVE_SYS_TYPES_H)
 144 CHECK_INCLUDE_FILE(sys/wait.h HAVE_SYS_WAIT_H)
 145 CHECK_INCLUDE_FILE(signal.h HAVE_SIGNAL_H)
 146 CHECK_INCLUDE_FILE(dlfcn.h HAVE_DLFCN_H)
 147
 148 IF(HAVE_DLFCN_H)
 149     CHECK_SHARED_LIBRARY_EXISTS(dl dlopen "" HAVE_LIBDL)
 150     IF(HAVE_LIBDL)
 151         SET(EXTRA_LIBS dl ${EXTRA_LIBS})
 152     ENDIF(HAVE_LIBDL)
 153 ENDIF(HAVE_DLFCN_H)
 154
 155 OPTION(DYNLOAD    "Dynamically load support libs at run-time" ON)
 156 OPTION(SNDFILE    "SoundFile support (for various formats)" ON)
 157 OPTION(VORBIS     "VorbisFile support (for Ogg Vorbis)"  ON)
 158 OPTION(FLAC       "FLAC support (for FLAC and Ogg FLAC)" ON)
 159 OPTION(MPG123     "MPG123 support (for MP1/MP2/MP3)" ON)
 160 OPTION(DUMB       "DUMB support (for IT/XM/S3M/MOD)" ON)
 161 OPTION(MODPLUG    "ModPlug support (for IT/XM/S3M/MOD)" OFF)
 162 OPTION(FLUIDSYNTH "FluidSynth support (for MID)" ON)
 163
 164 IF(WIN32)
 165     ADD_DEFINITIONS(-D_WIN32)
 166
 167     IF(CMAKE_SIZEOF_VOID_P MATCHES "8")
 168         SET(WIN_TYPE Win64)
 169         SET(XBITS x64)
 170     ELSE(CMAKE_SIZEOF_VOID_P MATCHES "8")
 171         SET(WIN_TYPE Win32)
 172         SET(XBITS x86)
 173     ENDIF(CMAKE_SIZEOF_VOID_P MATCHES "8")
 174
 175     SET(OPENAL_SEARCH_PATHS
 176         ENV ALSDK_DIR
 177         ENV MINGDIR
 178         "C:/Program Files/OpenAL 1.1 SDK"
 179         "C:/Program Files (x86)/OpenAL 1.1 SDK"
 180         "E:/Programs/Dev/OpenAL"
 181         "E:/Program Files (x86)/OpenAL 1.1 SDK" )
 182
 183     FIND_PATH(OPENAL_INCLUDE_DIR al.h
 184               PATHS ${OPENAL_SEARCH_PATHS}
 185               PATH_SUFFIXES include include/AL )
 186     IF(OPENAL_INCLUDE_DIR)
 187         INCLUDE_DIRECTORIES(${OPENAL_INCLUDE_DIR})
 188         FIND_LIBRARY(OPENAL_LIBRARIES OpenAL32
 189                      PATHS ${OPENAL_SEARCH_PATHS}
 190                      PATH_SUFFIXES lib libs/${WIN_TYPE} )
 191     ENDIF(OPENAL_INCLUDE_DIR)
 192
 193     IF(NOT OPENAL_LIBRARIES)
 194         MESSAGE(FATAL_ERROR "OpenAL not found!\nPlease try setting the ALSDK_DIR environment variable and try again.")
 195     ENDIF(NOT OPENAL_LIBRARIES)
 196
 197     MESSAGE(STATUS "OpenAL include: ${OPENAL_INCLUDE_DIR}")
 198     MESSAGE(STATUS "OpenAL lib: ${OPENAL_LIBRARIES}")
 199 ELSE(WIN32)
 200     IF(NOT HAVE_DLFCN_H OR NOT HAVE_LIBDL)
 201         SET(DYNLOAD OFF)
 202     ENDIF(NOT HAVE_DLFCN_H OR NOT HAVE_LIBDL)
 203
 204     PKG_CHECK_MODULES(OPENAL openal)
 205     IF(NOT OPENAL_FOUND)
 206         IF(APPLE)
 207             CHECK_INCLUDE_FILE(OpenAL/al.h HAVE_OPENAL_AL_H)
 208             IF(HAVE_OPENAL_AL_H)
 209                 SET(OPENAL_LIBRARIES "-framework OpenAL")
 210                 SET(HAS_OPENAL 1)
 211             ENDIF(HAVE_OPENAL_AL_H)
 212         ELSE(APPLE)
 213             CHECK_INCLUDE_FILE(AL/al.h HAVE_AL_AL_H)
 214             IF(HAVE_AL_AL_H)
 215                 CHECK_SHARED_LIBRARY_EXISTS(openal alcOpenDevice "" HAS_OPENAL)
 216                 IF(HAS_OPENAL)
 217                     SET(OPENAL_LIBRARIES openal)
 218                 ENDIF(HAS_OPENAL)
 219             ENDIF(HAVE_AL_AL_H)
 220         ENDIF(APPLE)
 221         IF(NOT HAS_OPENAL)
 222             MESSAGE(FATAL_ERROR "OpenAL not found!")
 223         ENDIF(NOT HAS_OPENAL)
 224     ELSE(NOT OPENAL_FOUND)
 225         INCLUDE_DIRECTORIES(${OPENAL_INCLUDE_DIRS})
 226         LINK_DIRECTORIES(${OPENAL_LIBRARY_DIRS})
 227     ENDIF(NOT OPENAL_FOUND)
 228 ENDIF(WIN32)
 229
 230 # SndFile support
 231 IF(SNDFILE)
 232     PKG_CHECK_MODULES(SNDFILE sndfile)
 233     IF(NOT SNDFILE_FOUND)
 234         CHECK_INCLUDE_FILE(sndfile.h HAVE_SNDFILE_H)
 235         IF(HAVE_SNDFILE_H)
 236             CHECK_SHARED_LIBRARY_EXISTS(sndfile sf_open "" HAVE_LIBSNDFILE)
 237             CHECK_SHARED_LIBRARY_EXISTS(libsndfile-1 sf_open "" HAVE_LIBSNDFILE1)
 238             IF(DYNLOAD OR HAVE_LIBSNDFILE OR HAVE_LIBSNDFILE1)
 239                 SET(HAS_SNDFILE 1)
 240                 IF(HAVE_LIBSNDFILE)
 241                     SET(SNDFILE_LIBRARIES "sndfile")
 242                 ELSEIF(HAVE_LIBSNDFILE1)
 243                     SET(SNDFILE_LIBRARIES "libsndfile-1")
 244                 ENDIF(HAVE_LIBSNDFILE)
 245             ENDIF(DYNLOAD OR HAVE_LIBSNDFILE OR HAVE_LIBSNDFILE1)
 246         ENDIF(HAVE_SNDFILE_H)
 247     ELSE(NOT SNDFILE_FOUND)
 248         SET(HAS_SNDFILE 1)
 249         INCLUDE_DIRECTORIES(${SNDFILE_INCLUDE_DIRS})
 250         LINK_DIRECTORIES(${SNDFILE_LIBRARY_DIRS})
 251     ENDIF(NOT SNDFILE_FOUND)
 252 ELSE(SNDFILE)
 253     SET(SNDFILE_LIBRARIES "")
 254 ENDIF(SNDFILE)
 255
 256 # Vorbis support
 257 IF(VORBIS)
 258     PKG_CHECK_MODULES(VORBISFILE vorbisfile)
 259     IF(NOT VORBISFILE_FOUND)
 260         CHECK_INCLUDE_FILE(vorbis/vorbisfile.h HAVE_VORBIS_VORBISFILE_H)
 261         IF(HAVE_VORBIS_VORBISFILE_H)
 262             CHECK_SHARED_LIBRARY_EXISTS(vorbisfile ov_open "" HAVE_LIBVORBISFILE)
 263             IF(DYNLOAD OR HAVE_LIBVORBISFILE)
 264                 SET(HAS_VORBISFILE 1)
 265                 IF(HAVE_LIBVORBISFILE)
 266                     SET(VORBISFILE_LIBRARIES "vorbisfile")
 267                 ENDIF(HAVE_LIBVORBISFILE)
 268             ENDIF(DYNLOAD OR HAVE_LIBVORBISFILE)
 269         ENDIF(HAVE_VORBIS_VORBISFILE_H)
 270     ELSE(NOT VORBISFILE_FOUND)
 271         SET(HAS_VORBISFILE 1)
 272         INCLUDE_DIRECTORIES(${VORBISFILE_INCLUDE_DIRS})
 273         LINK_DIRECTORIES(${VORBISFILE_LIBRARY_DIRS})
 274     ENDIF(NOT VORBISFILE_FOUND)
 275 ELSE(VORBIS)
 276     SET(VORBISFILE_LIBRARIES "")
 277 ENDIF(VORBIS)
 278
 279 # FLAC support
 280 IF(FLAC)
 281     #PKG_CHECK_MODULES(LIBFLAC flac)
 282     #IF(NOT LIBFLAC_FOUND)
 283         CHECK_INCLUDE_FILE(FLAC/all.h HAVE_FLAC_ALL_H)
 284         IF(HAVE_FLAC_ALL_H)
 285             CHECK_SHARED_LIBRARY_EXISTS(FLAC FLAC__stream_decoder_new "" HAVE_LIBFLAC)
 286             IF(DYNLOAD OR HAVE_LIBFLAC)
 287                 SET(HAS_FLAC 1)
 288                 IF(HAVE_LIBFLAC)
 289                     SET(LIBFLAC_LIBRARIES "FLAC")
 290                 ENDIF(HAVE_LIBFLAC)
 291             ENDIF(DYNLOAD OR HAVE_LIBFLAC)
 292         ENDIF(HAVE_FLAC_ALL_H)
 293     #ELSE(NOT LIBFLAC_FOUND)
 294     #    SET(HAS_FLAC 1)
 295     #    INCLUDE_DIRECTORIES(${LIBFLAC_INCLUDE_DIRS})
 296     #    LINK_DIRECTORIES(${LIBFLAC_LIBRARY_DIRS})
 297     #ENDIF(NOT LIBFLAC_FOUND)
 298 ELSE(FLAC)
 299     SET(LIBFLAC_LIBRARIES "")
 300 ENDIF(FLAC)
 301
 302 # MPG123 support
 303 IF(MPG123)
 304     PKG_CHECK_MODULES(MPG123 libmpg123)
 305     IF(NOT MPG123_FOUND)
 306         CHECK_INCLUDE_FILE(mpg123.h HAVE_MPG123_H)
 307         IF(HAVE_MPG123_H)
 308             CHECK_SHARED_LIBRARY_EXISTS(mpg123 mpg123_init "" HAVE_LIBMPG123)
 309             IF(DYNLOAD OR HAVE_LIBMPG123)
 310                 SET(HAS_MPG123 1)
 311                 IF(HAVE_LIBMPG123)
 312                     SET(MPG123_LIBRARIES "mpg123")
 313                 ENDIF(HAVE_LIBMPG123)
 314             ENDIF(DYNLOAD OR HAVE_LIBMPG123)
 315         ENDIF(HAVE_MPG123_H)
 316     ELSE(NOT MPG123_FOUND)
 317         SET(HAS_MPG123 1)
 318         INCLUDE_DIRECTORIES(${MPG123_INCLUDE_DIRS})
 319         LINK_DIRECTORIES(${MPG123_LIBRARY_DIRS})
 320     ENDIF(NOT MPG123_FOUND)
 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 ELSE(DUMB)
 342     SET(DUMB_LIBRARIES "")
 343 ENDIF(DUMB)
 344
 345 # ModPlug support
 346 IF(MODPLUG)
 347     PKG_CHECK_MODULES(MODPLUG libmodplug)
 348     IF(NOT MODPLUG_FOUND)
 349         CHECK_INCLUDE_FILE(modplug.h HAVE_MODPLUG_H)
 350         IF(HAVE_MODPLUG_H)
 351             CHECK_SHARED_LIBRARY_EXISTS(modplug ModPlug_Load "" 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_MODPLUG_H)
 359     ELSE(NOT MODPLUG_FOUND)
 360         SET(HAS_MODPLUG 1)
 361         INCLUDE_DIRECTORIES(${MODPLUG_INCLUDE_DIRS})
 362         LINK_DIRECTORIES(${MODPLUG_LIBRARY_DIRS})
 363     ENDIF(NOT MODPLUG_FOUND)
 364 ELSE(MODPLUG)
 365     SET(MODPLUG_LIBRARIES "")
 366 ENDIF(MODPLUG)
 367
 368 # FluidSynth support
 369 IF(FLUIDSYNTH)
 370     PKG_CHECK_MODULES(FLUIDSYNTH fluidsynth>=1.1.1)
 371     IF(NOT FLUIDSYNTH_FOUND)
 372         CHECK_INCLUDE_FILE(fluidsynth.h HAVE_FLUIDSYNTH_H)
 373         IF(HAVE_FLUIDSYNTH_H)
 374             CHECK_SHARED_LIBRARY_EXISTS(fluidsynth new_fluid_synth "" HAVE_LIBFLUIDSYNTH)
 375             IF(DYNLOAD OR HAVE_LIBFLUIDSYNTH)
 376                 SET(HAS_FLUIDSYNTH 1)
 377                 IF(HAVE_LIBFLUIDSYNTH)
 378                     SET(FLUIDSYNTH_LIBRARIES "fluidsynth")
 379                 ENDIF(HAVE_LIBFLUIDSYNTH)
 380             ENDIF(DYNLOAD OR HAVE_LIBFLUIDSYNTH)
 381         ENDIF(HAVE_FLUIDSYNTH_H)
 382     ELSE(NOT FLUIDSYNTH_FOUND)
 383         SET(HAS_FLUIDSYNTH 1)
 384         INCLUDE_DIRECTORIES(${FLUIDSYNTH_INCLUDE_DIRS})
 385         LINK_DIRECTORIES(${FLUIDSYNTH_LIBRARY_DIRS})
 386     ENDIF(NOT FLUIDSYNTH_FOUND)
 387 ELSE(FLUIDSYNTH)
 388     SET(FLUIDSYNTH_LIBRARIES "")
 389 ENDIF(FLUIDSYNTH)
 390
 391
 392 IF(NOT DYNLOAD)
 393     SET(EXTRA_LIBS ${SNDFILE_LIBRARIES} ${VORBISFILE_LIBRARIES} ${LIBFLAC_LIBRARIES} ${MPG123_LIBRARIES} ${DUMB_LIBRARIES} ${MODPLUG_LIBRARIES} ${FLUIDSYNTH_LIBRARIES} ${EXTRA_LIBS})
 394 ELSE(NOT DYNLOAD)
 395     ADD_DEFINITIONS(-DDYNLOAD=1)
 396 ENDIF(NOT DYNLOAD)
 397
 398 # For alure.pc.in
 399 SET(prefix ${CMAKE_INSTALL_PREFIX})
 400 SET(exec_prefix "\${prefix}")
 401 SET(libdir "\${exec_prefix}/lib${LIB_SUFFIX}")
 402 SET(bindir "\${exec_prefix}/bin")
 403 SET(includedir "\${prefix}/include")
 404 SET(PKG_CONFIG_REQUIRES openal)
 405 SET(PACKAGE_VERSION "${LIB_VERSION}")
 406
 407 # End configuration
 408 CONFIGURE_FILE(
 409     "${ALURE_SOURCE_DIR}/config.h.in"
 410     "${ALURE_BINARY_DIR}/config.h")
 411 IF(BUILD_SHARED)
 412     CONFIGURE_FILE(
 413         "${ALURE_SOURCE_DIR}/alure.pc.in"
 414         "${ALURE_BINARY_DIR}/alure.pc"
 415         @ONLY)
 416 ENDIF(BUILD_SHARED)
 417 IF(BUILD_STATIC)
 418     CONFIGURE_FILE(
 419         "${ALURE_SOURCE_DIR}/alure-static.pc.in"
 420         "${ALURE_BINARY_DIR}/alure-static.pc"
 421         @ONLY)
 422 ENDIF(BUILD_STATIC)
 423
 424 ADD_DEFINITIONS(-DHAVE_CONFIG_H)
 425
 426
 427 SET(ALURE_OBJS  src/alure.cpp
 428                 src/buffer.cpp
 429                 src/istream.cpp
 430                 src/stream.cpp
 431                 src/streamdec.cpp
 432                 src/streamplay.cpp
 433                 src/codec_wav.cpp
 434                 src/codec_aiff.cpp
 435 )
 436 IF(HAS_VORBISFILE)
 437     SET(ALURE_OBJS ${ALURE_OBJS} src/codec_vorbisfile.cpp)
 438 ENDIF(HAS_VORBISFILE)
 439 IF(HAS_FLAC)
 440     SET(ALURE_OBJS ${ALURE_OBJS} src/codec_flac.cpp)
 441 ENDIF(HAS_FLAC)
 442 IF(HAS_SNDFILE)
 443     SET(ALURE_OBJS ${ALURE_OBJS} src/codec_sndfile.cpp)
 444 ENDIF(HAS_SNDFILE)
 445 IF(HAS_FLUIDSYNTH)
 446     SET(ALURE_OBJS ${ALURE_OBJS} src/codec_fluidsynth.cpp)
 447 ENDIF(HAS_FLUIDSYNTH)
 448 IF(HAS_DUMB)
 449     SET(ALURE_OBJS ${ALURE_OBJS} src/codec_dumb.cpp)
 450 ENDIF(HAS_DUMB)
 451 IF(HAS_MODPLUG)
 452     SET(ALURE_OBJS ${ALURE_OBJS} src/codec_modplug.cpp)
 453 ENDIF(HAS_MODPLUG)
 454 IF(HAS_MPG123)
 455     SET(ALURE_OBJS ${ALURE_OBJS} src/codec_mpg123.cpp)
 456 ENDIF(HAS_MPG123)
 457
 458 IF(BUILD_SHARED)
 459     #build a shared library
 460     ADD_LIBRARY(${LIBNAME} SHARED ${ALURE_OBJS})
 461     SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES DEFINE_SYMBOL ALURE_BUILD_LIBRARY
 462                                                 VERSION ${LIB_VERSION}.0
 463                                                 SOVERSION ${LIB_MAJOR_VERSION})
 464     IF(WIN32)
 465         SET_TARGET_PROPERTIES(${LIBNAME} PROPERTIES PREFIX "")
 466     ENDIF(WIN32)
 467     TARGET_LINK_LIBRARIES(${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 468
 469     INSTALL(TARGETS ${LIBNAME}
 470             RUNTIME DESTINATION bin
 471             LIBRARY DESTINATION lib${LIB_SUFFIX}
 472             ARCHIVE DESTINATION lib${LIB_SUFFIX}
 473 )
 474 ENDIF(BUILD_SHARED)
 475 IF(BUILD_STATIC)
 476     #build a static library
 477     ADD_LIBRARY(${LIBNAME}-static STATIC ${ALURE_OBJS})
 478     SET_TARGET_PROPERTIES(${LIBNAME}-static PROPERTIES DEFINE_SYMBOL ALURE_BUILD_LIBRARY
 479                                                        COMPILE_FLAGS ${STATIC_CFLAGS}
 480                                                        VERSION ${LIB_VERSION}.0)
 481     INSTALL(TARGETS ${LIBNAME}-static
 482             RUNTIME DESTINATION bin
 483             LIBRARY DESTINATION lib${LIB_SUFFIX}
 484             ARCHIVE DESTINATION lib${LIB_SUFFIX}
 485 )
 486 ENDIF(BUILD_STATIC)
 487
 488
 489 ADD_EXECUTABLE(alureplay examples/alureplay.c)
 490 ADD_EXECUTABLE(alurecdplay examples/alurecdplay.c)
 491 ADD_EXECUTABLE(alurestream examples/alurestream.c)
 492 IF(BUILD_SHARED)
 493     TARGET_LINK_LIBRARIES(alureplay ${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 494     TARGET_LINK_LIBRARIES(alurecdplay ${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 495     TARGET_LINK_LIBRARIES(alurestream ${LIBNAME} ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 496 ELSE(BUILD_SHARED)
 497     SET_TARGET_PROPERTIES(alureplay PROPERTIES COMPILE_FLAGS -DALURE_STATIC_LIBRARY)
 498     SET_TARGET_PROPERTIES(alurecdplay PROPERTIES COMPILE_FLAGS -DALURE_STATIC_LIBRARY)
 499     SET_TARGET_PROPERTIES(alurestream PROPERTIES COMPILE_FLAGS -DALURE_STATIC_LIBRARY)
 500     TARGET_LINK_LIBRARIES(alureplay ${LIBNAME}-static ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 501     TARGET_LINK_LIBRARIES(alurecdplay ${LIBNAME}-static ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 502     TARGET_LINK_LIBRARIES(alurestream ${LIBNAME}-static ${OPENAL_LIBRARIES} ${EXTRA_LIBS})
 503 ENDIF(BUILD_SHARED)
 504
 505
 506 FIND_PROGRAM(NATDOCS_BIN NaturalDocs)
 507 IF(NATDOCS_BIN)
 508     ADD_CUSTOM_TARGET(docs
 509                       "${NATDOCS_BIN}" -i "${ALURE_SOURCE_DIR}/src" -o HTML "${ALURE_SOURCE_DIR}/docs/html" -p "${ALURE_SOURCE_DIR}/docs/naturaldocs" -s Default CustomStyle
 510                       COMMENT "Building NaturalDocs documentation..." VERBATIM)
 511 ELSE(NATDOCS_BIN)
 512     MESSAGE(STATUS "\nNaturalDocs not found; building documentation is disabled")
 513 ENDIF(NATDOCS_BIN)
 514
 515
 516 #add an install target here
 517 IF(APPLE)
 518     SET(INCPATH OpenAL)
 519 ELSE(APPLE)
 520     SET(INCPATH AL)
 521 ENDIF(APPLE)
 522
 523 INSTALL(DIRECTORY "${ALURE_SOURCE_DIR}/docs/html"
 524         DESTINATION share/doc/alure
 525 )
 526 INSTALL(FILES include/AL/alure.h
 527         DESTINATION "include/${INCPATH}"
 528 )
 529 IF(BUILD_SHARED)
 530     INSTALL(FILES "${ALURE_BINARY_DIR}/alure.pc"
 531             DESTINATION "lib${LIB_SUFFIX}/pkgconfig"
 532     )
 533 ENDIF(BUILD_SHARED)
 534 IF(BUILD_STATIC)
 535     INSTALL(FILES "${ALURE_BINARY_DIR}/alure-static.pc"
 536             DESTINATION "lib${LIB_SUFFIX}/pkgconfig"
 537     )
 538 ENDIF(BUILD_STATIC)
 539
 540
 541 MESSAGE(STATUS "\n********************** Configured options **********************")
 542 IF(BUILD_SHARED AND BUILD_STATIC)
 543     MESSAGE(STATUS "Building shared, static library")
 544 ELSEIF(BUILD_SHARED)
 545     MESSAGE(STATUS "Building shared library")
 546 ELSE(BUILD_SHARED AND BUILD_STATIC)
 547     MESSAGE(STATUS "Building static library")
 548 ENDIF(BUILD_SHARED AND BUILD_STATIC)
 549 MESSAGE(STATUS "")
 550 IF(HAS_SNDFILE)
 551     MESSAGE(STATUS "SndFile support: enabled")
 552 ELSE(HAS_SNDFILE)
 553     MESSAGE(STATUS "SndFile support: disabled")
 554 ENDIF(HAS_SNDFILE)
 555 IF(HAS_VORBISFILE)
 556     MESSAGE(STATUS "VorbisFile support: enabled")
 557 ELSE(HAS_VORBISFILE)
 558     MESSAGE(STATUS "VorbisFile support: disabled")
 559 ENDIF(HAS_VORBISFILE)
 560 IF(HAS_FLAC)
 561     MESSAGE(STATUS "FLAC support: enabled")
 562 ELSE(HAS_FLAC)
 563     MESSAGE(STATUS "FLAC support: disabled")
 564 ENDIF(HAS_FLAC)
 565 IF(HAS_MPG123)
 566     MESSAGE(STATUS "MPG123 support: enabled")
 567 ELSE(HAS_MPG123)
 568     MESSAGE(STATUS "MPG123 support: disabled")
 569 ENDIF(HAS_MPG123)
 570 IF(HAS_DUMB)
 571     MESSAGE(STATUS "DUMB support: enabled")
 572 ELSE(HAS_DUMB)
 573     MESSAGE(STATUS "DUMB support: disabled")
 574 ENDIF(HAS_DUMB)
 575 IF(HAS_MODPLUG)
 576     MESSAGE(STATUS "ModPlug support: enabled")
 577 ELSE(HAS_MODPLUG)
 578     MESSAGE(STATUS "ModPlug support: disabled")
 579 ENDIF(HAS_MODPLUG)
 580 IF(HAS_FLUIDSYNTH)
 581     MESSAGE(STATUS "FluidSynth support: enabled")
 582 ELSE(HAS_FLUIDSYNTH)
 583     MESSAGE(STATUS "FluidSynth support: disabled")
 584 ENDIF(HAS_FLUIDSYNTH)
 585 MESSAGE(STATUS "")