Remove duplicated CMake code for backend setup

Author: adrianbroher

CMakeLists.txt

@@ -62,11 +62,44 @@ if(DEFINED LIB_SUFFIX)
 endif()
 
 
-SET(CPP_DEFS ) # C pre-process, not C++
-SET(INC_PATHS )
-SET(C_FLAGS )
-SET(LINKER_FLAGS )
-SET(EXTRA_LIBS )
+# Adds configuration options for a backend with the given _NAME.
+#
+# Requires the following parameters:
+#
+# _NAME -   The name of the backend module.  This is used to create and select
+#           output variable and to print option documentation and status
+#           messages.
+# _MODULE - The name of the CMake search module used.
+# _SRC  -   Source file to implement the backend.
+#
+# Defines or modifies the following options and variables:
+#
+# ALSOFT_REQUIRE_${_NAME} - A user configuration to require the backend.
+# ${_NAME}_FOUND          - True if the backend was found.
+# ALSOFT_BACKEND_${_NAME} - A user configuration to enable a found backend.
+# HAVE_${_NAME}           - 1 if the backend was found.
+# ALC_OBJS                - Backend source files are appended to this.
+# BACKENDS                - Status messages are appended to this.
+MACRO(ADD_BACKEND _NAME _MODULE _SRC)
+    OPTION(ALSOFT_REQUIRE_${_NAME} "Require ${_NAME} backend" OFF)
+    FIND_PACKAGE(${_MODULE})
+    STRING(TOUPPER "${_MODULE}" _MODULE_U)
+    IF(${_MODULE_U}_FOUND)
+        OPTION(ALSOFT_BACKEND_${_NAME} "Enable ${_NAME} backend" ON)
+        IF(ALSOFT_BACKEND_${_NAME})
+            SET(HAVE_${_NAME} 1)
+            SET(BACKENDS  "${BACKENDS} ${_NAME}${IS_LINKED},")
+            SET(ALC_OBJS  ${ALC_OBJS} ${_SRC})
+            IF(CMAKE_VERSION VERSION_LESS "2.8.8")
+                INCLUDE_DIRECTORIES(${${_MODULE_U}_INCLUDE_DIRS})
+            ENDIF()
+        ENDIF()
+    ENDIF()
+    IF(ALSOFT_REQUIRE_${_NAME} AND NOT HAVE_${_NAME})
+        MESSAGE(FATAL_ERROR "Failed to enabled required ${_NAME} backend")
+    ENDIF()
+ENDMACRO()
+
 
 IF(WIN32)
     SET(CPP_DEFS ${CPP_DEFS} _WIN32 _WIN32_WINNT=0x0502)
@@ -939,198 +972,71 @@ SET(ALC_OBJS  ${ALC_OBJS}
 )
 
 # Check ALSA backend
