static pa_hook_result_t client_proplist_changed_cb(pa_core *core, pa_client *client, struct userdata *u) { pa_core_assert_ref(core); pa_assert(client); pa_assert(u); return process(u, client->proplist); }
static pa_hook_result_t sink_input_put_cb(pa_core *core, pa_sink_input *i, struct userdata *u) { pa_core_assert_ref(core); pa_sink_input_assert_ref(i); pa_assert(u); return process(u, PA_OBJECT(i), TRUE); }
static pa_hook_result_t source_output_put_cb(pa_core *core, pa_source_output *i, struct userdata *u) { pa_core_assert_ref(core); pa_source_output_assert_ref(i); pa_assert(u); return process(u, PA_OBJECT(i), FALSE); }
pa_client *pa_client_new(pa_core *core, pa_client_new_data *data) { pa_client *c; pa_core_assert_ref(core); pa_assert(data); if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_CLIENT_NEW], data) < 0) return NULL; c = pa_xnew(pa_client, 1); c->core = core; c->proplist = pa_proplist_copy(data->proplist); c->driver = pa_xstrdup(pa_path_get_filename(data->driver)); c->module = data->module; c->sink_inputs = pa_idxset_new(NULL, NULL); c->source_outputs = pa_idxset_new(NULL, NULL); c->userdata = NULL; c->kill = NULL; c->send_event = NULL; pa_assert_se(pa_idxset_put(core->clients, c, &c->index) >= 0); pa_log_info("Created %u \"%s\"", c->index, pa_strnull(pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME))); pa_subscription_post(core, PA_SUBSCRIPTION_EVENT_CLIENT|PA_SUBSCRIPTION_EVENT_NEW, c->index); pa_hook_fire(&core->hooks[PA_CORE_HOOK_CLIENT_PUT], c); pa_core_check_idle(core); return c; }
static pa_autoload_entry* entry_new(pa_core *c, const char *name) { pa_autoload_entry *e = NULL; pa_core_assert_ref(c); pa_assert(name); if (c->autoload_hashmap && (e = pa_hashmap_get(c->autoload_hashmap, name))) return NULL; e = pa_xnew(pa_autoload_entry, 1); e->core = c; e->name = pa_xstrdup(name); e->module = e->argument = NULL; e->in_action = 0; if (!c->autoload_hashmap) c->autoload_hashmap = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func); pa_assert(c->autoload_hashmap); pa_hashmap_put(c->autoload_hashmap, e->name, e); if (!c->autoload_idxset) c->autoload_idxset = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func); pa_idxset_put(c->autoload_idxset, e, &e->index); pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_AUTOLOAD|PA_SUBSCRIPTION_EVENT_NEW, e->index); return e; }
static pa_hook_result_t client_new_cb(pa_core *core, pa_client_new_data *data, struct userdata *u) { pa_core_assert_ref(core); pa_assert(data); pa_assert(u); return process(u, data->proplist); }
static pa_hook_result_t source_output_move_finish_cb(pa_core *core, pa_source_output *i, struct userdata *u) { pa_core_assert_ref(core); pa_source_output_assert_ref(i); pa_assert(u); /* module-filter-apply triggered this move, ignore */ if (pa_proplist_gets(i->proplist, PA_PROP_FILTER_APPLY_MOVING)) return PA_HOOK_OK; return process(u, PA_OBJECT(i), FALSE); }
const pa_autoload_entry* pa_autoload_get_by_index(pa_core *c, uint32_t idx) { pa_autoload_entry *e; pa_core_assert_ref(c); pa_assert(idx != PA_IDXSET_INVALID); if (!c->autoload_idxset || !(e = pa_idxset_get_by_index(c->autoload_idxset, idx))) return NULL; return e; }
const pa_autoload_entry* pa_autoload_get_by_name(pa_core *c, const char*name, pa_namereg_type_t type) { pa_autoload_entry *e; pa_core_assert_ref(c); pa_assert(name); if (!c->autoload_hashmap || !(e = pa_hashmap_get(c->autoload_hashmap, name)) || e->type != type) return NULL; return e; }
static void defer_cb(pa_mainloop_api*api, pa_defer_event *e, void *userdata) { void *state = NULL; pa_core *c = PA_CORE(userdata); pa_module *m; pa_core_assert_ref(c); api->defer_enable(e, 0); while ((m = pa_idxset_iterate(c->modules, &state, NULL))) if (m->unload_requested) pa_module_unload(c, m, TRUE); }
pa_x11_wrapper* pa_x11_wrapper_get(pa_core *c, const char *name) { char t[256]; pa_x11_wrapper *w; pa_core_assert_ref(c); pa_snprintf(t, sizeof(t), "x11-wrapper%s%s", name ? "@" : "", name ? name : ""); if ((w = pa_shared_get(c, t))) return pa_x11_wrapper_ref(w); return x11_wrapper_new(c, name, t); }
static int core_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) { pa_core *c = PA_CORE(o); pa_core_assert_ref(c); switch (code) { case PA_CORE_MESSAGE_UNLOAD_MODULE: pa_module_unload(c, userdata, true); return 0; default: return -1; } }
int pa_scache_add_directory_lazy(pa_core *c, const char *pathname) { DIR *dir; pa_core_assert_ref(c); pa_assert(pathname); /* First try to open this as directory */ if (!(dir = opendir(pathname))) { #ifdef HAVE_GLOB_H glob_t p; unsigned int i; /* If that fails, try to open it as shell glob */ if (glob(pathname, GLOB_ERR|GLOB_NOSORT, NULL, &p) < 0) { pa_log("failed to open directory '%s': %s", pathname, pa_cstrerror(errno)); return -1; } for (i = 0; i < p.gl_pathc; i++) add_file(c, p.gl_pathv[i]); globfree(&p); #else return -1; #endif } else { struct dirent *e; while ((e = readdir(dir))) { char *p; if (e->d_name[0] == '.') continue; p = pa_sprintf_malloc("%s" PA_PATH_SEP "%s", pathname, e->d_name); add_file(c, p); pa_xfree(p); } closedir(dir); } return 0; }
static void add_file(pa_core *c, const char *pathname) { struct stat st; const char *e; pa_core_assert_ref(c); pa_assert(pathname); e = pa_path_get_filename(pathname); if (stat(pathname, &st) < 0) { pa_log("stat('%s'): %s", pathname, pa_cstrerror(errno)); return; } #if defined(S_ISREG) && defined(S_ISLNK) if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) #endif pa_scache_add_file_lazy(c, e, pathname, NULL); }
static pa_hook_result_t sink_input_move_finish_cb(pa_core *core, pa_sink_input *i, struct userdata *u) { pa_core_assert_ref(core); pa_sink_input_assert_ref(i); return process(u, i, TRUE); }