pipewire/spa/include/meson.build

spa_sections = [
  'buffer',
  'control',
  'debug',
  'graph',
  'interfaces',
  'monitor',
  'node',
  'param',
  'pod',
  'support',
  'utils',
]

spa_headers = 'spa'  # used by doxygen
install_subdir('spa',
  install_dir : get_option('includedir') / spa_name,
)
doc: add spa to doxygen output This requires a helper script: doxygen doesn't differ between static methods and static inline methods. EXTRACT_STATIC defines whether it parses any static method but we're currently using all C files as input files as well. We cannot convince doxygen to just parse static inline functions in header files so for SPA we hack around this: meson passes the spa headers to a shell script with simply copies those changed to `/* static */ inline void (foo)` and doxygen then runs on those header files. The result: we get all spa functions added to your doxygen output at the cost of a few sed calls. 2021-05-21 13:53:19 +10:00			`spa_sections = [`
			`'buffer',`
			`'control',`
			`'debug',`
			`'graph',`
module-echo-cancel: Move backends to dynamic libaries Move all backends to dynamic libaries loaded with spa_plugin_loader so new backends not needs changes in pipewire or pipewire dependency to external code Change-Id: I702ce047598d0c318d6dc6ac8248062a5c12f643 2022-02-10 09:33:06 +01:00			`'interfaces',`
doc: add spa to doxygen output This requires a helper script: doxygen doesn't differ between static methods and static inline methods. EXTRACT_STATIC defines whether it parses any static method but we're currently using all C files as input files as well. We cannot convince doxygen to just parse static inline functions in header files so for SPA we hack around this: meson passes the spa headers to a shell script with simply copies those changed to `/* static */ inline void (foo)` and doxygen then runs on those header files. The result: we get all spa functions added to your doxygen output at the cost of a few sed calls. 2021-05-21 13:53:19 +10:00			`'monitor',`
			`'node',`
			`'param',`
			`'pod',`
			`'support',`
			`'utils',`
			`]`

			`spa_headers = 'spa' # used by doxygen`
spa: use meson's install_subdir to install our header files All files in spa/include are being installed anyway, so to avoid having to list each file one-by-one let's use meson's install_subdir() to install all of them in one go. 2021-04-15 14:21:52 +10:00			`install_subdir('spa',`
spa: utils: add scope based resource cleanup systemd, dbus-broker, and many glib applications heavily utilize the GNU C attribute "cleanup" to achieve C++ RAII-like semantics for local resource management. This commit introduces essentialy same mechanism into pipewire. At the moment, this is inteded to be a strictly private API. free() and close() as cleanup targets are sufficiently common to warrant their own special macros: spa_autofree char s = strdup(p); // will call `free(s)` at the end of the lifetime of `s` spa_autoclose int fd = openat(...); // will call `close(fd)` if `fd >= 0` at the end of the lifetime of `fd` However, with `spa_auto()` or `spa_autoptr()` it is possible to define other variables that will be cleaned up properly. Currently four are supported: spa_autoptr(FILE) f = fopen(...); // `f` has type `FILE ` // will call `fclose(f)` if `f != NULL` spa_autoptr(DIR) d = opendir(...); // `d` has type `DIR ` // will call `closedir(d)` if `d != NULL` spa_autoptr(pw_properties) p = pw_properties_new(NULL, NULL); // `p` has type `struct pw_properties ` // will call `pw_properties_free(p)` spa_auto(pw_strv) v = pw_split_strv(...); // `v` has type `char *` // will call `pw_strv_free(v)` It is possible to add support for other types, e.g. SPA_DEFINE_AUTOPTR_CLEANUP(pw_main_loop, struct pw_main_loop, { // the pointer can be accessed using `thing` // `thing` has type `struct pw_main_loop *` spa_clear_ptr(thing, pw_main_loop_destroy); }) spa_autoptr(pw_main_loop) l = ...; // `l` has type `struct pw_main_loop ` // will call `pw_main_loop_destroy(l)` or SPA_DEFINE_AUTO_CLEANUP(spa_pod_dynamic_builder, struct spa_pod_dynamic_builder, { // `thing` has type `struct spa_pod_dynamic_builder ` spa_pod_dynamic_builder_clean(thing); }) spa_auto(spa_pod_dynamic_builder) builder = ... // `builder` has type `struct spa_pod_dynamic_builder` // will call `spa_pod_dynamic_builder_clean(&builder)` The first argument is always an arbitrary name. This name must be passed to `spa_auto()` and `spa_autoptr()` as it is what determines the actual type and destructor used. The second parameter is the concrete type. For `SPA_DEFINE_AUTO_CLEANUP()` this is the concrete type to be used, while for `SPA_DEFINE_AUTOPTR_CLEANUP()` it is the concrete type without the outermost pointer. That is, SPA_DEFINE_AUTOPTR_CLEANUP(A, foo, ...) SPA_DEFINE_AUTO_CLEANUP(B, foo, ...) spa_autoptr(A) x; // `x` has type `foo *` spa_auto(B) y; // `y` has type `foo` A couple other macros are also added: spa_clear_ptr(ptr, destructor) // calls `destructor(ptr)` if `ptr != NULL` and sets `ptr` to `NULL` spa_clear_fd(fd) // calls `close(fd)` if `fd >= 0` and sets `fd` to -1 spa_steal_ptr(ptr) // sets `ptr` to `NULL` and returns the old value, // useful for preventing the auto cleanup mechanism from kicking in // when returning the pointer from a function spa_steal_fd(fd) // sets `fd` to -1 and returns the old value 2023-07-03 20:36:35 +02:00			`install_dir : get_option('includedir') / spa_name,`
spa: use meson's install_subdir to install our header files All files in spa/include are being installed anyway, so to avoid having to list each file one-by-one let's use meson's install_subdir() to install all of them in one go. 2021-04-15 14:21:52 +10:00			`)`