4 This file is part of PulseAudio.
6 Copyright 2004-2006 Lennart Poettering
7 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
9 PulseAudio is free software; you can redistribute it and/or modify
10 it under the terms of the GNU Lesser General Public License as published
11 by the Free Software Foundation; either version 2 of the License,
12 or (at your option) any later version.
14 PulseAudio is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 General Public License for more details.
19 You should have received a copy of the GNU Lesser General Public License
20 along with PulseAudio; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
38 #ifdef HAVE_SYS_POLL_H
41 #include "../pulsecore/poll.h"
44 #include "../pulsecore/winsock.h"
47 #include "../pulsecore/pipe.h"
50 #include <pulsecore/core-error.h>
51 #include <pulse/timeval.h>
52 #include <pulse/xmalloc.h>
54 #include <pulsecore/core-util.h>
55 #include <pulsecore/llist.h>
56 #include <pulsecore/log.h>
61 pa_mainloop *mainloop;
65 pa_io_event_flags_t events;
66 struct pollfd *pollfd;
68 pa_io_event_cb_t callback;
70 pa_io_event_destroy_cb_t destroy_callback;
72 PA_LLIST_FIELDS(pa_io_event);
75 struct pa_time_event {
76 pa_mainloop *mainloop;
80 struct timeval timeval;
82 pa_time_event_cb_t callback;
84 pa_time_event_destroy_cb_t destroy_callback;
86 PA_LLIST_FIELDS(pa_time_event);
89 struct pa_defer_event {
90 pa_mainloop *mainloop;
95 pa_defer_event_cb_t callback;
97 pa_defer_event_destroy_cb_t destroy_callback;
99 PA_LLIST_FIELDS(pa_defer_event);
103 PA_LLIST_HEAD(pa_io_event, io_events);
104 PA_LLIST_HEAD(pa_time_event, time_events);
105 PA_LLIST_HEAD(pa_defer_event, defer_events);
107 int n_enabled_defer_events, n_enabled_time_events, n_io_events;
108 int io_events_please_scan, time_events_please_scan, defer_events_please_scan;
110 struct pollfd *pollfds;
111 unsigned max_pollfds, n_pollfds;
114 int prepared_timeout;
115 pa_time_event *cached_next_time_event;
121 int wakeup_pipe_type;
122 int wakeup_requested;
132 pa_poll_func poll_func;
133 void *poll_func_userdata;
137 static short map_flags_to_libc(pa_io_event_flags_t flags) {
139 (flags & PA_IO_EVENT_INPUT ? POLLIN : 0) |
140 (flags & PA_IO_EVENT_OUTPUT ? POLLOUT : 0) |
141 (flags & PA_IO_EVENT_ERROR ? POLLERR : 0) |
142 (flags & PA_IO_EVENT_HANGUP ? POLLHUP : 0);
145 static pa_io_event_flags_t map_flags_from_libc(short flags) {
147 (flags & POLLIN ? PA_IO_EVENT_INPUT : 0) |
148 (flags & POLLOUT ? PA_IO_EVENT_OUTPUT : 0) |
149 (flags & POLLERR ? PA_IO_EVENT_ERROR : 0) |
150 (flags & POLLHUP ? PA_IO_EVENT_HANGUP : 0);
154 static pa_io_event* mainloop_io_new(
157 pa_io_event_flags_t events,
158 pa_io_event_cb_t callback,
170 assert(a == &m->api);
172 e = pa_xnew(pa_io_event, 1);
180 e->callback = callback;
181 e->userdata = userdata;
182 e->destroy_callback = NULL;
195 if ((select((SELECT_TYPE_ARG1) fd, NULL, NULL, SELECT_TYPE_ARG234 &xset,
196 SELECT_TYPE_ARG5 &tv) == -1) &&
197 (WSAGetLastError() == WSAENOTSOCK)) {
198 pa_log_warn("WARNING: cannot monitor non-socket file descriptors.");
204 PA_LLIST_PREPEND(pa_io_event, m->io_events, e);
205 m->rebuild_pollfds = 1;
208 pa_mainloop_wakeup(m);
213 static void mainloop_io_enable(pa_io_event *e, pa_io_event_flags_t events) {
217 if (e->events == events)
223 e->pollfd->events = map_flags_to_libc(events);
225 e->mainloop->rebuild_pollfds = 1;
227 pa_mainloop_wakeup(e->mainloop);
230 static void mainloop_io_free(pa_io_event *e) {
235 e->mainloop->io_events_please_scan ++;
237 e->mainloop->n_io_events --;
238 e->mainloop->rebuild_pollfds = 1;
240 pa_mainloop_wakeup(e->mainloop);
243 static void mainloop_io_set_destroy(pa_io_event *e, pa_io_event_destroy_cb_t callback) {
246 e->destroy_callback = callback;
250 static pa_defer_event* mainloop_defer_new(
252 pa_defer_event_cb_t callback,
263 assert(a == &m->api);
265 e = pa_xnew(pa_defer_event, 1);
270 m->n_enabled_defer_events++;
272 e->callback = callback;
273 e->userdata = userdata;
274 e->destroy_callback = NULL;
276 PA_LLIST_PREPEND(pa_defer_event, m->defer_events, e);
278 pa_mainloop_wakeup(e->mainloop);
283 static void mainloop_defer_enable(pa_defer_event *e, int b) {
287 if (e->enabled && !b) {
288 assert(e->mainloop->n_enabled_defer_events > 0);
289 e->mainloop->n_enabled_defer_events--;
290 } else if (!e->enabled && b) {
291 e->mainloop->n_enabled_defer_events++;
292 pa_mainloop_wakeup(e->mainloop);
298 static void mainloop_defer_free(pa_defer_event *e) {
303 e->mainloop->defer_events_please_scan ++;
306 assert(e->mainloop->n_enabled_defer_events > 0);
307 e->mainloop->n_enabled_defer_events--;
311 static void mainloop_defer_set_destroy(pa_defer_event *e, pa_defer_event_destroy_cb_t callback) {
315 e->destroy_callback = callback;
319 static pa_time_event* mainloop_time_new(
321 const struct timeval *tv,
322 pa_time_event_cb_t callback,
333 assert(a == &m->api);
335 e = pa_xnew(pa_time_event, 1);
339 if ((e->enabled = !!tv)) {
342 m->n_enabled_time_events++;
344 if (m->cached_next_time_event) {
345 assert(m->cached_next_time_event->enabled);
347 if (pa_timeval_cmp(tv, &m->cached_next_time_event->timeval) < 0)
348 m->cached_next_time_event = e;
352 e->callback = callback;
353 e->userdata = userdata;
354 e->destroy_callback = NULL;
356 PA_LLIST_PREPEND(pa_time_event, m->time_events, e);
359 pa_mainloop_wakeup(m);
364 static void mainloop_time_restart(pa_time_event *e, const struct timeval *tv) {
368 if (e->enabled && !tv) {
369 assert(e->mainloop->n_enabled_time_events > 0);
370 e->mainloop->n_enabled_time_events--;
371 } else if (!e->enabled && tv)
372 e->mainloop->n_enabled_time_events++;
374 if ((e->enabled = !!tv)) {
376 pa_mainloop_wakeup(e->mainloop);
379 if (e->mainloop->cached_next_time_event && e->enabled) {
380 assert(e->mainloop->cached_next_time_event->enabled);
382 if (pa_timeval_cmp(tv, &e->mainloop->cached_next_time_event->timeval) < 0)
383 e->mainloop->cached_next_time_event = e;
384 } else if (e->mainloop->cached_next_time_event == e)
385 e->mainloop->cached_next_time_event = NULL;
388 static void mainloop_time_free(pa_time_event *e) {
393 e->mainloop->time_events_please_scan ++;
396 assert(e->mainloop->n_enabled_time_events > 0);
397 e->mainloop->n_enabled_time_events--;
400 if (e->mainloop->cached_next_time_event == e)
401 e->mainloop->cached_next_time_event = NULL;
403 /* no wakeup needed here. Think about it! */
406 static void mainloop_time_set_destroy(pa_time_event *e, pa_time_event_destroy_cb_t callback) {
410 e->destroy_callback = callback;
415 static void mainloop_quit(pa_mainloop_api*a, int retval) {
421 assert(a == &m->api);
423 pa_mainloop_quit(m, retval);
426 static const pa_mainloop_api vtable = {
429 .io_new= mainloop_io_new,
430 .io_enable= mainloop_io_enable,
431 .io_free= mainloop_io_free,
432 .io_set_destroy= mainloop_io_set_destroy,
434 .time_new = mainloop_time_new,
435 .time_restart = mainloop_time_restart,
436 .time_free = mainloop_time_free,
437 .time_set_destroy = mainloop_time_set_destroy,
439 .defer_new = mainloop_defer_new,
440 .defer_enable = mainloop_defer_enable,
441 .defer_free = mainloop_defer_free,
442 .defer_set_destroy = mainloop_defer_set_destroy,
444 .quit = mainloop_quit,
447 pa_mainloop *pa_mainloop_new(void) {
450 m = pa_xnew(pa_mainloop, 1);
452 m->wakeup_pipe_type = 0;
453 if (pipe(m->wakeup_pipe) < 0) {
454 pa_log_error("ERROR: cannot create wakeup pipe");
459 pa_make_nonblock_fd(m->wakeup_pipe[0]);
460 pa_make_nonblock_fd(m->wakeup_pipe[1]);
461 m->wakeup_requested = 0;
463 PA_LLIST_HEAD_INIT(pa_io_event, m->io_events);
464 PA_LLIST_HEAD_INIT(pa_time_event, m->time_events);
465 PA_LLIST_HEAD_INIT(pa_defer_event, m->defer_events);
467 m->n_enabled_defer_events = m->n_enabled_time_events = m->n_io_events = 0;
468 m->io_events_please_scan = m->time_events_please_scan = m->defer_events_please_scan = 0;
470 m->cached_next_time_event = NULL;
471 m->prepared_timeout = 0;
474 m->max_pollfds = m->n_pollfds = 0;
475 m->rebuild_pollfds = 1;
477 m->quit = m->retval = 0;
482 m->state = STATE_PASSIVE;
485 m->poll_func_userdata = NULL;
486 m->poll_func_ret = -1;
491 static void cleanup_io_events(pa_mainloop *m, int force) {
496 pa_io_event *n = e->next;
498 if (!force && m->io_events_please_scan <= 0)
501 if (force || e->dead) {
502 PA_LLIST_REMOVE(pa_io_event, m->io_events, e);
505 assert(m->io_events_please_scan > 0);
506 m->io_events_please_scan--;
509 if (e->destroy_callback)
510 e->destroy_callback(&m->api, e, e->userdata);
514 m->rebuild_pollfds = 1;
520 assert(m->io_events_please_scan == 0);
523 static void cleanup_time_events(pa_mainloop *m, int force) {
528 pa_time_event *n = e->next;
530 if (!force && m->time_events_please_scan <= 0)
533 if (force || e->dead) {
534 PA_LLIST_REMOVE(pa_time_event, m->time_events, e);
537 assert(m->time_events_please_scan > 0);
538 m->time_events_please_scan--;
541 if (!e->dead && e->enabled) {
542 assert(m->n_enabled_time_events > 0);
543 m->n_enabled_time_events--;
546 if (e->destroy_callback)
547 e->destroy_callback(&m->api, e, e->userdata);
555 assert(m->time_events_please_scan == 0);
558 static void cleanup_defer_events(pa_mainloop *m, int force) {
563 pa_defer_event *n = e->next;
565 if (!force && m->defer_events_please_scan <= 0)
568 if (force || e->dead) {
569 PA_LLIST_REMOVE(pa_defer_event, m->defer_events, e);
572 assert(m->defer_events_please_scan > 0);
573 m->defer_events_please_scan--;
576 if (!e->dead && e->enabled) {
577 assert(m->n_enabled_defer_events > 0);
578 m->n_enabled_defer_events--;
581 if (e->destroy_callback)
582 e->destroy_callback(&m->api, e, e->userdata);
590 assert(m->defer_events_please_scan == 0);
594 void pa_mainloop_free(pa_mainloop* m) {
597 cleanup_io_events(m, 1);
598 cleanup_defer_events(m, 1);
599 cleanup_time_events(m, 1);
601 pa_xfree(m->pollfds);
603 if (m->wakeup_pipe[0] >= 0)
604 close(m->wakeup_pipe[0]);
605 if (m->wakeup_pipe[1] >= 0)
606 close(m->wakeup_pipe[1]);
611 static void scan_dead(pa_mainloop *m) {
614 if (m->io_events_please_scan)
615 cleanup_io_events(m, 0);
617 if (m->time_events_please_scan)
618 cleanup_time_events(m, 0);
620 if (m->defer_events_please_scan)
621 cleanup_defer_events(m, 0);
624 static void rebuild_pollfds(pa_mainloop *m) {
629 l = m->n_io_events + 1;
630 if (m->max_pollfds < l) {
632 m->pollfds = pa_xrealloc(m->pollfds, sizeof(struct pollfd)*l);
639 if (m->wakeup_pipe[0] >= 0) {
640 m->pollfds[0].fd = m->wakeup_pipe[0];
641 m->pollfds[0].events = POLLIN;
642 m->pollfds[0].revents = 0;
647 for (e = m->io_events; e; e = e->next) {
655 p->events = map_flags_to_libc(e->events);
662 m->rebuild_pollfds = 0;
665 static int dispatch_pollfds(pa_mainloop *m) {
669 assert(m->poll_func_ret > 0);
671 for (e = m->io_events, k = m->poll_func_ret; e && !m->quit && k > 0; e = e->next) {
672 if (e->dead || !e->pollfd || !e->pollfd->revents)
675 assert(e->pollfd->fd == e->fd && e->callback);
676 e->callback(&m->api, e, e->fd, map_flags_from_libc(e->pollfd->revents), e->userdata);
677 e->pollfd->revents = 0;
686 static int dispatch_defer(pa_mainloop *m) {
690 if (m->n_enabled_defer_events <= 0)
693 for (e = m->defer_events; e && !m->quit; e = e->next) {
694 if (e->dead || !e->enabled)
698 e->callback(&m->api, e, e->userdata);
705 static pa_time_event* find_next_time_event(pa_mainloop *m) {
706 pa_time_event *t, *n = NULL;
709 if (m->cached_next_time_event)
710 return m->cached_next_time_event;
712 for (t = m->time_events; t; t = t->next) {
714 if (t->dead || !t->enabled)
717 if (!n || pa_timeval_cmp(&t->timeval, &n->timeval) < 0) {
720 /* Shortcut for tv = { 0, 0 } */
721 if (n->timeval.tv_sec <= 0)
726 m->cached_next_time_event = n;
730 static int calc_next_timeout(pa_mainloop *m) {
735 if (!m->n_enabled_time_events)
738 t = find_next_time_event(m);
741 if (t->timeval.tv_sec <= 0)
744 pa_gettimeofday(&now);
746 if (pa_timeval_cmp(&t->timeval, &now) <= 0)
749 usec = pa_timeval_diff(&t->timeval, &now);
750 return (int) (usec / 1000);
753 static int dispatch_timeout(pa_mainloop *m) {
759 if (m->n_enabled_time_events <= 0)
762 pa_gettimeofday(&now);
764 for (e = m->time_events; e && !m->quit; e = e->next) {
766 if (e->dead || !e->enabled)
769 if (pa_timeval_cmp(&e->timeval, &now) <= 0) {
772 /* Disable time event */
773 mainloop_time_restart(e, NULL);
775 e->callback(&m->api, e, &e->timeval, e->userdata);
784 void pa_mainloop_wakeup(pa_mainloop *m) {
788 if (m->wakeup_pipe[1] >= 0 && m->state == STATE_POLLING) {
789 pa_write(m->wakeup_pipe[1], &c, sizeof(c), &m->wakeup_pipe_type);
790 m->wakeup_requested++;
794 static void clear_wakeup(pa_mainloop *m) {
799 if (m->wakeup_pipe[0] < 0)
802 if (m->wakeup_requested) {
803 while (pa_read(m->wakeup_pipe[0], &c, sizeof(c), &m->wakeup_pipe_type) == sizeof(c));
804 m->wakeup_requested = 0;
808 int pa_mainloop_prepare(pa_mainloop *m, int timeout) {
810 assert(m->state == STATE_PASSIVE);
818 if (m->n_enabled_defer_events <= 0) {
819 if (m->rebuild_pollfds)
822 m->prepared_timeout = calc_next_timeout(m);
823 if (timeout >= 0 && (timeout < m->prepared_timeout || m->prepared_timeout < 0))
824 m->prepared_timeout = timeout;
827 m->state = STATE_PREPARED;
831 m->state = STATE_QUIT;
835 int pa_mainloop_poll(pa_mainloop *m) {
837 assert(m->state == STATE_PREPARED);
842 m->state = STATE_POLLING;
844 if (m->n_enabled_defer_events )
845 m->poll_func_ret = 0;
847 assert(!m->rebuild_pollfds);
850 m->poll_func_ret = m->poll_func(m->pollfds, m->n_pollfds, m->prepared_timeout, m->poll_func_userdata);
852 m->poll_func_ret = poll(m->pollfds, m->n_pollfds, m->prepared_timeout);
854 if (m->poll_func_ret < 0) {
856 m->poll_func_ret = 0;
858 pa_log("poll(): %s", pa_cstrerror(errno));
862 m->state = m->poll_func_ret < 0 ? STATE_PASSIVE : STATE_POLLED;
863 return m->poll_func_ret;
866 m->state = STATE_QUIT;
870 int pa_mainloop_dispatch(pa_mainloop *m) {
874 assert(m->state == STATE_POLLED);
879 if (m->n_enabled_defer_events)
880 dispatched += dispatch_defer(m);
882 if (m->n_enabled_time_events)
883 dispatched += dispatch_timeout(m);
888 if (m->poll_func_ret > 0)
889 dispatched += dispatch_pollfds(m);
895 m->state = STATE_PASSIVE;
900 m->state = STATE_QUIT;
904 int pa_mainloop_get_retval(pa_mainloop *m) {
909 int pa_mainloop_iterate(pa_mainloop *m, int block, int *retval) {
913 if ((r = pa_mainloop_prepare(m, block ? -1 : 0)) < 0)
916 if ((r = pa_mainloop_poll(m)) < 0)
919 if ((r = pa_mainloop_dispatch(m)) < 0)
926 if ((r == -2) && retval)
927 *retval = pa_mainloop_get_retval(m);
931 int pa_mainloop_run(pa_mainloop *m, int *retval) {
934 while ((r = pa_mainloop_iterate(m, 1, retval)) >= 0);
944 void pa_mainloop_quit(pa_mainloop *m, int retval) {
949 pa_mainloop_wakeup(m);
952 pa_mainloop_api* pa_mainloop_get_api(pa_mainloop*m) {
957 void pa_mainloop_set_poll_func(pa_mainloop *m, pa_poll_func poll_func, void *userdata) {
960 m->poll_func = poll_func;
961 m->poll_func_userdata = userdata;