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

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <signal.h>
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <fcntl.h>
  33 #include <errno.h>
  34
  35 #ifdef HAVE_POLL_H
  36 #include <poll.h>
  37 #else
  38 #include <pulsecore/poll.h>
  39 #endif
  40
  41 #ifndef HAVE_PIPE
  42 #include <pulsecore/pipe.h>
  43 #endif
  44
  45 #include <pulse/timeval.h>
  46 #include <pulse/xmalloc.h>
  47 #include <pulse/i18n.h>
  48
  49 #include <pulsecore/core-util.h>
  50 #include <pulsecore/llist.h>
  51 #include <pulsecore/log.h>
  52 #include <pulsecore/core-error.h>
  53 #include <pulsecore/winsock.h>
  54 #include <pulsecore/macro.h>
  55
  56 #include "mainloop.h"
  57
  58 struct pa_io_event {
  59     pa_mainloop *mainloop;
  60     pa_bool_t dead:1;
  61
  62     int fd;
  63     pa_io_event_flags_t events;
  64     struct pollfd *pollfd;
  65
  66     pa_io_event_cb_t callback;
  67     void *userdata;
  68     pa_io_event_destroy_cb_t destroy_callback;
  69
  70     PA_LLIST_FIELDS(pa_io_event);
  71 };
  72
  73 struct pa_time_event {
  74     pa_mainloop *mainloop;
  75     pa_bool_t dead:1;
  76
  77     pa_bool_t enabled:1;
  78     struct timeval timeval;
  79
  80     pa_time_event_cb_t callback;
  81     void *userdata;
  82     pa_time_event_destroy_cb_t destroy_callback;
  83
  84     PA_LLIST_FIELDS(pa_time_event);
  85 };
  86
  87 struct pa_defer_event {
  88     pa_mainloop *mainloop;
  89     pa_bool_t dead:1;
  90
  91     pa_bool_t enabled:1;
  92
  93     pa_defer_event_cb_t callback;
  94     void *userdata;
  95     pa_defer_event_destroy_cb_t destroy_callback;
  96
  97     PA_LLIST_FIELDS(pa_defer_event);
  98 };
  99
 100 struct pa_mainloop {
 101     PA_LLIST_HEAD(pa_io_event, io_events);
 102     PA_LLIST_HEAD(pa_time_event, time_events);
 103     PA_LLIST_HEAD(pa_defer_event, defer_events);
 104
 105     unsigned n_enabled_defer_events, n_enabled_time_events, n_io_events;
 106     unsigned io_events_please_scan, time_events_please_scan, defer_events_please_scan;
 107
 108     pa_bool_t rebuild_pollfds:1;
 109     struct pollfd *pollfds;
 110     unsigned max_pollfds, n_pollfds;
 111
 112     int prepared_timeout;
 113     pa_time_event *cached_next_time_event;
 114
 115     pa_mainloop_api api;
 116
 117     int retval;
 118     pa_bool_t quit:1;
 119
 120     pa_bool_t wakeup_requested:1;
 121     int wakeup_pipe[2];
 122     int wakeup_pipe_type;
 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 (short)
 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     pa_assert(a);
 165     pa_assert(a->userdata);
 166     pa_assert(fd >= 0);
 167     pa_assert(callback);
 168
 169     m = a->userdata;
 170     pa_assert(a == &m->api);
 171
 172     e = pa_xnew(pa_io_event, 1);
 173     e->mainloop = m;
 174     e->dead = FALSE;
 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("Cannot monitor non-socket file descriptors.");
 199             e->dead = TRUE;
 200         }
 201     }
 202 #endif
 203
 204     PA_LLIST_PREPEND(pa_io_event, m->io_events, e);
 205     m->rebuild_pollfds = TRUE;
 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     pa_assert(e);
 215     pa_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 = TRUE;
 226
 227     pa_mainloop_wakeup(e->mainloop);
 228 }
 229
 230 static void mainloop_io_free(pa_io_event *e) {
 231     pa_assert(e);
 232     pa_assert(!e->dead);
 233
 234     e->dead = TRUE;
 235     e->mainloop->io_events_please_scan ++;
 236
 237     e->mainloop->n_io_events --;
 238     e->mainloop->rebuild_pollfds = TRUE;
 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     pa_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     pa_assert(a);
 259     pa_assert(a->userdata);
 260     pa_assert(callback);
 261
 262     m = a->userdata;
 263     pa_assert(a == &m->api);
 264
 265     e = pa_xnew(pa_defer_event, 1);
 266     e->mainloop = m;
 267     e->dead = FALSE;
 268
 269     e->enabled = TRUE;
 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     pa_assert(e);
 285     pa_assert(!e->dead);
 286
 287     if (e->enabled && !b) {
 288         pa_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     pa_assert(e);
 300     pa_assert(!e->dead);
 301
 302     e->dead = TRUE;
 303     e->mainloop->defer_events_please_scan ++;
 304
 305     if (e->enabled) {
 306         pa_assert(e->mainloop->n_enabled_defer_events > 0);
 307         e->mainloop->n_enabled_defer_events--;
 308         e->enabled = FALSE;
 309     }
 310 }
 311
 312 static void mainloop_defer_set_destroy(pa_defer_event *e, pa_defer_event_destroy_cb_t callback) {
 313     pa_assert(e);
 314     pa_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     pa_assert(a);
 330     pa_assert(a->userdata);
 331     pa_assert(callback);
 332
 333     m = a->userdata;
 334     pa_assert(a == &m->api);
 335
 336     e = pa_xnew(pa_time_event, 1);
 337     e->mainloop = m;
 338     e->dead = FALSE;
 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             pa_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     pa_assert(e);
 367     pa_assert(!e->dead);
 368
 369     if (e->enabled && !tv) {
 370         pa_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         pa_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     pa_assert(e);
 391     pa_assert(!e->dead);
 392
 393     e->dead = TRUE;
 394     e->mainloop->time_events_please_scan ++;
 395
 396     if (e->enabled) {
 397         pa_assert(e->mainloop->n_enabled_time_events > 0);
 398         e->mainloop->n_enabled_time_events--;
 399         e->enabled = FALSE;
 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     pa_assert(e);
 410     pa_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     pa_assert(a);
 421     pa_assert(a->userdata);
 422     m = a->userdata;
 423     pa_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     pa_init_i18n();
 453
 454     m = pa_xnew(pa_mainloop, 1);
 455
 456     m->wakeup_pipe_type = 0;
 457     if (pipe(m->wakeup_pipe) < 0) {
 458         pa_log_error("ERROR: cannot create wakeup pipe");
 459         pa_xfree(m);
 460         return NULL;
 461     }
 462
 463     pa_make_fd_nonblock(m->wakeup_pipe[0]);
 464     pa_make_fd_nonblock(m->wakeup_pipe[1]);
 465     pa_make_fd_cloexec(m->wakeup_pipe[0]);
 466     pa_make_fd_cloexec(m->wakeup_pipe[1]);
 467     m->wakeup_requested = FALSE;
 468
 469     PA_LLIST_HEAD_INIT(pa_io_event, m->io_events);
 470     PA_LLIST_HEAD_INIT(pa_time_event, m->time_events);
 471     PA_LLIST_HEAD_INIT(pa_defer_event, m->defer_events);
 472
 473     m->n_enabled_defer_events = m->n_enabled_time_events = m->n_io_events = 0;
 474     m->io_events_please_scan = m->time_events_please_scan = m->defer_events_please_scan = 0;
 475
 476     m->cached_next_time_event = NULL;
 477     m->prepared_timeout = 0;
 478
 479     m->pollfds = NULL;
 480     m->max_pollfds = m->n_pollfds = 0;
 481     m->rebuild_pollfds = TRUE;
 482
 483     m->quit = FALSE;
 484     m->retval = 0;
 485
 486     m->api = vtable;
 487     m->api.userdata = m;
 488
 489     m->state = STATE_PASSIVE;
 490
 491     m->poll_func = NULL;
 492     m->poll_func_userdata = NULL;
 493     m->poll_func_ret = -1;
 494
 495     return m;
 496 }
 497
 498 static void cleanup_io_events(pa_mainloop *m, pa_bool_t force) {
 499     pa_io_event *e;
 500
 501     e = m->io_events;
 502     while (e) {
 503         pa_io_event *n = e->next;
 504
 505         if (!force && m->io_events_please_scan <= 0)
 506             break;
 507
 508         if (force || e->dead) {
 509             PA_LLIST_REMOVE(pa_io_event, m->io_events, e);
 510
 511             if (e->dead) {
 512                 pa_assert(m->io_events_please_scan > 0);
 513                 m->io_events_please_scan--;
 514             }
 515
 516             if (e->destroy_callback)
 517                 e->destroy_callback(&m->api, e, e->userdata);
 518
 519             pa_xfree(e);
 520
 521             m->rebuild_pollfds = TRUE;
 522         }
 523
 524         e = n;
 525     }
 526
 527     pa_assert(m->io_events_please_scan == 0);
 528 }
 529
 530 static void cleanup_time_events(pa_mainloop *m, pa_bool_t force) {
 531     pa_time_event *e;
 532
 533     e = m->time_events;
 534     while (e) {
 535         pa_time_event *n = e->next;
 536
 537         if (!force && m->time_events_please_scan <= 0)
 538             break;
 539
 540         if (force || e->dead) {
 541             PA_LLIST_REMOVE(pa_time_event, m->time_events, e);
 542
 543             if (e->dead) {
 544                 pa_assert(m->time_events_please_scan > 0);
 545                 m->time_events_please_scan--;
 546             }
 547
 548             if (!e->dead && e->enabled) {
 549                 pa_assert(m->n_enabled_time_events > 0);
 550                 m->n_enabled_time_events--;
 551                 e->enabled = FALSE;
 552             }
 553
 554             if (e->destroy_callback)
 555                 e->destroy_callback(&m->api, e, e->userdata);
 556
 557             pa_xfree(e);
 558         }
 559
 560         e = n;
 561     }
 562
 563     pa_assert(m->time_events_please_scan == 0);
 564 }
 565
 566 static void cleanup_defer_events(pa_mainloop *m, pa_bool_t force) {
 567     pa_defer_event *e;
 568
 569     e = m->defer_events;
 570     while (e) {
 571         pa_defer_event *n = e->next;
 572
 573         if (!force && m->defer_events_please_scan <= 0)
 574             break;
 575
 576         if (force || e->dead) {
 577             PA_LLIST_REMOVE(pa_defer_event, m->defer_events, e);
 578
 579             if (e->dead) {
 580                 pa_assert(m->defer_events_please_scan > 0);
 581                 m->defer_events_please_scan--;
 582             }
 583
 584             if (!e->dead && e->enabled) {
 585                 pa_assert(m->n_enabled_defer_events > 0);
 586                 m->n_enabled_defer_events--;
 587                 e->enabled = FALSE;
 588             }
 589
 590             if (e->destroy_callback)
 591                 e->destroy_callback(&m->api, e, e->userdata);
 592
 593             pa_xfree(e);
 594         }
 595
 596         e = n;
 597     }
 598
 599     pa_assert(m->defer_events_please_scan == 0);
 600 }
 601
 602
 603 void pa_mainloop_free(pa_mainloop* m) {
 604     pa_assert(m);
 605
 606     cleanup_io_events(m, TRUE);
 607     cleanup_defer_events(m, TRUE);
 608     cleanup_time_events(m, TRUE);
 609
 610     pa_xfree(m->pollfds);
 611
 612     pa_close_pipe(m->wakeup_pipe);
 613
 614     pa_xfree(m);
 615 }
 616
 617 static void scan_dead(pa_mainloop *m) {
 618     pa_assert(m);
 619
 620     if (m->io_events_please_scan)
 621         cleanup_io_events(m, FALSE);
 622
 623     if (m->time_events_please_scan)
 624         cleanup_time_events(m, FALSE);
 625
 626     if (m->defer_events_please_scan)
 627         cleanup_defer_events(m, FALSE);
 628 }
 629
 630 static void rebuild_pollfds(pa_mainloop *m) {
 631     pa_io_event*e;
 632     struct pollfd *p;
 633     unsigned l;
 634
 635     l = m->n_io_events + 1;
 636     if (m->max_pollfds < l) {
 637         l *= 2;
 638         m->pollfds = pa_xrealloc(m->pollfds, sizeof(struct pollfd)*l);
 639         m->max_pollfds = l;
 640     }
 641
 642     m->n_pollfds = 0;
 643     p = m->pollfds;
 644
 645     if (m->wakeup_pipe[0] >= 0) {
 646         m->pollfds[0].fd = m->wakeup_pipe[0];
 647         m->pollfds[0].events = POLLIN;
 648         m->pollfds[0].revents = 0;
 649         p++;
 650         m->n_pollfds++;
 651     }
 652
 653     for (e = m->io_events; e; e = e->next) {
 654         if (e->dead) {
 655             e->pollfd = NULL;
 656             continue;
 657         }
 658
 659         e->pollfd = p;
 660         p->fd = e->fd;
 661         p->events = map_flags_to_libc(e->events);
 662         p->revents = 0;
 663
 664         p++;
 665         m->n_pollfds++;
 666     }
 667
 668     m->rebuild_pollfds = FALSE;
 669 }
 670
 671 static int dispatch_pollfds(pa_mainloop *m) {
 672     pa_io_event *e;
 673     int r = 0, k;
 674
 675     pa_assert(m->poll_func_ret > 0);
 676
 677     for (e = m->io_events, k = m->poll_func_ret; e && !m->quit && k > 0; e = e->next) {
 678         if (e->dead || !e->pollfd || !e->pollfd->revents)
 679             continue;
 680
 681         pa_assert(e->pollfd->fd == e->fd);
 682         pa_assert(e->callback);
 683         e->callback(&m->api, e, e->fd, map_flags_from_libc(e->pollfd->revents), e->userdata);
 684         e->pollfd->revents = 0;
 685         r++;
 686
 687         k--;
 688     }
 689
 690     return r;
 691 }
 692
 693 static int dispatch_defer(pa_mainloop *m) {
 694     pa_defer_event *e;
 695     int r = 0;
 696
 697     if (m->n_enabled_defer_events <= 0)
 698         return 0;
 699
 700     for (e = m->defer_events; e && !m->quit; e = e->next) {
 701         if (e->dead || !e->enabled)
 702             continue;
 703
 704         pa_assert(e->callback);
 705         e->callback(&m->api, e, e->userdata);
 706         r++;
 707     }
 708
 709     return r;
 710 }
 711
 712 static pa_time_event* find_next_time_event(pa_mainloop *m) {
 713     pa_time_event *t, *n = NULL;
 714     pa_assert(m);
 715
 716     if (m->cached_next_time_event)
 717         return m->cached_next_time_event;
 718
 719     for (t = m->time_events; t; t = t->next) {
 720
 721         if (t->dead || !t->enabled)
 722             continue;
 723
 724         if (!n || pa_timeval_cmp(&t->timeval, &n->timeval) < 0) {
 725             n = t;
 726
 727             /* Shortcut for tv = { 0, 0 } */
 728             if (n->timeval.tv_sec <= 0)
 729                 break;
 730         }
 731     }
 732
 733     m->cached_next_time_event = n;
 734     return n;
 735 }
 736
 737 static int calc_next_timeout(pa_mainloop *m) {
 738     pa_time_event *t;
 739     struct timeval now;
 740     pa_usec_t usec;
 741
 742     if (!m->n_enabled_time_events)
 743         return -1;
 744
 745     t = find_next_time_event(m);
 746     pa_assert(t);
 747
 748     if (t->timeval.tv_sec <= 0)
 749         return 0;
 750
 751     pa_gettimeofday(&now);
 752
 753     if (pa_timeval_cmp(&t->timeval, &now) <= 0)
 754         return 0;
 755
 756     usec = pa_timeval_diff(&t->timeval, &now);
 757     return (int) (usec / 1000);
 758 }
 759
 760 static int dispatch_timeout(pa_mainloop *m) {
 761     pa_time_event *e;
 762     struct timeval now;
 763     int r = 0;
 764     pa_assert(m);
 765
 766     if (m->n_enabled_time_events <= 0)
 767         return 0;
 768
 769     pa_gettimeofday(&now);
 770
 771     for (e = m->time_events; e && !m->quit; e = e->next) {
 772
 773         if (e->dead || !e->enabled)
 774             continue;
 775
 776         if (pa_timeval_cmp(&e->timeval, &now) <= 0) {
 777             pa_assert(e->callback);
 778
 779             /* Disable time event */
 780             mainloop_time_restart(e, NULL);
 781
 782             e->callback(&m->api, e, &e->timeval, e->userdata);
 783
 784             r++;
 785         }
 786     }
 787
 788     return r;
 789 }
 790
 791 void pa_mainloop_wakeup(pa_mainloop *m) {
 792     char c = 'W';
 793     pa_assert(m);
 794
 795     if (m->wakeup_pipe[1] >= 0 && m->state == STATE_POLLING) {
 796         pa_write(m->wakeup_pipe[1], &c, sizeof(c), &m->wakeup_pipe_type);
 797         m->wakeup_requested++;
 798     }
 799 }
 800
 801 static void clear_wakeup(pa_mainloop *m) {
 802     char c[10];
 803
 804     pa_assert(m);
 805
 806     if (m->wakeup_pipe[0] < 0)
 807         return;
 808
 809     if (m->wakeup_requested) {
 810         while (pa_read(m->wakeup_pipe[0], &c, sizeof(c), &m->wakeup_pipe_type) == sizeof(c));
 811         m->wakeup_requested = 0;
 812     }
 813 }
 814
 815 int pa_mainloop_prepare(pa_mainloop *m, int timeout) {
 816     pa_assert(m);
 817     pa_assert(m->state == STATE_PASSIVE);
 818
 819     clear_wakeup(m);
 820     scan_dead(m);
 821
 822     if (m->quit)
 823         goto quit;
 824
 825     if (m->n_enabled_defer_events <= 0) {
 826         if (m->rebuild_pollfds)
 827             rebuild_pollfds(m);
 828
 829         m->prepared_timeout = calc_next_timeout(m);
 830         if (timeout >= 0 && (timeout < m->prepared_timeout || m->prepared_timeout < 0))
 831             m->prepared_timeout = timeout;
 832     }
 833
 834     m->state = STATE_PREPARED;
 835     return 0;
 836
 837 quit:
 838     m->state = STATE_QUIT;
 839     return -2;
 840 }
 841
 842 int pa_mainloop_poll(pa_mainloop *m) {
 843     pa_assert(m);
 844     pa_assert(m->state == STATE_PREPARED);
 845
 846     if (m->quit)
 847         goto quit;
 848
 849     m->state = STATE_POLLING;
 850
 851     if (m->n_enabled_defer_events )
 852         m->poll_func_ret = 0;
 853     else {
 854         pa_assert(!m->rebuild_pollfds);
 855
 856         if (m->poll_func)
 857             m->poll_func_ret = m->poll_func(m->pollfds, m->n_pollfds, m->prepared_timeout, m->poll_func_userdata);
 858         else
 859             m->poll_func_ret = poll(m->pollfds, m->n_pollfds, m->prepared_timeout);
 860
 861         if (m->poll_func_ret < 0) {
 862             if (errno == EINTR)
 863                 m->poll_func_ret = 0;
 864             else
 865                 pa_log("poll(): %s", pa_cstrerror(errno));
 866         }
 867     }
 868
 869     m->state = m->poll_func_ret < 0 ? STATE_PASSIVE : STATE_POLLED;
 870     return m->poll_func_ret;
 871
 872 quit:
 873     m->state = STATE_QUIT;
 874     return -2;
 875 }
 876
 877 int pa_mainloop_dispatch(pa_mainloop *m) {
 878     int dispatched = 0;
 879
 880     pa_assert(m);
 881     pa_assert(m->state == STATE_POLLED);
 882
 883     if (m->quit)
 884         goto quit;
 885
 886     if (m->n_enabled_defer_events)
 887         dispatched += dispatch_defer(m);
 888     else {
 889         if (m->n_enabled_time_events)
 890             dispatched += dispatch_timeout(m);
 891
 892         if (m->quit)
 893             goto quit;
 894
 895         if (m->poll_func_ret > 0)
 896             dispatched += dispatch_pollfds(m);
 897     }
 898
 899     if (m->quit)
 900         goto quit;
 901
 902     m->state = STATE_PASSIVE;
 903
 904     return dispatched;
 905
 906 quit:
 907     m->state = STATE_QUIT;
 908     return -2;
 909 }
 910
 911 int pa_mainloop_get_retval(pa_mainloop *m) {
 912     pa_assert(m);
 913     return m->retval;
 914 }
 915
 916 int pa_mainloop_iterate(pa_mainloop *m, int block, int *retval) {
 917     int r;
 918     pa_assert(m);
 919
 920     if ((r = pa_mainloop_prepare(m, block ? -1 : 0)) < 0)
 921         goto quit;
 922
 923     if ((r = pa_mainloop_poll(m)) < 0)
 924         goto quit;
 925
 926     if ((r = pa_mainloop_dispatch(m)) < 0)
 927         goto quit;
 928
 929     return r;
 930
 931 quit:
 932
 933     if ((r == -2) && retval)
 934         *retval = pa_mainloop_get_retval(m);
 935     return r;
 936 }
 937
 938 int pa_mainloop_run(pa_mainloop *m, int *retval) {
 939     int r;
 940
 941     while ((r = pa_mainloop_iterate(m, 1, retval)) >= 0);
 942
 943     if (r == -2)
 944         return 1;
 945     else if (r < 0)
 946         return -1;
 947     else
 948         return 0;
 949 }
 950
 951 void pa_mainloop_quit(pa_mainloop *m, int retval) {
 952     pa_assert(m);
 953
 954     m->quit = TRUE;
 955     m->retval = retval;
 956     pa_mainloop_wakeup(m);
 957 }
 958
 959 pa_mainloop_api* pa_mainloop_get_api(pa_mainloop*m) {
 960     pa_assert(m);
 961     return &m->api;
 962 }
 963
 964 void pa_mainloop_set_poll_func(pa_mainloop *m, pa_poll_func poll_func, void *userdata) {
 965     pa_assert(m);
 966
 967     m->poll_func = poll_func;
 968     m->poll_func_userdata = userdata;
 969 }