Remove duplicated CMake code for backend setup

Author: adrianbroher

CMakeLists.txt

@@ -62,6 +62,45 @@ if(DEFINED LIB_SUFFIX)
 endif()
 
 
+# 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)
     ADD_DEFINITIONS("-D_WIN32 -D_WIN32_WINNT=0x0502")
 
@@ -867,209 +906,60 @@ 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})
-        IF(CMAKE_VERSION VERSION_LESS "2.8.8")
-            INCLUDE_DIRECTORIES(${ALSA_INCLUDE_DIRS})
-        ENDIF()
-    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(ALSOFT_BACKEND_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(CMAKE_VERSION VERSION_LESS "2.8.8")
-            INCLUDE_DIRECTORIES(${OSS_INCLUDE_DIRS})
-        ENDIF()
-    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)
-        IF(CMAKE_VERSION VERSION_LESS "2.8.8")
-            INCLUDE_DIRECTORIES(${AUDIOIO_INCLUDE_DIRS})
-        ENDIF()
-    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})
-        IF(CMAKE_VERSION VERSION_LESS "2.8.8")
-            INCLUDE_DIRECTORIES(${SOUNDIO_INCLUDE_DIRS})
-        ENDIF()
-    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(ALSOFT_BACKEND_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})
-        IF(CMAKE_VERSION VERSION_LESS "2.8.8")
-            INCLUDE_DIRECTORIES(${QSA_INCLUDE_DIRS})
-        ENDIF()
-    ENDIF()
+ADD_BACKEND(QSA QSA Alc/backends/qsa.c)
+IF(ALSOFT_BACKEND_QSA)
+    SET(EXTRA_LIBS ${QSA_LIBRARIES} ${EXTRA_LIBS})
 ENDIF()
-IF(ALSOFT_REQUIRE_QSA AND NOT HAVE_QSA)
-    MESSAGE(FATAL_ERROR "Failed to enabled required QSA backend")
-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_MMDEVAPI "Require MMDevApi backend" OFF)
-IF(HAVE_WINDOWS_H)
-    # Check MMSystem backend
-    CHECK_INCLUDE_FILES("windows.h;mmsystem.h" HAVE_MMSYSTEM_H -D_WIN32_WINNT=0x0502)
-    IF(HAVE_MMSYSTEM_H)
-        CHECK_SHARED_FUNCTION_EXISTS(waveOutOpen "windows.h;mmsystem.h" winmm "" HAVE_LIBWINMM)
-        IF(HAVE_LIBWINMM)
-            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 ${EXTRA_LIBS})
-            ENDIF()
-        ENDIF()
-    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})
-            IF(CMAKE_VERSION VERSION_LESS "2.8.8")
-                INCLUDE_DIRECTORIES(${DSOUND_INCLUDE_DIRS})
-            ENDIF()
-        ENDIF()
-    ENDIF()
 
-    # Check for MMDevApi backend
-    CHECK_INCLUDE_FILE(mmdeviceapi.h HAVE_MMDEVICEAPI_H)
-    IF(HAVE_MMDEVICEAPI_H)
-        OPTION(ALSOFT_BACKEND_MMDEVAPI "Enable MMDevApi backend" ON)
-        IF(ALSOFT_BACKEND_MMDEVAPI)
-            SET(HAVE_MMDEVAPI 1)
-            SET(BACKENDS  "${BACKENDS} MMDevApi,")
-            SET(ALC_OBJS  ${ALC_OBJS} Alc/backends/mmdevapi.c)
-        ENDIF()
-    ENDIF()
-ENDIF()
-IF(ALSOFT_REQUIRE_WINMM AND NOT HAVE_WINMM)
-    MESSAGE(FATAL_ERROR "Failed to enabled required WinMM backend")
+# Check WinMM (Windows) backend
+ADD_BACKEND(WINMM WinMM Alc/backends/winmm.c)
+IF(ALSOFT_BACKEND_WINMM)
+    SET(EXTRA_LIBS ${WINMM_LIBRARIES} ${EXTRA_LIBS})
 ENDIF()
-IF(ALSOFT_REQUIRE_DSOUND AND NOT HAVE_DSOUND)
-    MESSAGE(FATAL_ERROR "Failed to enabled required DSound backend")
-ENDIF()
-IF(ALSOFT_REQUIRE_MMDEVAPI AND NOT HAVE_MMDEVAPI)
-    MESSAGE(FATAL_ERROR "Failed to enabled required MMDevApi backend")
+
+# Check DSound (Windows) backend
+ADD_BACKEND(DSOUND DSound Alc/backends/dsound.c)
+IF(ALSOFT_BACKEND_DSOUND)
+    ADD_BACKEND_LIBS(${DSOUND_LIBRARIES})
 ENDIF()
 
+# Check for MMDevApi (Windows) backend
+ADD_BACKEND(MMDEVAPI MMDevAPI Alc/backends/mmdevapi.c)
+
 # 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})
-        IF(CMAKE_VERSION VERSION_LESS "2.8.8")
-            INCLUDE_DIRECTORIES(${PORTAUDIO_INCLUDE_DIRS})
-        ENDIF()
-    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(ALSOFT_BACKEND_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})
-        IF(CMAKE_VERSION VERSION_LESS "2.8.8")
-            INCLUDE_DIRECTORIES(${PULSEAUDIO_INCLUDE_DIRS})
-        ENDIF()
-    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(ALSOFT_BACKEND_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})
-        IF(CMAKE_VERSION VERSION_LESS "2.8.8")
-            INCLUDE_DIRECTORIES(${JACK_INCLUDE_DIRS})
-        ENDIF()
-    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(ALSOFT_BACKEND_JACK)
+    ADD_BACKEND_LIBS(${JACK_LIBRARIES})
 ENDIF()
 
 # Check CoreAudio backend
@@ -1106,22 +996,9 @@ IF(ALSOFT_REQUIRE_COREAUDIO AND NOT HAVE_COREAUDIO)
 ENDIF()
 
 # Check for OpenSL (Android) backend
-OPTION(ALSOFT_REQUIRE_OPENSL "Require OpenSL backend" OFF)
-CHECK_INCLUDE_FILES("SLES/OpenSLES.h;SLES/OpenSLES_Android.h" HAVE_SLES_OPENSLES_ANDROID_H)
-IF(HAVE_SLES_OPENSLES_ANDROID_H)
-    CHECK_SHARED_FUNCTION_EXISTS(slCreateEngine "SLES/OpenSLES.h" OpenSLES "" HAVE_LIBOPENSLES)
-    IF(HAVE_LIBOPENSLES)
-        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()
-ENDIF()
-IF(ALSOFT_REQUIRE_OPENSL AND NOT HAVE_OPENSL)
-    MESSAGE(FATAL_ERROR "Failed to enabled required OpenSL backend")
+ADD_BACKEND(OPENSL OpenSLES Alc/backends/opensl.c)
+IF(ALSOFT_BACKEND_OPENSL)
+    SET(EXTRA_LIBS OpenSLES ${EXTRA_LIBS})
 ENDIF()
 
 # Optionally enable the Wave Writer backend