static pa_defer_event* glib_defer_new(
pa_mainloop_api*m,
pa_defer_event_cb_t cb,
void *userdata) {
pa_defer_event *e;
pa_glib_mainloop *g;
g_assert(m);
g_assert(m->userdata);
g_assert(cb);
g = m->userdata;
e = pa_xnew(pa_defer_event, 1);
e->mainloop = g;
e->dead = 0;
e->enabled = 1;
g->n_enabled_defer_events++;
e->callback = cb;
e->userdata = userdata;
e->destroy_callback = NULL;
PA_LLIST_PREPEND(pa_defer_event, g->defer_events, e);
return e;
}
/* Add a new IO source for the specified X11 internal connection */
static pa_x11_internal* x11_internal_add(pa_x11_wrapper *w, int fd) {
pa_x11_internal *i;
pa_assert(fd >= 0);
i = pa_xnew(pa_x11_internal, 1);
i->wrapper = w;
i->io_event = w->core->mainloop->io_new(w->core->mainloop, fd, PA_IO_EVENT_INPUT, internal_io_event, w);
i->fd = fd;
PA_LLIST_PREPEND(pa_x11_internal, w->internals, i);
return i;
}
pa_x11_client* pa_x11_client_new(pa_x11_wrapper *w, pa_x11_event_cb_t event_cb, pa_x11_kill_cb_t kill_cb, void *userdata) {
pa_x11_client *c;
pa_assert(w);
pa_assert(PA_REFCNT_VALUE(w) >= 1);
c = pa_xnew(pa_x11_client, 1);
c->wrapper = w;
c->event_cb = event_cb;
c->kill_cb = kill_cb;
c->userdata = userdata;
PA_LLIST_PREPEND(pa_x11_client, w->clients, c);
return c;
}
static pa_dbus_pending* send_and_add_to_pending(pa_bluetooth_backend *backend, DBusMessage *m,
DBusPendingCallNotifyFunction func, void *call_data) {
pa_dbus_pending *p;
DBusPendingCall *call;
pa_assert(backend);
pa_assert(m);
pa_assert_se(dbus_connection_send_with_reply(pa_dbus_connection_get(backend->connection), m, &call, -1));
p = pa_dbus_pending_new(pa_dbus_connection_get(backend->connection), m, call, backend, call_data);
PA_LLIST_PREPEND(pa_dbus_pending, backend->pending, p);
dbus_pending_call_set_notify(call, func, p, NULL);
return p;
}
/* 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;
pa_assert(c);
pa_assert(m);
pa_assert(callback);
s = pa_xnew(pa_subscription, 1);
s->core = c;
s->dead = FALSE;
s->callback = callback;
s->userdata = userdata;
s->mask = m;
PA_LLIST_PREPEND(pa_subscription, c->subscriptions, s);
return s;
}
/* For receiving blocks from other nodes */
pa_memimport* pa_memimport_new(pa_mempool *p, pa_memimport_release_cb_t cb, void *userdata) {
pa_memimport *i;
pa_assert(p);
pa_assert(cb);
i = pa_xnew(pa_memimport, 1);
i->mutex = pa_mutex_new(true, true);
i->pool = p;
i->segments = pa_hashmap_new(NULL, NULL);
i->blocks = pa_hashmap_new(NULL, NULL);
i->release_cb = cb;
i->userdata = userdata;
pa_mutex_lock(p->mutex);
PA_LLIST_PREPEND(pa_memimport, p->imports, i);
pa_mutex_unlock(p->mutex);
return i;
}
static pa_time_event* glib_time_new(
pa_mainloop_api*m,
const struct timeval *tv,
pa_time_event_cb_t cb,
void *userdata) {
pa_glib_mainloop *g;
pa_time_event *e;
g_assert(m);
g_assert(m->userdata);
g_assert(cb);
g = m->userdata;
e = pa_xnew(pa_time_event, 1);
e->mainloop = g;
e->dead = 0;
if ((e->enabled = !!tv)) {
e->timeval = *tv;
g->n_enabled_time_events++;
if (g->cached_next_time_event) {
g_assert(g->cached_next_time_event->enabled);
if (pa_timeval_cmp(tv, &g->cached_next_time_event->timeval) < 0)
g->cached_next_time_event = e;
}
}
e->callback = cb;
e->userdata = userdata;
e->destroy_callback = NULL;
PA_LLIST_PREPEND(pa_time_event, g->time_events, e);
return e;
}
/* For sending blocks to other nodes */
pa_memexport* pa_memexport_new(pa_mempool *p, pa_memexport_revoke_cb_t cb, void *userdata) {
pa_memexport *e;
pa_assert(p);
pa_assert(cb);
if (!p->memory.shared)
return NULL;
e = pa_xnew(pa_memexport, 1);
e->mutex = pa_mutex_new(true, true);
e->pool = p;
PA_LLIST_HEAD_INIT(struct memexport_slot, e->free_slots);
PA_LLIST_HEAD_INIT(struct memexport_slot, e->used_slots);
e->n_init = 0;
e->revoke_cb = cb;
e->userdata = userdata;
pa_mutex_lock(p->mutex);
PA_LLIST_PREPEND(pa_memexport, p->exports, e);
pa_mutex_unlock(p->mutex);
return e;
}
static pa_io_event* glib_io_new(
pa_mainloop_api*m,
int fd,
pa_io_event_flags_t f,
pa_io_event_cb_t cb,
void *userdata) {
pa_io_event *e;
pa_glib_mainloop *g;
g_assert(m);
g_assert(m->userdata);
g_assert(fd >= 0);
g_assert(cb);
g = m->userdata;
e = pa_xnew(pa_io_event, 1);
e->mainloop = g;
e->dead = 0;
e->poll_fd.fd = fd;
e->poll_fd.events = map_flags_to_glib(f);
e->poll_fd.revents = 0;
e->callback = cb;
e->userdata = userdata;
e->destroy_callback = NULL;
PA_LLIST_PREPEND(pa_io_event, g->io_events, e);
g_source_add_poll(&g->source, &e->poll_fd);
e->poll_fd_added = 1;
return e;
}
