mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-05 13:30:02 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/src/modules/module-protocol-pulse/module.h

83 lines
2.4 KiB
C
Raw Normal View History

treewide: use SPDX tags to specify copyright information SPDX tags make the licensing information easy to understand and clear, and they are machine parseable. See https://spdx.dev for more information.
2023-02-08 18:12:00 +01:00
/* PipeWire */
/* SPDX-FileCopyrightText: Copyright © 2020 Georges Basile Stavracas Neto */
/* SPDX-FileCopyrightText: Copyright © 2021 Wim Taymans <wim.taymans@gmail.com> */
/* SPDX-License-Identifier: MIT */
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
#ifndef PIPEWIRE_PULSE_MODULE_H
#define PIPEWIRE_PULSE_MODULE_H
#include <spa/param/audio/raw.h>
pulse-server: split out module handling Part of !776.
2021-06-19 00:09:09 +02:00
#include <spa/utils/hook.h>
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
#include "internal.h"
struct module;
pulse-server: split out module handling Part of !776.
2021-06-19 00:09:09 +02:00
struct pw_properties;
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
struct module_info {
const char *name;
pulse-server: module: rework registry Move all module methods into the `module_info` struct, and place all such structs into the "pw_mod_pulse_modules" section of the executable. This way there is no need for an explicit module registry, and all information about a module can be declared in the module's source file in a single place.
2022-03-17 17:22:02 +01:00
pulse-server: make some modules load-once Add mechanism for allowing some modules to be loaded only once. Mark always-sink, raop-discover, switch-on-connect, zeroconf-discover as such.
2022-02-13 17:48:37 +02:00
unsigned int load_once:1;
pulse-server: module: rework registry Move all module methods into the `module_info` struct, and place all such structs into the "pw_mod_pulse_modules" section of the executable. This way there is no need for an explicit module registry, and all information about a module can be declared in the module's source file in a single place.
2022-03-17 17:22:02 +01:00
pulse-server: rename `module_info::prepare()` to `create()` Now that the method does not actually create the `module` object, it would be somewhat misleading to call it "create", so rename it to "prepare".
2022-06-01 20:53:42 +02:00
int (*prepare) (struct module *module);
pulse-server: module does not depend on client We don't need to pass the client to the module create and load functions, they can work without a client. The only place the client is used is to access the properties to make a new connection to pipewire. This is also however not a good idea, we should simply use the defaults used by the context or else a client could set strange properties like remote.name etc for these internal connections. Also removing the dependency of the client will make it possible to load modules from the startup script or other modules later.
2022-12-06 18:26:29 +01:00
int (*load) (struct module *module);
pulse-server: module: rework registry Move all module methods into the `module_info` struct, and place all such structs into the "pw_mod_pulse_modules" section of the executable. This way there is no need for an explicit module registry, and all information about a module can be declared in the module's source file in a single place.
2022-03-17 17:22:02 +01:00
int (*unload) (struct module *module);
pulse-server: serve module properties from static list None of the modules really need a dynamic property list, so serve the properties from a static list.
2022-06-01 17:42:12 +02:00
pulse-server: add an option to check module arguments Add a list of valid keys to the module info. When set, check if the module arguments only contain the allowed keys and give an error otherwise.
2023-09-13 12:26:57 +02:00
const char* const *valid_args;
pulse-server: serve module properties from static list None of the modules really need a dynamic property list, so serve the properties from a static list.
2022-06-01 17:42:12 +02:00
const struct spa_dict *properties;
pulse-server: pass already created module object to `module_info::create()` All modules need to manually create a `module` object and check if it was successfully created. The same with argument parsing. To simplify modules, move the module object creation and argument parsing into `module_create()`, and pass the already initialized module to `module_info::create()`. The semantics of `module_info::create()` are kept, that is, if it fails, `module_info::unload()` will not be called.
2022-06-01 18:26:18 +02:00
size_t data_size;
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
};
pulse-server: module: rework registry Move all module methods into the `module_info` struct, and place all such structs into the "pw_mod_pulse_modules" section of the executable. This way there is no need for an explicit module registry, and all information about a module can be declared in the module's source file in a single place.
2022-03-17 17:22:02 +01:00
#define DEFINE_MODULE_INFO(name) \
__attribute__((used)) \
treewide: retain sections to prevent linker garbage collection The linker may remove sections that are actually used when "--gc-sections" and "-z start-stop-gc" is set. Add the `retain` attribute to prevent that. Furthermore, fix the alignment for `pwtest_suite_decl` objects. See: #2292 See: https://lld.llvm.org/ELF/start-stop-gc.html See: https://github.com/systemd/systemd/issues/21847 See: https://github.com/systemd/systemd/pull/21855
2022-04-13 18:13:12 +02:00
__attribute__((retain)) \
pulse-server: module: rework registry Move all module methods into the `module_info` struct, and place all such structs into the "pw_mod_pulse_modules" section of the executable. This way there is no need for an explicit module registry, and all information about a module can be declared in the module's source file in a single place.
2022-03-17 17:22:02 +01:00
__attribute__((section("pw_mod_pulse_modules"))) \
__attribute__((aligned(__alignof__(struct module_info)))) \
const struct module_info name
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
struct module_events {
#define VERSION_MODULE_EVENTS 0
uint32_t version;
pulse-server: improve module loading Modules no longer need to emit the "loaded" event manually if they can load immediately. In that case, the module loading code will take care of emitting the event. If they can't, they must return an async spa result, and emit the "loaded" event when they see fit. Fixes #1232
2021-06-10 18:37:48 +02:00
void (*loaded) (void *data, int result);
pulse-server: handle if the module is destroyed while loading Create a new event for modules ('destroy') which is emitted from `module_free()`. It is used by the module loading logic, to handle when a module is destroyed without properly loading first.
2021-11-12 18:54:17 +01:00
void (*destroy) (void *data);
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
};
struct module {
pulse-server: make separate index Separate the id (the pipewire object id) from the index (what we send to the client to identify the objects).
2022-01-17 11:28:40 +01:00
uint32_t index;
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
const char *args;
struct pw_properties *props;
struct impl *impl;
pulse-server: module: rework registry Move all module methods into the `module_info` struct, and place all such structs into the "pw_mod_pulse_modules" section of the executable. This way there is no need for an explicit module registry, and all information about a module can be declared in the module's source file in a single place.
2022-03-17 17:22:02 +01:00
const struct module_info *info;
pulse-server: clear hook list when module is freed Moreover, rename the hook list to "listener_list".
2021-06-10 18:31:50 +02:00
struct spa_hook_list listener_list;
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
void *user_data;
pulse-server: don't broadcast remove event when a module wasn't loaded
2021-06-06 15:49:58 +02:00
unsigned int loaded:1;
pulse-server: module: do not schedule unloading multiple times While it is not a problem since `module_free()` calls `pw_work_queue_cancel()`, it is completely unnecessary to do it more than once. Introduce a new flag on the module which stores whether or not an unloading has been scheduled.
2021-12-28 19:21:01 +01:00
unsigned int unloading:1;
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
};
pulse-server: split out module handling Part of !776.
2021-06-19 00:09:09 +02:00
#define module_emit_loaded(m,r) spa_hook_list_call(&m->listener_list, struct module_events, loaded, 0, r)
pulse-server: handle if the module is destroyed while loading Create a new event for modules ('destroy') which is emitted from `module_free()`. It is used by the module loading logic, to handle when a module is destroyed without properly loading first.
2021-11-12 18:54:17 +01:00
#define module_emit_destroy(m) spa_hook_list_call(&(m)->listener_list, struct module_events, destroy, 0)
pulse-server: split out module handling Part of !776.
2021-06-19 00:09:09 +02:00
pulse-server: module does not depend on client We don't need to pass the client to the module create and load functions, they can work without a client. The only place the client is used is to access the properties to make a new connection to pipewire. This is also however not a good idea, we should simply use the defaults used by the context or else a client could set strange properties like remote.name etc for these internal connections. Also removing the dependency of the client will make it possible to load modules from the startup script or other modules later.
2022-12-06 18:26:29 +01:00
struct module *module_create(struct impl *impl, const char *name, const char *args);
pulse-server: split out module handling Part of !776.
2021-06-19 00:09:09 +02:00
void module_free(struct module *module);
pulse-server: module does not depend on client We don't need to pass the client to the module create and load functions, they can work without a client. The only place the client is used is to access the properties to make a new connection to pipewire. This is also however not a good idea, we should simply use the defaults used by the context or else a client could set strange properties like remote.name etc for these internal connections. Also removing the dependency of the client will make it possible to load modules from the startup script or other modules later.
2022-12-06 18:26:29 +01:00
int module_load(struct module *module);
pulse-server: module: remove unused `client` argument None of the modules use the `client` argument in their unload callbacks. Remove it.
2022-01-30 17:08:55 +01:00
int module_unload(struct module *module);
pulse-server: make method to schedule module unload
2021-04-21 13:11:16 +02:00
void module_schedule_unload(struct module *module);
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
pulse-server: split out module handling Part of !776.
2021-06-19 00:09:09 +02:00
void module_add_listener(struct module *module,
struct spa_hook *listener,
const struct module_events *events, void *data);
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
void module_args_add_props(struct pw_properties *props, const char *str);
int module_args_to_audioinfo(struct impl *impl, struct pw_properties *props, struct spa_audio_info_raw *info);
pulse-server: improve module args compatibility Boolean switches can also be true with 'y', 'yes', 't' and 'on'
2021-09-21 17:37:39 +02:00
bool module_args_parse_bool(const char *str);
pulse-server: rework audioinfo argument parsing Make a new method to parse parts of the audioinfo based on custom keys, leaving unparsed values to defaults. Implement the generic audio parsing with this. We can then remove some duplicate code where the audio keys didn't match or where only parts of the info needed to be parsed. Also make a method to serialize the audioinfo to properties and use that when making arguments to load the modules. Avoid doing some custom property serialization, move all key/values into properties and serialize those with the generic functions.
2023-05-04 18:43:08 +02:00
int module_args_to_audioinfo_keys(struct impl *impl, struct pw_properties *props,
const char *key_format, const char *key_rate,
const char *key_channels, const char *key_channel_map,
struct spa_audio_info_raw *info);
void audioinfo_to_properties(struct spa_audio_info_raw *info, struct pw_properties *props);
pulse-server: Factor out module code to compile independently This starts breaking up the giant monolith that is the pulse-server.c code into more manageable chunks by trying to split the module code into individual compilation units.
2021-04-15 15:53:05 -04:00
#endif
Reference in a new issue Copy permalink