code.delx.au - pulseaudio/blob - src/polyp/glib-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.h"
  33 #include "glib-mainloop.h"
  34
  35 struct pa_io_event  {
  36     pa_glib_mainloop *mainloop;
  37     int dead;
  38     GIOChannel *io_channel;
  39     GSource *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     GSource *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     GSource *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     GMainContext *glib_main_context;
  71     pa_mainloop_api api;
  72     GSource *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 = NULL;
 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 /* The callback GLIB calls whenever an IO condition is met */
 113 static gboolean io_cb(GIOChannel *source, GIOCondition condition, gpointer data) {
 114     pa_io_event *e = data;
 115     pa_io_event_flags_t f;
 116     assert(source && e && e->io_channel == source);
 117
 118     f = (condition & G_IO_IN ? PA_IO_EVENT_INPUT : 0) |
 119         (condition & G_IO_OUT ? PA_IO_EVENT_OUTPUT : 0) |
 120         (condition & G_IO_ERR ? PA_IO_EVENT_ERROR : 0) |
 121         (condition & G_IO_HUP ? PA_IO_EVENT_HANGUP : 0);
 122
 123     e->callback(&e->mainloop->api, e, e->fd, f, e->userdata);
 124     return TRUE;
 125 }
 126
 127 static void glib_io_enable(pa_io_event*e, pa_io_event_flags_t f) {
 128     GIOCondition c;
 129     assert(e && !e->dead);
 130
 131     c = (f & PA_IO_EVENT_INPUT ? G_IO_IN : 0) | (f & PA_IO_EVENT_OUTPUT ? G_IO_OUT : 0);
 132
 133     if (c == e->io_condition)
 134         return;
 135
 136     if (e->source) {
 137         g_source_destroy(e->source);
 138         g_source_unref(e->source);
 139     }
 140
 141     e->source = g_io_create_watch(e->io_channel, c | G_IO_ERR | G_IO_HUP);
 142     assert(e->source);
 143
 144     g_source_set_callback(e->source, (GSourceFunc) io_cb, e, NULL);
 145     g_source_attach(e->source, e->mainloop->glib_main_context);
 146     g_source_set_priority(e->source, G_PRIORITY_DEFAULT);
 147
 148     e->io_condition = c;
 149 }
 150
 151 static void glib_io_free(pa_io_event*e) {
 152     assert(e && !e->dead);
 153
 154     if (e->source) {
 155         g_source_destroy(e->source);
 156         g_source_unref(e->source);
 157         e->source = NULL;
 158     }
 159
 160     if (e->prev)
 161         e->prev->next = e->next;
 162     else
 163         e->mainloop->io_events = e->next;
 164
 165     if (e->next)
 166         e->next->prev = e->prev;
 167
 168     if ((e->next = e->mainloop->dead_io_events))
 169         e->next->prev = e;
 170
 171     e->mainloop->dead_io_events = e;
 172     e->prev = NULL;
 173
 174     e->dead = 1;
 175     schedule_free_dead_events(e->mainloop);
 176 }
 177
 178 static void glib_io_set_destroy(pa_io_event*e, void (*callback)(pa_mainloop_api*m, pa_io_event *e, void *userdata)) {
 179     assert(e);
 180     e->destroy_callback = callback;
 181 }
 182
 183 /* Time sources */
 184
 185 static void glib_time_restart(pa_time_event*e, const struct timeval *tv);
 186
 187 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) {
 188     pa_glib_mainloop *g;
 189     pa_time_event *e;
 190
 191     assert(m && m->userdata && tv && callback);
 192     g = m->userdata;
 193
 194     e = pa_xmalloc(sizeof(pa_time_event));
 195     e->mainloop = g;
 196     e->dead = 0;
 197     e->callback = callback;
 198     e->userdata = userdata;
 199     e->destroy_callback = NULL;
 200     e->source = NULL;
 201
 202     glib_time_restart(e, tv);
 203
 204     e->next = g->time_events;
 205     if (e->next) e->next->prev = e;
 206     g->time_events = e;
 207     e->prev = NULL;
 208
 209     return e;
 210 }
 211
 212 static guint msec_diff(const struct timeval *a, const struct timeval *b) {
 213     guint r;
 214     assert(a && b);
 215
 216     if (a->tv_sec < b->tv_sec)
 217         return 0;
 218
 219     if (a->tv_sec == b->tv_sec && a->tv_sec <= b->tv_sec)
 220         return 0;
 221
 222     r = (a->tv_sec-b->tv_sec)*1000;
 223
 224     if (a->tv_usec >= b->tv_usec)
 225         r += (a->tv_usec - b->tv_usec) / 1000;
 226     else
 227         r -= (b->tv_usec - a->tv_usec) / 1000;
 228
 229     return r;
 230 }
 231
 232 static gboolean time_cb(gpointer data) {
 233     pa_time_event* e = data;
 234     assert(e && e->mainloop && e->source);
 235
 236     g_source_unref(e->source);
 237     e->source = NULL;
 238
 239     e->callback(&e->mainloop->api, e, &e->timeval, e->userdata);
 240     return FALSE;
 241 }
 242
 243 static void glib_time_restart(pa_time_event*e, const struct timeval *tv) {
 244     struct timeval now;
 245     assert(e && e->mainloop && !e->dead);
 246
 247     pa_gettimeofday(&now);
 248     if (e->source) {
 249         g_source_destroy(e->source);
 250         g_source_unref(e->source);
 251     }
 252
 253     if (tv) {
 254         e->timeval = *tv;
 255         e->source = g_timeout_source_new(msec_diff(tv, &now));
 256         assert(e->source);
 257         g_source_set_callback(e->source, time_cb, e, NULL);
 258         g_source_set_priority(e->source, G_PRIORITY_DEFAULT);
 259         g_source_attach(e->source, e->mainloop->glib_main_context);
 260     } else
 261         e->source = NULL;
 262  }
 263
 264 static void glib_time_free(pa_time_event *e) {
 265     assert(e && e->mainloop && !e->dead);
 266
 267     if (e->source) {
 268         g_source_destroy(e->source);
 269         g_source_unref(e->source);
 270         e->source = NULL;
 271     }
 272
 273     if (e->prev)
 274         e->prev->next = e->next;
 275     else
 276         e->mainloop->time_events = e->next;
 277
 278     if (e->next)
 279         e->next->prev = e->prev;
 280
 281     if ((e->next = e->mainloop->dead_time_events))
 282         e->next->prev = e;
 283
 284     e->mainloop->dead_time_events = e;
 285     e->prev = NULL;
 286
 287     e->dead = 1;
 288     schedule_free_dead_events(e->mainloop);
 289 }
 290
 291 static void glib_time_set_destroy(pa_time_event *e, void (*callback)(pa_mainloop_api*m, pa_time_event*e, void *userdata)) {
 292     assert(e);
 293     e->destroy_callback = callback;
 294 }
 295
 296 /* Deferred sources */
 297
 298 static void glib_defer_enable(pa_defer_event *e, int b);
 299
 300 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) {
 301     pa_defer_event *e;
 302     pa_glib_mainloop *g;
 303
 304     assert(m && m->userdata && callback);
 305     g = m->userdata;
 306
 307     e = pa_xmalloc(sizeof(pa_defer_event));
 308     e->mainloop = g;
 309     e->dead = 0;
 310     e->callback = callback;
 311     e->userdata = userdata;
 312     e->destroy_callback = NULL;
 313     e->source = NULL;
 314
 315     glib_defer_enable(e, 1);
 316
 317     e->next = g->defer_events;
 318     if (e->next) e->next->prev = e;
 319     g->defer_events = e;
 320     e->prev = NULL;
 321     return e;
 322 }
 323
 324 static gboolean idle_cb(gpointer data) {
 325     pa_defer_event* e = data;
 326     assert(e && e->mainloop && e->source);
 327
 328     e->callback(&e->mainloop->api, e, e->userdata);
 329     return TRUE;
 330 }
 331
 332 static void glib_defer_enable(pa_defer_event *e, int b) {
 333     assert(e && e->mainloop);
 334
 335     if (e->source && !b) {
 336         g_source_destroy(e->source);
 337         g_source_unref(e->source);
 338         e->source = NULL;
 339     } else if (!e->source && b) {
 340         e->source = g_idle_source_new();
 341         assert(e->source);
 342         g_source_set_callback(e->source, idle_cb, e, NULL);
 343         g_source_attach(e->source, e->mainloop->glib_main_context);
 344         g_source_set_priority(e->source, G_PRIORITY_HIGH);
 345     }
 346 }
 347
 348 static void glib_defer_free(pa_defer_event *e) {
 349     assert(e && e->mainloop && !e->dead);
 350
 351     if (e->source) {
 352         g_source_destroy(e->source);
 353         g_source_unref(e->source);
 354         e->source = NULL;
 355     }
 356
 357     if (e->prev)
 358         e->prev->next = e->next;
 359     else
 360         e->mainloop->defer_events = e->next;
 361
 362     if (e->next)
 363         e->next->prev = e->prev;
 364
 365     if ((e->next = e->mainloop->dead_defer_events))
 366         e->next->prev = e;
 367
 368     e->mainloop->dead_defer_events = e;
 369     e->prev = NULL;
 370
 371     e->dead = 1;
 372     schedule_free_dead_events(e->mainloop);
 373 }
 374
 375 static void glib_defer_set_destroy(pa_defer_event *e, void (*callback)(pa_mainloop_api *m, pa_defer_event *e, void *userdata)) {
 376     assert(e);
 377     e->destroy_callback = callback;
 378 }
 379
 380 /* quit() */
 381
 382 static void glib_quit(pa_mainloop_api*a, PA_GCC_UNUSED int retval) {
 383     pa_glib_mainloop *g;
 384     assert(a && a->userdata);
 385     g = a->userdata;
 386
 387     /* NOOP */
 388 }
 389
 390 static const pa_mainloop_api vtable = {
 391     .userdata = NULL,
 392
 393     .io_new = glib_io_new,
 394     .io_enable = glib_io_enable,
 395     .io_free = glib_io_free,
 396     .io_set_destroy= glib_io_set_destroy,
 397
 398     .time_new = glib_time_new,
 399     .time_restart = glib_time_restart,
 400     .time_free = glib_time_free,
 401     .time_set_destroy = glib_time_set_destroy,
 402
 403     .defer_new = glib_defer_new,
 404     .defer_enable = glib_defer_enable,
 405     .defer_free = glib_defer_free,
 406     .defer_set_destroy = glib_defer_set_destroy,
 407
 408     .quit = glib_quit,
 409 };
 410
 411 pa_glib_mainloop *pa_glib_mainloop_new(GMainContext *c) {
 412     pa_glib_mainloop *g;
 413
 414     g = pa_xmalloc(sizeof(pa_glib_mainloop));
 415     if (c) {
 416         g->glib_main_context = c;
 417         g_main_context_ref(c);
 418     } else
 419         g->glib_main_context = g_main_context_default();
 420
 421     g->api = vtable;
 422     g->api.userdata = g;
 423
 424     g->io_events = g->dead_io_events = NULL;
 425     g->time_events = g->dead_time_events = NULL;
 426     g->defer_events = g->dead_defer_events = NULL;
 427
 428     g->cleanup_source = NULL;
 429     return g;
 430 }
 431
 432 static void free_io_events(pa_io_event *e) {
 433     while (e) {
 434         pa_io_event *r = e;
 435         e = r->next;
 436
 437         if (r->source) {
 438             g_source_destroy(r->source);
 439             g_source_unref(r->source);
 440         }
 441
 442         if (r->io_channel)
 443             g_io_channel_unref(r->io_channel);
 444
 445         if (r->destroy_callback)
 446             r->destroy_callback(&r->mainloop->api, r, r->userdata);
 447
 448         pa_xfree(r);
 449     }
 450 }
 451
 452 static void free_time_events(pa_time_event *e) {
 453     while (e) {
 454         pa_time_event *r = e;
 455         e = r->next;
 456
 457         if (r->source) {
 458             g_source_destroy(r->source);
 459             g_source_unref(r->source);
 460         }
 461
 462         if (r->destroy_callback)
 463             r->destroy_callback(&r->mainloop->api, r, r->userdata);
 464
 465         pa_xfree(r);
 466     }
 467 }
 468
 469 static void free_defer_events(pa_defer_event *e) {
 470     while (e) {
 471         pa_defer_event *r = e;
 472         e = r->next;
 473
 474         if (r->source) {
 475             g_source_destroy(r->source);
 476             g_source_unref(r->source);
 477         }
 478
 479         if (r->destroy_callback)
 480             r->destroy_callback(&r->mainloop->api, r, r->userdata);
 481
 482         pa_xfree(r);
 483     }
 484 }
 485
 486 void pa_glib_mainloop_free(pa_glib_mainloop* g) {
 487     assert(g);
 488
 489     free_io_events(g->io_events);
 490     free_io_events(g->dead_io_events);
 491     free_defer_events(g->defer_events);
 492     free_defer_events(g->dead_defer_events);
 493     free_time_events(g->time_events);
 494     free_time_events(g->dead_time_events);
 495
 496     if (g->cleanup_source) {
 497         g_source_destroy(g->cleanup_source);
 498         g_source_unref(g->cleanup_source);
 499     }
 500
 501     g_main_context_unref(g->glib_main_context);
 502     pa_xfree(g);
 503 }
 504
 505 pa_mainloop_api* pa_glib_mainloop_get_api(pa_glib_mainloop *g) {
 506     assert(g);
 507     return &g->api;
 508 }
 509
 510 static gboolean free_dead_events(gpointer p) {
 511     pa_glib_mainloop *g = p;
 512     assert(g);
 513
 514     free_io_events(g->dead_io_events);
 515     free_defer_events(g->dead_defer_events);
 516     free_time_events(g->dead_time_events);
 517
 518     g->dead_io_events = NULL;
 519     g->dead_defer_events = NULL;
 520     g->dead_time_events = NULL;
 521
 522     g_source_destroy(g->cleanup_source);
 523     g_source_unref(g->cleanup_source);
 524     g->cleanup_source = NULL;
 525
 526     return FALSE;
 527 }
 528
 529 static void schedule_free_dead_events(pa_glib_mainloop *g) {
 530     assert(g && g->glib_main_context);
 531
 532     if (g->cleanup_source)
 533         return;
 534
 535     g->cleanup_source = g_idle_source_new();
 536     assert(g->cleanup_source);
 537     g_source_set_callback(g->cleanup_source, free_dead_events, g, NULL);
 538     g_source_attach(g->cleanup_source, g->glib_main_context);
 539 }