-OPTION(ALSOFT_REQUIRE_ALSA "Require ALSA backend" OFF)
-FIND_PACKAGE(ALSA)
-IF(ALSA_FOUND)
-    OPTION(ALSOFT_BACKEND_ALSA "Enable ALSA backend" ON)
-    IF(ALSOFT_BACKEND_ALSA)
-        SET(HAVE_ALSA 1)
-        SET(BACKENDS  "${BACKENDS} ALSA${IS_LINKED},")
-        SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/alsa.c)
-        ADD_BACKEND_LIBS(${ALSA_LIBRARIES})
-        SET(INC_PATHS ${INC_PATHS} ${ALSA_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_ALSA AND NOT HAVE_ALSA)
-    MESSAGE(FATAL_ERROR "Failed to enabled required ALSA backend")
+ADD_BACKEND(ALSA ALSA Alc/backends/alsa.c)
+IF(HAVE_ALSA)
+    ADD_BACKEND_LIBS(${ALSA_LIBRARIES})
 ENDIF()
 
 # Check OSS backend
-OPTION(ALSOFT_REQUIRE_OSS "Require OSS backend" OFF)
-FIND_PACKAGE(OSS)
-IF(OSS_FOUND)
-    OPTION(ALSOFT_BACKEND_OSS "Enable OSS backend" ON)
-    IF(ALSOFT_BACKEND_OSS)
-        SET(HAVE_OSS 1)
-        SET(BACKENDS  "${BACKENDS} OSS,")
-        SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/oss.c)
-        IF(OSS_LIBRARIES)
-            SET(EXTRA_LIBS ${OSS_LIBRARIES} ${EXTRA_LIBS})
-        ENDIF()
-        SET(INC_PATHS ${INC_PATHS} ${OSS_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_OSS AND NOT HAVE_OSS)
-    MESSAGE(FATAL_ERROR "Failed to enabled required OSS backend")
-ENDIF()
+ADD_BACKEND(OSS OSS Alc/backends/oss.c)
 
 # Check Solaris backend
-OPTION(ALSOFT_REQUIRE_SOLARIS "Require Solaris backend" OFF)
-FIND_PACKAGE(AudioIO)
-IF(AUDIOIO_FOUND)
-    OPTION(ALSOFT_BACKEND_SOLARIS "Enable Solaris backend" ON)
-    IF(ALSOFT_BACKEND_SOLARIS)
-        SET(HAVE_SOLARIS 1)
-        SET(BACKENDS  "${BACKENDS} Solaris,")
-        SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/solaris.c)
-        SET(INC_PATHS ${INC_PATHS} ${AUDIOIO_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_SOLARIS AND NOT HAVE_SOLARIS)
-    MESSAGE(FATAL_ERROR "Failed to enabled required Solaris backend")
-ENDIF()
+ADD_BACKEND(SOLARIS AudioIO Alc/backends/solaris.c)
 
 # Check SndIO backend
-OPTION(ALSOFT_REQUIRE_SNDIO "Require SndIO backend" OFF)
-FIND_PACKAGE(SoundIO)
-IF(SOUNDIO_FOUND)
-    OPTION(ALSOFT_BACKEND_SNDIO "Enable SndIO backend" ON)
-    IF(ALSOFT_BACKEND_SNDIO)
-        SET(HAVE_SNDIO 1)
-        SET(BACKENDS  "${BACKENDS} SndIO (linked),")
-        SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/sndio.c)
-        SET(EXTRA_LIBS ${SOUNDIO_LIBRARIES} ${EXTRA_LIBS})
-        SET(INC_PATHS ${INC_PATHS} ${SOUNDIO_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_SNDIO AND NOT HAVE_SNDIO)
-    MESSAGE(FATAL_ERROR "Failed to enabled required SndIO backend")
+ADD_BACKEND(SNDIO SoundIO Alc/backends/sndio.c)
+IF(HAVE_SNDIO)
+    SET(EXTRA_LIBS ${SOUNDIO_LIBRARIES} ${EXTRA_LIBS})
 ENDIF()
 
 # Check QSA backend
-OPTION(ALSOFT_REQUIRE_QSA "Require QSA backend" OFF)
-FIND_PACKAGE(QSA)
-IF(QSA_FOUND)
-    OPTION(ALSOFT_BACKEND_QSA "Enable QSA backend" ON)
-    IF(ALSOFT_BACKEND_QSA)
-        SET(HAVE_QSA 1)
-        SET(BACKENDS  "${BACKENDS} QSA (linked),")
-        SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/qsa.c)
-        SET(EXTRA_LIBS ${QSA_LIBRARIES} ${EXTRA_LIBS})
-        SET(INC_PATHS ${INC_PATHS} ${QSA_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_QSA AND NOT HAVE_QSA)
-    MESSAGE(FATAL_ERROR "Failed to enabled required QSA backend")
+ADD_BACKEND(QSA QSA Alc/backends/qsa.c)
+IF(HAVE_QSA)
+    SET(EXTRA_LIBS ${QSA_LIBRARIES} ${EXTRA_LIBS})
 ENDIF()
 
-# Check Windows-only backends
-OPTION(ALSOFT_REQUIRE_WINMM "Require Windows Multimedia backend" OFF)
-OPTION(ALSOFT_REQUIRE_DSOUND "Require DirectSound backend" OFF)
-OPTION(ALSOFT_REQUIRE_WASAPI "Require WASAPI backend" OFF)
 IF(HAVE_WINDOWS_H)
     SET(OLD_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS})
     SET(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} -D_WIN32_WINNT=0x0502)
 
