4 This file is part of polypaudio.
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.
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.
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
28 #include <polyp/xmalloc.h>
29 #include <polyp/timeval.h>
31 #include <polypcore/idxset.h>
32 #include <polypcore/core-util.h>
35 #include "glib-mainloop.h"
38 pa_glib_mainloop
*mainloop
;
40 GIOChannel
*io_channel
;
42 GIOCondition io_condition
;
44 void (*callback
) (pa_mainloop_api
*m
, pa_io_event
*e
, int fd
, pa_io_event_flags_t f
, void *userdata
);
46 void (*destroy_callback
) (pa_mainloop_api
*m
, pa_io_event
*e
, void *userdata
);
47 pa_io_event
*next
, *prev
;
50 struct pa_time_event
{
51 pa_glib_mainloop
*mainloop
;
54 struct timeval timeval
;
55 void (*callback
) (pa_mainloop_api
*m
, pa_time_event
*e
, const struct timeval
*tv
, void *userdata
);
57 void (*destroy_callback
) (pa_mainloop_api
*m
, pa_time_event
*e
, void *userdata
);
58 pa_time_event
*next
, *prev
;
61 struct pa_defer_event
{
62 pa_glib_mainloop
*mainloop
;
65 void (*callback
) (pa_mainloop_api
*m
, pa_defer_event
*e
, void *userdata
);
67 void (*destroy_callback
) (pa_mainloop_api
*m
, pa_defer_event
*e
, void *userdata
);
68 pa_defer_event
*next
, *prev
;
71 struct pa_glib_mainloop
{
72 GMainContext
*glib_main_context
;
74 GSource
*cleanup_source
;
75 pa_io_event
*io_events
, *dead_io_events
;
76 pa_time_event
*time_events
, *dead_time_events
;
77 pa_defer_event
*defer_events
, *dead_defer_events
;
80 static void schedule_free_dead_events(pa_glib_mainloop
*g
);
82 static void glib_io_enable(pa_io_event
*e
, pa_io_event_flags_t f
);
84 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
) {
88 assert(m
&& m
->userdata
&& fd
>= 0 && callback
);
91 e
= pa_xmalloc(sizeof(pa_io_event
));
92 e
->mainloop
= m
->userdata
;
95 e
->callback
= callback
;
96 e
->userdata
= userdata
;
97 e
->destroy_callback
= NULL
;
99 e
->io_channel
= g_io_channel_unix_new(e
->fd
);
100 assert(e
->io_channel
);
104 glib_io_enable(e
, f
);
106 e
->next
= g
->io_events
;
107 if (e
->next
) e
->next
->prev
= e
;
114 /* The callback GLIB calls whenever an IO condition is met */
115 static gboolean
io_cb(GIOChannel
*source
, GIOCondition condition
, gpointer data
) {
116 pa_io_event
*e
= data
;
117 pa_io_event_flags_t f
;
118 assert(source
&& e
&& e
->io_channel
== source
);
120 f
= (condition
& G_IO_IN
? PA_IO_EVENT_INPUT
: 0) |
121 (condition
& G_IO_OUT
? PA_IO_EVENT_OUTPUT
: 0) |
122 (condition
& G_IO_ERR
? PA_IO_EVENT_ERROR
: 0) |
123 (condition
& G_IO_HUP
? PA_IO_EVENT_HANGUP
: 0);
125 e
->callback(&e
->mainloop
->api
, e
, e
->fd
, f
, e
->userdata
);
129 static void glib_io_enable(pa_io_event
*e
, pa_io_event_flags_t f
) {
131 assert(e
&& !e
->dead
);
133 c
= (f
& PA_IO_EVENT_INPUT
? G_IO_IN
: 0) | (f
& PA_IO_EVENT_OUTPUT
? G_IO_OUT
: 0);
135 if (c
== e
->io_condition
)
139 g_source_destroy(e
->source
);
140 g_source_unref(e
->source
);
143 e
->source
= g_io_create_watch(e
->io_channel
, c
| G_IO_ERR
| G_IO_HUP
);
146 g_source_set_callback(e
->source
, (GSourceFunc
) io_cb
, e
, NULL
);
147 g_source_attach(e
->source
, e
->mainloop
->glib_main_context
);
148 g_source_set_priority(e
->source
, G_PRIORITY_DEFAULT
);
153 static void glib_io_free(pa_io_event
*e
) {
154 assert(e
&& !e
->dead
);
157 g_source_destroy(e
->source
);
158 g_source_unref(e
->source
);
163 e
->prev
->next
= e
->next
;
165 e
->mainloop
->io_events
= e
->next
;
168 e
->next
->prev
= e
->prev
;
170 if ((e
->next
= e
->mainloop
->dead_io_events
))
173 e
->mainloop
->dead_io_events
= e
;
177 schedule_free_dead_events(e
->mainloop
);
180 static void glib_io_set_destroy(pa_io_event
*e
, void (*callback
)(pa_mainloop_api
*m
, pa_io_event
*e
, void *userdata
)) {
182 e
->destroy_callback
= callback
;
187 static void glib_time_restart(pa_time_event
*e
, const struct timeval
*tv
);
189 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
) {
193 assert(m
&& m
->userdata
&& tv
&& callback
);
196 e
= pa_xmalloc(sizeof(pa_time_event
));
199 e
->callback
= callback
;
200 e
->userdata
= userdata
;
201 e
->destroy_callback
= NULL
;
204 glib_time_restart(e
, tv
);
206 e
->next
= g
->time_events
;
207 if (e
->next
) e
->next
->prev
= e
;
214 static guint
msec_diff(const struct timeval
*a
, const struct timeval
*b
) {
218 if (a
->tv_sec
< b
->tv_sec
)
221 if (a
->tv_sec
== b
->tv_sec
&& a
->tv_sec
<= b
->tv_sec
)
224 r
= (a
->tv_sec
-b
->tv_sec
)*1000;
226 if (a
->tv_usec
>= b
->tv_usec
)
227 r
+= (a
->tv_usec
- b
->tv_usec
) / 1000;
229 r
-= (b
->tv_usec
- a
->tv_usec
) / 1000;
234 static gboolean
time_cb(gpointer data
) {
235 pa_time_event
* e
= data
;
236 assert(e
&& e
->mainloop
&& e
->source
);
238 g_source_unref(e
->source
);
241 e
->callback(&e
->mainloop
->api
, e
, &e
->timeval
, e
->userdata
);
245 static void glib_time_restart(pa_time_event
*e
, const struct timeval
*tv
) {
247 assert(e
&& e
->mainloop
&& !e
->dead
);
249 pa_gettimeofday(&now
);
251 g_source_destroy(e
->source
);
252 g_source_unref(e
->source
);
257 e
->source
= g_timeout_source_new(msec_diff(tv
, &now
));
259 g_source_set_callback(e
->source
, time_cb
, e
, NULL
);
260 g_source_set_priority(e
->source
, G_PRIORITY_DEFAULT
);
261 g_source_attach(e
->source
, e
->mainloop
->glib_main_context
);
266 static void glib_time_free(pa_time_event
*e
) {
267 assert(e
&& e
->mainloop
&& !e
->dead
);
270 g_source_destroy(e
->source
);
271 g_source_unref(e
->source
);
276 e
->prev
->next
= e
->next
;
278 e
->mainloop
->time_events
= e
->next
;
281 e
->next
->prev
= e
->prev
;
283 if ((e
->next
= e
->mainloop
->dead_time_events
))
286 e
->mainloop
->dead_time_events
= e
;
290 schedule_free_dead_events(e
->mainloop
);
293 static void glib_time_set_destroy(pa_time_event
*e
, void (*callback
)(pa_mainloop_api
*m
, pa_time_event
*e
, void *userdata
)) {
295 e
->destroy_callback
= callback
;
298 /* Deferred sources */
300 static void glib_defer_enable(pa_defer_event
*e
, int b
);
302 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
) {
306 assert(m
&& m
->userdata
&& callback
);
309 e
= pa_xmalloc(sizeof(pa_defer_event
));
312 e
->callback
= callback
;
313 e
->userdata
= userdata
;
314 e
->destroy_callback
= NULL
;
317 glib_defer_enable(e
, 1);
319 e
->next
= g
->defer_events
;
320 if (e
->next
) e
->next
->prev
= e
;
326 static gboolean
idle_cb(gpointer data
) {
327 pa_defer_event
* e
= data
;
328 assert(e
&& e
->mainloop
&& e
->source
);
330 e
->callback(&e
->mainloop
->api
, e
, e
->userdata
);
334 static void glib_defer_enable(pa_defer_event
*e
, int b
) {
335 assert(e
&& e
->mainloop
);
337 if (e
->source
&& !b
) {
338 g_source_destroy(e
->source
);
339 g_source_unref(e
->source
);
341 } else if (!e
->source
&& b
) {
342 e
->source
= g_idle_source_new();
344 g_source_set_callback(e
->source
, idle_cb
, e
, NULL
);
345 g_source_attach(e
->source
, e
->mainloop
->glib_main_context
);
346 g_source_set_priority(e
->source
, G_PRIORITY_HIGH
);
350 static void glib_defer_free(pa_defer_event
*e
) {
351 assert(e
&& e
->mainloop
&& !e
->dead
);
354 g_source_destroy(e
->source
);
355 g_source_unref(e
->source
);
360 e
->prev
->next
= e
->next
;
362 e
->mainloop
->defer_events
= e
->next
;
365 e
->next
->prev
= e
->prev
;
367 if ((e
->next
= e
->mainloop
->dead_defer_events
))
370 e
->mainloop
->dead_defer_events
= e
;
374 schedule_free_dead_events(e
->mainloop
);
377 static void glib_defer_set_destroy(pa_defer_event
*e
, void (*callback
)(pa_mainloop_api
*m
, pa_defer_event
*e
, void *userdata
)) {
379 e
->destroy_callback
= callback
;
384 static void glib_quit(pa_mainloop_api
*a
, PA_GCC_UNUSED
int retval
) {
386 assert(a
&& a
->userdata
);
392 static const pa_mainloop_api vtable
= {
395 .io_new
= glib_io_new
,
396 .io_enable
= glib_io_enable
,
397 .io_free
= glib_io_free
,
398 .io_set_destroy
= glib_io_set_destroy
,
400 .time_new
= glib_time_new
,
401 .time_restart
= glib_time_restart
,
402 .time_free
= glib_time_free
,
403 .time_set_destroy
= glib_time_set_destroy
,
405 .defer_new
= glib_defer_new
,
406 .defer_enable
= glib_defer_enable
,
407 .defer_free
= glib_defer_free
,
408 .defer_set_destroy
= glib_defer_set_destroy
,
413 pa_glib_mainloop
*pa_glib_mainloop_new(GMainContext
*c
) {
416 g
= pa_xmalloc(sizeof(pa_glib_mainloop
));
418 g
->glib_main_context
= c
;
419 g_main_context_ref(c
);
421 g
->glib_main_context
= g_main_context_default();
426 g
->io_events
= g
->dead_io_events
= NULL
;
427 g
->time_events
= g
->dead_time_events
= NULL
;
428 g
->defer_events
= g
->dead_defer_events
= NULL
;
430 g
->cleanup_source
= NULL
;
434 static void free_io_events(pa_io_event
*e
) {
440 g_source_destroy(r
->source
);
441 g_source_unref(r
->source
);
445 g_io_channel_unref(r
->io_channel
);
447 if (r
->destroy_callback
)
448 r
->destroy_callback(&r
->mainloop
->api
, r
, r
->userdata
);
454 static void free_time_events(pa_time_event
*e
) {
456 pa_time_event
*r
= e
;
460 g_source_destroy(r
->source
);
461 g_source_unref(r
->source
);
464 if (r
->destroy_callback
)
465 r
->destroy_callback(&r
->mainloop
->api
, r
, r
->userdata
);
471 static void free_defer_events(pa_defer_event
*e
) {
473 pa_defer_event
*r
= e
;
477 g_source_destroy(r
->source
);
478 g_source_unref(r
->source
);
481 if (r
->destroy_callback
)
482 r
->destroy_callback(&r
->mainloop
->api
, r
, r
->userdata
);
488 void pa_glib_mainloop_free(pa_glib_mainloop
* g
) {
491 free_io_events(g
->io_events
);
492 free_io_events(g
->dead_io_events
);
493 free_defer_events(g
->defer_events
);
494 free_defer_events(g
->dead_defer_events
);
495 free_time_events(g
->time_events
);
496 free_time_events(g
->dead_time_events
);
498 if (g
->cleanup_source
) {
499 g_source_destroy(g
->cleanup_source
);
500 g_source_unref(g
->cleanup_source
);
503 g_main_context_unref(g
->glib_main_context
);
507 pa_mainloop_api
* pa_glib_mainloop_get_api(pa_glib_mainloop
*g
) {
512 static gboolean
free_dead_events(gpointer p
) {
513 pa_glib_mainloop
*g
= p
;
516 free_io_events(g
->dead_io_events
);
517 free_defer_events(g
->dead_defer_events
);
518 free_time_events(g
->dead_time_events
);
520 g
->dead_io_events
= NULL
;
521 g
->dead_defer_events
= NULL
;
522 g
->dead_time_events
= NULL
;
524 g_source_destroy(g
->cleanup_source
);
525 g_source_unref(g
->cleanup_source
);
526 g
->cleanup_source
= NULL
;
531 static void schedule_free_dead_events(pa_glib_mainloop
*g
) {
532 assert(g
&& g
->glib_main_context
);
534 if (g
->cleanup_source
)
537 g
->cleanup_source
= g_idle_source_new();
538 assert(g
->cleanup_source
);
539 g_source_set_callback(g
->cleanup_source
, free_dead_events
, g
, NULL
);
540 g_source_attach(g
->cleanup_source
, g
->glib_main_context
);