Handle ALSA file descriptors more correctly. This means a bit more overhead,

but following their API properly should avoid problems in the future.


git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@606 fefdeb5f-60dc-0310-8127-8f9354f1896f

1 files changed, 182 insertions, 43 deletions

diff --git a/src/modules/alsa-util.c b/src/modules/alsa-util.c
index 4e1db545..5f4323f8 100644
--- a/src/modules/alsa-util.c
+++ b/src/modules/alsa-util.c
@@ -32,6 +32,188 @@
 
 #include "alsa-util.h"
 
+struct pa_alsa_fdlist {
+    int num_fds;
+    struct pollfd *fds;
+    /* This is a temporary buffer used to avoid lots of mallocs */
+    struct pollfd *work_fds;
+
+    snd_pcm_t *pcm;
+
+    pa_mainloop_api *m;
+    pa_defer_event *defer;
+    pa_io_event **ios;
+
+    int polled;
+
+    void (*cb)(void *userdata);
+    void *userdata;
+};
+
+static void io_cb(pa_mainloop_api*a, pa_io_event* e, int fd, pa_io_event_flags_t events, void *userdata) {
+    struct pa_alsa_fdlist *fdl = (struct pa_alsa_fdlist*)userdata;
+    int err, i;
+    unsigned short revents;
+
+    assert(a && fdl && fdl->pcm);
+
+    if (fdl->polled)
+        return;
+
+    fdl->polled = 1;
+
+    memcpy(fdl->work_fds, fdl->fds, sizeof(struct pollfd) * fdl->num_fds);
+
+    for (i = 0;i < fdl->num_fds;i++) {
+        if (e == fdl->ios[i]) {
+            if (events & PA_IO_EVENT_INPUT)
+                fdl->work_fds[i].revents |= POLLIN;
+            if (events & PA_IO_EVENT_OUTPUT)
+                fdl->work_fds[i].revents |= POLLOUT;
+            if (events & PA_IO_EVENT_ERROR)
+                fdl->work_fds[i].revents |= POLLERR;
+            if (events & PA_IO_EVENT_HANGUP)
+                fdl->work_fds[i].revents |= POLLHUP;
+            break;
+        }
+    }
+
+    assert(i != fdl->num_fds);
+
+    err = snd_pcm_poll_descriptors_revents(fdl->pcm, fdl->work_fds, fdl->num_fds, &revents);
+    if (err < 0) {
+        pa_log_error(__FILE__": Unable to get poll revent: %s",
+            snd_strerror(err));
+        a->defer_enable(fdl->defer, 0);
+        return;
+    }
+
+    if (revents)
+        fdl->cb(fdl->userdata);
+}
+
+static void defer_cb(pa_mainloop_api*a, pa_defer_event* e, void *userdata) {
+    struct pa_alsa_fdlist *fdl = (struct pa_alsa_fdlist*)userdata;
+    int num_fds, i, err;
+    struct pollfd *temp;
+
+    assert(a && fdl && fdl->pcm);
+
+    num_fds = snd_pcm_poll_descriptors_count(fdl->pcm);
+    assert(num_fds > 0);
+
+    if (num_fds != fdl->num_fds) {
+        if (fdl->fds)
+            pa_xfree(fdl->fds);
+        if (fdl->work_fds)
+            pa_xfree(fdl->work_fds);
+        fdl->fds = pa_xmalloc(sizeof(struct pollfd) * num_fds);
+        fdl->work_fds = pa_xmalloc(sizeof(struct pollfd) * num_fds);
+    }
+
+    memset(fdl->work_fds, 0, sizeof(struct pollfd) * num_fds);
+    err = snd_pcm_poll_descriptors(fdl->pcm, fdl->work_fds, num_fds);
+    if (err < 0) {
+        pa_log_error(__FILE__": Unable to get poll descriptors: %s",
+            snd_strerror(err));
+        a->defer_enable(fdl->defer, 0);
+        return;
+    }
+
+    fdl->polled = 0;
+
+    if (memcmp(fdl->fds, fdl->work_fds, sizeof(struct pollfd) * num_fds) == 0)
+        return;
+
+    if (fdl->ios) {
+        for (i = 0;i < fdl->num_fds;i++)
+            a->io_free(fdl->ios[i]);
+        if (num_fds != fdl->num_fds) {
+            pa_xfree(fdl->ios);
+            fdl->ios = pa_xmalloc(sizeof(pa_io_event*) * num_fds);
+            assert(fdl->ios);
+        }
+    } else {
+        fdl->ios = pa_xmalloc(sizeof(pa_io_event*) * num_fds);
+        assert(fdl->ios);
+    }
+
+    /* Swap pointers */
+    temp = fdl->work_fds;
+    fdl->work_fds = fdl->fds;
+    fdl->fds = temp;
+
+    fdl->num_fds = num_fds;
+
+    for (i = 0;i < num_fds;i++) {
+        fdl->ios[i] = a->io_new(a, fdl->fds[i].fd,
+            ((fdl->fds[i].events & POLLIN) ? PA_IO_EVENT_INPUT : 0) |
+            ((fdl->fds[i].events & POLLOUT) ? PA_IO_EVENT_OUTPUT : 0),
+            io_cb, fdl);
+        assert(fdl->ios[i]);
+    }
+}
+
+struct pa_alsa_fdlist *pa_alsa_fdlist_new(void) {
+    struct pa_alsa_fdlist *fdl;
+
+    fdl = pa_xmalloc(sizeof(struct pa_alsa_fdlist));
+    assert(fdl);
+
+    fdl->num_fds = 0;
+    fdl->fds = NULL;
+    fdl->work_fds = NULL;
+
+    fdl->pcm = NULL;
+
+    fdl->m = NULL;
+    fdl->defer = NULL;
+    fdl->ios = NULL;
+
+    fdl->polled = 0;
+
+    return fdl;
+}
+
+void pa_alsa_fdlist_free(struct pa_alsa_fdlist *fdl) {
+    assert(fdl);
+
+    if (fdl->defer) {
+        assert(fdl->m);
+        fdl->m->defer_free(fdl->defer);
+    }
+
+    if (fdl->ios) {
+        int i;
+        assert(fdl->m);
+        for (i = 0;i < fdl->num_fds;i++)
+            fdl->m->io_free(fdl->ios[0]);
+        pa_xfree(fdl->ios);
+    }
+
+    if (fdl->fds)
+        pa_xfree(fdl->fds);
+    if (fdl->work_fds)
+        pa_xfree(fdl->work_fds);
+
+    pa_xfree(fdl);
+}
+
+int pa_alsa_fdlist_init_pcm(struct pa_alsa_fdlist *fdl, snd_pcm_t *pcm_handle, pa_mainloop_api* m, void (*cb)(void *userdata), void *userdata) {
+    assert(fdl && pcm_handle && m && !fdl->m && cb);
+
+    fdl->pcm = pcm_handle;
+    fdl->m = m;
+
+    fdl->defer = m->defer_new(m, defer_cb, fdl);
+    assert(fdl->defer);
+
+    fdl->cb = cb;
+    fdl->userdata = userdata;
+
+    return 0;
+}
+
 /* Set the hardware parameters of the given ALSA device. Returns the
  * selected fragment settings in *period and *period_size */
 int pa_alsa_set_hw_params(snd_pcm_t *pcm_handle, const pa_sample_spec *ss, uint32_t *periods, snd_pcm_uframes_t *period_size) {
@@ -86,49 +268,6 @@ finish:
     return ret;
 }
 
