From 7a46c07230b8d8108c0e8e80df4522d0ac116538 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:28:17 +0200 Subject: Adding upstream version 0.3.65. Signed-off-by: Daniel Baumann --- .../client-session/client-session.c | 295 ++++++++++++++++ .../client-session/client-session.h | 62 ++++ .../client-session/endpoint-link.c | 369 +++++++++++++++++++++ .../client-session/endpoint-link.h | 65 ++++ .../client-session/session.c | 344 +++++++++++++++++++ .../client-session/session.h | 62 ++++ 6 files changed, 1197 insertions(+) create mode 100644 src/modules/module-session-manager/client-session/client-session.c create mode 100644 src/modules/module-session-manager/client-session/client-session.h create mode 100644 src/modules/module-session-manager/client-session/endpoint-link.c create mode 100644 src/modules/module-session-manager/client-session/endpoint-link.h create mode 100644 src/modules/module-session-manager/client-session/session.c create mode 100644 src/modules/module-session-manager/client-session/session.h (limited to 'src/modules/module-session-manager/client-session') diff --git a/src/modules/module-session-manager/client-session/client-session.c b/src/modules/module-session-manager/client-session/client-session.c new file mode 100644 index 0000000..89997c9 --- /dev/null +++ b/src/modules/module-session-manager/client-session/client-session.c @@ -0,0 +1,295 @@ +/* PipeWire + * + * Copyright © 2019 Collabora Ltd. + * @author George Kiagiadakis + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include + +#include +#include + +#include "client-session.h" +#include "session.h" +#include "endpoint-link.h" + +#define NAME "client-session" + +struct factory_data { + struct pw_impl_module *module; + struct spa_hook module_listener; + + struct pw_impl_factory *factory; + struct spa_hook factory_listener; +}; + +static struct endpoint_link *find_link(struct client_session *this, uint32_t id) +{ + struct endpoint_link *l; + spa_list_for_each(l, &this->links, link) { + if (l->id == id) + return l; + } + return NULL; +} + +static int client_session_update(void *object, + uint32_t change_mask, + uint32_t n_params, + const struct spa_pod **params, + const struct pw_session_info *info) +{ + struct client_session *this = object; + struct session *session = &this->session; + + return session_update(session, change_mask, n_params, params, info); +} + +static int client_session_link_update(void *object, + uint32_t link_id, + uint32_t change_mask, + uint32_t n_params, + const struct spa_pod **params, + const struct pw_endpoint_link_info *info) +{ + struct client_session *this = object; + struct session *session = &this->session; + struct endpoint_link *link = find_link(this, link_id); + struct pw_properties *props = NULL; + + if (!link) { + static const char * const keys[] = { + PW_KEY_FACTORY_ID, + PW_KEY_CLIENT_ID, + PW_KEY_SESSION_ID, + PW_KEY_ENDPOINT_LINK_OUTPUT_ENDPOINT, + PW_KEY_ENDPOINT_LINK_OUTPUT_STREAM, + PW_KEY_ENDPOINT_LINK_INPUT_ENDPOINT, + PW_KEY_ENDPOINT_LINK_INPUT_STREAM, + NULL + }; + + struct pw_context *context = pw_global_get_context(session->global); + + link = calloc(1, sizeof(struct endpoint_link)); + if (!link) + goto no_mem; + + props = pw_properties_new(NULL, NULL); + if (!props) + goto no_mem; + pw_properties_update_keys(props, &session->props->dict, keys); + if (info && info->props) + pw_properties_update_keys(props, info->props, keys); + + if (endpoint_link_init(link, link_id, session->info.id, + this, context, props) < 0) + goto no_mem; + + spa_list_append(&this->links, &link->link); + } + else if (change_mask & PW_CLIENT_SESSION_LINK_UPDATE_DESTROYED) { + endpoint_link_clear(link); + spa_list_remove(&link->link); + free(link); + link = NULL; + } + + return link ? + endpoint_link_update(link, change_mask, n_params, params, info) + : 0; + + no_mem: + pw_properties_free(props); + free(link); + pw_log_error(NAME" %p: cannot update link: no memory", this); + pw_resource_error(this->resource, -ENOMEM, + "cannot update link: no memory"); + return -ENOMEM; +} + +static const struct pw_client_session_methods methods = { + PW_VERSION_CLIENT_SESSION_METHODS, + .update = client_session_update, + .link_update = client_session_link_update, +}; + +static void client_session_destroy(void *data) +{ + struct client_session *this = data; + struct endpoint_link *l; + + pw_log_debug(NAME" %p: destroy", this); + + spa_list_consume(l, &this->links, link) { + endpoint_link_clear(l); + spa_list_remove(&l->link); + free(l); + } + session_clear(&this->session); + spa_hook_remove(&this->resource_listener); + + free(this); +} + +static const struct pw_resource_events resource_events = { + PW_VERSION_RESOURCE_EVENTS, + .destroy = client_session_destroy, +}; + +static void *create_object(void *data, + struct pw_resource *owner_resource, + const char *type, + uint32_t version, + struct pw_properties *properties, + uint32_t new_id) +{ + struct factory_data *d = data; + struct pw_impl_factory *factory = d->factory; + struct client_session *this; + struct pw_impl_client *owner = pw_resource_get_client(owner_resource); + struct pw_context *context = pw_impl_client_get_context(owner); + + this = calloc(1, sizeof(struct client_session)); + if (this == NULL) + goto no_mem; + + spa_list_init(&this->links); + + pw_log_debug(NAME" %p: new", this); + + if (!properties) + properties = pw_properties_new(NULL, NULL); + if (!properties) + goto no_mem; + + pw_properties_setf(properties, PW_KEY_CLIENT_ID, "%d", + pw_impl_client_get_info(owner)->id); + pw_properties_setf(properties, PW_KEY_FACTORY_ID, "%d", + pw_impl_factory_get_info(factory)->id); + + this->resource = pw_resource_new(owner, new_id, PW_PERM_ALL, type, version, 0); + if (this->resource == NULL) + goto no_mem; + + if (session_init(&this->session, this, context, properties) < 0) + goto no_mem; + + pw_resource_add_listener(this->resource, &this->resource_listener, + &resource_events, this); + pw_resource_add_object_listener(this->resource, &this->object_listener, + &methods, this); + + return this; + + no_mem: + pw_properties_free(properties); + if (this && this->resource) + pw_resource_destroy(this->resource); + free(this); + pw_log_error("can't create client session: no memory"); + pw_resource_error(owner_resource, -ENOMEM, + "can't create client session: no memory"); + return NULL; +} + +static const struct pw_impl_factory_implementation impl_factory = { + PW_VERSION_IMPL_FACTORY_IMPLEMENTATION, + .create_object = create_object, +}; + +static void factory_destroy(void *data) +{ + struct factory_data *d = data; + spa_hook_remove(&d->factory_listener); + d->factory = NULL; + if (d->module) + pw_impl_module_destroy(d->module); +} + +static const struct pw_impl_factory_events factory_events = { + PW_VERSION_IMPL_FACTORY_EVENTS, + .destroy = factory_destroy, +}; + +static void module_destroy(void *data) +{ + struct factory_data *d = data; + spa_hook_remove(&d->module_listener); + d->module = NULL; + if (d->factory) + pw_impl_factory_destroy(d->factory); +} + +static void module_registered(void *data) +{ + struct factory_data *d = data; + struct pw_impl_module *module = d->module; + struct pw_impl_factory *factory = d->factory; + struct spa_dict_item items[1]; + char id[16]; + int res; + + snprintf(id, sizeof(id), "%d", pw_impl_module_get_info(module)->id); + items[0] = SPA_DICT_ITEM_INIT(PW_KEY_MODULE_ID, id); + pw_impl_factory_update_properties(factory, &SPA_DICT_INIT(items, 1)); + + if ((res = pw_impl_factory_register(factory, NULL)) < 0) { + pw_log_error(NAME" %p: can't register factory: %s", factory, spa_strerror(res)); + } +} + +static const struct pw_impl_module_events module_events = { + PW_VERSION_IMPL_MODULE_EVENTS, + .destroy = module_destroy, + .registered = module_registered, +}; + +int client_session_factory_init(struct pw_impl_module *module) +{ + struct pw_context *context = pw_impl_module_get_context(module); + struct pw_impl_factory *factory; + struct factory_data *data; + + factory = pw_context_create_factory(context, + "client-session", + PW_TYPE_INTERFACE_ClientSession, + PW_VERSION_CLIENT_SESSION, + NULL, + sizeof(*data)); + if (factory == NULL) + return -ENOMEM; + + data = pw_impl_factory_get_user_data(factory); + data->factory = factory; + data->module = module; + + pw_impl_factory_set_implementation(factory, &impl_factory, data); + pw_impl_factory_add_listener(factory, &data->factory_listener, &factory_events, data); + + pw_impl_module_add_listener(module, &data->module_listener, &module_events, data); + + return 0; +} diff --git a/src/modules/module-session-manager/client-session/client-session.h b/src/modules/module-session-manager/client-session/client-session.h new file mode 100644 index 0000000..fc6124c --- /dev/null +++ b/src/modules/module-session-manager/client-session/client-session.h @@ -0,0 +1,62 @@ +/* PipeWire + * + * Copyright © 2019 Collabora Ltd. + * @author George Kiagiadakis + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#ifndef MODULE_SESSION_MANAGER_CLIENT_SESSION_H +#define MODULE_SESSION_MANAGER_CLIENT_SESSION_H + +#include "session.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct client_session { + struct pw_resource *resource; + struct spa_hook resource_listener; + struct spa_hook object_listener; + struct session session; + struct spa_list links; +}; + +#define pw_client_session_resource(r,m,v,...) \ + pw_resource_call_res(r,struct pw_client_session_events,m,v,__VA_ARGS__) +#define pw_client_session_resource_set_id(r,...) \ + pw_client_session_resource(r,set_id,0,__VA_ARGS__) +#define pw_client_session_resource_set_param(r,...) \ + pw_client_session_resource(r,set_param,0,__VA_ARGS__) +#define pw_client_session_resource_link_set_param(r,...) \ + pw_client_session_resource(r,link_set_param,0,__VA_ARGS__) +#define pw_client_session_resource_create_link(r,...) \ + pw_client_session_resource(r,create_link,0,__VA_ARGS__) +#define pw_client_session_resource_destroy_link(r,...) \ + pw_client_session_resource(r,destroy_link,0,__VA_ARGS__) +#define pw_client_session_resource_link_request_state(r,...) \ + pw_client_session_resource(r,link_request_state,0,__VA_ARGS__) + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* MODULE_SESSION_MANAGER_CLIENT_SESSION_H */ diff --git a/src/modules/module-session-manager/client-session/endpoint-link.c b/src/modules/module-session-manager/client-session/endpoint-link.c new file mode 100644 index 0000000..0bdbfc9 --- /dev/null +++ b/src/modules/module-session-manager/client-session/endpoint-link.c @@ -0,0 +1,369 @@ +/* PipeWire + * + * Copyright © 2019 Collabora Ltd. + * @author George Kiagiadakis + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include +#include + +#include + +#include "endpoint-link.h" +#include "client-session.h" + +#define NAME "endpoint-link" + +struct resource_data { + struct endpoint_link *link; + struct spa_hook object_listener; + uint32_t n_subscribe_ids; + uint32_t subscribe_ids[32]; +}; + +#define pw_endpoint_link_resource(r,m,v,...) \ + pw_resource_call(r,struct pw_endpoint_link_events,m,v,__VA_ARGS__) +#define pw_endpoint_link_resource_info(r,...) \ + pw_endpoint_link_resource(r,info,0,__VA_ARGS__) +#define pw_endpoint_link_resource_param(r,...) \ + pw_endpoint_link_resource(r,param,0,__VA_ARGS__) + +static int endpoint_link_enum_params (void *object, int seq, + uint32_t id, uint32_t start, uint32_t num, + const struct spa_pod *filter) +{ + struct pw_resource *resource = object; + struct resource_data *data = pw_resource_get_user_data(resource); + struct endpoint_link *this = data->link; + struct spa_pod *result; + struct spa_pod *param; + uint8_t buffer[1024]; + struct spa_pod_builder b = { 0 }; + uint32_t index; + uint32_t next = start; + uint32_t count = 0; + + while (true) { + index = next++; + if (index >= this->n_params) + break; + + param = this->params[index]; + + if (param == NULL || !spa_pod_is_object_id(param, id)) + continue; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + if (spa_pod_filter(&b, &result, param, filter) != 0) + continue; + + pw_log_debug(NAME" %p: %d param %u", this, seq, index); + + pw_endpoint_link_resource_param(resource, seq, id, index, next, result); + + if (++count == num) + break; + } + return 0; +} + +static int endpoint_link_subscribe_params (void *object, uint32_t *ids, uint32_t n_ids) +{ + struct pw_resource *resource = object; + struct resource_data *data = pw_resource_get_user_data(resource); + uint32_t i; + + n_ids = SPA_MIN(n_ids, SPA_N_ELEMENTS(data->subscribe_ids)); + data->n_subscribe_ids = n_ids; + + for (i = 0; i < n_ids; i++) { + data->subscribe_ids[i] = ids[i]; + pw_log_debug(NAME" %p: resource %d subscribe param %u", + data->link, pw_resource_get_id(resource), ids[i]); + endpoint_link_enum_params(resource, 1, ids[i], 0, UINT32_MAX, NULL); + } + return 0; +} + +static int endpoint_link_set_param (void *object, uint32_t id, uint32_t flags, + const struct spa_pod *param) +{ + struct pw_resource *resource = object; + struct resource_data *data = pw_resource_get_user_data(resource); + struct endpoint_link *this = data->link; + + pw_client_session_resource_set_param(this->client_sess->resource, + id, flags, param); + + return 0; +} + +static int endpoint_link_request_state(void *object, enum pw_endpoint_link_state state) +{ + struct pw_resource *resource = object; + struct resource_data *data = pw_resource_get_user_data(resource); + struct endpoint_link *this = data->link; + + pw_client_session_resource_link_request_state(this->client_sess->resource, + this->id, state); + + return 0; +} + +static const struct pw_endpoint_link_methods methods = { + PW_VERSION_ENDPOINT_LINK_METHODS, + .subscribe_params = endpoint_link_subscribe_params, + .enum_params = endpoint_link_enum_params, + .set_param = endpoint_link_set_param, + .request_state = endpoint_link_request_state, +}; + +struct emit_param_data { + struct endpoint_link *this; + struct spa_pod *param; + uint32_t id; + uint32_t index; + uint32_t next; +}; + +static int emit_param(void *_data, struct pw_resource *resource) +{ + struct emit_param_data *d = _data; + struct resource_data *data; + uint32_t i; + + data = pw_resource_get_user_data(resource); + for (i = 0; i < data->n_subscribe_ids; i++) { + if (data->subscribe_ids[i] == d->id) { + pw_endpoint_link_resource_param(resource, 1, + d->id, d->index, d->next, d->param); + } + } + return 0; +} + +static void endpoint_link_notify_subscribed(struct endpoint_link *this, + uint32_t index, uint32_t next) +{ + struct pw_global *global = this->global; + struct emit_param_data data; + struct spa_pod *param = this->params[index]; + + if (!param || !spa_pod_is_object (param)) + return; + + data.this = this; + data.param = param; + data.id = SPA_POD_OBJECT_ID (param); + data.index = index; + data.next = next; + + pw_global_for_each_resource(global, emit_param, &data); +} + +static int emit_info(void *data, struct pw_resource *resource) +{ + struct endpoint_link *this = data; + pw_endpoint_link_resource_info(resource, &this->info); + return 0; +} + +int endpoint_link_update(struct endpoint_link *this, + uint32_t change_mask, + uint32_t n_params, + const struct spa_pod **params, + const struct pw_endpoint_link_info *info) +{ + if (change_mask & PW_CLIENT_SESSION_UPDATE_PARAMS) { + uint32_t i; + + pw_log_debug(NAME" %p: update %d params", this, n_params); + + for (i = 0; i < this->n_params; i++) + free(this->params[i]); + this->n_params = n_params; + if (this->n_params == 0) { + free(this->params); + this->params = NULL; + } else { + void *p; + p = pw_reallocarray(this->params, n_params, sizeof(struct spa_pod*)); + if (p == NULL) { + free(this->params); + this->params = NULL; + this->n_params = 0; + goto no_mem; + } + this->params = p; + } + for (i = 0; i < this->n_params; i++) { + this->params[i] = params[i] ? spa_pod_copy(params[i]) : NULL; + endpoint_link_notify_subscribed(this, i, i+1); + } + } + + if (change_mask & PW_CLIENT_SESSION_UPDATE_INFO) { + if (info->change_mask & PW_ENDPOINT_LINK_CHANGE_MASK_STATE) { + this->info.state = info->state; + free(this->info.error); + this->info.error = info->error ? strdup(info->error) : NULL; + } + + if (info->change_mask & PW_ENDPOINT_LINK_CHANGE_MASK_PROPS) + pw_properties_update(this->props, info->props); + + if (info->change_mask & PW_ENDPOINT_LINK_CHANGE_MASK_PARAMS) { + this->info.n_params = info->n_params; + if (info->n_params == 0) { + free(this->info.params); + this->info.params = NULL; + } else { + void *p; + p = pw_reallocarray(this->info.params, info->n_params, sizeof(struct spa_param_info)); + if (p == NULL) { + free(this->info.params); + this->info.params = NULL; + this->info.n_params = 0; + goto no_mem; + } + this->info.params = p; + memcpy(this->info.params, info->params, info->n_params * sizeof(struct spa_param_info)); + } + } + + if (!this->info.output_endpoint_id) { + this->info.output_endpoint_id = info->output_endpoint_id; + this->info.output_stream_id = info->output_stream_id; + this->info.input_endpoint_id = info->input_endpoint_id; + this->info.input_stream_id = info->input_stream_id; + } + + this->info.change_mask = info->change_mask; + pw_global_for_each_resource(this->global, emit_info, this); + this->info.change_mask = 0; + } + + return 0; + + no_mem: + pw_log_error(NAME" %p: can't update: no memory", this); + pw_resource_error(this->client_sess->resource, -ENOMEM, + "can't update: no memory"); + return -ENOMEM; +} + +static int endpoint_link_bind(void *_data, struct pw_impl_client *client, + uint32_t permissions, uint32_t version, uint32_t id) +{ + struct endpoint_link *this = _data; + struct pw_global *global = this->global; + struct pw_resource *resource; + struct resource_data *data; + + resource = pw_resource_new(client, id, permissions, + pw_global_get_type(global), version, sizeof(*data)); + if (resource == NULL) + goto no_mem; + + data = pw_resource_get_user_data(resource); + data->link = this; + pw_resource_add_object_listener(resource, &data->object_listener, + &methods, resource); + + pw_log_debug(NAME" %p: bound to %d", this, pw_resource_get_id(resource)); + pw_global_add_resource(global, resource); + + this->info.change_mask = PW_ENDPOINT_LINK_CHANGE_MASK_ALL; + pw_endpoint_link_resource_info(resource, &this->info); + this->info.change_mask = 0; + + return 0; + + no_mem: + pw_log_error(NAME" %p: can't create resource: no memory", this); + pw_resource_error(this->client_sess->resource, -ENOMEM, + "can't create resource: no memory"); + return -ENOMEM; +} + +int endpoint_link_init(struct endpoint_link *this, + uint32_t id, uint32_t session_id, + struct client_session *client_sess, + struct pw_context *context, + struct pw_properties *properties) +{ + pw_log_debug(NAME" %p: new", this); + + this->client_sess = client_sess; + this->id = id; + this->props = properties; + + pw_properties_setf(properties, PW_KEY_SESSION_ID, "%u", session_id); + + properties = pw_properties_copy(properties); + if (!properties) + goto no_mem; + + this->global = pw_global_new(context, + PW_TYPE_INTERFACE_EndpointLink, + PW_VERSION_ENDPOINT_LINK, + properties, endpoint_link_bind, this); + if (!this->global) + goto no_mem; + + pw_properties_setf(this->props, PW_KEY_OBJECT_ID, "%u", + pw_global_get_id(this->global)); + pw_properties_setf(this->props, PW_KEY_OBJECT_SERIAL, "%"PRIu64, + pw_global_get_serial(this->global)); + + this->info.version = PW_VERSION_ENDPOINT_LINK_INFO; + this->info.id = pw_global_get_id(this->global); + this->info.session_id = session_id; + this->info.props = &this->props->dict; + + return pw_global_register(this->global); + + no_mem: + pw_log_error(NAME" - can't create - out of memory"); + return -ENOMEM; +} + +void endpoint_link_clear(struct endpoint_link *this) +{ + uint32_t i; + + pw_log_debug(NAME" %p: destroy", this); + + pw_global_destroy(this->global); + + for (i = 0; i < this->n_params; i++) + free(this->params[i]); + free(this->params); + + free(this->info.error); + free(this->info.params); + + pw_properties_free(this->props); +} diff --git a/src/modules/module-session-manager/client-session/endpoint-link.h b/src/modules/module-session-manager/client-session/endpoint-link.h new file mode 100644 index 0000000..c75f975 --- /dev/null +++ b/src/modules/module-session-manager/client-session/endpoint-link.h @@ -0,0 +1,65 @@ +/* PipeWire + * + * Copyright © 2019 Collabora Ltd. + * @author George Kiagiadakis + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#ifndef MODULE_SESSION_MANAGER_ENDPOINT_LINK_H +#define MODULE_SESSION_MANAGER_ENDPOINT_LINK_H +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct client_session; + +struct endpoint_link { + struct spa_list link; + struct client_session *client_sess; + struct pw_global *global; + uint32_t id; /* session-local link id */ + uint32_t n_params; + struct spa_pod **params; + struct pw_endpoint_link_info info; + struct pw_properties *props; /* wrapper of info.props */ +}; + +int endpoint_link_init(struct endpoint_link *this, + uint32_t id, uint32_t session_id, + struct client_session *client_sess, + struct pw_context *context, + struct pw_properties *properties); + +void endpoint_link_clear(struct endpoint_link *this); + +int endpoint_link_update(struct endpoint_link *this, + uint32_t change_mask, + uint32_t n_params, + const struct spa_pod **params, + const struct pw_endpoint_link_info *info); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* MODULE_SESSION_MANAGER_ENDPOINT_LINK_H */ diff --git a/src/modules/module-session-manager/client-session/session.c b/src/modules/module-session-manager/client-session/session.c new file mode 100644 index 0000000..87c1b96 --- /dev/null +++ b/src/modules/module-session-manager/client-session/session.c @@ -0,0 +1,344 @@ +/* PipeWire + * + * Copyright © 2019 Collabora Ltd. + * @author George Kiagiadakis + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include +#include + +#include + +#include "session.h" +#include "client-session.h" + +#define NAME "session" + +struct resource_data { + struct session *session; + struct spa_hook object_listener; + uint32_t n_subscribe_ids; + uint32_t subscribe_ids[32]; +}; + +#define pw_session_resource(r,m,v,...) \ + pw_resource_call(r,struct pw_session_events,m,v,__VA_ARGS__) +#define pw_session_resource_info(r,...) \ + pw_session_resource(r,info,0,__VA_ARGS__) +#define pw_session_resource_param(r,...) \ + pw_session_resource(r,param,0,__VA_ARGS__) + +static int session_enum_params (void *object, int seq, + uint32_t id, uint32_t start, uint32_t num, + const struct spa_pod *filter) +{ + struct pw_resource *resource = object; + struct resource_data *data = pw_resource_get_user_data(resource); + struct session *this = data->session; + struct spa_pod *result; + struct spa_pod *param; + uint8_t buffer[1024]; + struct spa_pod_builder b = { 0 }; + uint32_t index; + uint32_t next = start; + uint32_t count = 0; + + while (true) { + index = next++; + if (index >= this->n_params) + break; + + param = this->params[index]; + + if (param == NULL || !spa_pod_is_object_id(param, id)) + continue; + + spa_pod_builder_init(&b, buffer, sizeof(buffer)); + if (spa_pod_filter(&b, &result, param, filter) != 0) + continue; + + pw_log_debug(NAME" %p: %d param %u", this, seq, index); + + pw_session_resource_param(resource, seq, id, index, next, result); + + if (++count == num) + break; + } + return 0; +} + +static int session_subscribe_params (void *object, uint32_t *ids, uint32_t n_ids) +{ + struct pw_resource *resource = object; + struct resource_data *data = pw_resource_get_user_data(resource); + uint32_t i; + + n_ids = SPA_MIN(n_ids, SPA_N_ELEMENTS(data->subscribe_ids)); + data->n_subscribe_ids = n_ids; + + for (i = 0; i < n_ids; i++) { + data->subscribe_ids[i] = ids[i]; + pw_log_debug(NAME" %p: resource %d subscribe param %u", + data->session, pw_resource_get_id(resource), ids[i]); + session_enum_params(resource, 1, ids[i], 0, UINT32_MAX, NULL); + } + return 0; +} + +static int session_set_param (void *object, uint32_t id, uint32_t flags, + const struct spa_pod *param) +{ + struct pw_resource *resource = object; + struct resource_data *data = pw_resource_get_user_data(resource); + struct session *this = data->session; + + pw_client_session_resource_set_param(this->client_sess->resource, + id, flags, param); + + return 0; +} + +static const struct pw_session_methods methods = { + PW_VERSION_SESSION_METHODS, + .subscribe_params = session_subscribe_params, + .enum_params = session_enum_params, + .set_param = session_set_param, +}; + +struct emit_param_data { + struct session *this; + struct spa_pod *param; + uint32_t id; + uint32_t index; + uint32_t next; +}; + +static int emit_param(void *_data, struct pw_resource *resource) +{ + struct emit_param_data *d = _data; + struct resource_data *data; + uint32_t i; + + data = pw_resource_get_user_data(resource); + for (i = 0; i < data->n_subscribe_ids; i++) { + if (data->subscribe_ids[i] == d->id) { + pw_session_resource_param(resource, 1, + d->id, d->index, d->next, d->param); + } + } + return 0; +} + +static void session_notify_subscribed(struct session *this, + uint32_t index, uint32_t next) +{ + struct pw_global *global = this->global; + struct emit_param_data data; + struct spa_pod *param = this->params[index]; + + if (!param || !spa_pod_is_object (param)) + return; + + data.this = this; + data.param = param; + data.id = SPA_POD_OBJECT_ID (param); + data.index = index; + data.next = next; + + pw_global_for_each_resource(global, emit_param, &data); +} + +static int emit_info(void *data, struct pw_resource *resource) +{ + struct session *this = data; + pw_session_resource_info(resource, &this->info); + return 0; +} + +int session_update(struct session *this, + uint32_t change_mask, + uint32_t n_params, + const struct spa_pod **params, + const struct pw_session_info *info) +{ + if (change_mask & PW_CLIENT_SESSION_UPDATE_PARAMS) { + uint32_t i; + + pw_log_debug(NAME" %p: update %d params", this, n_params); + + for (i = 0; i < this->n_params; i++) + free(this->params[i]); + this->n_params = n_params; + if (this->n_params == 0) { + free(this->params); + this->params = NULL; + } else { + void *p; + p = pw_reallocarray(this->params, n_params, sizeof(struct spa_pod*)); + if (p == NULL) { + free(this->params); + this->params = NULL; + this->n_params = 0; + goto no_mem; + } + this->params = p; + } + for (i = 0; i < this->n_params; i++) { + this->params[i] = params[i] ? spa_pod_copy(params[i]) : NULL; + session_notify_subscribed(this, i, i+1); + } + } + + if (change_mask & PW_CLIENT_SESSION_UPDATE_INFO) { + if (info->change_mask & PW_SESSION_CHANGE_MASK_PROPS) + pw_properties_update(this->props, info->props); + + if (info->change_mask & PW_SESSION_CHANGE_MASK_PARAMS) { + this->info.n_params = info->n_params; + if (info->n_params == 0) { + free(this->info.params); + this->info.params = NULL; + } else { + void *p; + p = pw_reallocarray(this->info.params, info->n_params, sizeof(struct spa_param_info)); + if (p == NULL) { + free(this->info.params); + this->info.params = NULL; + this->info.n_params = 0; + goto no_mem; + } + this->info.params = p; + memcpy(this->info.params, info->params, info->n_params * sizeof(struct spa_param_info)); + } + } + this->info.change_mask = info->change_mask; + pw_global_for_each_resource(this->global, emit_info, this); + this->info.change_mask = 0; + } + + return 0; + + no_mem: + pw_log_error(NAME" can't update: no memory"); + pw_resource_error(this->client_sess->resource, -ENOMEM, + NAME" can't update: no memory"); + return -ENOMEM; +} + +static int session_bind(void *_data, struct pw_impl_client *client, + uint32_t permissions, uint32_t version, uint32_t id) +{ + struct session *this = _data; + struct pw_global *global = this->global; + struct pw_resource *resource; + struct resource_data *data; + + resource = pw_resource_new(client, id, permissions, + pw_global_get_type(global), version, sizeof(*data)); + if (resource == NULL) + goto no_mem; + + data = pw_resource_get_user_data(resource); + data->session = this; + + pw_resource_add_object_listener(resource, &data->object_listener, + &methods, resource); + + pw_log_debug(NAME" %p: bound to %d", this, pw_resource_get_id(resource)); + pw_global_add_resource(global, resource); + + this->info.change_mask = PW_SESSION_CHANGE_MASK_ALL; + pw_session_resource_info(resource, &this->info); + this->info.change_mask = 0; + + return 0; + + no_mem: + pw_log_error(NAME" can't create resource: no memory"); + pw_resource_error(this->client_sess->resource, -ENOMEM, + NAME" can't create resource: no memory"); + return -ENOMEM; +} + +int session_init(struct session *this, + struct client_session *client_sess, + struct pw_context *context, + struct pw_properties *properties) +{ + static const char * const keys[] = { + PW_KEY_OBJECT_SERIAL, + PW_KEY_FACTORY_ID, + PW_KEY_CLIENT_ID, + NULL + }; + + pw_log_debug(NAME" %p: new", this); + + this->client_sess = client_sess; + this->props = properties; + + this->global = pw_global_new (context, + PW_TYPE_INTERFACE_Session, + PW_VERSION_SESSION, + NULL, session_bind, this); + if (!this->global) + goto no_mem; + + pw_properties_setf(this->props, PW_KEY_OBJECT_ID, "%u", + pw_global_get_id(this->global)); + pw_properties_setf(this->props, PW_KEY_OBJECT_SERIAL, "%"PRIu64, + pw_global_get_serial(this->global)); + + this->info.version = PW_VERSION_SESSION_INFO; + this->info.id = pw_global_get_id(this->global); + this->info.props = &this->props->dict; + + pw_global_update_keys(this->global, &this->props->dict, keys); + + pw_resource_set_bound_id(client_sess->resource, this->info.id); + + return pw_global_register(this->global); + + no_mem: + pw_log_error(NAME" - can't create - out of memory"); + return -ENOMEM; +} + +void session_clear(struct session *this) +{ + uint32_t i; + + pw_log_debug(NAME" %p: destroy", this); + + pw_global_destroy(this->global); + + for (i = 0; i < this->n_params; i++) + free(this->params[i]); + free(this->params); + + free(this->info.params); + + pw_properties_free(this->props); +} diff --git a/src/modules/module-session-manager/client-session/session.h b/src/modules/module-session-manager/client-session/session.h new file mode 100644 index 0000000..a94b18f --- /dev/null +++ b/src/modules/module-session-manager/client-session/session.h @@ -0,0 +1,62 @@ +/* PipeWire + * + * Copyright © 2019 Collabora Ltd. + * @author George Kiagiadakis + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#ifndef MODULE_SESSION_MANAGER_SESSION_H +#define MODULE_SESSION_MANAGER_SESSION_H +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct client_session; + +struct session { + struct client_session *client_sess; + struct pw_global *global; + uint32_t n_params; + struct spa_pod **params; + struct pw_session_info info; + struct pw_properties *props; /* wrapper of info.props */ +}; + +int session_init(struct session *this, + struct client_session *client_sess, + struct pw_context *context, + struct pw_properties *properties); + +void session_clear(struct session *this); + +int session_update(struct session *this, + uint32_t change_mask, + uint32_t n_params, + const struct spa_pod **params, + const struct pw_session_info *info); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* MODULE_SESSION_MANAGER_SESSION_H */ -- cgit v1.2.3