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; }