Conditional build of OSS sequencer support

As OSS sequencer support is slightly large and mostly optional, allow
to build without it for smaller systems via a configure option.
It's still enabled as default.

Signed-off-by: Takashi Iwai <tiwai@suse.de>

diff --git a/alsa/Makefile.am b/alsa/Makefile.am
index f88e35e9612bb3a6fd610c7c823cd3fabcbeaa86..90705994b82f14befee076b1d55e62599f3dbe78 100644 (file)
--- a/alsa/Makefile.am
+++ b/alsa/Makefile.am
@@ -13,6 +13,9 @@ libaoss_la_LIBADD = libalsatoss.la
 libaoss_la_LDFLAGS = -version-info $(COMPATNUM)
 
 libalsatoss_la_CFLAGS = @ALSA_CFLAGS@
-libalsatoss_la_SOURCES = pcm.c mixer.c sequencer.c
+libalsatoss_la_SOURCES = pcm.c mixer.c
+if ENABLE_SEQUENCER
+libalsatoss_la_SOURCES += sequencer.c
+endif
 libalsatoss_la_LIBADD = @ALSA_LIBS@
 libalsatoss_la_LDFLAGS = -version-info $(COMPATNUM)

diff --git a/alsa/alsa-oss.c b/alsa/alsa-oss.c
index c4a3760544e4994a0c716a95a2beebaccf5bb34a..339031aef9aabfe7e61a8478266b0eda03f75653 100644 (file)
--- a/alsa/alsa-oss.c
+++ b/alsa/alsa-oss.c
@@ -121,7 +121,11 @@ static inline int is_oss_device(int fd)
 }
 
 #define is_oss_pcm_class(fd)   (fds[fd]->class == FD_OSS_DSP)
+#ifdef ENABLE_SEQUENCER
 #define is_oss_seq_class(fd)   (fds[fd]->class == FD_OSS_SEQ)
+#else
+#define is_oss_seq_class(fd)   0
+#endif /* ENABLE_SEQUENCER */
 #define is_oss_pcm_or_seq_class(fd)    (is_oss_pcm_class(fd) || is_oss_seq_class(fd))
 
 static int is_dsp_device(const char *pathname)
@@ -144,6 +148,7 @@ static int is_mixer_device(const char *pathname)
        return 0;
 }
 
+#ifdef ENABLE_SEQUENCER
 static int is_seq_device(const char *pathname)
 {
        if(!pathname) return 0;
@@ -151,6 +156,9 @@ static int is_seq_device(const char *pathname)
        if(strncmp(pathname,"/dev/music",10) == 0) return 1;
        return 0;
 }
+#else /* ENABLE_SEQUENCER */
+#define is_seq_device(pathname)                0
+#endif /* ENABLE_SEQUENCER */
 
 static int oss_pcm_fcntl(int fd, int cmd, ...)
 {
@@ -276,6 +284,7 @@ static ops_t ops[FD_CLASSES] = {
                .mmap = bad_mmap,
                .munmap = bad_munmap,
        },
+#ifdef ENABLE_SEQUENCER
         [FD_OSS_SEQ] = {
                .close = lib_oss_seq_close,
                .write = lib_oss_seq_write,
@@ -285,6 +294,7 @@ static ops_t ops[FD_CLASSES] = {
                .mmap = bad_mmap,
                .munmap = bad_munmap,
        },
+#endif /* ENABLE_SEQUENCER */
 };
 
 static int dsp_open_helper(const char *file, int oflag)
@@ -327,6 +337,7 @@ static int mixer_open_helper(const char *file, int oflag)
        return fd;
 }
 
+#ifdef ENABLE_SEQUENCER
 static int seq_open_helper(const char *file, int oflag)
 {
        int fd;
@@ -350,6 +361,21 @@ static int seq_open_helper(const char *file, int oflag)
        return fd;
 } 
 