-    # Check MMSystem backend
-    FIND_PACKAGE(WinMM)
-    IF(WINMM_FOUND)
-        OPTION(ALSOFT_BACKEND_WINMM "Enable Windows Multimedia backend" ON)
-        IF(ALSOFT_BACKEND_WINMM)
-            SET(HAVE_WINMM 1)
-            SET(BACKENDS  "${BACKENDS} WinMM,")
-            SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/winmm.c)
-            SET(EXTRA_LIBS ${WINMM_LIBRARIES} ${EXTRA_LIBS})
-            SET(INC_PATHS ${INC_PATHS} ${WINMM_INCLUDE_DIRS})
-        ENDIF()
+    # Check WinMM (Windows) backend
+    ADD_BACKEND(WINMM WinMM Alc/backends/winmm.c)
+    IF(HAVE_WINMM)
+        SET(EXTRA_LIBS ${WINMM_LIBRARIES} ${EXTRA_LIBS})
     ENDIF()
 
-    # Check DSound backend
-    FIND_PACKAGE(DSound)
-    IF(DSOUND_FOUND)
-        OPTION(ALSOFT_BACKEND_DSOUND "Enable DirectSound backend" ON)
-        IF(ALSOFT_BACKEND_DSOUND)
-            SET(HAVE_DSOUND 1)
-            SET(BACKENDS  "${BACKENDS} DirectSound${IS_LINKED},")
-            SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/dsound.c)
-            ADD_BACKEND_LIBS(${DSOUND_LIBRARIES})
-            SET(INC_PATHS ${INC_PATHS} ${DSOUND_INCLUDE_DIRS})
-        ENDIF()
+    # Check DSound (Windows) backend
+    ADD_BACKEND(DSOUND DSound Alc/backends/dsound.c)
+    IF(HAVE_DSOUND)
+        ADD_BACKEND_LIBS(${DSOUND_LIBRARIES})
     ENDIF()
 
-    # Check for WASAPI backend
+    # Check for WASAPI (Windows) backend
     FIND_PACKAGE(WASAPI)
     IF(WASAPI_FOUND)
-        OPTION(ALSOFT_BACKEND_WASAPI "Enable WASAPI backend" ON)
-        IF(ALSOFT_BACKEND_WASAPI)
-            SET(HAVE_WASAPI 1)
-            SET(BACKENDS  "${BACKENDS} WASAPI,")
-            SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/wasapi.c)
-        ENDIF()
+        ADD_BACKEND(WASAPI WASAPI Alc/backends/wasapi.c)
     ENDIF()
 
     SET(CMAKE_REQUIRED_DEFINITIONS ${OLD_REQUIRED_DEFINITIONS})
     UNSET(OLD_REQUIRED_DEFINITIONS)
 ENDIF()
-IF(ALSOFT_REQUIRE_WINMM AND NOT HAVE_WINMM)
-    MESSAGE(FATAL_ERROR "Failed to enabled required WinMM backend")
-ENDIF()
-IF(ALSOFT_REQUIRE_DSOUND AND NOT HAVE_DSOUND)
-    MESSAGE(FATAL_ERROR "Failed to enabled required DSound backend")
-ENDIF()
-IF(ALSOFT_REQUIRE_WASAPI AND NOT HAVE_WASAPI)
-    MESSAGE(FATAL_ERROR "Failed to enabled required WASAPI backend")
-ENDIF()
 
 # Check PortAudio backend
