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