-/* Allocate an IO event for every ALSA poll descriptor for the
- * specified ALSA device. Return a pointer to such an array in
- * *io_events. Store the length of that array in *n_io_events. Use the
- * specified callback function and userdata. The array has to be freed
- * with pa_free_io_events(). */
-int pa_create_io_events(snd_pcm_t *pcm_handle, pa_mainloop_api* m, pa_io_event ***io_events, unsigned *n_io_events, void (*cb)(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags_t events, void *userdata), void *userdata) {
-    unsigned i;
-    struct pollfd *pfds, *ppfd;
-    pa_io_event **ios;
-    assert(pcm_handle && m && io_events && n_io_events && cb);
-
-    *n_io_events = snd_pcm_poll_descriptors_count(pcm_handle);
-
-    pfds = pa_xmalloc(sizeof(struct pollfd) * *n_io_events);
-    if (snd_pcm_poll_descriptors(pcm_handle, pfds, *n_io_events) < 0) {
-        pa_xfree(pfds);
-        return -1;
-    }
-    
-    *io_events = pa_xmalloc(sizeof(void*) * *n_io_events);
-
-    for (i = 0, ios = *io_events, ppfd = pfds; i < *n_io_events; i++, ios++, ppfd++) {
-        *ios = m->io_new(m, ppfd->fd,
-                            ((ppfd->events & POLLIN) ? PA_IO_EVENT_INPUT : 0) |
-                            ((ppfd->events & POLLOUT) ? PA_IO_EVENT_OUTPUT : 0), cb, userdata);
-        assert(*ios);
-    }
-
-    pa_xfree(pfds);
-    return 0;
-}
-
-/* Free the memory allocated by pa_create_io_events() */
-void pa_free_io_events(pa_mainloop_api* m, pa_io_event **io_events, unsigned n_io_events) {
-    unsigned i;
-    pa_io_event **ios;
-    assert(m && io_events);
-    
-    for (ios = io_events, i = 0; i < n_io_events; i++, ios++)
-        m->io_free(*ios);
-    pa_xfree(io_events);
-}
-
 int pa_alsa_prepare_mixer(snd_mixer_t *mixer, const char *dev) {
     int err;