-OPTION(ALSOFT_REQUIRE_PORTAUDIO "Require PortAudio backend" OFF)
-FIND_PACKAGE(PortAudio)
-IF(PORTAUDIO_FOUND)
-    OPTION(ALSOFT_BACKEND_PORTAUDIO "Enable PortAudio backend" ON)
-    IF(ALSOFT_BACKEND_PORTAUDIO)
-        SET(HAVE_PORTAUDIO 1)
-        SET(BACKENDS  "${BACKENDS} PortAudio${IS_LINKED},")
-        SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/portaudio.c)
-        ADD_BACKEND_LIBS(${PORTAUDIO_LIBRARIES})
-        SET(INC_PATHS ${INC_PATHS} ${PORTAUDIO_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_PORTAUDIO AND NOT HAVE_PORTAUDIO)
-    MESSAGE(FATAL_ERROR "Failed to enabled required PortAudio backend")
+ADD_BACKEND(PORTAUDIO PortAudio Alc/backends/portaudio.c)
+IF(HAVE_PORTAUDIO)
+    ADD_BACKEND_LIBS(${PORTAUDIO_LIBRARIES})
 ENDIF()
 
 # Check PulseAudio backend
-OPTION(ALSOFT_REQUIRE_PULSEAUDIO "Require PulseAudio backend" OFF)
-FIND_PACKAGE(PulseAudio)
-IF(PULSEAUDIO_FOUND)
-    OPTION(ALSOFT_BACKEND_PULSEAUDIO "Enable PulseAudio backend" ON)
-    IF(ALSOFT_BACKEND_PULSEAUDIO)
-        SET(HAVE_PULSEAUDIO 1)
-        SET(BACKENDS  "${BACKENDS} PulseAudio${IS_LINKED},")
-        SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/pulseaudio.c)
-        ADD_BACKEND_LIBS(${PULSEAUDIO_LIBRARIES})
-        SET(INC_PATHS ${INC_PATHS} ${PULSEAUDIO_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_PULSEAUDIO AND NOT HAVE_PULSEAUDIO)
-    MESSAGE(FATAL_ERROR "Failed to enabled required PulseAudio backend")
+ADD_BACKEND(PULSEAUDIO PulseAudio Alc/backends/pulseaudio.c)
+IF(HAVE_PULSEAUDIO)
+    ADD_BACKEND_LIBS(${PULSEAUDIO_LIBRARIES})
 ENDIF()
 
 # Check JACK backend
-OPTION(ALSOFT_REQUIRE_JACK "Require JACK backend" OFF)
-FIND_PACKAGE(JACK)
-IF(JACK_FOUND)
-    OPTION(ALSOFT_BACKEND_JACK "Enable JACK backend" ON)
-    IF(ALSOFT_BACKEND_JACK)
-        SET(HAVE_JACK 1)
-        SET(BACKENDS  "${BACKENDS} JACK${IS_LINKED},")
-        SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/jack.c)
-        ADD_BACKEND_LIBS(${JACK_LIBRARIES})
-        SET(INC_PATHS ${INC_PATHS} ${JACK_INCLUDE_DIRS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_JACK AND NOT HAVE_JACK)
-    MESSAGE(FATAL_ERROR "Failed to enabled required JACK backend")
+ADD_BACKEND(JACK JACK Alc/backends/jack.c)
+IF(HAVE_JACK)
+    ADD_BACKEND_LIBS(${JACK_LIBRARIES})
 ENDIF()
 
 # Check CoreAudio backend
@@ -1167,19 +1073,9 @@ IF(ALSOFT_REQUIRE_COREAUDIO AND NOT HAVE_COREAUDIO)
 ENDIF()
 
 # Check for OpenSL (Android) backend
-OPTION(ALSOFT_REQUIRE_OPENSL "Require OpenSL backend" OFF)
-FIND_PACKAGE(OpenSLES)
+ADD_BACKEND(OPENSL OpenSLES Alc/backends/opensl.c)
 IF(OPENSLES_FOUND)
-    OPTION(ALSOFT_BACKEND_OPENSL "Enable OpenSL backend" ON)
-    IF(ALSOFT_BACKEND_OPENSL)
-        SET(HAVE_OPENSL 1)
-        SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/opensl.c)
-        SET(BACKENDS  "${BACKENDS} OpenSL,")
-        SET(EXTRA_LIBS OpenSLES ${EXTRA_LIBS})
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_OPENSL AND NOT HAVE_OPENSL)
-    MESSAGE(FATAL_ERROR "Failed to enabled required OpenSL backend")
+    SET(EXTRA_LIBS OpenSLES ${EXTRA_LIBS})
 ENDIF()
 
 # Check for SDL2 backend