+#define call_seq_poll_prepare  lib_oss_seq_poll_prepare
+#define call_seq_poll_result   lib_oss_seq_poll_result
+#define call_seq_poll_fds      lib_oss_seq_poll_fds
+#define call_seq_select_prepare        lib_oss_seq_select_prepare
+#define call_seq_select_result lib_oss_seq_select_result
+
+#else /* ENABLE_SEQUENCER */
+#define seq_open_helper(file, oflag)   -1
+#define call_seq_poll_prepare(fd, ...) -1
+#define call_seq_poll_result(fd, ...)  -1
+#define call_seq_poll_fds(fd, ...)     -1
+#define call_seq_select_prepare(fd, ...) -1
+#define call_seq_select_result(fd, ...)        -1
+#endif /* ENABLE_SEQUENCER */
+
 #define DECL_OPEN(name, callback) \
 int name(const char *file, int oflag, ...) \
 { \
@@ -588,7 +614,7 @@ static int poll_with_pcm_or_seq(struct pollfd *pfds, unsigned long nfds, int tim
                        if (is_oss_pcm_class(fd))
                                count = lib_oss_pcm_poll_prepare(fd, fmode, &pfds1[nfds1]);
                        else
-                               count = lib_oss_seq_poll_prepare(fd, fmode, &pfds1[nfds1]);
+                               count = call_seq_poll_prepare(fd, fmode, &pfds1[nfds1]);
                        if (count < 0)
                                return -1;
                        nfds1 += count;
@@ -624,7 +650,7 @@ static int poll_with_pcm_or_seq(struct pollfd *pfds, unsigned long nfds, int tim
                        if (is_oss_pcm_class(fd))
                                result = lib_oss_pcm_poll_result(fd, &pfds1[nfds1]);
                        else
-                               result = lib_oss_seq_poll_result(fd, &pfds1[nfds1]);
+                               result = call_seq_poll_result(fd, &pfds1[nfds1]);
                        revents = 0;
                        if (result < 0) {
                                revents |= POLLNVAL;
@@ -636,7 +662,7 @@ static int poll_with_pcm_or_seq(struct pollfd *pfds, unsigned long nfds, int tim
                        if (is_oss_pcm_class(fd))
                                nfds1 += lib_oss_pcm_poll_fds(fd);
                        else
-                               nfds1 += lib_oss_seq_poll_fds(fd);
+                               nfds1 += call_seq_poll_fds(fd);
                } else {
                        revents = pfds1[nfds1].revents;
                        nfds1++;
@@ -724,8 +750,8 @@ static int select_with_pcm_or_seq(int nfds, fd_set *rfds, fd_set *wfds,
                                res = lib_oss_pcm_select_prepare(fd, fmode, rfds1, wfds1,
                                                                 e ? efds1 : NULL);
                        else
-                               res = lib_oss_seq_select_prepare(fd, fmode, rfds1, wfds1,
-                                                                e ? efds1 : NULL);
+                               res = call_seq_select_prepare(fd, fmode, rfds1, wfds1,
+                                                             e ? efds1 : NULL);
                        if (res < 0)
                                return -1;
                        if (nfds1 < res + 1)
@@ -772,7 +798,7 @@ static int select_with_pcm_or_seq(int nfds, fd_set *rfds, fd_set *wfds,
                        if (is_oss_pcm_class(fd))
                                result = lib_oss_pcm_select_result(fd, rfds1, wfds1, efds1);
                        else
-                               result = lib_oss_seq_select_result(fd, rfds1, wfds1, efds1);
+                               result = call_seq_select_result(fd, rfds1, wfds1, efds1);
                        r1 = w1 = e1 = 0;
                        if (result < 0 && e) {
                                if (efds)

diff --git a/configure.ac b/configure.ac
index 583b95fc8f75bf4e408a09c2543d40b9b435642e..a26791c55bdb643385805d3ded1d09cb8c81e4e9 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -27,6 +27,19 @@ else
 fi
 AM_CONDITIONAL(WITH_AOSS, test x$with_aoss = xyes)
 
+dnl Check for aoss...
+AC_MSG_CHECKING(for sequencer)
+AC_ARG_WITH(sequencer,
+  [  --with-sequencer=yes,no     Enable OSS sequencer support],
+  with_sequencer="$withval", with_sequencer="yes")
+if test "$with_sequencer" = "yes"; then
+  AC_MSG_RESULT(yes)
+  AC_DEFINE(ENABLE_SEQUENCER,,[Support OSS sequencer])
+else
+  AC_MSG_RESULT(no)
+fi
+AM_CONDITIONAL(ENABLE_SEQUENCER, test x$with_sequencer = xyes)
+
 if test "$with_aoss" = "yes"; then
   OLD_CFLAGS="$CFLAGS"
   OLD_LIBS="$LIBS"

diff --git a/oss-redir/oss-redir.c b/oss-redir/oss-redir.c
index 1ec7532c94392e110dbf01207966aa737272da5f..eac9e299254af324f066abc4aa8e214f9a935a66 100644 (file)
--- a/oss-redir/oss-redir.c
+++ b/oss-redir/oss-redir.c
@@ -60,6 +60,7 @@ static int (*x_oss_mixer_open)(const char *pathname, int flags);
 static int (*x_oss_mixer_close)(int fd);
 int (*oss_mixer_ioctl)(int fd, unsigned long int request, ...);
 
+#ifdef ENABLE_SEQUENCER
 static int (*x_oss_seq_open)(const char *pathname, int flags);
 static int (*x_oss_seq_close)(int fd);
 int (*oss_seq_nonblock)(int fd, int nonblock);
@@ -71,6 +72,7 @@ int (*oss_seq_select_result)(int fd, fd_set *readfds, fd_set *writefds, fd_set *
 int (*oss_seq_poll_fds)(int fd);
 int (*oss_seq_poll_prepare)(int fd, int fmode, struct pollfd *ufds);
 int (*oss_seq_poll_result)(int fd, struct pollfd *ufds);
+#endif /* ENABLE_SEQUENCER */
 
 static int native_pcm_nonblock(int fd, int nonblock)
 {
@@ -211,6 +213,7 @@ int oss_mixer_close(int fd)
        return call_close(fd, x_oss_mixer_close);
 }
 
+#ifdef ENABLE_SEQUENCER
 int oss_seq_open(const char *pathname, int flags, ...)
 {
        return call_open(pathname, flags, x_oss_seq_open);
@@ -220,6 +223,7 @@ int oss_seq_close(int fd)
 {
        return call_close(fd, x_oss_seq_close);
 }
+#endif /* ENABLE_SEQUENCER */
 
 static void initialize(void)
 {
@@ -248,6 +252,7 @@ static void initialize(void)
                oss_pcm_poll_prepare = native_pcm_poll_prepare;
                oss_pcm_poll_result = native_pcm_poll_result;
                oss_mixer_ioctl = ioctl;
+#ifdef ENABLE_SEQUENCER
                /* reuse PCM helpers for sequencer */
                oss_seq_nonblock = native_pcm_nonblock;
                oss_seq_read = read;
@@ -258,6 +263,7 @@ static void initialize(void)
                oss_seq_poll_fds = native_pcm_poll_fds;
                oss_seq_poll_prepare = native_pcm_poll_prepare;
                oss_seq_poll_result = native_pcm_poll_result;
+#endif /* ENABLE_SEQUENCER */
        } else {
                dl_handle = dlopen(hal, RTLD_NOW);
                if (dl_handle == NULL) {
@@ -282,6 +288,7 @@ static void initialize(void)
                x_oss_mixer_open = dlsym(dl_handle, "lib_oss_mixer_open");
                x_oss_mixer_close = dlsym(dl_handle, "lib_oss_mixer_close");
                oss_mixer_ioctl = dlsym(dl_handle, "lib_oss_mixer_ioctl");
+#ifdef ENABLE_SEQUENCER
                x_oss_seq_open = dlsym(dl_handle, "lib_oss_seq_open");
                x_oss_seq_close = dlsym(dl_handle, "lib_oss_seq_close");
                oss_seq_nonblock = dlsym(dl_handle, "lib_oss_seq_nonblock");
@@ -293,5 +300,6 @@ static void initialize(void)
                oss_seq_poll_fds = dlsym(dl_handle, "lib_oss_seq_poll_fds");
                oss_seq_poll_prepare = dlsym(dl_handle, "lib_oss_seq_poll_prepare");
                oss_seq_poll_result = dlsym(dl_handle, "lib_oss_seq_poll_result");
+#endif /* ENABLE_SEQUENCER */
        }
 }