code.delx.au - pulseaudio/blob - src/polyp/glib12-mainloop.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of polypaudio.
   5
   6   polypaudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   polypaudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with polypaudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <assert.h>
  27
  28 #include <polypcore/idxset.h>
  29 #include <polypcore/xmalloc.h>
  30 #include <polypcore/util.h>
  31
  32 #include "glib-mainloop.h"
  33
  34 /* A mainloop implementation based on GLIB 1.2 */
  35
  36 struct pa_io_event {
  37     pa_glib_mainloop *mainloop;
  38     int dead;
  39     GIOChannel *io_channel;
  40     guint source;
  41     GIOCondition io_condition;
  42     int fd;
  43     void (*callback) (pa_mainloop_api*m, pa_io_event *e, int fd, pa_io_event_flags_t f, void *userdata);
  44     void *userdata;
  45     void (*destroy_callback) (pa_mainloop_api *m, pa_io_event*e, void *userdata);
  46     pa_io_event *next, *prev;
  47 };
  48
  49 struct pa_time_event {
  50     pa_glib_mainloop *mainloop;
  51     int dead;
  52     guint source;
  53     struct timeval timeval;
  54     void (*callback) (pa_mainloop_api*m, pa_time_event *e, const struct timeval *tv, void *userdata);
  55     void *userdata;
  56     void (*destroy_callback) (pa_mainloop_api *m, pa_time_event*e, void *userdata);
  57     pa_time_event *next, *prev;
  58 };
  59
  60 struct pa_defer_event {
  61     pa_glib_mainloop *mainloop;
  62     int dead;
  63     guint source;
  64     void (*callback) (pa_mainloop_api*m, pa_defer_event *e, void *userdata);
  65     void *userdata;
  66     void (*destroy_callback) (pa_mainloop_api *m, pa_defer_event*e, void *userdata);
  67     pa_defer_event *next, *prev;
  68 };
  69
  70 struct pa_glib_mainloop {
  71     pa_mainloop_api api;
  72     guint cleanup_source;
  73     pa_io_event *io_events, *dead_io_events;
  74     pa_time_event *time_events, *dead_time_events;
  75     pa_defer_event *defer_events, *dead_defer_events;
  76 };
  77
  78 static void schedule_free_dead_events(pa_glib_mainloop *g);
  79
  80 static void glib_io_enable(pa_io_event*e, pa_io_event_flags_t f);
  81
  82 static pa_io_event* glib_io_new(pa_mainloop_api*m, int fd, pa_io_event_flags_t f, void (*callback) (pa_mainloop_api*m, pa_io_event*e, int fd, pa_io_event_flags_t f, void *userdata), void *userdata) {
  83     pa_io_event *e;
  84     pa_glib_mainloop *g;
  85
  86     assert(m && m->userdata && fd >= 0 && callback);
  87     g = m->userdata;
  88
  89     e = pa_xmalloc(sizeof(pa_io_event));
  90     e->mainloop = m->userdata;
  91     e->dead = 0;
  92     e->fd = fd;
  93     e->callback = callback;
  94     e->userdata = userdata;
  95     e->destroy_callback = NULL;
  96
  97     e->io_channel = g_io_channel_unix_new(e->fd);
  98     assert(e->io_channel);
  99     e->source = (guint) -1;
 100     e->io_condition = 0;
 101
 102     glib_io_enable(e, f);
 103
 104     e->next = g->io_events;
 105     if (e->next) e->next->prev = e;
 106     g->io_events = e;
 107     e->prev = NULL;
 108
 109     return e;
 110 }
 111
 112 static gboolean io_cb(GIOChannel *source, GIOCondition condition, gpointer data) {
 113     pa_io_event *e = data;
 114     pa_io_event_flags_t f;
 115     assert(source && e && e->io_channel == source);
 116
 117     f = (condition & G_IO_IN ? PA_IO_EVENT_INPUT : 0) |
 118         (condition & G_IO_OUT ? PA_IO_EVENT_OUTPUT : 0) |
 119         (condition & G_IO_ERR ? PA_IO_EVENT_ERROR : 0) |
 120         (condition & G_IO_HUP ? PA_IO_EVENT_HANGUP : 0);
 121
 122     e->callback(&e->mainloop->api, e, e->fd, f, e->userdata);
 123     return TRUE;
 124 }
 125
 126 static void glib_io_enable(pa_io_event*e, pa_io_event_flags_t f) {
 127     GIOCondition c;
 128     assert(e && !e->dead);
 129
 130     c = (f & PA_IO_EVENT_INPUT ? G_IO_IN : 0) | (f & PA_IO_EVENT_OUTPUT ? G_IO_OUT : 0);
 131
 132     if (c == e->io_condition)
 133         return;
 134
 135     if (e->source != (guint) -1)
 136         g_source_remove(e->source);
 137
 138     e->source = g_io_add_watch_full(e->io_channel, G_PRIORITY_DEFAULT, c | G_IO_ERR | G_IO_HUP, io_cb, e, NULL);
 139     assert(e->source != (guint) -1);
 140     e->io_condition = c;
 141 }
 142
 143 static void glib_io_free(pa_io_event*e) {
 144     assert(e && !e->dead);
 145
 146     if (e->source != (guint) -1) {
 147         g_source_remove(e->source);
 148         e->source = (guint) -1;
 149     }
 150
 151     if (e->prev)
 152         e->prev->next = e->next;
 153     else
 154         e->mainloop->io_events = e->next;
 155
 156     if (e->next)
 157         e->next->prev = e->prev;
 158
 159     if ((e->next = e->mainloop->dead_io_events))
 160         e->next->prev = e;
 161
 162     e->mainloop->dead_io_events = e;
 163     e->prev = NULL;
 164
 165     e->dead = 1;
 166     schedule_free_dead_events(e->mainloop);
 167 }
 168
 169 static void glib_io_set_destroy(pa_io_event*e, void (*callback)(pa_mainloop_api*m, pa_io_event *e, void *userdata)) {
 170     assert(e);
 171     e->destroy_callback = callback;
 172 }
 173
 174 /* Time sources */
 175
 176 static void glib_time_restart(pa_time_event*e, const struct timeval *tv);
 177
 178 static pa_time_event* glib_time_new(pa_mainloop_api*m, const struct timeval *tv, void (*callback) (pa_mainloop_api*m, pa_time_event*e, const struct timeval *tv, void *userdata), void *userdata) {
 179     pa_glib_mainloop *g;
 180     pa_time_event *e;
 181
 182     assert(m && m->userdata && tv && callback);
 183     g = m->userdata;
 184
 185     e = pa_xmalloc(sizeof(pa_time_event));
 186     e->mainloop = g;
 187     e->dead = 0;
 188     e->callback = callback;
 189     e->userdata = userdata;
 190     e->destroy_callback = NULL;
 191     e->source = (guint) -1;
 192
 193     glib_time_restart(e, tv);
 194
 195     e->next = g->time_events;
 196     if (e->next) e->next->prev = e;
 197     g->time_events = e;
 198     e->prev = NULL;
 199
 200     return e;
 201 }
 202
 203 static guint msec_diff(const struct timeval *a, const struct timeval *b) {
 204     guint r;
 205     assert(a && b);
 206
 207     if (a->tv_sec < b->tv_sec)
 208         return 0;
 209
 210     if (a->tv_sec == b->tv_sec && a->tv_sec <= b->tv_sec)
 211         return 0;
 212
 213     r = (a->tv_sec-b->tv_sec)*1000;
 214
 215     if (a->tv_usec >= b->tv_usec)
 216         r += (a->tv_usec - b->tv_usec) / 1000;
 217     else
 218         r -= (b->tv_usec - a->tv_usec) / 1000;
 219
 220     return r;
 221 }
 222
 223 static gboolean time_cb(gpointer data) {
 224     pa_time_event* e = data;
 225     assert(e && e->mainloop && e->source != (guint) -1);
 226
 227     g_source_remove(e->source);
 228     e->source = (guint) -1;
 229
 230     e->callback(&e->mainloop->api, e, &e->timeval, e->userdata);
 231     return FALSE;
 232 }
 233
 234 static void glib_time_restart(pa_time_event*e, const struct timeval *tv) {
 235     struct timeval now;
 236     assert(e && e->mainloop && !e->dead);
 237
 238     pa_gettimeofday(&now);
 239     if (e->source != (guint) -1)
 240         g_source_remove(e->source);
 241
 242     if (tv) {
 243         e->timeval = *tv;
 244         e->source = g_timeout_add_full(G_PRIORITY_DEFAULT, msec_diff(tv, &now), time_cb, e, NULL);
 245         assert(e->source != (guint) -1);
 246     } else
 247         e->source = (guint) -1;
 248  }
 249
 250 static void glib_time_free(pa_time_event *e) {
 251     assert(e && e->mainloop && !e->dead);
 252
 253     if (e->source != (guint) -1) {
 254         g_source_remove(e->source);
 255         e->source = (guint) -1;
 256     }
 257
 258     if (e->prev)
 259         e->prev->next = e->next;
 260     else
 261         e->mainloop->time_events = e->next;
 262
 263     if (e->next)
 264         e->next->prev = e->prev;
 265
 266     if ((e->next = e->mainloop->dead_time_events))
 267         e->next->prev = e;
 268
 269     e->mainloop->dead_time_events = e;
 270     e->prev = NULL;
 271
 272     e->dead = 1;
 273     schedule_free_dead_events(e->mainloop);
 274 }
 275
 276 static void glib_time_set_destroy(pa_time_event *e, void (*callback)(pa_mainloop_api*m, pa_time_event*e, void *userdata)) {
 277     assert(e);
 278     e->destroy_callback = callback;
 279 }
 280
 281 /* Deferred sources */
 282
 283 static void glib_defer_enable(pa_defer_event *e, int b);
 284
 285 static pa_defer_event* glib_defer_new(pa_mainloop_api*m, void (*callback) (pa_mainloop_api*m, pa_defer_event *e, void *userdata), void *userdata) {
 286     pa_defer_event *e;
 287     pa_glib_mainloop *g;
 288
 289     assert(m && m->userdata && callback);
 290     g = m->userdata;
 291
 292     e = pa_xmalloc(sizeof(pa_defer_event));
 293     e->mainloop = g;
 294     e->dead = 0;
 295     e->callback = callback;
 296     e->userdata = userdata;
 297     e->destroy_callback = NULL;
 298     e->source = (guint) -1;
 299
 300     glib_defer_enable(e, 1);
 301
 302     e->next = g->defer_events;
 303     if (e->next) e->next->prev = e;
 304     g->defer_events = e;
 305     e->prev = NULL;
 306     return e;
 307 }
 308
 309 static gboolean idle_cb(gpointer data) {
 310     pa_defer_event* e = data;
 311     assert(e && e->mainloop && e->source != (guint) -1);
 312
 313     e->callback(&e->mainloop->api, e, e->userdata);
 314     return TRUE;
 315 }
 316
 317 static void glib_defer_enable(pa_defer_event *e, int b) {
 318     assert(e && e->mainloop);
 319
 320     if (e->source != (guint) -1 && !b) {
 321         g_source_remove(e->source);
 322         e->source = (guint) -1;
 323     } else if (e->source == (guint) -1 && b) {
 324         e->source = g_idle_add_full(G_PRIORITY_HIGH, idle_cb, e, NULL);
 325         assert(e->source != (guint) -1);
 326     }
 327 }
 328
 329 static void glib_defer_free(pa_defer_event *e) {
 330     assert(e && e->mainloop && !e->dead);
 331
 332     if (e->source != (guint) -1) {
 333         g_source_remove(e->source);
 334         e->source = (guint) -1;
 335     }
 336
 337     if (e->prev)
 338         e->prev->next = e->next;
 339     else
 340         e->mainloop->defer_events = e->next;
 341
 342     if (e->next)
 343         e->next->prev = e->prev;
 344
 345     if ((e->next = e->mainloop->dead_defer_events))
 346         e->next->prev = e;
 347
 348     e->mainloop->dead_defer_events = e;
 349     e->prev = NULL;
 350
 351     e->dead = 1;
 352     schedule_free_dead_events(e->mainloop);
 353 }
 354
 355 static void glib_defer_set_destroy(pa_defer_event *e, void (*callback)(pa_mainloop_api *m, pa_defer_event *e, void *userdata)) {
 356     assert(e);
 357     e->destroy_callback = callback;
 358 }
 359
 360 /* quit() */
 361
 362 static void glib_quit(pa_mainloop_api*a, PA_GCC_UNUSED int retval) {
 363     pa_glib_mainloop *g;
 364     assert(a && a->userdata);
 365     g = a->userdata;
 366
 367     /* NOOP */
 368 }
 369
 370 static const pa_mainloop_api vtable = {
 371     .userdata = NULL,
 372
 373     .io_new = glib_io_new,
 374     .io_enable = glib_io_enable,
 375     .io_free = glib_io_free,
 376     .io_set_destroy= glib_io_set_destroy,
 377
 378     .time_new = glib_time_new,
 379     .time_restart = glib_time_restart,
 380     .time_free = glib_time_free,
 381     .time_set_destroy = glib_time_set_destroy,
 382
 383     .defer_new = glib_defer_new,
 384     .defer_enable = glib_defer_enable,
 385     .defer_free = glib_defer_free,
 386     .defer_set_destroy = glib_defer_set_destroy,
 387
 388     .quit = glib_quit,
 389 };
 390
 391 pa_glib_mainloop *pa_glib_mainloop_new(void) {
 392     pa_glib_mainloop *g;
 393
 394     g = pa_xmalloc(sizeof(pa_glib_mainloop));
 395
 396     g->api = vtable;
 397     g->api.userdata = g;
 398
 399     g->io_events = g->dead_io_events = NULL;
 400     g->time_events = g->dead_time_events = NULL;
 401     g->defer_events = g->dead_defer_events = NULL;
 402
 403     g->cleanup_source = (guint) -1;
 404     return g;
 405 }
 406
 407 static void free_io_events(pa_io_event *e) {
 408     while (e) {
 409         pa_io_event *r = e;
 410         e = r->next;
 411
 412         if (r->source != (guint) -1)
 413             g_source_remove(r->source);
 414
 415         if (r->io_channel)
 416             g_io_channel_unref(r->io_channel);
 417
 418         if (r->destroy_callback)
 419             r->destroy_callback(&r->mainloop->api, r, r->userdata);
 420
 421         pa_xfree(r);
 422     }
 423 }
 424
 425 static void free_time_events(pa_time_event *e) {
 426     while (e) {
 427         pa_time_event *r = e;
 428         e = r->next;
 429
 430         if (r->source != (guint) -1)
 431             g_source_remove(r->source);
 432
 433         if (r->destroy_callback)
 434             r->destroy_callback(&r->mainloop->api, r, r->userdata);
 435
 436         pa_xfree(r);
 437     }
 438 }
 439
 440 static void free_defer_events(pa_defer_event *e) {
 441     while (e) {
 442         pa_defer_event *r = e;
 443         e = r->next;
 444
 445         if (r->source != (guint) -1)
 446             g_source_remove(r->source);
 447
 448         if (r->destroy_callback)
 449             r->destroy_callback(&r->mainloop->api, r, r->userdata);
 450
 451         pa_xfree(r);
 452     }
 453 }
 454
 455 void pa_glib_mainloop_free(pa_glib_mainloop* g) {
 456     assert(g);
 457
 458     free_io_events(g->io_events);
 459     free_io_events(g->dead_io_events);
 460     free_defer_events(g->defer_events);
 461     free_defer_events(g->dead_defer_events);
 462     free_time_events(g->time_events);
 463     free_time_events(g->dead_time_events);
 464
 465     if (g->cleanup_source != (guint) -1)
 466         g_source_remove(g->cleanup_source);
 467
 468     pa_xfree(g);
 469 }
 470
 471 pa_mainloop_api* pa_glib_mainloop_get_api(pa_glib_mainloop *g) {
 472     assert(g);
 473     return &g->api;
 474 }
 475
 476 static gboolean free_dead_events(gpointer p) {
 477     pa_glib_mainloop *g = p;
 478     assert(g);
 479
 480     free_io_events(g->dead_io_events);
 481     free_defer_events(g->dead_defer_events);
 482     free_time_events(g->dead_time_events);
 483
 484     g->dead_io_events = NULL;
 485     g->dead_defer_events = NULL;
 486     g->dead_time_events = NULL;
 487
 488     g_source_remove(g->cleanup_source);
 489     g->cleanup_source = (guint) -1;
 490
 491     return FALSE;
 492 }
 493
 494 static void schedule_free_dead_events(pa_glib_mainloop *g) {
 495     assert(g);
 496
 497     if (g->cleanup_source != (guint) -1)
 498         return;
 499
 500     g->cleanup_source = g_idle_add_full(G_PRIORITY_HIGH, free_dead_events, g, NULL);
 501 }