-/* $Id$ */
-
/***
This file is part of PulseAudio.
-
+
+ Copyright 2004-2006 Lennart Poettering
+
PulseAudio is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
- by the Free Software Foundation; either version 2 of the License,
+ by the Free Software Foundation; either version 2.1 of the License,
or (at your option) any later version.
-
+
PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
-
+
You should have received a copy of the GNU Lesser General Public License
along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
#endif
#include <stdio.h>
-#include <assert.h>
#include <pulse/xmalloc.h>
-#include <pulsecore/queue.h>
#include <pulsecore/log.h>
+#include <pulsecore/macro.h>
#include "core-subscribe.h"
struct pa_subscription {
pa_core *core;
- int dead;
+ bool dead;
pa_subscription_cb_t callback;
void *userdata;
/* Allocate a new subscription object for the given subscription mask. Use the specified callback function and user data */
pa_subscription* pa_subscription_new(pa_core *c, pa_subscription_mask_t m, pa_subscription_cb_t callback, void *userdata) {
pa_subscription *s;
-
- assert(c);
- assert(m);
- assert(callback);
+
+ pa_assert(c);
+ pa_assert(m);
+ pa_assert(callback);
s = pa_xnew(pa_subscription, 1);
s->core = c;
- s->dead = 0;
+ s->dead = false;
s->callback = callback;
s->userdata = userdata;
s->mask = m;
/* Free a subscription object, effectively marking it for deletion */
void pa_subscription_free(pa_subscription*s) {
- assert(s);
- assert(!s->dead);
-
- s->dead = 1;
+ pa_assert(s);
+ pa_assert(!s->dead);
+
+ s->dead = true;
sched_event(s->core);
}
static void free_subscription(pa_subscription *s) {
- assert(s);
- assert(s->core);
+ pa_assert(s);
+ pa_assert(s->core);
PA_LLIST_REMOVE(pa_subscription, s->core->subscriptions, s);
pa_xfree(s);
}
static void free_event(pa_subscription_event *s) {
- assert(s);
- assert(s->core);
+ pa_assert(s);
+ pa_assert(s->core);
if (!s->next)
s->core->subscription_event_last = s->prev;
-
+
PA_LLIST_REMOVE(pa_subscription_event, s->core->subscription_event_queue, s);
pa_xfree(s);
}
/* Free all subscription objects */
void pa_subscription_free_all(pa_core *c) {
- assert(c);
-
+ pa_assert(c);
+
while (c->subscriptions)
free_subscription(c->subscriptions);
[PA_SUBSCRIPTION_EVENT_REMOVE] = "REMOVE"
};
- pa_log(__FILE__": %s event (%s|%s|%u)",
+ pa_log_debug("%s event (%s|%s|%u)",
prefix,
fac_table[e->type & PA_SUBSCRIPTION_EVENT_FACILITY_MASK],
type_table[e->type & PA_SUBSCRIPTION_EVENT_TYPE_MASK],
}
#endif
-/* Deferred callback for dispatching subscirption events */
+/* Deferred callback for dispatching subscription events */
static void defer_cb(pa_mainloop_api *m, pa_defer_event *de, void *userdata) {
pa_core *c = userdata;
pa_subscription *s;
-
- assert(c->mainloop == m);
- assert(c);
- assert(c->subscription_defer_event == de);
+
+ pa_assert(c->mainloop == m);
+ pa_assert(c);
+ pa_assert(c->subscription_defer_event == de);
c->mainloop->defer_enable(c->subscription_defer_event, 0);
pa_subscription_event *e = c->subscription_event_queue;
for (s = c->subscriptions; s; s = s->next) {
-
+
if (!s->dead && pa_subscription_match_flags(s->mask, e->type))
s->callback(c, e->type, e->index, s->userdata);
}
}
/* Remove dead subscriptions */
-
+
s = c->subscriptions;
while (s) {
pa_subscription *n = s->next;
/* Schedule an mainloop event so that a pending subscription event is dispatched */
static void sched_event(pa_core *c) {
- assert(c);
+ pa_assert(c);
if (!c->subscription_defer_event) {
c->subscription_defer_event = c->mainloop->defer_new(c->mainloop, defer_cb, c);
- assert(c->subscription_defer_event);
+ pa_assert(c->subscription_defer_event);
}
-
+
c->mainloop->defer_enable(c->subscription_defer_event, 1);
}
/* Append a new subscription event to the subscription event queue and schedule a main loop event */
-void pa_subscription_post(pa_core *c, pa_subscription_event_type_t t, uint32_t index) {
+void pa_subscription_post(pa_core *c, pa_subscription_event_type_t t, uint32_t idx) {
pa_subscription_event *e;
- assert(c);
+ pa_assert(c);
- /* No need for queuing subscriptions of noone is listening */
+ /* No need for queuing subscriptions of no one is listening */
if (!c->subscriptions)
return;
-
+
if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) != PA_SUBSCRIPTION_EVENT_NEW) {
pa_subscription_event *i, *n;
-
+
/* Check for duplicates */
for (i = c->subscription_event_last; i; i = n) {
n = i->prev;
-
+
/* not the same object type */
if (((t ^ i->type) & PA_SUBSCRIPTION_EVENT_FACILITY_MASK))
continue;
-
+
/* not the same object */
- if (i->index != index)
+ if (i->index != idx)
continue;
if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
* entry in the queue. */
free_event(i);
- pa_log_debug(__FILE__": dropped redundant event.");
+ pa_log_debug("Dropped redundant event due to remove event.");
continue;
}
/* This object has changed. If a "new" or "change" event for
* this object is still in the queue we can exit. */
- pa_log_debug(__FILE__": dropped redundant event.");
+ pa_log_debug("Dropped redundant event due to change event.");
return;
}
}
e = pa_xnew(pa_subscription_event, 1);
e->core = c;
e->type = t;
- e->index = index;
+ e->index = idx;
- PA_LLIST_INSERT_AFTER(pa_subscription_event, c->subscription_event_queue, c->subscription_event_last, e);
+ PA_LLIST_INSERT_AFTER(pa_subscription_event, c->subscription_event_queue, c->subscription_event_last, e);
c->subscription_event_last = e;
#ifdef DEBUG