mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-11-03 09:01:54 -05:00
pipewire: only load spa_handle
Only provide a method to load a spa_handle, getting the interface from that is easy and we only use refcounting on the handle.
This commit is contained in:
Wim Taymans
parent
da9f0ed160
commit
b195a25636
5 changed files with 86 additions and 128 deletions
|
|
@ -91,6 +91,7 @@ struct impl {
|
|||
enum spa_direction direction;
|
||||
|
||||
struct spa_node *cnode;
|
||||
struct spa_handle *handle;
|
||||
struct spa_node *adapter;
|
||||
struct spa_hook adapter_listener;
|
||||
struct spa_node *adapter_mix;
|
||||
|
|
@ -1055,6 +1056,7 @@ static void client_node_initialized(void *data)
|
|||
media_subtype == SPA_MEDIA_SUBTYPE_raw) {
|
||||
struct spa_dict_item items[2];
|
||||
const char *mode;
|
||||
void *iface;
|
||||
|
||||
if (impl->direction == SPA_DIRECTION_OUTPUT)
|
||||
mode = "split";
|
||||
|
|
@ -1064,13 +1066,18 @@ static void client_node_initialized(void *data)
|
|||
items[0] = SPA_DICT_ITEM_INIT("factory.mode", mode);
|
||||
items[1] = SPA_DICT_ITEM_INIT("resample.peaks", monitor ? "1" : "0");
|
||||
|
||||
if ((impl->adapter = pw_load_spa_interface("audioconvert/libspa-audioconvert",
|
||||
|
||||
if ((impl->handle = pw_load_spa_handle("audioconvert/libspa-audioconvert",
|
||||
"audioconvert",
|
||||
SPA_TYPE_INTERFACE_Node,
|
||||
&SPA_DICT_INIT(items, 2),
|
||||
0, NULL)) == NULL)
|
||||
return;
|
||||
|
||||
if ((res = spa_handle_get_interface(impl->handle,
|
||||
SPA_TYPE_INTERFACE_Node, &iface)) < 0)
|
||||
return;
|
||||
|
||||
impl->adapter = iface;
|
||||
impl->adapter_mix = impl->adapter;
|
||||
impl->adapter_mix_port = 0;
|
||||
impl->use_converter = true;
|
||||
|
|
@ -1118,8 +1125,8 @@ static void cleanup(struct impl *impl)
|
|||
{
|
||||
pw_log_debug("client-stream %p: cleanup", &impl->this);
|
||||
if (impl->use_converter) {
|
||||
if (impl->adapter)
|
||||
pw_unload_spa_interface(impl->adapter);
|
||||
if (impl->handle)
|
||||
pw_unload_spa_handle(impl->handle);
|
||||
}
|
||||
|
||||
free(impl->buffers);
|
||||
|
|
|
|||
|
|
@ -68,12 +68,8 @@ static void device_destroy(void *data)
|
|||
pw_log_debug("spa-device %p: free", device);
|
||||
|
||||
spa_hook_remove(&impl->device_listener);
|
||||
if (impl->unload)
|
||||
pw_unload_spa_interface(impl->unload);
|
||||
if (impl->handle) {
|
||||
spa_handle_clear(impl->handle);
|
||||
free(impl->handle);
|
||||
}
|
||||
if (impl->handle)
|
||||
pw_unload_spa_handle(impl->handle);
|
||||
free(impl->lib);
|
||||
free(impl->factory_name);
|
||||
}
|
||||
|
|
@ -106,6 +102,7 @@ pw_spa_device_new(struct pw_core *core,
|
|||
impl->owner = owner;
|
||||
impl->parent = parent;
|
||||
impl->device = device;
|
||||
impl->handle = handle;
|
||||
impl->flags = flags;
|
||||
|
||||
if (user_data_size > 0)
|
||||
|
|
@ -138,22 +135,28 @@ struct pw_device *pw_spa_device_load(struct pw_core *core,
|
|||
{
|
||||
struct pw_device *this;
|
||||
struct impl *impl;
|
||||
struct spa_device *device;
|
||||
struct spa_handle *handle;
|
||||
const struct spa_support *support;
|
||||
uint32_t n_support;
|
||||
void *iface;
|
||||
int res;
|
||||
|
||||
support = pw_core_get_support(core, &n_support);
|
||||
|
||||
device = pw_load_spa_interface(lib, factory_name, SPA_TYPE_INTERFACE_Device,
|
||||
handle = pw_load_spa_handle(lib, factory_name,
|
||||
properties ? &properties->dict : NULL, n_support, support);
|
||||
if (device == NULL)
|
||||
if (handle == NULL)
|
||||
goto open_failed;
|
||||
|
||||
if ((res = spa_handle_get_interface(handle, SPA_TYPE_INTERFACE_Device, &iface)) < 0) {
|
||||
pw_log_error("can't get device interface %d\n", res);
|
||||
goto open_failed;
|
||||
}
|
||||
|
||||
this = pw_spa_device_new(core, owner, parent, name, flags,
|
||||
device, NULL, properties, user_data_size);
|
||||
iface, handle, properties, user_data_size);
|
||||
|
||||
impl = this->user_data;
|
||||
impl->unload = device;
|
||||
impl->lib = strdup(lib);
|
||||
impl->factory_name = strdup(factory_name);
|
||||
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@
|
|||
/** \cond */
|
||||
struct impl {
|
||||
struct pw_core this;
|
||||
void *dbus_iface;
|
||||
struct spa_handle *dbus_handle;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -441,6 +441,8 @@ struct pw_core *pw_core_new(struct pw_loop *main_loop,
|
|||
struct impl *impl;
|
||||
struct pw_core *this;
|
||||
const char *name;
|
||||
void *dbus_iface = NULL;
|
||||
int res;
|
||||
|
||||
impl = calloc(1, sizeof(struct impl) + user_data_size);
|
||||
if (impl == NULL)
|
||||
|
|
@ -473,9 +475,14 @@ struct pw_core *pw_core_new(struct pw_loop *main_loop,
|
|||
this->support[1] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_MainLoop, this->main_loop->loop);
|
||||
this->support[2] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_LoopUtils, this->main_loop->utils);
|
||||
this->support[3] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Log, pw_log_get());
|
||||
impl->dbus_iface = pw_load_spa_interface("support/libspa-dbus",
|
||||
"dbus", SPA_TYPE_INTERFACE_DBus, NULL, 4, this->support);
|
||||
this->support[4] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_DBus, impl->dbus_iface);
|
||||
|
||||
impl->dbus_handle = pw_load_spa_handle("support/libspa-dbus", "dbus", NULL, 4, this->support);
|
||||
if (impl->dbus_handle) {
|
||||
if ((res = spa_handle_get_interface(impl->dbus_handle,
|
||||
SPA_TYPE_INTERFACE_DBus, &dbus_iface)) < 0)
|
||||
pw_log_warn("can't load dbus interface: %s", spa_strerror(res));
|
||||
}
|
||||
this->support[4] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_DBus, dbus_iface);
|
||||
this->support[5] = SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_CPU,
|
||||
pw_get_support_interface(SPA_TYPE_INTERFACE_CPU));
|
||||
this->n_support = 6;
|
||||
|
|
@ -586,7 +593,8 @@ void pw_core_destroy(struct pw_core *core)
|
|||
|
||||
pw_map_clear(&core->globals);
|
||||
|
||||
pw_unload_spa_interface(impl->dbus_iface);
|
||||
if (impl->dbus_handle)
|
||||
pw_unload_spa_handle(impl->dbus_handle);
|
||||
|
||||
pw_log_debug("core %p: free", core);
|
||||
free(core);
|
||||
|
|
|
|||
|
|
@ -54,17 +54,8 @@ struct handle {
|
|||
struct spa_list link;
|
||||
struct plugin *plugin;
|
||||
const char *factory_name;
|
||||
struct spa_handle *handle;
|
||||
struct spa_list interfaces;
|
||||
int ref;
|
||||
};
|
||||
|
||||
struct interface {
|
||||
struct spa_list link;
|
||||
struct handle *handle;
|
||||
void *iface;
|
||||
uint32_t type;
|
||||
int ref;
|
||||
struct spa_handle handle;
|
||||
};
|
||||
|
||||
struct registry {
|
||||
|
|
@ -182,41 +173,32 @@ load_handle(struct plugin *plugin,
|
|||
{
|
||||
int res;
|
||||
struct handle *handle;
|
||||
struct spa_handle *hnd;
|
||||
const struct spa_handle_factory *factory;
|
||||
|
||||
factory = find_factory(plugin, factory_name);
|
||||
if (factory == NULL)
|
||||
goto not_found;
|
||||
|
||||
hnd = calloc(1, spa_handle_factory_get_size(factory, NULL));
|
||||
if (hnd == NULL)
|
||||
handle = calloc(1, sizeof(struct handle) + spa_handle_factory_get_size(factory, info));
|
||||
if (handle == NULL)
|
||||
goto alloc_failed;
|
||||
|
||||
if ((res = spa_handle_factory_init(factory,
|
||||
hnd, info,
|
||||
&handle->handle, info,
|
||||
support, n_support)) < 0) {
|
||||
fprintf(stderr, "can't make factory instance %s: %d\n", factory_name, res);
|
||||
goto init_failed;
|
||||
}
|
||||
|
||||
if ((handle = calloc(1, sizeof(struct handle))) == NULL)
|
||||
goto handle_failed;
|
||||
|
||||
handle->ref = 1;
|
||||
handle->plugin = plugin;
|
||||
handle->factory_name = factory_name;
|
||||
handle->handle = hnd;
|
||||
spa_list_init(&handle->interfaces);
|
||||
|
||||
spa_list_append(&plugin->handles, &handle->link);
|
||||
|
||||
return handle;
|
||||
|
||||
handle_failed:
|
||||
spa_handle_clear(hnd);
|
||||
init_failed:
|
||||
free(hnd);
|
||||
free(handle);
|
||||
alloc_failed:
|
||||
not_found:
|
||||
return NULL;
|
||||
|
|
@ -226,64 +208,12 @@ static void unref_handle(struct handle *handle)
|
|||
{
|
||||
if (--handle->ref == 0) {
|
||||
spa_list_remove(&handle->link);
|
||||
spa_handle_clear(handle->handle);
|
||||
free(handle->handle);
|
||||
spa_handle_clear(&handle->handle);
|
||||
unref_plugin(handle->plugin);
|
||||
free(handle);
|
||||
}
|
||||
}
|
||||
|
||||
static struct interface *
|
||||
load_interface(struct plugin *plugin,
|
||||
const char *factory_name,
|
||||
uint32_t type_id,
|
||||
const struct spa_dict *info,
|
||||
uint32_t n_support,
|
||||
struct spa_support support[n_support])
|
||||
{
|
||||
int res;
|
||||
struct handle *handle;
|
||||
void *ptr;
|
||||
struct interface *iface;
|
||||
|
||||
handle = load_handle(plugin, factory_name, info, n_support, support);
|
||||
if (handle == NULL)
|
||||
goto not_found;
|
||||
|
||||
if ((res = spa_handle_get_interface(handle->handle, type_id, &ptr)) < 0) {
|
||||
fprintf(stderr, "can't get %d interface %d\n", type_id, res);
|
||||
goto interface_failed;
|
||||
}
|
||||
|
||||
if ((iface = calloc(1, sizeof(struct interface))) == NULL)
|
||||
goto alloc_failed;
|
||||
|
||||
iface->ref = 1;
|
||||
iface->handle = handle;
|
||||
iface->type = type_id;
|
||||
iface->iface = ptr;
|
||||
spa_list_append(&handle->interfaces, &iface->link);
|
||||
|
||||
return iface;
|
||||
|
||||
alloc_failed:
|
||||
interface_failed:
|
||||
unref_handle(handle);
|
||||
free(handle);
|
||||
not_found:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
unref_interface(struct interface *iface)
|
||||
{
|
||||
if (--iface->ref == 0) {
|
||||
spa_list_remove(&iface->link);
|
||||
unref_handle(iface->handle);
|
||||
free(iface);
|
||||
}
|
||||
}
|
||||
|
||||
static void configure_debug(struct support *support, const char *str)
|
||||
{
|
||||
char **level;
|
||||
|
|
@ -327,7 +257,8 @@ const struct spa_support *pw_get_support(uint32_t *n_support)
|
|||
}
|
||||
|
||||
SPA_EXPORT
|
||||
void *pw_load_spa_interface(const char *lib, const char *factory_name, uint32_t type,
|
||||
struct spa_handle *pw_load_spa_handle(const char *lib,
|
||||
const char *factory_name,
|
||||
const struct spa_dict *info,
|
||||
uint32_t n_support,
|
||||
const struct spa_support support[])
|
||||
|
|
@ -336,7 +267,7 @@ void *pw_load_spa_interface(const char *lib, const char *factory_name, uint32_t
|
|||
struct spa_support extra_support[MAX_SUPPORT];
|
||||
uint32_t extra_n_support;
|
||||
struct plugin *plugin;
|
||||
struct interface *iface;
|
||||
struct handle *handle;
|
||||
uint32_t i;
|
||||
|
||||
extra_n_support = sup->n_support;
|
||||
|
|
@ -353,40 +284,37 @@ void *pw_load_spa_interface(const char *lib, const char *factory_name, uint32_t
|
|||
return NULL;
|
||||
}
|
||||
|
||||
if ((iface = load_interface(plugin, factory_name, type, info,
|
||||
extra_n_support, extra_support)) == NULL)
|
||||
handle = load_handle(plugin, factory_name, info, extra_n_support, extra_support);
|
||||
if (handle == NULL)
|
||||
return NULL;
|
||||
|
||||
return iface->iface;
|
||||
return &handle->handle;
|
||||
}
|
||||
|
||||
static struct interface *find_interface(void *iface)
|
||||
static struct handle *find_handle(struct spa_handle *handle)
|
||||
{
|
||||
struct registry *registry = global_support.registry;
|
||||
struct plugin *p;
|
||||
struct handle *h;
|
||||
struct interface *i;
|
||||
|
||||
spa_list_for_each(p, ®istry->plugins, link) {
|
||||
spa_list_for_each(h, &p->handles, link) {
|
||||
spa_list_for_each(i, &h->interfaces, link) {
|
||||
if (i->iface == iface)
|
||||
return i;
|
||||
}
|
||||
if (&h->handle == handle)
|
||||
return h;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
SPA_EXPORT
|
||||
int pw_unload_spa_interface(void *iface)
|
||||
int pw_unload_spa_handle(struct spa_handle *handle)
|
||||
{
|
||||
struct interface *i;
|
||||
struct handle *h;
|
||||
|
||||
if ((i = find_interface(iface)) == NULL)
|
||||
if ((h = find_handle(handle)) == NULL)
|
||||
return -ENOENT;
|
||||
|
||||
unref_interface(i);
|
||||
unref_handle(h);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -407,11 +335,13 @@ SPA_EXPORT
|
|||
void pw_init(int *argc, char **argv[])
|
||||
{
|
||||
const char *str;
|
||||
struct interface *iface;
|
||||
struct handle *handle;
|
||||
void *iface;
|
||||
struct support *support = &global_support;
|
||||
struct plugin *plugin;
|
||||
struct spa_dict info;
|
||||
struct spa_dict_item items[1];
|
||||
int res = 0;
|
||||
|
||||
if ((str = getenv("PIPEWIRE_DEBUG")))
|
||||
configure_debug(support, str);
|
||||
|
|
@ -437,22 +367,31 @@ void pw_init(int *argc, char **argv[])
|
|||
items[0] = SPA_DICT_ITEM_INIT("log.colors", "1");
|
||||
info = SPA_DICT_INIT(items, 1);
|
||||
|
||||
iface = load_interface(plugin, "logger", SPA_TYPE_INTERFACE_Log, &info,
|
||||
support->n_support, support->support);
|
||||
if (iface != NULL) {
|
||||
support->support[support->n_support++] =
|
||||
SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Log, iface->iface);
|
||||
pw_log_set(iface->iface);
|
||||
handle = load_handle(plugin, "logger", &info, support->n_support, support->support);
|
||||
if (handle == NULL ||
|
||||
(res = spa_handle_get_interface(&handle->handle,
|
||||
SPA_TYPE_INTERFACE_Log, &iface)) < 0) {
|
||||
fprintf(stderr, "can't get Log interface %d\n", res);
|
||||
}
|
||||
iface = load_interface(plugin, "cpu", SPA_TYPE_INTERFACE_CPU, &info,
|
||||
support->n_support, support->support);
|
||||
if (iface != NULL) {
|
||||
struct spa_cpu *cpu = iface->iface;
|
||||
else {
|
||||
support->support[support->n_support++] =
|
||||
SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_Log, iface);
|
||||
pw_log_set(iface);
|
||||
}
|
||||
|
||||
handle = load_handle(plugin, "cpu", &info, support->n_support, support->support);
|
||||
if (handle == NULL ||
|
||||
(res = spa_handle_get_interface(&handle->handle,
|
||||
SPA_TYPE_INTERFACE_CPU, &iface)) < 0) {
|
||||
fprintf(stderr, "can't get CPU interface %d\n", res);
|
||||
}
|
||||
else {
|
||||
struct spa_cpu *cpu = iface;
|
||||
if ((str = getenv("PIPEWIRE_CPU")))
|
||||
spa_cpu_force_flags(cpu, strtoul(str, NULL, 0));
|
||||
|
||||
support->support[support->n_support++] =
|
||||
SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_CPU, iface->iface);
|
||||
SPA_SUPPORT_INIT(SPA_TYPE_INTERFACE_CPU, iface);
|
||||
}
|
||||
pw_log_info("version %s", pw_get_library_version());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -139,12 +139,13 @@ pw_direction_reverse(enum pw_direction direction);
|
|||
void *
|
||||
pw_get_support_interface(uint32_t type);
|
||||
|
||||
void *pw_load_spa_interface(const char *lib, const char *factory_name, uint32_t type,
|
||||
struct spa_handle *pw_load_spa_handle(const char *lib,
|
||||
const char *factory_name,
|
||||
const struct spa_dict *info,
|
||||
uint32_t n_support,
|
||||
const struct spa_support support[]);
|
||||
|
||||
int pw_unload_spa_interface(void *iface);
|
||||
int pw_unload_spa_handle(struct spa_handle *handle);
|
||||
|
||||
const struct spa_handle_factory *
|
||||
pw_get_support_factory(const char *factory_name);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue