code.delx.au - pulseaudio/blob - src/pulse/mainloop.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of PulseAudio.
   5
   6   Copyright 2004-2006 Lennart Poettering
   7   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   8
   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.
  13
  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.
  18
  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
  22   USA.
  23 ***/
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #include <stdio.h>
  30 #include <signal.h>
  31 #include <unistd.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <assert.h>
  35 #include <fcntl.h>
  36 #include <errno.h>
  37
  38 #ifdef HAVE_SYS_POLL_H
  39 #include <sys/poll.h>
  40 #else
  41 #include "../pulsecore/poll.h"
  42 #endif
  43
  44 #include "../pulsecore/winsock.h"
  45
  46 #ifndef HAVE_PIPE
  47 #include "../pulsecore/pipe.h"
  48 #endif
  49
  50 #include <pulsecore/core-error.h>
  51 #include <pulse/timeval.h>
  52 #include <pulse/xmalloc.h>
  53
  54 #include <pulsecore/core-util.h>
  55 #include <pulsecore/llist.h>
  56 #include <pulsecore/log.h>
  57
  58 #include "mainloop.h"
  59
  60 struct pa_io_event {
  61     pa_mainloop *mainloop;
  62     int dead;
  63
  64     int fd;
  65     pa_io_event_flags_t events;
  66     struct pollfd *pollfd;
  67
  68     pa_io_event_cb_t callback;
  69     void *userdata;
  70     pa_io_event_destroy_cb_t destroy_callback;
  71
  72     PA_LLIST_FIELDS(pa_io_event);
  73 };
  74
  75 struct pa_time_event {
  76     pa_mainloop *mainloop;
  77     int dead;
  78
  79     int enabled;
  80     struct timeval timeval;
  81
  82     pa_time_event_cb_t callback;
  83     void *userdata;
  84     pa_time_event_destroy_cb_t destroy_callback;
  85
  86     PA_LLIST_FIELDS(pa_time_event);
  87 };
  88
  89 struct pa_defer_event {
  90     pa_mainloop *mainloop;
  91     int dead;
  92
  93     int enabled;
  94
  95     pa_defer_event_cb_t callback;
  96     void *userdata;
  97     pa_defer_event_destroy_cb_t destroy_callback;
  98
  99     PA_LLIST_FIELDS(pa_defer_event);
 100 };
 101
 102 struct pa_mainloop {
 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);
 106
 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;
 109
 110     struct pollfd *pollfds;
 111     unsigned max_pollfds, n_pollfds;
 112     int rebuild_pollfds;
 113
 114     int prepared_timeout;
 115     pa_time_event *cached_next_time_event;
 116
 117     int quit, retval;
 118     pa_mainloop_api api;
 119
 120     int wakeup_pipe[2];
 121     int wakeup_pipe_type;
 122     int wakeup_requested;
 123
 124     enum {
 125         STATE_PASSIVE,
 126         STATE_PREPARED,
 127         STATE_POLLING,
 128         STATE_POLLED,
 129         STATE_QUIT
 130     } state;
 131
 132     pa_poll_func poll_func;
 133     void *poll_func_userdata;
 134     int poll_func_ret;
 135 };
 136
 137 static short map_flags_to_libc(pa_io_event_flags_t flags) {
 138     return
 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);
 143 }
 144
 145 static pa_io_event_flags_t map_flags_from_libc(short flags) {
 146     return
 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);
 151 }
 152
 153 /* IO events */
 154 static pa_io_event* mainloop_io_new(
 155         pa_mainloop_api*a,
 156         int fd,
 157         pa_io_event_flags_t events,
 158         pa_io_event_cb_t callback,
 159         void *userdata) {
 160
 161     pa_mainloop *m;
 162     pa_io_event *e;
 163
 164     assert(a);
 165     assert(a->userdata);
 166     assert(fd >= 0);
 167     assert(callback);
 168
 169     m = a->userdata;
 170     assert(a == &m->api);
 171
 172     e = pa_xnew(pa_io_event, 1);
 173     e->mainloop = m;
 174     e->dead = 0;
 175
 176     e->fd = fd;
 177     e->events = events;
 178     e->pollfd = NULL;
 179
 180     e->callback = callback;
 181     e->userdata = userdata;
 182     e->destroy_callback = NULL;
 183
 184 #ifdef OS_IS_WIN32
 185     {
 186         fd_set xset;
 187         struct timeval tv;
 188
 189         tv.tv_sec = 0;
 190         tv.tv_usec = 0;
 191
 192         FD_ZERO (&xset);
 193         FD_SET (fd, &xset);
 194
 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.");
 199             e->dead = 1;
 200         }
 201     }
 202 #endif
 203
 204     PA_LLIST_PREPEND(pa_io_event, m->io_events, e);
 205     m->rebuild_pollfds = 1;
 206     m->n_io_events ++;
 207
 208     pa_mainloop_wakeup(m);
 209
 210     return e;
 211 }
 212
 213 static void mainloop_io_enable(pa_io_event *e, pa_io_event_flags_t events) {
 214     assert(e);
 215     assert(!e->dead);
 216
 217     if (e->events == events)
 218         return;
 219
 220     e->events = events;
 221
 222     if (e->pollfd)
 223         e->pollfd->events = map_flags_to_libc(events);
 224     else
 225         e->mainloop->rebuild_pollfds = 1;
 226
 227     pa_mainloop_wakeup(e->mainloop);
 228 }
 229
 230 static void mainloop_io_free(pa_io_event *e) {
 231     assert(e);
 232     assert(!e->dead);
 233
 234     e->dead = 1;
 235     e->mainloop->io_events_please_scan ++;
 236
 237     e->mainloop->n_io_events --;
 238     e->mainloop->rebuild_pollfds = 1;
 239
 240     pa_mainloop_wakeup(e->mainloop);
 241 }
 242
 243 static void mainloop_io_set_destroy(pa_io_event *e, pa_io_event_destroy_cb_t callback) {
 244     assert(e);
 245
 246     e->destroy_callback = callback;
 247 }
 248
 249 /* Defer events */
 250 static pa_defer_event* mainloop_defer_new(
 251         pa_mainloop_api*a,
 252         pa_defer_event_cb_t callback,
 253         void *userdata) {
 254
 255     pa_mainloop *m;
 256     pa_defer_event *e;
 257
 258     assert(a);
 259     assert(a->userdata);
 260     assert(callback);
 261
 262     m = a->userdata;
 263     assert(a == &m->api);
 264
 265     e = pa_xnew(pa_defer_event, 1);
 266     e->mainloop = m;
 267     e->dead = 0;
 268
 269     e->enabled = 1;
 270     m->n_enabled_defer_events++;
 271
 272     e->callback = callback;
 273     e->userdata = userdata;
 274     e->destroy_callback = NULL;
 275
 276     PA_LLIST_PREPEND(pa_defer_event, m->defer_events, e);
 277
 278     pa_mainloop_wakeup(e->mainloop);
 279
 280     return e;
 281 }
 282
 283 static void mainloop_defer_enable(pa_defer_event *e, int b) {
 284     assert(e);
 285     assert(!e->dead);
 286
 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);
 293     }
 294
 295     e->enabled = b;
 296 }
 297
 298 static void mainloop_defer_free(pa_defer_event *e) {
 299     assert(e);
 300     assert(!e->dead);
 301
 302     e->dead = 1;
 303     e->mainloop->defer_events_please_scan ++;
 304
 305     if (e->enabled) {
 306         assert(e->mainloop->n_enabled_defer_events > 0);
 307         e->mainloop->n_enabled_defer_events--;
 308         e->enabled = 0;
 309     }
 310 }
 311
 312 static void mainloop_defer_set_destroy(pa_defer_event *e, pa_defer_event_destroy_cb_t callback) {
 313     assert(e);
 314     assert(!e->dead);
 315
 316     e->destroy_callback = callback;
 317 }
 318
 319 /* Time events */
 320 static pa_time_event* mainloop_time_new(
 321         pa_mainloop_api*a,
 322         const struct timeval *tv,
 323         pa_time_event_cb_t callback,
 324         void *userdata) {
 325
 326     pa_mainloop *m;
 327     pa_time_event *e;
 328
 329     assert(a);
 330     assert(a->userdata);
 331     assert(callback);
 332
 333     m = a->userdata;
 334     assert(a == &m->api);
 335
 336     e = pa_xnew(pa_time_event, 1);
 337     e->mainloop = m;
 338     e->dead = 0;
 339
 340     if ((e->enabled = !!tv)) {
 341         e->timeval = *tv;
 342
 343         m->n_enabled_time_events++;
 344
 345         if (m->cached_next_time_event) {
 346             assert(m->cached_next_time_event->enabled);
 347
 348             if (pa_timeval_cmp(tv, &m->cached_next_time_event->timeval) < 0)
 349                 m->cached_next_time_event = e;
 350         }
 351     }
 352
 353     e->callback = callback;
 354     e->userdata = userdata;
 355     e->destroy_callback = NULL;
 356
 357     PA_LLIST_PREPEND(pa_time_event, m->time_events, e);
 358
 359     if (e->enabled)
 360         pa_mainloop_wakeup(m);
 361
 362     return e;
 363 }
 364
 365 static void mainloop_time_restart(pa_time_event *e, const struct timeval *tv) {
 366     assert(e);
 367     assert(!e->dead);
 368
 369     if (e->enabled && !tv) {
 370         assert(e->mainloop->n_enabled_time_events > 0);
 371         e->mainloop->n_enabled_time_events--;
 372     } else if (!e->enabled && tv)
 373         e->mainloop->n_enabled_time_events++;
 374
 375     if ((e->enabled = !!tv)) {
 376         e->timeval = *tv;
 377         pa_mainloop_wakeup(e->mainloop);
 378     }
 379
 380     if (e->mainloop->cached_next_time_event && e->enabled) {
 381         assert(e->mainloop->cached_next_time_event->enabled);
 382
 383         if (pa_timeval_cmp(tv, &e->mainloop->cached_next_time_event->timeval) < 0)
 384             e->mainloop->cached_next_time_event = e;
 385     } else if (e->mainloop->cached_next_time_event == e)
 386         e->mainloop->cached_next_time_event = NULL;
 387 }
 388
 389 static void mainloop_time_free(pa_time_event *e) {
 390     assert(e);
 391     assert(!e->dead);
 392
 393     e->dead = 1;
 394     e->mainloop->time_events_please_scan ++;
 395
 396     if (e->enabled) {
 397         assert(e->mainloop->n_enabled_time_events > 0);
 398         e->mainloop->n_enabled_time_events--;
 399         e->enabled = 0;
 400     }
 401
 402     if (e->mainloop->cached_next_time_event == e)
 403         e->mainloop->cached_next_time_event = NULL;
 404
 405     /* no wakeup needed here. Think about it! */
 406 }
 407
 408 static void mainloop_time_set_destroy(pa_time_event *e, pa_time_event_destroy_cb_t callback) {
 409     assert(e);
 410     assert(!e->dead);
 411
 412     e->destroy_callback = callback;
 413 }
 414
 415 /* quit() */
 416
 417 static void mainloop_quit(pa_mainloop_api*a, int retval) {
 418     pa_mainloop *m;
 419
 420     assert(a);
 421     assert(a->userdata);
 422     m = a->userdata;
 423     assert(a == &m->api);
 424
 425     pa_mainloop_quit(m, retval);
 426 }
 427
 428 static const pa_mainloop_api vtable = {
 429     .userdata = NULL,
 430
 431     .io_new= mainloop_io_new,
 432     .io_enable= mainloop_io_enable,
 433     .io_free= mainloop_io_free,
 434     .io_set_destroy= mainloop_io_set_destroy,
 435
 436     .time_new = mainloop_time_new,
 437     .time_restart = mainloop_time_restart,
 438     .time_free = mainloop_time_free,
 439     .time_set_destroy = mainloop_time_set_destroy,
 440
 441     .defer_new = mainloop_defer_new,
 442     .defer_enable = mainloop_defer_enable,
 443     .defer_free = mainloop_defer_free,
 444     .defer_set_destroy = mainloop_defer_set_destroy,
 445
 446     .quit = mainloop_quit,
 447 };
 448
 449 pa_mainloop *pa_mainloop_new(void) {
 450     pa_mainloop *m;
 451
 452     m = pa_xnew(pa_mainloop, 1);
 453
 454     m->wakeup_pipe_type = 0;
 455     if (pipe(m->wakeup_pipe) < 0) {
 456         pa_log_error("ERROR: cannot create wakeup pipe");
 457         pa_xfree(m);
 458         return NULL;
 459     }
 460
 461     pa_make_nonblock_fd(m->wakeup_pipe[0]);
 462     pa_make_nonblock_fd(m->wakeup_pipe[1]);
 463     m->wakeup_requested = 0;
 464
 465     PA_LLIST_HEAD_INIT(pa_io_event, m->io_events);
 466     PA_LLIST_HEAD_INIT(pa_time_event, m->time_events);
 467     PA_LLIST_HEAD_INIT(pa_defer_event, m->defer_events);
 468
 469     m->n_enabled_defer_events = m->n_enabled_time_events = m->n_io_events = 0;
 470     m->io_events_please_scan = m->time_events_please_scan = m->defer_events_please_scan = 0;
 471
 472     m->cached_next_time_event = NULL;
 473     m->prepared_timeout = 0;
 474
 475     m->pollfds = NULL;
 476     m->max_pollfds = m->n_pollfds = 0;
 477     m->rebuild_pollfds = 1;
 478
 479     m->quit = m->retval = 0;
 480
 481     m->api = vtable;
 482     m->api.userdata = m;
 483
 484     m->state = STATE_PASSIVE;
 485
 486     m->poll_func = NULL;
 487     m->poll_func_userdata = NULL;
 488     m->poll_func_ret = -1;
 489
 490     return m;
 491 }
 492
 493 static void cleanup_io_events(pa_mainloop *m, int force) {
 494     pa_io_event *e;
 495
 496     e = m->io_events;
 497     while (e) {
 498         pa_io_event *n = e->next;
 499
 500         if (!force && m->io_events_please_scan <= 0)
 501             break;
 502
 503         if (force || e->dead) {
 504             PA_LLIST_REMOVE(pa_io_event, m->io_events, e);
 505
 506             if (e->dead) {
 507                 assert(m->io_events_please_scan > 0);
 508                 m->io_events_please_scan--;
 509             }
 510
 511             if (e->destroy_callback)
 512                 e->destroy_callback(&m->api, e, e->userdata);
 513
 514             pa_xfree(e);
 515
 516             m->rebuild_pollfds = 1;
 517         }
 518
 519         e = n;
 520     }
 521
 522     assert(m->io_events_please_scan == 0);
 523 }
 524
 525 static void cleanup_time_events(pa_mainloop *m, int force) {
 526     pa_time_event *e;
 527
 528     e = m->time_events;
 529     while (e) {
 530         pa_time_event *n = e->next;
 531
 532         if (!force && m->time_events_please_scan <= 0)
 533             break;
 534
 535         if (force || e->dead) {
 536             PA_LLIST_REMOVE(pa_time_event, m->time_events, e);
 537
 538             if (e->dead) {
 539                 assert(m->time_events_please_scan > 0);
 540                 m->time_events_please_scan--;
 541             }
 542
 543             if (!e->dead && e->enabled) {
 544                 assert(m->n_enabled_time_events > 0);
 545                 m->n_enabled_time_events--;
 546                 e->enabled = 0;
 547             }
 548
 549             if (e->destroy_callback)
 550                 e->destroy_callback(&m->api, e, e->userdata);
 551
 552             pa_xfree(e);
 553         }
 554
 555         e = n;
 556     }
 557
 558     assert(m->time_events_please_scan == 0);
 559 }
 560
 561 static void cleanup_defer_events(pa_mainloop *m, int force) {
 562     pa_defer_event *e;
 563
 564     e = m->defer_events;
 565     while (e) {
 566         pa_defer_event *n = e->next;
 567
 568         if (!force && m->defer_events_please_scan <= 0)
 569             break;
 570
 571         if (force || e->dead) {
 572             PA_LLIST_REMOVE(pa_defer_event, m->defer_events, e);
 573
 574             if (e->dead) {
 575                 assert(m->defer_events_please_scan > 0);
 576                 m->defer_events_please_scan--;
 577             }
 578
 579             if (!e->dead && e->enabled) {
 580                 assert(m->n_enabled_defer_events > 0);
 581                 m->n_enabled_defer_events--;
 582                 e->enabled = 0;
 583             }
 584
 585             if (e->destroy_callback)
 586                 e->destroy_callback(&m->api, e, e->userdata);
 587
 588             pa_xfree(e);
 589         }
 590
 591         e = n;
 592     }
 593
 594     assert(m->defer_events_please_scan == 0);
 595 }
 596
 597
 598 void pa_mainloop_free(pa_mainloop* m) {
 599     assert(m);
 600
 601     cleanup_io_events(m, 1);
 602     cleanup_defer_events(m, 1);
 603     cleanup_time_events(m, 1);
 604
 605     pa_xfree(m->pollfds);
 606
 607     if (m->wakeup_pipe[0] >= 0)
 608         close(m->wakeup_pipe[0]);
 609     if (m->wakeup_pipe[1] >= 0)
 610         close(m->wakeup_pipe[1]);
 611
 612     pa_xfree(m);
 613 }
 614
 615 static void scan_dead(pa_mainloop *m) {
 616     assert(m);
 617
 618     if (m->io_events_please_scan)
 619         cleanup_io_events(m, 0);
 620
 621     if (m->time_events_please_scan)
 622         cleanup_time_events(m, 0);
 623
 624     if (m->defer_events_please_scan)
 625         cleanup_defer_events(m, 0);
 626 }
 627
 628 static void rebuild_pollfds(pa_mainloop *m) {
 629     pa_io_event*e;
 630     struct pollfd *p;
 631     unsigned l;
 632
 633     l = m->n_io_events + 1;
 634     if (m->max_pollfds < l) {
 635         l *= 2;
 636         m->pollfds = pa_xrealloc(m->pollfds, sizeof(struct pollfd)*l);
 637         m->max_pollfds = l;
 638     }
 639
 640     m->n_pollfds = 0;
 641     p = m->pollfds;
 642
 643     if (m->wakeup_pipe[0] >= 0) {
 644         m->pollfds[0].fd = m->wakeup_pipe[0];
 645         m->pollfds[0].events = POLLIN;
 646         m->pollfds[0].revents = 0;
 647         p++;
 648         m->n_pollfds++;
 649     }
 650
 651     for (e = m->io_events; e; e = e->next) {
 652         if (e->dead) {
 653             e->pollfd = NULL;
 654             continue;
 655         }
 656
 657         e->pollfd = p;
 658         p->fd = e->fd;
 659         p->events = map_flags_to_libc(e->events);
 660         p->revents = 0;
 661
 662         p++;
 663         m->n_pollfds++;
 664     }
 665
 666     m->rebuild_pollfds = 0;
 667 }
 668
 669 static int dispatch_pollfds(pa_mainloop *m) {
 670     pa_io_event *e;
 671     int r = 0, k;
 672
 673     assert(m->poll_func_ret > 0);
 674
 675     for (e = m->io_events, k = m->poll_func_ret; e && !m->quit && k > 0; e = e->next) {
 676         if (e->dead || !e->pollfd || !e->pollfd->revents)
 677             continue;
 678
 679         assert(e->pollfd->fd == e->fd && e->callback);
 680         e->callback(&m->api, e, e->fd, map_flags_from_libc(e->pollfd->revents), e->userdata);
 681         e->pollfd->revents = 0;
 682         r++;
 683
 684         k--;
 685     }
 686
 687     return r;
 688 }
 689
 690 static int dispatch_defer(pa_mainloop *m) {
 691     pa_defer_event *e;
 692     int r = 0;
 693
 694     if (m->n_enabled_defer_events <= 0)
 695         return 0;
 696
 697     for (e = m->defer_events; e && !m->quit; e = e->next) {
 698         if (e->dead || !e->enabled)
 699             continue;
 700
 701         assert(e->callback);
 702         e->callback(&m->api, e, e->userdata);
 703         r++;
 704     }
 705
 706     return r;
 707 }
 708
 709 static pa_time_event* find_next_time_event(pa_mainloop *m) {
 710     pa_time_event *t, *n = NULL;
 711     assert(m);
 712
 713     if (m->cached_next_time_event)
 714         return m->cached_next_time_event;
 715
 716     for (t = m->time_events; t; t = t->next) {
 717
 718         if (t->dead || !t->enabled)
 719             continue;
 720
 721         if (!n || pa_timeval_cmp(&t->timeval, &n->timeval) < 0) {
 722             n = t;
 723
 724             /* Shortcut for tv = { 0, 0 } */
 725             if (n->timeval.tv_sec <= 0)
 726                 break;
 727         }
 728     }
 729
 730     m->cached_next_time_event = n;
 731     return n;
 732 }
 733
 734 static int calc_next_timeout(pa_mainloop *m) {
 735     pa_time_event *t;
 736     struct timeval now;
 737     pa_usec_t usec;
 738
 739     if (!m->n_enabled_time_events)
 740         return -1;
 741
 742     t = find_next_time_event(m);
 743     assert(t);
 744
 745     if (t->timeval.tv_sec <= 0)
 746         return 0;
 747
 748     pa_gettimeofday(&now);
 749
 750     if (pa_timeval_cmp(&t->timeval, &now) <= 0)
 751         return 0;
 752
 753     usec = pa_timeval_diff(&t->timeval, &now);
 754     return (int) (usec / 1000);
 755 }
 756
 757 static int dispatch_timeout(pa_mainloop *m) {
 758     pa_time_event *e;
 759     struct timeval now;
 760     int r = 0;
 761     assert(m);
 762
 763     if (m->n_enabled_time_events <= 0)
 764         return 0;
 765
 766     pa_gettimeofday(&now);
 767
 768     for (e = m->time_events; e && !m->quit; e = e->next) {
 769
 770         if (e->dead || !e->enabled)
 771             continue;
 772
 773         if (pa_timeval_cmp(&e->timeval, &now) <= 0) {
 774             assert(e->callback);
 775
 776             /* Disable time event */
 777             mainloop_time_restart(e, NULL);
 778
 779             e->callback(&m->api, e, &e->timeval, e->userdata);
 780
 781             r++;
 782         }
 783     }
 784
 785     return r;
 786 }
 787
 788 void pa_mainloop_wakeup(pa_mainloop *m) {
 789     char c = 'W';
 790     assert(m);
 791
 792     if (m->wakeup_pipe[1] >= 0 && m->state == STATE_POLLING) {
 793         pa_write(m->wakeup_pipe[1], &c, sizeof(c), &m->wakeup_pipe_type);
 794         m->wakeup_requested++;
 795     }
 796 }
 797
 798 static void clear_wakeup(pa_mainloop *m) {
 799     char c[10];
 800
 801     assert(m);
 802
 803     if (m->wakeup_pipe[0] < 0)
 804         return;
 805
 806     if (m->wakeup_requested) {
 807         while (pa_read(m->wakeup_pipe[0], &c, sizeof(c), &m->wakeup_pipe_type) == sizeof(c));
 808         m->wakeup_requested = 0;
 809     }
 810 }
 811
 812 int pa_mainloop_prepare(pa_mainloop *m, int timeout) {
 813     assert(m);
 814     assert(m->state == STATE_PASSIVE);
 815
 816     clear_wakeup(m);
 817     scan_dead(m);
 818
 819     if (m->quit)
 820         goto quit;
 821
 822     if (m->n_enabled_defer_events <= 0) {
 823         if (m->rebuild_pollfds)
 824             rebuild_pollfds(m);
 825
 826         m->prepared_timeout = calc_next_timeout(m);
 827         if (timeout >= 0 && (timeout < m->prepared_timeout || m->prepared_timeout < 0))
 828             m->prepared_timeout = timeout;
 829     }
 830
 831     m->state = STATE_PREPARED;
 832     return 0;
 833
 834 quit:
 835     m->state = STATE_QUIT;
 836     return -2;
 837 }
 838
 839 int pa_mainloop_poll(pa_mainloop *m) {
 840     assert(m);
 841     assert(m->state == STATE_PREPARED);
 842
 843     if (m->quit)
 844         goto quit;
 845
 846     m->state = STATE_POLLING;
 847
 848     if (m->n_enabled_defer_events )
 849         m->poll_func_ret = 0;
 850     else {
 851         assert(!m->rebuild_pollfds);
 852
 853         if (m->poll_func)
 854             m->poll_func_ret = m->poll_func(m->pollfds, m->n_pollfds, m->prepared_timeout, m->poll_func_userdata);
 855         else
 856             m->poll_func_ret = poll(m->pollfds, m->n_pollfds, m->prepared_timeout);
 857
 858         if (m->poll_func_ret < 0) {
 859             if (errno == EINTR)
 860                 m->poll_func_ret = 0;
 861             else
 862                 pa_log("poll(): %s", pa_cstrerror(errno));
 863         }
 864     }
 865
 866     m->state = m->poll_func_ret < 0 ? STATE_PASSIVE : STATE_POLLED;
 867     return m->poll_func_ret;
 868
 869 quit:
 870     m->state = STATE_QUIT;
 871     return -2;
 872 }
 873
 874 int pa_mainloop_dispatch(pa_mainloop *m) {
 875     int dispatched = 0;
 876
 877     assert(m);
 878     assert(m->state == STATE_POLLED);
 879
 880     if (m->quit)
 881         goto quit;
 882
 883     if (m->n_enabled_defer_events)
 884         dispatched += dispatch_defer(m);
 885     else {
 886         if (m->n_enabled_time_events)
 887             dispatched += dispatch_timeout(m);
 888
 889         if (m->quit)
 890             goto quit;
 891
 892         if (m->poll_func_ret > 0)
 893             dispatched += dispatch_pollfds(m);
 894     }
 895
 896     if (m->quit)
 897         goto quit;
 898
 899     m->state = STATE_PASSIVE;
 900
 901     return dispatched;
 902
 903 quit:
 904     m->state = STATE_QUIT;
 905     return -2;
 906 }
 907
 908 int pa_mainloop_get_retval(pa_mainloop *m) {
 909     assert(m);
 910     return m->retval;
 911 }
 912
 913 int pa_mainloop_iterate(pa_mainloop *m, int block, int *retval) {
 914     int r;
 915     assert(m);
 916
 917     if ((r = pa_mainloop_prepare(m, block ? -1 : 0)) < 0)
 918         goto quit;
 919
 920     if ((r = pa_mainloop_poll(m)) < 0)
 921         goto quit;
 922
 923     if ((r = pa_mainloop_dispatch(m)) < 0)
 924         goto quit;
 925
 926     return r;
 927
 928 quit:
 929
 930     if ((r == -2) && retval)
 931         *retval = pa_mainloop_get_retval(m);
 932     return r;
 933 }
 934
 935 int pa_mainloop_run(pa_mainloop *m, int *retval) {
 936     int r;
 937
 938     while ((r = pa_mainloop_iterate(m, 1, retval)) >= 0);
 939
 940     if (r == -2)
 941         return 1;
 942     else if (r < 0)
 943         return -1;
 944     else
 945         return 0;
 946 }
 947
 948 void pa_mainloop_quit(pa_mainloop *m, int retval) {
 949     assert(m);
 950
 951     m->quit = 1;
 952     m->retval = retval;
 953     pa_mainloop_wakeup(m);
 954 }
 955
 956 pa_mainloop_api* pa_mainloop_get_api(pa_mainloop*m) {
 957     assert(m);
 958     return &m->api;
 959 }
 960
 961 void pa_mainloop_set_poll_func(pa_mainloop *m, pa_poll_func poll_func, void *userdata) {
 962     assert(m);
 963
 964     m->poll_func = poll_func;
 965     m->poll_func_userdata = userdata;
 966 }