mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

add per type API defines

Browse source
This commit is contained in:
Wim Taymans 2024-11-21 11:50:12 +01:00
parent b03f2f7afa
commit 31802d4994
85 changed files with 1137 additions and 509 deletions
Download patch file Download diff file Expand all files Collapse all files

16
spa/include/spa/buffer/alloc.h
View file

@ -11,6 +11,14 @@ extern "C" {
#include <spa/buffer/buffer.h>
#ifndef SPA_API_BUFFER_ALLOC
#ifdef SPA_API_IMPL
#define SPA_API_BUFFER_ALLOC SPA_API_IMPL
#else
#define SPA_API_BUFFER_ALLOC static inline
#endif
#endif
/**
* \addtogroup spa_buffer
* \{
@ -58,7 +66,7 @@ struct spa_buffer_alloc_info {
* \param data_aligns \a n_datas alignments
* \return 0 on success.
* */
SPA_API_IMPL int spa_buffer_alloc_fill_info(struct spa_buffer_alloc_info *info,
SPA_API_BUFFER_ALLOC int spa_buffer_alloc_fill_info(struct spa_buffer_alloc_info *info,
uint32_t n_metas, struct spa_meta metas[],
uint32_t n_datas, struct spa_data datas[],
uint32_t data_aligns[])
@ -179,7 +187,7 @@ SPA_API_IMPL int spa_buffer_alloc_fill_info(struct spa_buffer_alloc_info *info,
* \param data_mem memory to hold the meta, chunk and memory
* \return a struct \ref spa_buffer in \a skel_mem
*/
SPA_API_IMPL struct spa_buffer *
SPA_API_BUFFER_ALLOC struct spa_buffer *
spa_buffer_alloc_layout(struct spa_buffer_alloc_info *info,
void *skel_mem, void *data_mem)
{
@ -257,7 +265,7 @@ spa_buffer_alloc_layout(struct spa_buffer_alloc_info *info,
* \return 0 on success.
*
*/
SPA_API_IMPL int
SPA_API_BUFFER_ALLOC int
spa_buffer_alloc_layout_array(struct spa_buffer_alloc_info *info,
uint32_t n_buffers, struct spa_buffer *buffers[],
void *skel_mem, void *data_mem)
@ -292,7 +300,7 @@ spa_buffer_alloc_layout_array(struct spa_buffer_alloc_info *info,
* allocation failed.
*
*/
SPA_API_IMPL struct spa_buffer **
SPA_API_BUFFER_ALLOC struct spa_buffer **
spa_buffer_alloc_array(uint32_t n_buffers, uint32_t flags,
uint32_t n_metas, struct spa_meta metas[],
uint32_t n_datas, struct spa_data datas[],

12
spa/include/spa/buffer/buffer.h
View file

@ -12,6 +12,14 @@ extern "C" {
#include <spa/utils/defs.h>
#include <spa/buffer/meta.h>
#ifndef SPA_API_BUFFER
#ifdef SPA_API_IMPL
#define SPA_API_BUFFER SPA_API_IMPL
#else
#define SPA_API_BUFFER static inline
#endif
#endif
/** \defgroup spa_buffer Buffers
*
* Buffers describe the data and metadata that is exchanged between
@ -91,7 +99,7 @@ struct spa_buffer {
};
/** Find metadata in a buffer */
SPA_API_IMPL struct spa_meta *spa_buffer_find_meta(const struct spa_buffer *b, uint32_t type)
SPA_API_BUFFER struct spa_meta *spa_buffer_find_meta(const struct spa_buffer *b, uint32_t type)
{
uint32_t i;
@ -102,7 +110,7 @@ SPA_API_IMPL struct spa_meta *spa_buffer_find_meta(const struct spa_buffer *b, u
return NULL;
}
SPA_API_IMPL void *spa_buffer_find_meta_data(const struct spa_buffer *b, uint32_t type, size_t size)
SPA_API_BUFFER void *spa_buffer_find_meta_data(const struct spa_buffer *b, uint32_t type, size_t size)
{
struct spa_meta *m;
if ((m = spa_buffer_find_meta(b, type)) && m->size >= size)

14
spa/include/spa/buffer/meta.h
View file

@ -12,6 +12,14 @@ extern "C" {
#include <spa/utils/defs.h>
#include <spa/pod/pod.h>
#ifndef SPA_API_META
#ifdef SPA_API_IMPL
#define SPA_API_META SPA_API_IMPL
#else
#define SPA_API_META static inline
#endif
#endif
/**
* \addtogroup spa_buffer
* \{
@ -46,11 +54,11 @@ struct spa_meta {
void *data; /**< pointer to metadata */
};
SPA_API_IMPL void *spa_meta_first(const struct spa_meta *m) {
SPA_API_META void *spa_meta_first(const struct spa_meta *m) {
return m->data;
}
#define spa_meta_first spa_meta_first
SPA_API_IMPL void *spa_meta_end(const struct spa_meta *m) {
SPA_API_META void *spa_meta_end(const struct spa_meta *m) {
return SPA_PTROFF(m->data,m->size,void);
}
#define spa_meta_end spa_meta_end
@ -80,7 +88,7 @@ struct spa_meta_region {
struct spa_region region;
};
SPA_API_IMPL bool spa_meta_region_is_valid(const struct spa_meta_region *m) {
SPA_API_META bool spa_meta_region_is_valid(const struct spa_meta_region *m) {
return m->region.size.width != 0 && m->region.size.height != 0;
}
#define spa_meta_region_is_valid spa_meta_region_is_valid

13
spa/include/spa/control/ump-utils.h
View file

@ -13,12 +13,19 @@ extern "C" {
#include <errno.h>
#include <spa/utils/defs.h>
#ifndef SPA_API_CONTROL_UMP_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_CONTROL_UMP_UTILS SPA_API_IMPL
#else
#define SPA_API_CONTROL_UMP_UTILS static inline
#endif
#endif
/**
* \addtogroup spa_control
* \{
*/
SPA_API_IMPL size_t spa_ump_message_size(uint8_t message_type)
SPA_API_CONTROL_UMP_UTILS size_t spa_ump_message_size(uint8_t message_type)
{
static const uint32_t ump_sizes[] = {
[0x0] = 1, /* Utility messages */
@ -41,7 +48,7 @@ SPA_API_IMPL size_t spa_ump_message_size(uint8_t message_type)
return ump_sizes[message_type & 0xf];
}
SPA_API_IMPL int spa_ump_to_midi(uint32_t *ump, size_t ump_size,
SPA_API_CONTROL_UMP_UTILS int spa_ump_to_midi(uint32_t *ump, size_t ump_size,
uint8_t *midi, size_t midi_maxsize)
{
int size = 0;
@ -102,7 +109,7 @@ SPA_API_IMPL int spa_ump_to_midi(uint32_t *ump, size_t ump_size,
return size;
}
SPA_API_IMPL int spa_ump_from_midi(uint8_t **midi, size_t *midi_size,
SPA_API_CONTROL_UMP_UTILS int spa_ump_from_midi(uint8_t **midi, size_t *midi_size,
uint32_t *ump, size_t ump_maxsize, uint8_t group, uint64_t *state)
{
int size = 0;

12
spa/include/spa/debug/buffer.h
View file

@ -23,7 +23,15 @@ extern "C" {
#include <spa/debug/types.h>
#include <spa/buffer/type-info.h>
SPA_API_IMPL int spa_debugc_buffer(struct spa_debug_context *ctx, int indent, const struct spa_buffer *buffer)
#ifndef SPA_API_DEBUG_BUFFER
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_BUFFER SPA_API_IMPL
#else
#define SPA_API_DEBUG_BUFFER static inline
#endif
#endif
SPA_API_DEBUG_BUFFER int spa_debugc_buffer(struct spa_debug_context *ctx, int indent, const struct spa_buffer *buffer)
{
uint32_t i;
@ -98,7 +106,7 @@ SPA_API_IMPL int spa_debugc_buffer(struct spa_debug_context *ctx, int indent, co
return 0;
}
SPA_API_IMPL int spa_debug_buffer(int indent, const struct spa_buffer *buffer)
SPA_API_DEBUG_BUFFER int spa_debug_buffer(int indent, const struct spa_buffer *buffer)
{
return spa_debugc_buffer(NULL, indent, buffer);
}

11
spa/include/spa/debug/context.h
View file

@ -26,13 +26,22 @@ extern "C" {
#define spa_debug(_fmt,...) spa_debugn(_fmt"\n", ## __VA_ARGS__)
#endif
#ifndef SPA_API_DEBUG_CONTEXT
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_CONTEXT SPA_API_IMPL
#else
#define SPA_API_DEBUG_CONTEXT static inline
#endif
#endif
struct spa_debug_context {
void (*log) (struct spa_debug_context *ctx, const char *fmt, ...) SPA_PRINTF_FUNC(2, 3);
};
#define spa_debugc(_c,_fmt,...) (_c)?((_c)->log((_c),_fmt, ## __VA_ARGS__)):(void)spa_debug(_fmt, ## __VA_ARGS__)
SPA_API_IMPL void spa_debugc_error_location(struct spa_debug_context *c,
SPA_API_DEBUG_CONTEXT void spa_debugc_error_location(struct spa_debug_context *c,
struct spa_error_location *loc)
{
int i, skip = loc->col > 80 ? loc->col - 40 : 0, lc = loc->col-skip-1;

12
spa/include/spa/debug/dict.h
View file

@ -17,7 +17,15 @@ extern "C" {
#include <spa/debug/context.h>
#include <spa/utils/dict.h>
SPA_API_IMPL int spa_debugc_dict(struct spa_debug_context *ctx, int indent, const struct spa_dict *dict)
#ifndef SPA_API_DEBUG_DICT
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_DICT SPA_API_IMPL
#else
#define SPA_API_DEBUG_DICT static inline
#endif
#endif
SPA_API_DEBUG_DICT int spa_debugc_dict(struct spa_debug_context *ctx, int indent, const struct spa_dict *dict)
{
const struct spa_dict_item *item;
spa_debugc(ctx, "%*sflags:%08x n_items:%d", indent, "", dict->flags, dict->n_items);
@ -27,7 +35,7 @@ SPA_API_IMPL int spa_debugc_dict(struct spa_debug_context *ctx, int indent, cons
return 0;
}
SPA_API_IMPL int spa_debug_dict(int indent, const struct spa_dict *dict)
SPA_API_DEBUG_DICT int spa_debug_dict(int indent, const struct spa_dict *dict)
{
return spa_debugc_dict(NULL, indent, dict);
}

10
spa/include/spa/debug/file.h
View file

@ -26,13 +26,21 @@ extern "C" {
* \{
*/
#ifndef SPA_API_DEBUG_FILE
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_FILE SPA_API_IMPL
#else
#define SPA_API_DEBUG_FILE static inline
#endif
#endif
struct spa_debug_file_ctx {
struct spa_debug_context ctx;
FILE *f;
};
SPA_PRINTF_FUNC(2,3)
SPA_API_IMPL void spa_debug_file_log(struct spa_debug_context *ctx, const char *fmt, ...)
SPA_API_DEBUG_FILE void spa_debug_file_log(struct spa_debug_context *ctx, const char *fmt, ...)
{
struct spa_debug_file_ctx *c = SPA_CONTAINER_OF(ctx, struct spa_debug_file_ctx, ctx);
va_list args;

17
spa/include/spa/debug/format.h
View file

@ -21,7 +21,16 @@ extern "C" {
#include <spa/param/type-info.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_DEBUG_FORMAT
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_FORMAT SPA_API_IMPL
#else
#define SPA_API_DEBUG_FORMAT static inline
#endif
#endif
SPA_API_DEBUG_FORMAT int
spa_debug_strbuf_format_value(struct spa_strbuf *buffer, const struct spa_type_info *info,
uint32_t type, void *body, uint32_t size)
{
@ -96,7 +105,7 @@ spa_debug_strbuf_format_value(struct spa_strbuf *buffer, const struct spa_type_i
return 0;
}
SPA_API_IMPL int
SPA_API_DEBUG_FORMAT int
spa_debug_format_value(const struct spa_type_info *info,
uint32_t type, void *body, uint32_t size)
{
@ -108,7 +117,7 @@ spa_debug_format_value(const struct spa_type_info *info,
return 0;
}
SPA_API_IMPL int spa_debugc_format(struct spa_debug_context *ctx, int indent,
SPA_API_DEBUG_FORMAT int spa_debugc_format(struct spa_debug_context *ctx, int indent,
const struct spa_type_info *info, const struct spa_pod *format)
{
const char *media_type;
@ -198,7 +207,7 @@ SPA_API_IMPL int spa_debugc_format(struct spa_debug_context *ctx, int indent,
return 0;
}
SPA_API_IMPL int spa_debug_format(int indent,
SPA_API_DEBUG_FORMAT int spa_debug_format(int indent,
const struct spa_type_info *info, const struct spa_pod *format)
{
return spa_debugc_format(NULL, indent, info, format);

10
spa/include/spa/debug/log.h
View file

@ -20,6 +20,14 @@ extern "C" {
#include <spa/debug/mem.h>
#include <spa/debug/pod.h>
#ifndef SPA_API_DEBUG_LOG
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_LOG SPA_API_IMPL
#else
#define SPA_API_DEBUG_LOG static inline
#endif
#endif
/**
* \addtogroup spa_debug
* \{
@ -36,7 +44,7 @@ struct spa_debug_log_ctx {
};
SPA_PRINTF_FUNC(2,3)
SPA_API_IMPL void spa_debug_log_log(struct spa_debug_context *ctx, const char *fmt, ...)
SPA_API_DEBUG_LOG void spa_debug_log_log(struct spa_debug_context *ctx, const char *fmt, ...)
{
struct spa_debug_log_ctx *c = SPA_CONTAINER_OF(ctx, struct spa_debug_log_ctx, ctx);
va_list args;

12
spa/include/spa/debug/mem.h
View file

@ -18,7 +18,15 @@ extern "C" {
#include <spa/debug/context.h>
SPA_API_IMPL int spa_debugc_mem(struct spa_debug_context *ctx, int indent, const void *data, size_t size)
#ifndef SPA_API_DEBUG_MEM
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_MEM SPA_API_IMPL
#else
#define SPA_API_DEBUG_MEM static inline
#endif
#endif
SPA_API_DEBUG_MEM int spa_debugc_mem(struct spa_debug_context *ctx, int indent, const void *data, size_t size)
{
const uint8_t *t = (const uint8_t*)data;
char buffer[512];
@ -36,7 +44,7 @@ SPA_API_IMPL int spa_debugc_mem(struct spa_debug_context *ctx, int indent, const
return 0;
}
SPA_API_IMPL int spa_debug_mem(int indent, const void *data, size_t size)
SPA_API_DEBUG_MEM int spa_debug_mem(int indent, const void *data, size_t size)
{
return spa_debugc_mem(NULL, indent, data, size);
}

12
spa/include/spa/debug/node.h
View file

@ -18,7 +18,15 @@ extern "C" {
#include <spa/debug/context.h>
#include <spa/debug/dict.h>
SPA_API_IMPL int spa_debugc_port_info(struct spa_debug_context *ctx, int indent, const struct spa_port_info *info)
#ifndef SPA_API_DEBUG_NODE
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_NODE SPA_API_IMPL
#else
#define SPA_API_DEBUG_NODE static inline
#endif
#endif
SPA_API_DEBUG_NODE int spa_debugc_port_info(struct spa_debug_context *ctx, int indent, const struct spa_port_info *info)
{
spa_debugc(ctx, "%*s" "struct spa_port_info %p:", indent, "", info);
spa_debugc(ctx, "%*s" " flags: \t%08" PRIx64, indent, "", info->flags);
@ -31,7 +39,7 @@ SPA_API_IMPL int spa_debugc_port_info(struct spa_debug_context *ctx, int indent,
return 0;
}
SPA_API_IMPL int spa_debug_port_info(int indent, const struct spa_port_info *info)
SPA_API_DEBUG_NODE int spa_debug_port_info(int indent, const struct spa_port_info *info)
{
return spa_debugc_port_info(NULL, indent, info);
}

16
spa/include/spa/debug/pod.h
View file

@ -20,7 +20,15 @@ extern "C" {
#include <spa/pod/pod.h>
#include <spa/pod/iter.h>
SPA_API_IMPL int
#ifndef SPA_API_DEBUG_POD
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_POD SPA_API_IMPL
#else
#define SPA_API_DEBUG_POD static inline
#endif
#endif
SPA_API_DEBUG_POD int
spa_debugc_pod_value(struct spa_debug_context *ctx, int indent, const struct spa_type_info *info,
uint32_t type, void *body, uint32_t size)
{
@ -174,7 +182,7 @@ spa_debugc_pod_value(struct spa_debug_context *ctx, int indent, const struct spa
return 0;
}
SPA_API_IMPL int spa_debugc_pod(struct spa_debug_context *ctx, int indent,
SPA_API_DEBUG_POD int spa_debugc_pod(struct spa_debug_context *ctx, int indent,
const struct spa_type_info *info, const struct spa_pod *pod)
{
return spa_debugc_pod_value(ctx, indent, info ? info : SPA_TYPE_ROOT,
@ -183,14 +191,14 @@ SPA_API_IMPL int spa_debugc_pod(struct spa_debug_context *ctx, int indent,
SPA_POD_BODY_SIZE(pod));
}
SPA_API_IMPL int
SPA_API_DEBUG_POD int
spa_debug_pod_value(int indent, const struct spa_type_info *info,
uint32_t type, void *body, uint32_t size)
{
return spa_debugc_pod_value(NULL, indent, info, type, body, size);
}
SPA_API_IMPL int spa_debug_pod(int indent,
SPA_API_DEBUG_POD int spa_debug_pod(int indent,
const struct spa_type_info *info, const struct spa_pod *pod)
{
return spa_debugc_pod(NULL, indent, info, pod);

23
spa/include/spa/debug/types.h
View file

@ -18,7 +18,16 @@ extern "C" {
#include <string.h>
SPA_API_IMPL const struct spa_type_info *spa_debug_type_find(const struct spa_type_info *info, uint32_t type)
#ifndef SPA_API_DEBUG_TYPES
#ifdef SPA_API_IMPL
#define SPA_API_DEBUG_TYPES SPA_API_IMPL
#else
#define SPA_API_DEBUG_TYPES static inline
#endif
#endif
SPA_API_DEBUG_TYPES const struct spa_type_info *spa_debug_type_find(const struct spa_type_info *info, uint32_t type)
{
const struct spa_type_info *res;
@ -37,19 +46,19 @@ SPA_API_IMPL const struct spa_type_info *spa_debug_type_find(const struct spa_ty
return NULL;
}
SPA_API_IMPL const char *spa_debug_type_short_name(const char *name)
SPA_API_DEBUG_TYPES const char *spa_debug_type_short_name(const char *name)
{
return spa_type_short_name(name);
}
SPA_API_IMPL const char *spa_debug_type_find_name(const struct spa_type_info *info, uint32_t type)
SPA_API_DEBUG_TYPES const char *spa_debug_type_find_name(const struct spa_type_info *info, uint32_t type)
{
if ((info = spa_debug_type_find(info, type)) == NULL)
return NULL;
return info->name;
}
SPA_API_IMPL const char *spa_debug_type_find_short_name(const struct spa_type_info *info, uint32_t type)
SPA_API_DEBUG_TYPES const char *spa_debug_type_find_short_name(const struct spa_type_info *info, uint32_t type)
{
const char *str;
if ((str = spa_debug_type_find_name(info, type)) == NULL)
@ -57,7 +66,7 @@ SPA_API_IMPL const char *spa_debug_type_find_short_name(const struct spa_type_in
return spa_debug_type_short_name(str);
}
SPA_API_IMPL uint32_t spa_debug_type_find_type(const struct spa_type_info *info, const char *name)
SPA_API_DEBUG_TYPES uint32_t spa_debug_type_find_type(const struct spa_type_info *info, const char *name)
{
if (info == NULL)
info = SPA_TYPE_ROOT;
@ -73,7 +82,7 @@ SPA_API_IMPL uint32_t spa_debug_type_find_type(const struct spa_type_info *info,
return SPA_ID_INVALID;
}
SPA_API_IMPL const struct spa_type_info *spa_debug_type_find_short(const struct spa_type_info *info, const char *name)
SPA_API_DEBUG_TYPES const struct spa_type_info *spa_debug_type_find_short(const struct spa_type_info *info, const char *name)
{
while (info && info->name) {
if (strcmp(spa_debug_type_short_name(info->name), name) == 0)
@ -87,7 +96,7 @@ SPA_API_IMPL const struct spa_type_info *spa_debug_type_find_short(const struct
return NULL;
}
SPA_API_IMPL uint32_t spa_debug_type_find_type_short(const struct spa_type_info *info, const char *name)
SPA_API_DEBUG_TYPES uint32_t spa_debug_type_find_type_short(const struct spa_type_info *info, const char *name)
{
if ((info = spa_debug_type_find_short(info, name)) == NULL)
return SPA_ID_INVALID;

24
spa/include/spa/filter-graph/filter-graph.h
View file

@ -15,6 +15,14 @@ extern "C" {
#include <spa/utils/hook.h>
#include <spa/pod/builder.h>
#ifndef SPA_API_FILTER_GRAPH
#ifdef SPA_API_IMPL
#define SPA_API_FILTER_GRAPH SPA_API_IMPL
#else
#define SPA_API_FILTER_GRAPH static inline
#endif
#endif
/** \defgroup spa_filter_graph Filter Graph
* a graph of filters
*/
@ -83,7 +91,7 @@ struct spa_filter_graph_methods {
struct spa_filter_graph_chunk out[], uint32_t n_out);
};
SPA_API_IMPL int spa_filter_graph_add_listener(struct spa_filter_graph *object,
SPA_API_FILTER_GRAPH int spa_filter_graph_add_listener(struct spa_filter_graph *object,
struct spa_hook *listener,
const struct spa_filter_graph_events *events, void *data)
{
@ -92,44 +100,44 @@ SPA_API_IMPL int spa_filter_graph_add_listener(struct spa_filter_graph *object,
events, data);
}
SPA_API_IMPL int spa_filter_graph_enum_prop_info(struct spa_filter_graph *object,
SPA_API_FILTER_GRAPH int spa_filter_graph_enum_prop_info(struct spa_filter_graph *object,
uint32_t idx, struct spa_pod_builder *b)
{
return spa_api_method_r(int, -ENOTSUP,
spa_filter_graph, &object->iface, enum_prop_info, 0, idx, b);
}
SPA_API_IMPL int spa_filter_graph_get_props(struct spa_filter_graph *object,
SPA_API_FILTER_GRAPH int spa_filter_graph_get_props(struct spa_filter_graph *object,
struct spa_pod_builder *b, const struct spa_pod **props)
{
return spa_api_method_r(int, -ENOTSUP,
spa_filter_graph, &object->iface, get_props, 0, b, props);
}
SPA_API_IMPL int spa_filter_graph_set_props(struct spa_filter_graph *object,
SPA_API_FILTER_GRAPH int spa_filter_graph_set_props(struct spa_filter_graph *object,
enum spa_direction direction, const struct spa_pod *props)
{
return spa_api_method_r(int, -ENOTSUP,
spa_filter_graph, &object->iface, set_props, 0, direction, props);
}
SPA_API_IMPL int spa_filter_graph_activate(struct spa_filter_graph *object, const struct spa_fraction *rate)
SPA_API_FILTER_GRAPH int spa_filter_graph_activate(struct spa_filter_graph *object, const struct spa_fraction *rate)
{
return spa_api_method_r(int, -ENOTSUP,
spa_filter_graph, &object->iface, activate, 0, rate);
}
SPA_API_IMPL int spa_filter_graph_deactivate(struct spa_filter_graph *object)
SPA_API_FILTER_GRAPH int spa_filter_graph_deactivate(struct spa_filter_graph *object)
{
return spa_api_method_r(int, -ENOTSUP,
spa_filter_graph, &object->iface, deactivate, 0);
}
SPA_API_IMPL int spa_filter_graph_reset(struct spa_filter_graph *object)
SPA_API_FILTER_GRAPH int spa_filter_graph_reset(struct spa_filter_graph *object)
{
return spa_api_method_r(int, -ENOTSUP,
spa_filter_graph, &object->iface, reset, 0);
}
SPA_API_IMPL int spa_filter_graph_process(struct spa_filter_graph *object,
SPA_API_FILTER_GRAPH int spa_filter_graph_process(struct spa_filter_graph *object,
const struct spa_filter_graph_chunk in[], uint32_t n_in,
struct spa_filter_graph_chunk out[], uint32_t n_out)
{

55
spa/include/spa/graph/graph.h
View file

@ -25,6 +25,15 @@ extern "C" {
#include <spa/node/node.h>
#include <spa/node/io.h>
#ifndef SPA_API_GRAPH
#ifdef SPA_API_IMPL
#define SPA_API_GRAPH SPA_API_IMPL
#else
#define SPA_API_GRAPH static inline
#endif
#endif
#ifndef spa_debug
#define spa_debug(...)
#endif
@ -40,7 +49,7 @@ struct spa_graph_state {
int32_t pending; /**< number of pending signals */
};
SPA_API_IMPL void spa_graph_state_reset(struct spa_graph_state *state)
SPA_API_GRAPH void spa_graph_state_reset(struct spa_graph_state *state)
{
state->pending = state->required;
}
@ -56,7 +65,7 @@ struct spa_graph_link {
#define spa_graph_state_dec(s) (SPA_ATOMIC_DEC(s->pending) == 0)
SPA_API_IMPL int spa_graph_link_trigger(struct spa_graph_link *link)
SPA_API_GRAPH int spa_graph_link_trigger(struct spa_graph_link *link)
{
struct spa_graph_state *state = link->state;
@ -118,7 +127,7 @@ struct spa_graph_port {
struct spa_graph_port *peer; /**< peer */
};
SPA_API_IMPL int spa_graph_node_trigger(struct spa_graph_node *node)
SPA_API_GRAPH int spa_graph_node_trigger(struct spa_graph_node *node)
{
struct spa_graph_link *l;
spa_debug("node %p trigger", node);
@ -127,7 +136,7 @@ SPA_API_IMPL int spa_graph_node_trigger(struct spa_graph_node *node)
return 0;
}
SPA_API_IMPL int spa_graph_run(struct spa_graph *graph)
SPA_API_GRAPH int spa_graph_run(struct spa_graph *graph)
{
struct spa_graph_node *n, *t;
struct spa_list pending;
@ -152,27 +161,27 @@ SPA_API_IMPL int spa_graph_run(struct spa_graph *graph)
return 0;
}
SPA_API_IMPL int spa_graph_finish(struct spa_graph *graph)
SPA_API_GRAPH int spa_graph_finish(struct spa_graph *graph)
{
spa_debug("graph %p finish", graph);
if (graph->parent)
return spa_graph_node_trigger(graph->parent);
return 0;
}
SPA_API_IMPL int spa_graph_link_signal_node(void *data)
SPA_API_GRAPH int spa_graph_link_signal_node(void *data)
{
struct spa_graph_node *node = (struct spa_graph_node *)data;
spa_debug("node %p call process", node);
return spa_graph_node_process(node);
}
SPA_API_IMPL int spa_graph_link_signal_graph(void *data)
SPA_API_GRAPH int spa_graph_link_signal_graph(void *data)
{
struct spa_graph_node *node = (struct spa_graph_node *)data;
return spa_graph_finish(node->graph);
}
SPA_API_IMPL void spa_graph_init(struct spa_graph *graph, struct spa_graph_state *state)
SPA_API_GRAPH void spa_graph_init(struct spa_graph *graph, struct spa_graph_state *state)
{
spa_list_init(&graph->nodes);
graph->flags = 0;
@ -180,7 +189,7 @@ SPA_API_IMPL void spa_graph_init(struct spa_graph *graph, struct spa_graph_state
spa_debug("graph %p init state %p", graph, state);
}
SPA_API_IMPL void
SPA_API_GRAPH void
spa_graph_link_add(struct spa_graph_node *out,
struct spa_graph_state *state,
struct spa_graph_link *link)
@ -191,14 +200,14 @@ spa_graph_link_add(struct spa_graph_node *out,
spa_list_append(&out->links, &link->link);
}
SPA_API_IMPL void spa_graph_link_remove(struct spa_graph_link *link)
SPA_API_GRAPH void spa_graph_link_remove(struct spa_graph_link *link)
{
link->state->required--;
spa_debug("link %p state %p remove %d", link, link->state, link->state->required);
spa_list_remove(&link->link);
}
SPA_API_IMPL void
SPA_API_GRAPH void
spa_graph_node_init(struct spa_graph_node *node, struct spa_graph_state *state)
{
spa_list_init(&node->ports[SPA_DIRECTION_INPUT]);
@ -215,7 +224,7 @@ spa_graph_node_init(struct spa_graph_node *node, struct spa_graph_state *state)
}
SPA_API_IMPL int spa_graph_node_impl_sub_process(void *data SPA_UNUSED, struct spa_graph_node *node)
SPA_API_GRAPH int spa_graph_node_impl_sub_process(void *data SPA_UNUSED, struct spa_graph_node *node)
{
struct spa_graph *graph = node->subgraph;
spa_debug("node %p: sub process %p", node, graph);
@ -227,7 +236,7 @@ static const struct spa_graph_node_callbacks spa_graph_node_sub_impl_default = {
.process = spa_graph_node_impl_sub_process,
};
SPA_API_IMPL void spa_graph_node_set_subgraph(struct spa_graph_node *node,
SPA_API_GRAPH void spa_graph_node_set_subgraph(struct spa_graph_node *node,
struct spa_graph *subgraph)
{
node->subgraph = subgraph;
@ -235,7 +244,7 @@ SPA_API_IMPL void spa_graph_node_set_subgraph(struct spa_graph_node *node,
spa_debug("node %p set subgraph %p", node, subgraph);
}
SPA_API_IMPL void
SPA_API_GRAPH void
spa_graph_node_set_callbacks(struct spa_graph_node *node,
const struct spa_graph_node_callbacks *callbacks,
void *data)
@ -243,7 +252,7 @@ spa_graph_node_set_callbacks(struct spa_graph_node *node,
node->callbacks = SPA_CALLBACKS_INIT(callbacks, data);
}
SPA_API_IMPL void
SPA_API_GRAPH void
spa_graph_node_add(struct spa_graph *graph,
struct spa_graph_node *node)
{
@ -255,7 +264,7 @@ spa_graph_node_add(struct spa_graph *graph,
spa_graph_link_add(node, graph->state, &node->graph_link);
}
SPA_API_IMPL void spa_graph_node_remove(struct spa_graph_node *node)
SPA_API_GRAPH void spa_graph_node_remove(struct spa_graph_node *node)
{
spa_debug("node %p remove from graph %p, state %p required %d",
node, node->graph, node->state, node->state->required);
@ -265,7 +274,7 @@ SPA_API_IMPL void spa_graph_node_remove(struct spa_graph_node *node)
}
SPA_API_IMPL void
SPA_API_GRAPH void
spa_graph_port_init(struct spa_graph_port *port,
enum spa_direction direction,
uint32_t port_id,
@ -277,7 +286,7 @@ spa_graph_port_init(struct spa_graph_port *port,
port->flags = flags;
}
SPA_API_IMPL void
SPA_API_GRAPH void
spa_graph_port_add(struct spa_graph_node *node,
struct spa_graph_port *port)
{
@ -286,13 +295,13 @@ spa_graph_port_add(struct spa_graph_node *node,
spa_list_append(&node->ports[port->direction], &port->link);
}
SPA_API_IMPL void spa_graph_port_remove(struct spa_graph_port *port)
SPA_API_GRAPH void spa_graph_port_remove(struct spa_graph_port *port)
{
spa_debug("port %p remove", port);
spa_list_remove(&port->link);
}
SPA_API_IMPL void
SPA_API_GRAPH void
spa_graph_port_link(struct spa_graph_port *out, struct spa_graph_port *in)
{
spa_debug("port %p link to %p %p %p", out, in, in->node, in->node->state);
@ -300,7 +309,7 @@ spa_graph_port_link(struct spa_graph_port *out, struct spa_graph_port *in)
in->peer = out;
}
SPA_API_IMPL void
SPA_API_GRAPH void
spa_graph_port_unlink(struct spa_graph_port *port)
{
spa_debug("port %p unlink from %p", port, port->peer);
@ -310,7 +319,7 @@ spa_graph_port_unlink(struct spa_graph_port *port)
}
}
SPA_API_IMPL int spa_graph_node_impl_process(void *data, struct spa_graph_node *node)
SPA_API_GRAPH int spa_graph_node_impl_process(void *data, struct spa_graph_node *node)
{
struct spa_node *n = (struct spa_node *)data;
struct spa_graph_state *state = node->state;
@ -322,7 +331,7 @@ SPA_API_IMPL int spa_graph_node_impl_process(void *data, struct spa_graph_node *
return state->status;
}
SPA_API_IMPL int spa_graph_node_impl_reuse_buffer(void *data, struct spa_graph_node *node SPA_UNUSED,
SPA_API_GRAPH int spa_graph_node_impl_reuse_buffer(void *data, struct spa_graph_node *node SPA_UNUSED,
uint32_t port_id, uint32_t buffer_id)
{
struct spa_node *n = (struct spa_node *)data;

28
spa/include/spa/interfaces/audio/aec.h
View file

@ -14,6 +14,14 @@
extern "C" {
#endif
#ifndef SPA_API_AUDIO_AEC
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_AEC SPA_API_IMPL
#else
#define SPA_API_AUDIO_AEC static inline
#endif
#endif
#define SPA_TYPE_INTERFACE_AUDIO_AEC SPA_TYPE_INFO_INTERFACE_BASE "Audio:AEC"
#define SPA_VERSION_AUDIO_AEC 1
@ -68,7 +76,7 @@ struct spa_audio_aec_methods {
struct spa_audio_info_raw *out_info);
};
SPA_API_IMPL int spa_audio_aec_add_listener(struct spa_audio_aec *object,
SPA_API_AUDIO_AEC int spa_audio_aec_add_listener(struct spa_audio_aec *object,
struct spa_hook *listener,
const struct spa_audio_aec_events *events,
void *data)
@ -77,52 +85,52 @@ SPA_API_IMPL int spa_audio_aec_add_listener(struct spa_audio_aec *object,
spa_audio_aec, &object->iface, add_listener, 0, listener, events, data);
}
SPA_API_IMPL int spa_audio_aec_init(struct spa_audio_aec *object,
SPA_API_AUDIO_AEC int spa_audio_aec_init(struct spa_audio_aec *object,
const struct spa_dict *args, const struct spa_audio_info_raw *info)
{
return spa_api_method_r(int, -ENOTSUP,
spa_audio_aec, &object->iface, init, 0, args, info);
}
SPA_API_IMPL int spa_audio_aec_run(struct spa_audio_aec *object,
SPA_API_AUDIO_AEC int spa_audio_aec_run(struct spa_audio_aec *object,
const float *rec[], const float *play[], float *out[], uint32_t n_samples)
{
return spa_api_method_r(int, -ENOTSUP,
spa_audio_aec, &object->iface, run, 0, rec, play, out, n_samples);
}
SPA_API_IMPL int spa_audio_aec_set_props(struct spa_audio_aec *object, const struct spa_dict *args)
SPA_API_AUDIO_AEC int spa_audio_aec_set_props(struct spa_audio_aec *object, const struct spa_dict *args)
{
return spa_api_method_r(int, -ENOTSUP,
spa_audio_aec, &object->iface, set_props, 0, args);
}
SPA_API_IMPL int spa_audio_aec_activate(struct spa_audio_aec *object)
SPA_API_AUDIO_AEC int spa_audio_aec_activate(struct spa_audio_aec *object)
{
return spa_api_method_r(int, -ENOTSUP,
spa_audio_aec, &object->iface, activate, 1);
}
SPA_API_IMPL int spa_audio_aec_deactivate(struct spa_audio_aec *object)
SPA_API_AUDIO_AEC int spa_audio_aec_deactivate(struct spa_audio_aec *object)
{
return spa_api_method_r(int, -ENOTSUP,
spa_audio_aec, &object->iface, deactivate, 1);
}
SPA_API_IMPL int spa_audio_aec_enum_props(struct spa_audio_aec *object,
SPA_API_AUDIO_AEC int spa_audio_aec_enum_props(struct spa_audio_aec *object,
int index, struct spa_pod_builder* builder)
{
return spa_api_method_r(int, -ENOTSUP,
spa_audio_aec, &object->iface, enum_props, 2, index, builder);
}
SPA_API_IMPL int spa_audio_aec_get_params(struct spa_audio_aec *object,
SPA_API_AUDIO_AEC int spa_audio_aec_get_params(struct spa_audio_aec *object,
struct spa_pod_builder* builder)
{
return spa_api_method_r(int, -ENOTSUP,
spa_audio_aec, &object->iface, get_params, 2, builder);
}
SPA_API_IMPL int spa_audio_aec_set_params(struct spa_audio_aec *object,
SPA_API_AUDIO_AEC int spa_audio_aec_set_params(struct spa_audio_aec *object,
const struct spa_pod *args)
{
return spa_api_method_r(int, -ENOTSUP,
spa_audio_aec, &object->iface, set_params, 2, args);
}
SPA_API_IMPL int spa_audio_aec_init2(struct spa_audio_aec *object,
SPA_API_AUDIO_AEC int spa_audio_aec_init2(struct spa_audio_aec *object,
const struct spa_dict *args,
struct spa_audio_info_raw *play_info,
struct spa_audio_info_raw *rec_info,

16
spa/include/spa/monitor/device.h
View file

@ -14,6 +14,14 @@ extern "C" {
#include <spa/utils/dict.h>
#include <spa/pod/event.h>
#ifndef SPA_API_DEVICE
#ifdef SPA_API_IMPL
#define SPA_API_DEVICE SPA_API_IMPL
#else
#define SPA_API_DEVICE static inline
#endif
#endif
/**
* \defgroup spa_device Device
*
@ -220,7 +228,7 @@ struct spa_device_methods {
const struct spa_pod *param);
};
SPA_API_IMPL int spa_device_add_listener(struct spa_device *object,
SPA_API_DEVICE int spa_device_add_listener(struct spa_device *object,
struct spa_hook *listener,
const struct spa_device_events *events,
void *data)
@ -229,19 +237,19 @@ SPA_API_IMPL int spa_device_add_listener(struct spa_device *object,
listener, events, data);
}
SPA_API_IMPL int spa_device_sync(struct spa_device *object, int seq)
SPA_API_DEVICE int spa_device_sync(struct spa_device *object, int seq)
{
return spa_api_method_r(int, -ENOTSUP, spa_device, &object->iface, sync, 0,
seq);
}
SPA_API_IMPL int spa_device_enum_params(struct spa_device *object, int seq,
SPA_API_DEVICE int spa_device_enum_params(struct spa_device *object, int seq,
uint32_t id, uint32_t index, uint32_t max,
const struct spa_pod *filter)
{
return spa_api_method_r(int, -ENOTSUP, spa_device, &object->iface, enum_params, 0,
seq, id, index, max, filter);
}
SPA_API_IMPL int spa_device_set_param(struct spa_device *object,
SPA_API_DEVICE int spa_device_set_param(struct spa_device *object,
uint32_t id, uint32_t flags,
const struct spa_pod *param)
{

12
spa/include/spa/monitor/utils.h
View file

@ -12,6 +12,14 @@ extern "C" {
#include <spa/pod/builder.h>
#include <spa/monitor/device.h>
#ifndef SPA_API_DEVICE_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_DEVICE_UTILS SPA_API_IMPL
#else
#define SPA_API_DEVICE_UTILS static inline
#endif
#endif
/**
* \addtogroup spa_device
* \{
@ -22,7 +30,7 @@ struct spa_result_device_params_data {
struct spa_result_device_params data;
};
SPA_API_IMPL void spa_result_func_device_params(void *data, int seq SPA_UNUSED, int res SPA_UNUSED,
SPA_API_DEVICE_UTILS void spa_result_func_device_params(void *data, int seq SPA_UNUSED, int res SPA_UNUSED,
uint32_t type SPA_UNUSED, const void *result)
{
struct spa_result_device_params_data *d =
@ -36,7 +44,7 @@ SPA_API_IMPL void spa_result_func_device_params(void *data, int seq SPA_UNUSED,
d->data.param = spa_pod_builder_deref(d->builder, offset);
}
SPA_API_IMPL int spa_device_enum_params_sync(struct spa_device *device,
SPA_API_DEVICE_UTILS int spa_device_enum_params_sync(struct spa_device *device,
uint32_t id, uint32_t *index,
const struct spa_pod *filter,
struct spa_pod **param,

42
spa/include/spa/node/node.h
View file

@ -27,6 +27,14 @@ extern "C" {
#include <spa/node/event.h>
#include <spa/node/command.h>
#ifndef SPA_API_NODE
#ifdef SPA_API_IMPL
#define SPA_API_NODE SPA_API_IMPL
#else
#define SPA_API_NODE static inline
#endif
#endif
#define SPA_TYPE_INTERFACE_Node SPA_TYPE_INFO_INTERFACE_BASE "Node"
@ -634,7 +642,7 @@ struct spa_node_methods {
};
SPA_API_IMPL int spa_node_add_listener(struct spa_node *object,
SPA_API_NODE int spa_node_add_listener(struct spa_node *object,
struct spa_hook *listener,
const struct spa_node_events *events,
void *data)
@ -642,58 +650,58 @@ SPA_API_IMPL int spa_node_add_listener(struct spa_node *object,
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, add_listener, 0,
listener, events, data);
}
SPA_API_IMPL int spa_node_set_callbacks(struct spa_node *object,
SPA_API_NODE int spa_node_set_callbacks(struct spa_node *object,
const struct spa_node_callbacks *callbacks,
void *data)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, set_callbacks, 0,
callbacks, data);
}
SPA_API_IMPL int spa_node_sync(struct spa_node *object, int seq)
SPA_API_NODE int spa_node_sync(struct spa_node *object, int seq)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, sync, 0,
seq);
}
SPA_API_IMPL int spa_node_enum_params(struct spa_node *object, int seq,
SPA_API_NODE int spa_node_enum_params(struct spa_node *object, int seq,
uint32_t id, uint32_t start, uint32_t max,
const struct spa_pod *filter)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, enum_params, 0,
seq, id, start, max, filter);
}
SPA_API_IMPL int spa_node_set_param(struct spa_node *object,
SPA_API_NODE int spa_node_set_param(struct spa_node *object,
uint32_t id, uint32_t flags,
const struct spa_pod *param)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, set_param, 0,
id, flags, param);
}
SPA_API_IMPL int spa_node_set_io(struct spa_node *object,
SPA_API_NODE int spa_node_set_io(struct spa_node *object,
uint32_t id, void *data, size_t size)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, set_io, 0,
id, data, size);
}
SPA_API_IMPL int spa_node_send_command(struct spa_node *object,
SPA_API_NODE int spa_node_send_command(struct spa_node *object,
const struct spa_command *command)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, send_command, 0,
command);
}
SPA_API_IMPL int spa_node_add_port(struct spa_node *object,
SPA_API_NODE int spa_node_add_port(struct spa_node *object,
enum spa_direction direction, uint32_t port_id,
const struct spa_dict *props)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, add_port, 0,
direction, port_id, props);
}
SPA_API_IMPL int spa_node_remove_port(struct spa_node *object,
SPA_API_NODE int spa_node_remove_port(struct spa_node *object,
enum spa_direction direction, uint32_t port_id)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, remove_port, 0,
direction, port_id);
}
SPA_API_IMPL int spa_node_port_enum_params(struct spa_node *object, int seq,
SPA_API_NODE int spa_node_port_enum_params(struct spa_node *object, int seq,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t start, uint32_t max,
const struct spa_pod *filter)
@ -701,7 +709,7 @@ SPA_API_IMPL int spa_node_port_enum_params(struct spa_node *object, int seq,
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, port_enum_params, 0,
seq, direction, port_id, id, start, max, filter);
}
SPA_API_IMPL int spa_node_port_set_param(struct spa_node *object,
SPA_API_NODE int spa_node_port_set_param(struct spa_node *object,
enum spa_direction direction,
uint32_t port_id,
uint32_t id, uint32_t flags,
@ -710,7 +718,7 @@ SPA_API_IMPL int spa_node_port_set_param(struct spa_node *object,
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, port_set_param, 0,
direction, port_id, id, flags, param);
}
SPA_API_IMPL int spa_node_port_use_buffers(struct spa_node *object,
SPA_API_NODE int spa_node_port_use_buffers(struct spa_node *object,
enum spa_direction direction,
uint32_t port_id,
uint32_t flags,
@ -720,7 +728,7 @@ SPA_API_IMPL int spa_node_port_use_buffers(struct spa_node *object,
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, port_use_buffers, 0,
direction, port_id, flags, buffers, n_buffers);
}
SPA_API_IMPL int spa_node_port_set_io(struct spa_node *object,
SPA_API_NODE int spa_node_port_set_io(struct spa_node *object,
enum spa_direction direction,
uint32_t port_id,
uint32_t id, void *data, size_t size)
@ -729,21 +737,21 @@ SPA_API_IMPL int spa_node_port_set_io(struct spa_node *object,
direction, port_id, id, data, size);
}
SPA_API_IMPL int spa_node_port_reuse_buffer(struct spa_node *object, uint32_t port_id, uint32_t buffer_id)
SPA_API_NODE int spa_node_port_reuse_buffer(struct spa_node *object, uint32_t port_id, uint32_t buffer_id)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, port_reuse_buffer, 0,
port_id, buffer_id);
}
SPA_API_IMPL int spa_node_port_reuse_buffer_fast(struct spa_node *object, uint32_t port_id, uint32_t buffer_id)
SPA_API_NODE int spa_node_port_reuse_buffer_fast(struct spa_node *object, uint32_t port_id, uint32_t buffer_id)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_node, &object->iface, port_reuse_buffer, 0,
port_id, buffer_id);
}
SPA_API_IMPL int spa_node_process(struct spa_node *object)
SPA_API_NODE int spa_node_process(struct spa_node *object)
{
return spa_api_method_r(int, -ENOTSUP, spa_node, &object->iface, process, 0);
}
SPA_API_IMPL int spa_node_process_fast(struct spa_node *object)
SPA_API_NODE int spa_node_process_fast(struct spa_node *object)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_node, &object->iface, process, 0);
}

14
spa/include/spa/node/utils.h
View file

@ -18,12 +18,20 @@ extern "C" {
#include <spa/node/node.h>
#ifndef SPA_API_NODE_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_NODE_UTILS SPA_API_IMPL
#else
#define SPA_API_NODE_UTILS static inline
#endif
#endif
struct spa_result_node_params_data {
struct spa_pod_builder *builder;
struct spa_result_node_params data;
};
SPA_API_IMPL void spa_result_func_node_params(void *data,
SPA_API_NODE_UTILS void spa_result_func_node_params(void *data,
int seq SPA_UNUSED, int res SPA_UNUSED, uint32_t type SPA_UNUSED, const void *result)
{
struct spa_result_node_params_data *d =
@ -37,7 +45,7 @@ SPA_API_IMPL void spa_result_func_node_params(void *data,
d->data.param = spa_pod_builder_deref(d->builder, offset);
}
SPA_API_IMPL int spa_node_enum_params_sync(struct spa_node *node,
SPA_API_NODE_UTILS int spa_node_enum_params_sync(struct spa_node *node,
uint32_t id, uint32_t *index,
const struct spa_pod *filter,
struct spa_pod **param,
@ -70,7 +78,7 @@ SPA_API_IMPL int spa_node_enum_params_sync(struct spa_node *node,
return res;
}
SPA_API_IMPL int spa_node_port_enum_params_sync(struct spa_node *node,
SPA_API_NODE_UTILS int spa_node_port_enum_params_sync(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t *index,
const struct spa_pod *filter,

12
spa/include/spa/param/audio/aac-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_AAC_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_AAC_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_AAC_UTILS static inline
#endif
#endif
SPA_API_AUDIO_AAC_UTILS int
spa_format_audio_aac_parse(const struct spa_pod *format, struct spa_audio_info_aac *info)
{
int res;
@ -33,7 +41,7 @@ spa_format_audio_aac_parse(const struct spa_pod *format, struct spa_audio_info_a
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_AAC_UTILS struct spa_pod *
spa_format_audio_aac_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_aac *info)
{

13
spa/include/spa/param/audio/alac-utils.h
View file

@ -19,7 +19,16 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_ALAC_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_ALAC_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_ALAC_UTILS static inline
#endif
#endif
SPA_API_AUDIO_ALAC_UTILS int
spa_format_audio_alac_parse(const struct spa_pod *format, struct spa_audio_info_alac *info)
{
int res;
@ -30,7 +39,7 @@ spa_format_audio_alac_parse(const struct spa_pod *format, struct spa_audio_info_
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_ALAC_UTILS struct spa_pod *
spa_format_audio_alac_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_alac *info)
{

13
spa/include/spa/param/audio/amr-utils.h
View file

@ -19,7 +19,16 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_AMR_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_AMR_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_AMR_UTILS static inline
#endif
#endif
SPA_API_AUDIO_AMR_UTILS int
spa_format_audio_amr_parse(const struct spa_pod *format, struct spa_audio_info_amr *info)
{
int res;
@ -31,7 +40,7 @@ spa_format_audio_amr_parse(const struct spa_pod *format, struct spa_audio_info_a
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_AMR_UTILS struct spa_pod *
spa_format_audio_amr_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_amr *info)
{

12
spa/include/spa/param/audio/ape-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_APE_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_APE_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_APE_UTILS static inline
#endif
#endif
SPA_API_AUDIO_APE_UTILS int
spa_format_audio_ape_parse(const struct spa_pod *format, struct spa_audio_info_ape *info)
{
int res;
@ -30,7 +38,7 @@ spa_format_audio_ape_parse(const struct spa_pod *format, struct spa_audio_info_a
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_APE_UTILS struct spa_pod *
spa_format_audio_ape_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_ape *info)
{

12
spa/include/spa/param/audio/dsd-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/format-utils.h>
#include <spa/param/audio/format.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_DSD_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_DSD_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_DSD_UTILS static inline
#endif
#endif
SPA_API_AUDIO_DSD_UTILS int
spa_format_audio_dsd_parse(const struct spa_pod *format, struct spa_audio_info_dsd *info)
{
struct spa_pod *position = NULL;
@ -39,7 +47,7 @@ spa_format_audio_dsd_parse(const struct spa_pod *format, struct spa_audio_info_d
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_DSD_UTILS struct spa_pod *
spa_format_audio_dsd_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_dsd *info)
{

12
spa/include/spa/param/audio/dsp-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_DSP_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_DSP_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_DSP_UTILS static inline
#endif
#endif
SPA_API_AUDIO_DSP_UTILS int
spa_format_audio_dsp_parse(const struct spa_pod *format, struct spa_audio_info_dsp *info)
{
int res;
@ -29,7 +37,7 @@ spa_format_audio_dsp_parse(const struct spa_pod *format, struct spa_audio_info_d
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_DSP_UTILS struct spa_pod *
spa_format_audio_dsp_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_dsp *info)
{

12
spa/include/spa/param/audio/flac-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_FLAC_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_FLAC_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_FLAC_UTILS static inline
#endif
#endif
SPA_API_AUDIO_FLAC_UTILS int
spa_format_audio_flac_parse(const struct spa_pod *format, struct spa_audio_info_flac *info)
{
int res;
@ -30,7 +38,7 @@ spa_format_audio_flac_parse(const struct spa_pod *format, struct spa_audio_info_
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_FLAC_UTILS struct spa_pod *
spa_format_audio_flac_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_flac *info)
{

12
spa/include/spa/param/audio/format-utils.h
View file

@ -34,7 +34,15 @@ extern "C" {
* \{
*/
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_FORMAT_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_FORMAT_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_FORMAT_UTILS static inline
#endif
#endif
SPA_API_AUDIO_FORMAT_UTILS int
spa_format_audio_parse(const struct spa_pod *format, struct spa_audio_info *info)
{
int res;
@ -76,7 +84,7 @@ spa_format_audio_parse(const struct spa_pod *format, struct spa_audio_info *info
return -ENOTSUP;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_FORMAT_UTILS struct spa_pod *
spa_format_audio_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info *info)
{

12
spa/include/spa/param/audio/iec958-types.h
View file

@ -17,6 +17,14 @@ extern "C" {
* \{
*/
#ifndef SPA_API_AUDIO_IEC958_TYPES
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_IEC958_TYPES SPA_API_IMPL
#else
#define SPA_API_AUDIO_IEC958_TYPES static inline
#endif
#endif
#define SPA_TYPE_INFO_AudioIEC958Codec SPA_TYPE_INFO_ENUM_BASE "AudioIEC958Codec"
#define SPA_TYPE_INFO_AUDIO_IEC958_CODEC_BASE SPA_TYPE_INFO_AudioIEC958Codec ":"
@ -33,11 +41,11 @@ static const struct spa_type_info spa_type_audio_iec958_codec[] = {
{ 0, 0, NULL, NULL },
};
SPA_API_IMPL uint32_t spa_type_audio_iec958_codec_from_short_name(const char *name)
SPA_API_AUDIO_IEC958_TYPES uint32_t spa_type_audio_iec958_codec_from_short_name(const char *name)
{
return spa_type_from_short_name(name, spa_type_audio_iec958_codec, SPA_AUDIO_IEC958_CODEC_UNKNOWN);
}
SPA_API_IMPL const char * spa_type_audio_iec958_codec_to_short_name(uint32_t type)
SPA_API_AUDIO_IEC958_TYPES const char * spa_type_audio_iec958_codec_to_short_name(uint32_t type)
{
return spa_type_to_short_name(type, spa_type_audio_iec958_codec, "UNKNOWN");
}

12
spa/include/spa/param/audio/iec958-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_IEC958_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_IEC958_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_IEC958_UTILS static inline
#endif
#endif
SPA_API_AUDIO_IEC958_UTILS int
spa_format_audio_iec958_parse(const struct spa_pod *format, struct spa_audio_info_iec958 *info)
{
int res;
@ -30,7 +38,7 @@ spa_format_audio_iec958_parse(const struct spa_pod *format, struct spa_audio_inf
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_IEC958_UTILS struct spa_pod *
spa_format_audio_iec958_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_iec958 *info)
{

12
spa/include/spa/param/audio/mp3-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_MP3_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_MP3_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_MP3_UTILS static inline
#endif
#endif
SPA_API_AUDIO_MP3_UTILS int
spa_format_audio_mp3_parse(const struct spa_pod *format, struct spa_audio_info_mp3 *info)
{
int res;
@ -30,7 +38,7 @@ spa_format_audio_mp3_parse(const struct spa_pod *format, struct spa_audio_info_m
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_MP3_UTILS struct spa_pod *
spa_format_audio_mp3_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_mp3 *info)
{

12
spa/include/spa/param/audio/ra-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_RA_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_RA_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_RA_UTILS static inline
#endif
#endif
SPA_API_AUDIO_RA_UTILS int
spa_format_audio_ra_parse(const struct spa_pod *format, struct spa_audio_info_ra *info)
{
int res;
@ -30,7 +38,7 @@ spa_format_audio_ra_parse(const struct spa_pod *format, struct spa_audio_info_ra
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_RA_UTILS struct spa_pod *
spa_format_audio_ra_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_ra *info)
{

14
spa/include/spa/param/audio/raw-json.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/raw.h>
#include <spa/param/audio/raw-types.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_RAW_JSON
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_RAW_JSON SPA_API_IMPL
#else
#define SPA_API_AUDIO_RAW_JSON static inline
#endif
#endif
SPA_API_AUDIO_RAW_JSON int
spa_audio_parse_position(const char *str, size_t len,
uint32_t *position, uint32_t *n_channels)
{
@ -38,7 +46,7 @@ spa_audio_parse_position(const char *str, size_t len,
return channels;
}
SPA_API_IMPL int
SPA_API_AUDIO_RAW_JSON int
spa_audio_info_raw_update(struct spa_audio_info_raw *info, const char *key, const char *val, bool force)
{
uint32_t v;
@ -60,7 +68,7 @@ spa_audio_info_raw_update(struct spa_audio_info_raw *info, const char *key, cons
return 0;
}
SPA_API_IMPL int SPA_SENTINEL
SPA_API_AUDIO_RAW_JSON int SPA_SENTINEL
spa_audio_info_raw_init_dict_keys(struct spa_audio_info_raw *info,
const struct spa_dict *defaults,
const struct spa_dict *dict, ...)

16
spa/include/spa/param/audio/raw-types.h
View file

@ -18,6 +18,14 @@ extern "C" {
#include <spa/utils/string.h>
#include <spa/param/audio/raw.h>
#ifndef SPA_API_AUDIO_RAW_TYPES
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_RAW_TYPES SPA_API_IMPL
#else
#define SPA_API_AUDIO_RAW_TYPES static inline
#endif
#endif
#define SPA_TYPE_INFO_AudioFormat SPA_TYPE_INFO_ENUM_BASE "AudioFormat"
#define SPA_TYPE_INFO_AUDIO_FORMAT_BASE SPA_TYPE_INFO_AudioFormat ":"
@ -129,11 +137,11 @@ static const struct spa_type_info spa_type_audio_format[] = {
{ 0, 0, NULL, NULL },
};
SPA_API_IMPL uint32_t spa_type_audio_format_from_short_name(const char *name)
SPA_API_AUDIO_RAW_TYPES uint32_t spa_type_audio_format_from_short_name(const char *name)
{
return spa_type_from_short_name(name, spa_type_audio_format, SPA_AUDIO_FORMAT_UNKNOWN);
}
SPA_API_IMPL const char * spa_type_audio_format_to_short_name(uint32_t type)
SPA_API_AUDIO_RAW_TYPES const char * spa_type_audio_format_to_short_name(uint32_t type)
{
return spa_type_to_short_name(type, spa_type_audio_format, "UNKNOWN");
}
@ -257,11 +265,11 @@ static const struct spa_type_info spa_type_audio_channel[] = {
{ 0, 0, NULL, NULL },
};
SPA_API_IMPL uint32_t spa_type_audio_channel_from_short_name(const char *name)
SPA_API_AUDIO_RAW_TYPES uint32_t spa_type_audio_channel_from_short_name(const char *name)
{
return spa_type_from_short_name(name, spa_type_audio_channel, SPA_AUDIO_CHANNEL_UNKNOWN);
}
SPA_API_IMPL const char * spa_type_audio_channel_to_short_name(uint32_t type)
SPA_API_AUDIO_RAW_TYPES const char * spa_type_audio_channel_to_short_name(uint32_t type)
{
return spa_type_to_short_name(type, spa_type_audio_channel, "UNK");
}

12
spa/include/spa/param/audio/raw-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_RAW_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_RAW_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_RAW_UTILS static inline
#endif
#endif
SPA_API_AUDIO_RAW_UTILS int
spa_format_audio_raw_parse(const struct spa_pod *format, struct spa_audio_info_raw *info)
{
struct spa_pod *position = NULL;
@ -38,7 +46,7 @@ spa_format_audio_raw_parse(const struct spa_pod *format, struct spa_audio_info_r
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_RAW_UTILS struct spa_pod *
spa_format_audio_raw_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_raw *info)
{

12
spa/include/spa/param/audio/vorbis-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_VORBIS_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_VORBIS_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_VORBIS_UTILS static inline
#endif
#endif
SPA_API_AUDIO_VORBIS_UTILS int
spa_format_audio_vorbis_parse(const struct spa_pod *format, struct spa_audio_info_vorbis *info)
{
int res;
@ -30,7 +38,7 @@ spa_format_audio_vorbis_parse(const struct spa_pod *format, struct spa_audio_inf
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_VORBIS_UTILS struct spa_pod *
spa_format_audio_vorbis_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_vorbis *info)
{

12
spa/include/spa/param/audio/wma-utils.h
View file

@ -19,7 +19,15 @@ extern "C" {
#include <spa/param/audio/format.h>
#include <spa/param/format-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_AUDIO_WMA_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_AUDIO_WMA_UTILS SPA_API_IMPL
#else
#define SPA_API_AUDIO_WMA_UTILS static inline
#endif
#endif
SPA_API_AUDIO_WMA_UTILS int
spa_format_audio_wma_parse(const struct spa_pod *format, struct spa_audio_info_wma *info)
{
int res;
@ -33,7 +41,7 @@ spa_format_audio_wma_parse(const struct spa_pod *format, struct spa_audio_info_w
return res;
}
SPA_API_IMPL struct spa_pod *
SPA_API_AUDIO_WMA_UTILS struct spa_pod *
spa_format_audio_wma_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_audio_info_wma *info)
{

10
spa/include/spa/param/format-utils.h
View file

@ -18,7 +18,15 @@ extern "C" {
#include <spa/pod/parser.h>
#include <spa/param/format.h>
SPA_API_IMPL int
#ifndef SPA_API_FORMAT_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_FORMAT_UTILS SPA_API_IMPL
#else
#define SPA_API_FORMAT_UTILS static inline
#endif
#endif
SPA_API_FORMAT_UTILS int
spa_format_parse(const struct spa_pod *format, uint32_t *media_type, uint32_t *media_subtype)
{
return spa_pod_parse_object(format,

28
spa/include/spa/param/latency-utils.h
View file

@ -20,7 +20,15 @@ extern "C" {
#include <spa/pod/parser.h>
#include <spa/param/latency.h>
SPA_API_IMPL int
#ifndef SPA_API_LATENCY_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_LATENCY_UTILS SPA_API_IMPL
#else
#define SPA_API_LATENCY_UTILS static inline
#endif
#endif
SPA_API_LATENCY_UTILS int
spa_latency_info_compare(const struct spa_latency_info *a, const struct spa_latency_info *b)
{
if (a->min_quantum == b->min_quantum &&
@ -33,7 +41,7 @@ spa_latency_info_compare(const struct spa_latency_info *a, const struct spa_late
return 1;
}
SPA_API_IMPL void
SPA_API_LATENCY_UTILS void
spa_latency_info_combine_start(struct spa_latency_info *info, enum spa_direction direction)
{
*info = SPA_LATENCY_INFO(direction,
@ -44,7 +52,7 @@ spa_latency_info_combine_start(struct spa_latency_info *info, enum spa_direction
.min_ns = INT64_MAX,
.max_ns = INT64_MIN);
}
SPA_API_IMPL void
SPA_API_LATENCY_UTILS void
spa_latency_info_combine_finish(struct spa_latency_info *info)
{
if (info->min_quantum == FLT_MAX)
@ -61,7 +69,7 @@ spa_latency_info_combine_finish(struct spa_latency_info *info)
info->max_ns = 0;
}
SPA_API_IMPL int
SPA_API_LATENCY_UTILS int
spa_latency_info_combine(struct spa_latency_info *info, const struct spa_latency_info *other)
{
if (info->direction != other->direction)
@ -81,7 +89,7 @@ spa_latency_info_combine(struct spa_latency_info *info, const struct spa_latency
return 0;
}
SPA_API_IMPL int
SPA_API_LATENCY_UTILS int
spa_latency_parse(const struct spa_pod *latency, struct spa_latency_info *info)
{
int res;
@ -100,7 +108,7 @@ spa_latency_parse(const struct spa_pod *latency, struct spa_latency_info *info)
return 0;
}
SPA_API_IMPL struct spa_pod *
SPA_API_LATENCY_UTILS struct spa_pod *
spa_latency_build(struct spa_pod_builder *builder, uint32_t id, const struct spa_latency_info *info)
{
return (struct spa_pod *)spa_pod_builder_add_object(builder,
@ -114,7 +122,7 @@ spa_latency_build(struct spa_pod_builder *builder, uint32_t id, const struct spa
SPA_PARAM_LATENCY_maxNs, SPA_POD_Long(info->max_ns));
}
SPA_API_IMPL int
SPA_API_LATENCY_UTILS int
spa_process_latency_parse(const struct spa_pod *latency, struct spa_process_latency_info *info)
{
int res;
@ -128,7 +136,7 @@ spa_process_latency_parse(const struct spa_pod *latency, struct spa_process_late
return 0;
}
SPA_API_IMPL struct spa_pod *
SPA_API_LATENCY_UTILS struct spa_pod *
spa_process_latency_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_process_latency_info *info)
{
@ -139,7 +147,7 @@ spa_process_latency_build(struct spa_pod_builder *builder, uint32_t id,
SPA_PARAM_PROCESS_LATENCY_ns, SPA_POD_Long(info->ns));
}
SPA_API_IMPL int
SPA_API_LATENCY_UTILS int
spa_process_latency_info_add(const struct spa_process_latency_info *process,
struct spa_latency_info *info)
{
@ -152,7 +160,7 @@ spa_process_latency_info_add(const struct spa_process_latency_info *process,
return 0;
}
SPA_API_IMPL int
SPA_API_LATENCY_UTILS int
spa_process_latency_info_compare(const struct spa_process_latency_info *a,
const struct spa_process_latency_info *b)
{

22
spa/include/spa/param/tag-utils.h
View file

@ -21,14 +21,22 @@ extern "C" {
#include <spa/pod/parser.h>
#include <spa/param/tag.h>
SPA_API_IMPL int
#ifndef SPA_API_TAG_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_TAG_UTILS SPA_API_IMPL
#else
#define SPA_API_TAG_UTILS static inline
#endif
#endif
SPA_API_TAG_UTILS int
spa_tag_compare(const struct spa_pod *a, const struct spa_pod *b)
{
return ((a == b) || (a && b && SPA_POD_SIZE(a) == SPA_POD_SIZE(b) &&
memcmp(a, b, SPA_POD_SIZE(b)) == 0)) ? 0 : 1;
}
SPA_API_IMPL int
SPA_API_TAG_UTILS int
spa_tag_parse(const struct spa_pod *tag, struct spa_tag_info *info, void **state)
{
int res;
@ -57,7 +65,7 @@ spa_tag_parse(const struct spa_pod *tag, struct spa_tag_info *info, void **state
return 0;
}
SPA_API_IMPL int
SPA_API_TAG_UTILS int
spa_tag_info_parse(const struct spa_tag_info *info, struct spa_dict *dict, struct spa_dict_item *items)
{
struct spa_pod_parser prs;
@ -90,7 +98,7 @@ spa_tag_info_parse(const struct spa_tag_info *info, struct spa_dict *dict, struc
return 0;
}
SPA_API_IMPL void
SPA_API_TAG_UTILS void
spa_tag_build_start(struct spa_pod_builder *builder, struct spa_pod_frame *f,
uint32_t id, enum spa_direction direction)
{
@ -100,7 +108,7 @@ spa_tag_build_start(struct spa_pod_builder *builder, struct spa_pod_frame *f,
0);
}
SPA_API_IMPL void
SPA_API_TAG_UTILS void
spa_tag_build_add_info(struct spa_pod_builder *builder, const struct spa_pod *info)
{
spa_pod_builder_add(builder,
@ -108,7 +116,7 @@ spa_tag_build_add_info(struct spa_pod_builder *builder, const struct spa_pod *in
0);
}
SPA_API_IMPL void
SPA_API_TAG_UTILS void
spa_tag_build_add_dict(struct spa_pod_builder *builder, const struct spa_dict *dict)
{
uint32_t i, n_items;
@ -126,7 +134,7 @@ spa_tag_build_add_dict(struct spa_pod_builder *builder, const struct spa_dict *d
spa_pod_builder_pop(builder, &f);
}
SPA_API_IMPL struct spa_pod *
SPA_API_TAG_UTILS struct spa_pod *
spa_tag_build_end(struct spa_pod_builder *builder, struct spa_pod_frame *f)
{
return (struct spa_pod*)spa_pod_builder_pop(builder, f);

12
spa/include/spa/param/video/dsp-utils.h
View file

@ -18,7 +18,15 @@ extern "C" {
#include <spa/pod/builder.h>
#include <spa/param/video/dsp.h>
SPA_API_IMPL int
#ifndef SPA_API_VIDEO_DSP_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_VIDEO_DSP_UTILS SPA_API_IMPL
#else
#define SPA_API_VIDEO_DSP_UTILS static inline
#endif
#endif
SPA_API_VIDEO_DSP_UTILS int
spa_format_video_dsp_parse(const struct spa_pod *format,
struct spa_video_info_dsp *info)
{
@ -36,7 +44,7 @@ spa_format_video_dsp_parse(const struct spa_pod *format,
SPA_FORMAT_VIDEO_modifier, SPA_POD_OPT_Long(&info->modifier));
}
SPA_API_IMPL struct spa_pod *
SPA_API_VIDEO_DSP_UTILS struct spa_pod *
spa_format_video_dsp_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_video_info_dsp *info)
{

12
spa/include/spa/param/video/format-utils.h
View file

@ -16,7 +16,15 @@ extern "C" {
#include <spa/param/video/h264-utils.h>
#include <spa/param/video/mjpg-utils.h>
SPA_API_IMPL int
#ifndef SPA_API_VIDEO_FORMAT_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_VIDEO_FORMAT_UTILS SPA_API_IMPL
#else
#define SPA_API_VIDEO_FORMAT_UTILS static inline
#endif
#endif
SPA_API_VIDEO_FORMAT_UTILS int
spa_format_video_parse(const struct spa_pod *format, struct spa_video_info *info)
{
int res;
@ -40,7 +48,7 @@ spa_format_video_parse(const struct spa_pod *format, struct spa_video_info *info
return -ENOTSUP;
}
SPA_API_IMPL struct spa_pod *
SPA_API_VIDEO_FORMAT_UTILS struct spa_pod *
spa_format_video_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_video_info *info)
{

12
spa/include/spa/param/video/h264-utils.h
View file

@ -18,7 +18,15 @@ extern "C" {
#include <spa/pod/builder.h>
#include <spa/param/video/h264.h>
SPA_API_IMPL int
#ifndef SPA_API_VIDEO_H264_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_VIDEO_H264_UTILS SPA_API_IMPL
#else
#define SPA_API_VIDEO_H264_UTILS static inline
#endif
#endif
SPA_API_VIDEO_H264_UTILS int
spa_format_video_h264_parse(const struct spa_pod *format,
struct spa_video_info_h264 *info)
{
@ -31,7 +39,7 @@ spa_format_video_h264_parse(const struct spa_pod *format,
SPA_FORMAT_VIDEO_H264_alignment, SPA_POD_OPT_Id(&info->alignment));
}
SPA_API_IMPL struct spa_pod *
SPA_API_VIDEO_H264_UTILS struct spa_pod *
spa_format_video_h264_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_video_info_h264 *info)
{

12
spa/include/spa/param/video/mjpg-utils.h
View file

@ -18,7 +18,15 @@ extern "C" {
#include <spa/pod/builder.h>
#include <spa/param/video/mjpg.h>
SPA_API_IMPL int
#ifndef SPA_API_VIDEO_MJPG_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_VIDEO_MJPG_UTILS SPA_API_IMPL
#else
#define SPA_API_VIDEO_MJPG_UTILS static inline
#endif
#endif
SPA_API_VIDEO_MJPG_UTILS int
spa_format_video_mjpg_parse(const struct spa_pod *format,
struct spa_video_info_mjpg *info)
{
@ -29,7 +37,7 @@ spa_format_video_mjpg_parse(const struct spa_pod *format,
SPA_FORMAT_VIDEO_maxFramerate, SPA_POD_OPT_Fraction(&info->max_framerate));
}
SPA_API_IMPL struct spa_pod *
SPA_API_VIDEO_MJPG_UTILS struct spa_pod *
spa_format_video_mjpg_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_video_info_mjpg *info)
{

12
spa/include/spa/param/video/raw-types.h
View file

@ -16,6 +16,14 @@ extern "C" {
#include <spa/utils/type.h>
#include <spa/param/video/raw.h>
#ifndef SPA_API_VIDEO_RAW_TYPES
#ifdef SPA_API_IMPL
#define SPA_API_VIDEO_RAW_TYPES SPA_API_IMPL
#else
#define SPA_API_VIDEO_RAW_TYPES static inline
#endif
#endif
#define SPA_TYPE_INFO_VideoFormat SPA_TYPE_INFO_ENUM_BASE "VideoFormat"
#define SPA_TYPE_INFO_VIDEO_FORMAT_BASE SPA_TYPE_INFO_VideoFormat ":"
@ -111,11 +119,11 @@ static const struct spa_type_info spa_type_video_format[] = {
{ 0, 0, NULL, NULL },
};
SPA_API_IMPL uint32_t spa_type_video_format_from_short_name(const char *name)
SPA_API_VIDEO_RAW_TYPES uint32_t spa_type_video_format_from_short_name(const char *name)
{
return spa_type_from_short_name(name, spa_type_video_format, SPA_VIDEO_FORMAT_UNKNOWN);
}
SPA_API_IMPL const char * spa_type_video_format_to_short_name(uint32_t type)
SPA_API_VIDEO_RAW_TYPES const char * spa_type_video_format_to_short_name(uint32_t type)
{
return spa_type_to_short_name(type, spa_type_video_format, "UNKNOWN");
}

12
spa/include/spa/param/video/raw-utils.h
View file

@ -18,7 +18,15 @@ extern "C" {
#include <spa/pod/builder.h>
#include <spa/param/video/raw.h>
SPA_API_IMPL int
#ifndef SPA_API_VIDEO_RAW_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_VIDEO_RAW_UTILS SPA_API_IMPL
#else
#define SPA_API_VIDEO_RAW_UTILS static inline
#endif
#endif
SPA_API_VIDEO_RAW_UTILS int
spa_format_video_raw_parse(const struct spa_pod *format,
struct spa_video_info_raw *info)
{
@ -49,7 +57,7 @@ spa_format_video_raw_parse(const struct spa_pod *format,
SPA_FORMAT_VIDEO_colorPrimaries, SPA_POD_OPT_Id(&info->color_primaries));
}
SPA_API_IMPL struct spa_pod *
SPA_API_VIDEO_RAW_UTILS struct spa_pod *
spa_format_video_raw_build(struct spa_pod_builder *builder, uint32_t id,
const struct spa_video_info_raw *info)
{

90
spa/include/spa/pod/builder.h
View file

@ -24,6 +24,14 @@ extern "C" {
#include <spa/pod/iter.h>
#include <spa/pod/vararg.h>
#ifndef SPA_API_POD_BUILDER
#ifdef SPA_API_IMPL
#define SPA_API_POD_BUILDER SPA_API_IMPL
#else
#define SPA_API_POD_BUILDER static inline
#endif
#endif
struct spa_pod_builder_state {
uint32_t offset;
#define SPA_POD_BUILDER_FLAG_BODY (1<<0)
@ -51,20 +59,20 @@ struct spa_pod_builder {
#define SPA_POD_BUILDER_INIT(buffer,size) ((struct spa_pod_builder){ (buffer), (size), 0, {0,0,NULL},{NULL,NULL}})
SPA_API_IMPL void
SPA_API_POD_BUILDER void
spa_pod_builder_get_state(struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
{
*state = builder->state;
}
SPA_API_IMPL void
SPA_API_POD_BUILDER void
spa_pod_builder_set_callbacks(struct spa_pod_builder *builder,
const struct spa_pod_builder_callbacks *callbacks, void *data)
{
builder->callbacks = SPA_CALLBACKS_INIT(callbacks, data);
}
SPA_API_IMPL void
SPA_API_POD_BUILDER void
spa_pod_builder_reset(struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
{
struct spa_pod_frame *f;
@ -74,12 +82,12 @@ spa_pod_builder_reset(struct spa_pod_builder *builder, struct spa_pod_builder_st
f->pod.size -= size;
}
SPA_API_IMPL void spa_pod_builder_init(struct spa_pod_builder *builder, void *data, uint32_t size)
SPA_API_POD_BUILDER void spa_pod_builder_init(struct spa_pod_builder *builder, void *data, uint32_t size)
{
*builder = SPA_POD_BUILDER_INIT(data, size);
}
SPA_API_IMPL struct spa_pod *
SPA_API_POD_BUILDER struct spa_pod *
spa_pod_builder_deref(struct spa_pod_builder *builder, uint32_t offset)
{
uint32_t size = builder->size;
@ -91,7 +99,7 @@ spa_pod_builder_deref(struct spa_pod_builder *builder, uint32_t offset)
return NULL;
}
SPA_API_IMPL struct spa_pod *
SPA_API_POD_BUILDER struct spa_pod *
spa_pod_builder_frame(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
{
if (frame->offset + SPA_POD_SIZE(&frame->pod) <= builder->size)
@ -99,7 +107,7 @@ spa_pod_builder_frame(struct spa_pod_builder *builder, struct spa_pod_frame *fra
return NULL;
}
SPA_API_IMPL void
SPA_API_POD_BUILDER void
spa_pod_builder_push(struct spa_pod_builder *builder,
struct spa_pod_frame *frame,
const struct spa_pod *pod,
@ -115,7 +123,7 @@ spa_pod_builder_push(struct spa_pod_builder *builder,
builder->state.flags = SPA_POD_BUILDER_FLAG_FIRST | SPA_POD_BUILDER_FLAG_BODY;
}
SPA_API_IMPL int spa_pod_builder_raw(struct spa_pod_builder *builder, const void *data, uint32_t size)
SPA_API_POD_BUILDER int spa_pod_builder_raw(struct spa_pod_builder *builder, const void *data, uint32_t size)
{
int res = 0;
struct spa_pod_frame *f;
@ -139,14 +147,14 @@ SPA_API_IMPL int spa_pod_builder_raw(struct spa_pod_builder *builder, const void
return res;
}
SPA_API_IMPL int spa_pod_builder_pad(struct spa_pod_builder *builder, uint32_t size)
SPA_API_POD_BUILDER int spa_pod_builder_pad(struct spa_pod_builder *builder, uint32_t size)
{
uint64_t zeroes = 0;
size = SPA_ROUND_UP_N(size, 8) - size;
return size ? spa_pod_builder_raw(builder, &zeroes, size) : 0;
}
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, uint32_t size)
{
int r, res = spa_pod_builder_raw(builder, data, size);
@ -155,7 +163,7 @@ spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, ui
return res;
}
SPA_API_IMPL void *spa_pod_builder_pop(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
SPA_API_POD_BUILDER void *spa_pod_builder_pop(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
{
struct spa_pod *pod;
@ -172,7 +180,7 @@ SPA_API_IMPL void *spa_pod_builder_pop(struct spa_pod_builder *builder, struct s
return pod;
}
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod *p)
{
const void *data;
@ -198,13 +206,13 @@ spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod
#define SPA_POD_INIT_None() SPA_POD_INIT(0, SPA_TYPE_None)
SPA_API_IMPL int spa_pod_builder_none(struct spa_pod_builder *builder)
SPA_API_POD_BUILDER int spa_pod_builder_none(struct spa_pod_builder *builder)
{
const struct spa_pod p = SPA_POD_INIT_None();
return spa_pod_builder_primitive(builder, &p);
}
SPA_API_IMPL int spa_pod_builder_child(struct spa_pod_builder *builder, uint32_t size, uint32_t type)
SPA_API_POD_BUILDER int spa_pod_builder_child(struct spa_pod_builder *builder, uint32_t size, uint32_t type)
{
const struct spa_pod p = SPA_POD_INIT(size,type);
SPA_FLAG_CLEAR(builder->state.flags, SPA_POD_BUILDER_FLAG_FIRST);
@ -213,7 +221,7 @@ SPA_API_IMPL int spa_pod_builder_child(struct spa_pod_builder *builder, uint32_t
#define SPA_POD_INIT_Bool(val) ((struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, (val) ? 1 : 0, 0 })
SPA_API_IMPL int spa_pod_builder_bool(struct spa_pod_builder *builder, bool val)
SPA_API_POD_BUILDER int spa_pod_builder_bool(struct spa_pod_builder *builder, bool val)
{
const struct spa_pod_bool p = SPA_POD_INIT_Bool(val);
return spa_pod_builder_primitive(builder, &p.pod);
@ -221,7 +229,7 @@ SPA_API_IMPL int spa_pod_builder_bool(struct spa_pod_builder *builder, bool val)
#define SPA_POD_INIT_Id(val) ((struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, (val), 0 })
SPA_API_IMPL int spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
SPA_API_POD_BUILDER int spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
{
const struct spa_pod_id p = SPA_POD_INIT_Id(val);
return spa_pod_builder_primitive(builder, &p.pod);
@ -229,7 +237,7 @@ SPA_API_IMPL int spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t va
#define SPA_POD_INIT_Int(val) ((struct spa_pod_int){ { sizeof(int32_t), SPA_TYPE_Int }, (val), 0 })
SPA_API_IMPL int spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
SPA_API_POD_BUILDER int spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
{
const struct spa_pod_int p = SPA_POD_INIT_Int(val);
return spa_pod_builder_primitive(builder, &p.pod);
@ -237,7 +245,7 @@ SPA_API_IMPL int spa_pod_builder_int(struct spa_pod_builder *builder, int32_t va
#define SPA_POD_INIT_Long(val) ((struct spa_pod_long){ { sizeof(int64_t), SPA_TYPE_Long }, (val) })
SPA_API_IMPL int spa_pod_builder_long(struct spa_pod_builder *builder, int64_t val)
SPA_API_POD_BUILDER int spa_pod_builder_long(struct spa_pod_builder *builder, int64_t val)
{
const struct spa_pod_long p = SPA_POD_INIT_Long(val);
return spa_pod_builder_primitive(builder, &p.pod);
@ -245,7 +253,7 @@ SPA_API_IMPL int spa_pod_builder_long(struct spa_pod_builder *builder, int64_t v
#define SPA_POD_INIT_Float(val) ((struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, (val), 0 })
SPA_API_IMPL int spa_pod_builder_float(struct spa_pod_builder *builder, float val)
SPA_API_POD_BUILDER int spa_pod_builder_float(struct spa_pod_builder *builder, float val)
{
const struct spa_pod_float p = SPA_POD_INIT_Float(val);
return spa_pod_builder_primitive(builder, &p.pod);
@ -253,7 +261,7 @@ SPA_API_IMPL int spa_pod_builder_float(struct spa_pod_builder *builder, float va
#define SPA_POD_INIT_Double(val) ((struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, (val) })
SPA_API_IMPL int spa_pod_builder_double(struct spa_pod_builder *builder, double val)
SPA_API_POD_BUILDER int spa_pod_builder_double(struct spa_pod_builder *builder, double val)
{
const struct spa_pod_double p = SPA_POD_INIT_Double(val);
return spa_pod_builder_primitive(builder, &p.pod);
@ -261,7 +269,7 @@ SPA_API_IMPL int spa_pod_builder_double(struct spa_pod_builder *builder, double
#define SPA_POD_INIT_String(len) ((struct spa_pod_string){ { (len), SPA_TYPE_String } })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len)
{
int r, res;
@ -273,7 +281,7 @@ spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, u
return res;
}
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_string_len(struct spa_pod_builder *builder, const char *str, uint32_t len)
{
const struct spa_pod_string p = SPA_POD_INIT_String(len+1);
@ -283,7 +291,7 @@ spa_pod_builder_string_len(struct spa_pod_builder *builder, const char *str, uin
return res;
}
SPA_API_IMPL int spa_pod_builder_string(struct spa_pod_builder *builder, const char *str)
SPA_API_POD_BUILDER int spa_pod_builder_string(struct spa_pod_builder *builder, const char *str)
{
uint32_t len = str ? strlen(str) : 0;
return spa_pod_builder_string_len(builder, str ? str : "", len);
@ -291,7 +299,7 @@ SPA_API_IMPL int spa_pod_builder_string(struct spa_pod_builder *builder, const c
#define SPA_POD_INIT_Bytes(len) ((struct spa_pod_bytes){ { (len), SPA_TYPE_Bytes } })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
{
const struct spa_pod_bytes p = SPA_POD_INIT_Bytes(len);
@ -300,7 +308,7 @@ spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32
res = r;
return res;
}
SPA_API_IMPL void *
SPA_API_POD_BUILDER void *
spa_pod_builder_reserve_bytes(struct spa_pod_builder *builder, uint32_t len)
{
uint32_t offset = builder->state.offset;
@ -311,7 +319,7 @@ spa_pod_builder_reserve_bytes(struct spa_pod_builder *builder, uint32_t len)
#define SPA_POD_INIT_Pointer(type,value) ((struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { (type), 0, (value) } })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, const void *val)
{
const struct spa_pod_pointer p = SPA_POD_INIT_Pointer(type, val);
@ -320,7 +328,7 @@ spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, const vo
#define SPA_POD_INIT_Fd(fd) ((struct spa_pod_fd){ { sizeof(int64_t), SPA_TYPE_Fd }, (fd) })
SPA_API_IMPL int spa_pod_builder_fd(struct spa_pod_builder *builder, int64_t fd)
SPA_API_POD_BUILDER int spa_pod_builder_fd(struct spa_pod_builder *builder, int64_t fd)
{
const struct spa_pod_fd p = SPA_POD_INIT_Fd(fd);
return spa_pod_builder_primitive(builder, &p.pod);
@ -328,7 +336,7 @@ SPA_API_IMPL int spa_pod_builder_fd(struct spa_pod_builder *builder, int64_t fd)
#define SPA_POD_INIT_Rectangle(val) ((struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, (val) })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height)
{
const struct spa_pod_rectangle p = SPA_POD_INIT_Rectangle(SPA_RECTANGLE(width, height));
@ -337,14 +345,14 @@ spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint3
#define SPA_POD_INIT_Fraction(val) ((struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, (val) })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
{
const struct spa_pod_fraction p = SPA_POD_INIT_Fraction(SPA_FRACTION(num, denom));
return spa_pod_builder_primitive(builder, &p.pod);
}
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_push_array(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
{
const struct spa_pod_array p =
@ -356,7 +364,7 @@ spa_pod_builder_push_array(struct spa_pod_builder *builder, struct spa_pod_frame
return res;
}
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_array(struct spa_pod_builder *builder,
uint32_t child_size, uint32_t child_type, uint32_t n_elems, const void *elems)
{
@ -378,7 +386,7 @@ spa_pod_builder_array(struct spa_pod_builder *builder,
{ { { (n_vals) * sizeof(ctype) + sizeof(struct spa_pod_choice_body), SPA_TYPE_Choice }, \
{ (type), 0, { sizeof(ctype), (child_type) } } }, { __VA_ARGS__ } })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_push_choice(struct spa_pod_builder *builder, struct spa_pod_frame *frame,
uint32_t type, uint32_t flags)
{
@ -393,7 +401,7 @@ spa_pod_builder_push_choice(struct spa_pod_builder *builder, struct spa_pod_fram
#define SPA_POD_INIT_Struct(size) ((struct spa_pod_struct){ { (size), SPA_TYPE_Struct } })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_push_struct(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
{
const struct spa_pod_struct p = SPA_POD_INIT_Struct(0);
@ -405,7 +413,7 @@ spa_pod_builder_push_struct(struct spa_pod_builder *builder, struct spa_pod_fram
#define SPA_POD_INIT_Object(size,type,id,...) ((struct spa_pod_object){ { (size), SPA_TYPE_Object }, { (type), (id) }, ##__VA_ARGS__ })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_push_object(struct spa_pod_builder *builder, struct spa_pod_frame *frame,
uint32_t type, uint32_t id)
{
@ -420,7 +428,7 @@ spa_pod_builder_push_object(struct spa_pod_builder *builder, struct spa_pod_fram
#define SPA_POD_INIT_Prop(key,flags,size,type) \
((struct spa_pod_prop){ (key), (flags), { (size), (type) } })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t flags)
{
const struct { uint32_t key; uint32_t flags; } p = { key, flags };
@ -430,7 +438,7 @@ spa_pod_builder_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t fla
#define SPA_POD_INIT_Sequence(size,unit) \
((struct spa_pod_sequence){ { (size), SPA_TYPE_Sequence}, {(unit), 0 } })
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_push_sequence(struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t unit)
{
const struct spa_pod_sequence p =
@ -441,14 +449,14 @@ spa_pod_builder_push_sequence(struct spa_pod_builder *builder, struct spa_pod_fr
return res;
}
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_control(struct spa_pod_builder *builder, uint32_t offset, uint32_t type)
{
const struct { uint32_t offset; uint32_t type; } p = { offset, type };
return spa_pod_builder_raw(builder, &p, sizeof(p));
}
SPA_API_IMPL uint32_t spa_choice_from_id(char id)
SPA_API_POD_BUILDER uint32_t spa_choice_from_id(char id)
{
switch (id) {
case 'r':
@ -560,7 +568,7 @@ do { \
} \
} while(false)
SPA_API_IMPL int
SPA_API_POD_BUILDER int
spa_pod_builder_addv(struct spa_pod_builder *builder, va_list args)
{
int res = 0;
@ -618,7 +626,7 @@ spa_pod_builder_addv(struct spa_pod_builder *builder, va_list args)
return res;
}
SPA_API_IMPL int spa_pod_builder_add(struct spa_pod_builder *builder, ...)
SPA_API_POD_BUILDER int spa_pod_builder_add(struct spa_pod_builder *builder, ...)
{
int res;
va_list args;
@ -658,7 +666,7 @@ SPA_API_IMPL int spa_pod_builder_add(struct spa_pod_builder *builder, ...)
})
/** Copy a pod structure */
SPA_API_IMPL struct spa_pod *
SPA_API_POD_BUILDER struct spa_pod *
spa_pod_copy(const struct spa_pod *pod)
{
size_t size;

12
spa/include/spa/pod/compare.h
View file

@ -20,12 +20,20 @@ extern "C" {
#include <spa/pod/iter.h>
#include <spa/pod/builder.h>
#ifndef SPA_API_POD_COMPARE
#ifdef SPA_API_IMPL
#define SPA_API_POD_COMPARE SPA_API_IMPL
#else
#define SPA_API_POD_COMPARE static inline
#endif
#endif
/**
* \addtogroup spa_pod
* \{
*/
SPA_API_IMPL int spa_pod_compare_value(uint32_t type, const void *r1, const void *r2, uint32_t size)
SPA_API_POD_COMPARE int spa_pod_compare_value(uint32_t type, const void *r1, const void *r2, uint32_t size)
{
switch (type) {
case SPA_TYPE_None:
@ -72,7 +80,7 @@ SPA_API_IMPL int spa_pod_compare_value(uint32_t type, const void *r1, const void
return 0;
}
SPA_API_IMPL int spa_pod_compare(const struct spa_pod *pod1,
SPA_API_POD_COMPARE int spa_pod_compare(const struct spa_pod *pod1,
const struct spa_pod *pod2)
{
int res = 0;

12
spa/include/spa/pod/dynamic.h
View file

@ -12,6 +12,14 @@ extern "C" {
#include <spa/pod/builder.h>
#include <spa/utils/cleanup.h>
#ifndef SPA_API_POD_DYNAMIC
#ifdef SPA_API_IMPL
#define SPA_API_POD_DYNAMIC SPA_API_IMPL
#else
#define SPA_API_POD_DYNAMIC static inline
#endif
#endif
struct spa_pod_dynamic_builder {
struct spa_pod_builder b;
void *data;
@ -37,7 +45,7 @@ static int spa_pod_dynamic_builder_overflow(void *data, uint32_t size)
return 0;
}
SPA_API_IMPL void spa_pod_dynamic_builder_init(struct spa_pod_dynamic_builder *builder,
SPA_API_POD_DYNAMIC void spa_pod_dynamic_builder_init(struct spa_pod_dynamic_builder *builder,
void *data, uint32_t size, uint32_t extend)
{
static const struct spa_pod_builder_callbacks spa_pod_dynamic_builder_callbacks = {
@ -50,7 +58,7 @@ SPA_API_IMPL void spa_pod_dynamic_builder_init(struct spa_pod_dynamic_builder *b
builder->data = data;
}
SPA_API_IMPL void spa_pod_dynamic_builder_clean(struct spa_pod_dynamic_builder *builder)
SPA_API_POD_DYNAMIC void spa_pod_dynamic_builder_clean(struct spa_pod_dynamic_builder *builder)
{
if (builder->data != builder->b.data)
free(builder->b.data);

20
spa/include/spa/pod/filter.h
View file

@ -20,12 +20,20 @@ extern "C" {
#include <spa/pod/builder.h>
#include <spa/pod/compare.h>
#ifndef SPA_API_POD_FILTER
#ifdef SPA_API_IMPL
#define SPA_API_POD_FILTER SPA_API_IMPL
#else
#define SPA_API_POD_FILTER static inline
#endif
#endif
/**
* \addtogroup spa_pod
* \{
*/
SPA_API_IMPL int spa_pod_choice_fix_default(struct spa_pod_choice *choice)
SPA_API_POD_FILTER int spa_pod_choice_fix_default(struct spa_pod_choice *choice)
{
void *val, *alt;
int i, nvals;
@ -77,7 +85,7 @@ SPA_API_IMPL int spa_pod_choice_fix_default(struct spa_pod_choice *choice)
return 0;
}
SPA_API_IMPL int spa_pod_filter_flags_value(struct spa_pod_builder *b,
SPA_API_POD_FILTER int spa_pod_filter_flags_value(struct spa_pod_builder *b,
uint32_t type, const void *r1, const void *r2, uint32_t size SPA_UNUSED)
{
switch (type) {
@ -103,7 +111,7 @@ SPA_API_IMPL int spa_pod_filter_flags_value(struct spa_pod_builder *b,
return 1;
}
SPA_API_IMPL int spa_pod_filter_is_step_of(uint32_t type, const void *r1,
SPA_API_POD_FILTER int spa_pod_filter_is_step_of(uint32_t type, const void *r1,
const void *r2, uint32_t size SPA_UNUSED)
{
switch (type) {
@ -125,7 +133,7 @@ SPA_API_IMPL int spa_pod_filter_is_step_of(uint32_t type, const void *r1,
return 0;
}
SPA_API_IMPL int
SPA_API_POD_FILTER int
spa_pod_filter_prop(struct spa_pod_builder *b,
const struct spa_pod_prop *p1,
const struct spa_pod_prop *p2)
@ -322,7 +330,7 @@ spa_pod_filter_prop(struct spa_pod_builder *b,
return 0;
}
SPA_API_IMPL int spa_pod_filter_part(struct spa_pod_builder *b,
SPA_API_POD_FILTER int spa_pod_filter_part(struct spa_pod_builder *b,
const struct spa_pod *pod, uint32_t pod_size,
const struct spa_pod *filter, uint32_t filter_size)
{
@ -422,7 +430,7 @@ SPA_API_IMPL int spa_pod_filter_part(struct spa_pod_builder *b,
return res;
}
SPA_API_IMPL int
SPA_API_POD_FILTER int
spa_pod_filter(struct spa_pod_builder *b,
struct spa_pod **result,
const struct spa_pod *pod,

114
spa/include/spa/pod/iter.h
View file

@ -14,6 +14,14 @@ extern "C" {
#include <spa/pod/pod.h>
#ifndef SPA_API_POD_ITER
#ifdef SPA_API_IMPL
#define SPA_API_POD_ITER SPA_API_IMPL
#else
#define SPA_API_POD_ITER static inline
#endif
#endif
/**
* \addtogroup spa_pod
* \{
@ -26,7 +34,7 @@ struct spa_pod_frame {
uint32_t flags;
};
SPA_API_IMPL bool spa_pod_is_inside(const void *pod, uint32_t size, const void *iter)
SPA_API_POD_ITER bool spa_pod_is_inside(const void *pod, uint32_t size, const void *iter)
{
size_t remaining;
@ -34,17 +42,17 @@ SPA_API_IMPL bool spa_pod_is_inside(const void *pod, uint32_t size, const void *
remaining >= SPA_POD_BODY_SIZE(iter);
}
SPA_API_IMPL void *spa_pod_next(const void *iter)
SPA_API_POD_ITER void *spa_pod_next(const void *iter)
{
return SPA_PTROFF(iter, SPA_ROUND_UP_N(SPA_POD_SIZE(iter), 8), void);
}
SPA_API_IMPL struct spa_pod_prop *spa_pod_prop_first(const struct spa_pod_object_body *body)
SPA_API_POD_ITER struct spa_pod_prop *spa_pod_prop_first(const struct spa_pod_object_body *body)
{
return SPA_PTROFF(body, sizeof(struct spa_pod_object_body), struct spa_pod_prop);
}
SPA_API_IMPL bool spa_pod_prop_is_inside(const struct spa_pod_object_body *body,
SPA_API_POD_ITER bool spa_pod_prop_is_inside(const struct spa_pod_object_body *body,
uint32_t size, const struct spa_pod_prop *iter)
{
size_t remaining;
@ -53,17 +61,17 @@ SPA_API_IMPL bool spa_pod_prop_is_inside(const struct spa_pod_object_body *body,
remaining >= iter->value.size;
}
SPA_API_IMPL struct spa_pod_prop *spa_pod_prop_next(const struct spa_pod_prop *iter)
SPA_API_POD_ITER struct spa_pod_prop *spa_pod_prop_next(const struct spa_pod_prop *iter)
{
return SPA_PTROFF(iter, SPA_ROUND_UP_N(SPA_POD_PROP_SIZE(iter), 8), struct spa_pod_prop);
}
SPA_API_IMPL struct spa_pod_control *spa_pod_control_first(const struct spa_pod_sequence_body *body)
SPA_API_POD_ITER struct spa_pod_control *spa_pod_control_first(const struct spa_pod_sequence_body *body)
{
return SPA_PTROFF(body, sizeof(struct spa_pod_sequence_body), struct spa_pod_control);
}
SPA_API_IMPL bool spa_pod_control_is_inside(const struct spa_pod_sequence_body *body,
SPA_API_POD_ITER bool spa_pod_control_is_inside(const struct spa_pod_sequence_body *body,
uint32_t size, const struct spa_pod_control *iter)
{
size_t remaining;
@ -72,7 +80,7 @@ SPA_API_IMPL bool spa_pod_control_is_inside(const struct spa_pod_sequence_body *
remaining >= iter->value.size;
}
SPA_API_IMPL struct spa_pod_control *spa_pod_control_next(const struct spa_pod_control *iter)
SPA_API_POD_ITER struct spa_pod_control *spa_pod_control_next(const struct spa_pod_control *iter)
{
return SPA_PTROFF(iter, SPA_ROUND_UP_N(SPA_POD_CONTROL_SIZE(iter), 8), struct spa_pod_control);
}
@ -118,7 +126,7 @@ SPA_API_IMPL struct spa_pod_control *spa_pod_control_next(const struct spa_pod_c
SPA_POD_SEQUENCE_BODY_FOREACH(&(seq)->body, SPA_POD_BODY_SIZE(seq), iter)
SPA_API_IMPL void *spa_pod_from_data(void *data, size_t maxsize, off_t offset, size_t size)
SPA_API_POD_ITER void *spa_pod_from_data(void *data, size_t maxsize, off_t offset, size_t size)
{
void *pod;
if (size < sizeof(struct spa_pod) || offset + size > maxsize)
@ -129,17 +137,17 @@ SPA_API_IMPL void *spa_pod_from_data(void *data, size_t maxsize, off_t offset, s
return pod;
}
SPA_API_IMPL int spa_pod_is_none(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_none(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_None);
}
SPA_API_IMPL int spa_pod_is_bool(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_bool(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Bool && SPA_POD_BODY_SIZE(pod) >= sizeof(int32_t));
}
SPA_API_IMPL int spa_pod_get_bool(const struct spa_pod *pod, bool *value)
SPA_API_POD_ITER int spa_pod_get_bool(const struct spa_pod *pod, bool *value)
{
if (!spa_pod_is_bool(pod))
return -EINVAL;
@ -147,12 +155,12 @@ SPA_API_IMPL int spa_pod_get_bool(const struct spa_pod *pod, bool *value)
return 0;
}
SPA_API_IMPL int spa_pod_is_id(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_id(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Id && SPA_POD_BODY_SIZE(pod) >= sizeof(uint32_t));
}
SPA_API_IMPL int spa_pod_get_id(const struct spa_pod *pod, uint32_t *value)
SPA_API_POD_ITER int spa_pod_get_id(const struct spa_pod *pod, uint32_t *value)
{
if (!spa_pod_is_id(pod))
return -EINVAL;
@ -160,12 +168,12 @@ SPA_API_IMPL int spa_pod_get_id(const struct spa_pod *pod, uint32_t *value)
return 0;
}
SPA_API_IMPL int spa_pod_is_int(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_int(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Int && SPA_POD_BODY_SIZE(pod) >= sizeof(int32_t));
}
SPA_API_IMPL int spa_pod_get_int(const struct spa_pod *pod, int32_t *value)
SPA_API_POD_ITER int spa_pod_get_int(const struct spa_pod *pod, int32_t *value)
{
if (!spa_pod_is_int(pod))
return -EINVAL;
@ -173,12 +181,12 @@ SPA_API_IMPL int spa_pod_get_int(const struct spa_pod *pod, int32_t *value)
return 0;
}
SPA_API_IMPL int spa_pod_is_long(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_long(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Long && SPA_POD_BODY_SIZE(pod) >= sizeof(int64_t));
}
SPA_API_IMPL int spa_pod_get_long(const struct spa_pod *pod, int64_t *value)
SPA_API_POD_ITER int spa_pod_get_long(const struct spa_pod *pod, int64_t *value)
{
if (!spa_pod_is_long(pod))
return -EINVAL;
@ -186,12 +194,12 @@ SPA_API_IMPL int spa_pod_get_long(const struct spa_pod *pod, int64_t *value)
return 0;
}
SPA_API_IMPL int spa_pod_is_float(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_float(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Float && SPA_POD_BODY_SIZE(pod) >= sizeof(float));
}
SPA_API_IMPL int spa_pod_get_float(const struct spa_pod *pod, float *value)
SPA_API_POD_ITER int spa_pod_get_float(const struct spa_pod *pod, float *value)
{
if (!spa_pod_is_float(pod))
return -EINVAL;
@ -199,12 +207,12 @@ SPA_API_IMPL int spa_pod_get_float(const struct spa_pod *pod, float *value)
return 0;
}
SPA_API_IMPL int spa_pod_is_double(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_double(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Double && SPA_POD_BODY_SIZE(pod) >= sizeof(double));
}
SPA_API_IMPL int spa_pod_get_double(const struct spa_pod *pod, double *value)
SPA_API_POD_ITER int spa_pod_get_double(const struct spa_pod *pod, double *value)
{
if (!spa_pod_is_double(pod))
return -EINVAL;
@ -212,7 +220,7 @@ SPA_API_IMPL int spa_pod_get_double(const struct spa_pod *pod, double *value)
return 0;
}
SPA_API_IMPL int spa_pod_is_string(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_string(const struct spa_pod *pod)
{
const char *s = (const char *)SPA_POD_CONTENTS(struct spa_pod_string, pod);
return (SPA_POD_TYPE(pod) == SPA_TYPE_String &&
@ -220,7 +228,7 @@ SPA_API_IMPL int spa_pod_is_string(const struct spa_pod *pod)
s[SPA_POD_BODY_SIZE(pod)-1] == '\0');
}
SPA_API_IMPL int spa_pod_get_string(const struct spa_pod *pod, const char **value)
SPA_API_POD_ITER int spa_pod_get_string(const struct spa_pod *pod, const char **value)
{
if (!spa_pod_is_string(pod))
return -EINVAL;
@ -228,7 +236,7 @@ SPA_API_IMPL int spa_pod_get_string(const struct spa_pod *pod, const char **valu
return 0;
}
SPA_API_IMPL int spa_pod_copy_string(const struct spa_pod *pod, size_t maxlen, char *dest)
SPA_API_POD_ITER int spa_pod_copy_string(const struct spa_pod *pod, size_t maxlen, char *dest)
{
const char *s = (const char *)SPA_POD_CONTENTS(struct spa_pod_string, pod);
if (!spa_pod_is_string(pod) || maxlen < 1)
@ -238,12 +246,12 @@ SPA_API_IMPL int spa_pod_copy_string(const struct spa_pod *pod, size_t maxlen, c
return 0;
}
SPA_API_IMPL int spa_pod_is_bytes(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_bytes(const struct spa_pod *pod)
{
return SPA_POD_TYPE(pod) == SPA_TYPE_Bytes;
}
SPA_API_IMPL int spa_pod_get_bytes(const struct spa_pod *pod, const void **value, uint32_t *len)
SPA_API_POD_ITER int spa_pod_get_bytes(const struct spa_pod *pod, const void **value, uint32_t *len)
{
if (!spa_pod_is_bytes(pod))
return -EINVAL;
@ -252,13 +260,13 @@ SPA_API_IMPL int spa_pod_get_bytes(const struct spa_pod *pod, const void **value
return 0;
}
SPA_API_IMPL int spa_pod_is_pointer(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_pointer(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Pointer &&
SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_pointer_body));
}
SPA_API_IMPL int spa_pod_get_pointer(const struct spa_pod *pod, uint32_t *type, const void **value)
SPA_API_POD_ITER int spa_pod_get_pointer(const struct spa_pod *pod, uint32_t *type, const void **value)
{
if (!spa_pod_is_pointer(pod))
return -EINVAL;
@ -267,13 +275,13 @@ SPA_API_IMPL int spa_pod_get_pointer(const struct spa_pod *pod, uint32_t *type,
return 0;
}
SPA_API_IMPL int spa_pod_is_fd(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_fd(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Fd &&
SPA_POD_BODY_SIZE(pod) >= sizeof(int64_t));
}
SPA_API_IMPL int spa_pod_get_fd(const struct spa_pod *pod, int64_t *value)
SPA_API_POD_ITER int spa_pod_get_fd(const struct spa_pod *pod, int64_t *value)
{
if (!spa_pod_is_fd(pod))
return -EINVAL;
@ -281,13 +289,13 @@ SPA_API_IMPL int spa_pod_get_fd(const struct spa_pod *pod, int64_t *value)
return 0;
}
SPA_API_IMPL int spa_pod_is_rectangle(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_rectangle(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Rectangle &&
SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_rectangle));
}
SPA_API_IMPL int spa_pod_get_rectangle(const struct spa_pod *pod, struct spa_rectangle *value)
SPA_API_POD_ITER int spa_pod_get_rectangle(const struct spa_pod *pod, struct spa_rectangle *value)
{
if (!spa_pod_is_rectangle(pod))
return -EINVAL;
@ -295,39 +303,39 @@ SPA_API_IMPL int spa_pod_get_rectangle(const struct spa_pod *pod, struct spa_rec
return 0;
}
SPA_API_IMPL int spa_pod_is_fraction(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_fraction(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Fraction &&
SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_fraction));
}
SPA_API_IMPL int spa_pod_get_fraction(const struct spa_pod *pod, struct spa_fraction *value)
SPA_API_POD_ITER int spa_pod_get_fraction(const struct spa_pod *pod, struct spa_fraction *value)
{
spa_return_val_if_fail(spa_pod_is_fraction(pod), -EINVAL);
*value = SPA_POD_VALUE(struct spa_pod_fraction, pod);
return 0;
}
SPA_API_IMPL int spa_pod_is_bitmap(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_bitmap(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Bitmap &&
SPA_POD_BODY_SIZE(pod) >= sizeof(uint8_t));
}
SPA_API_IMPL int spa_pod_is_array(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_array(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Array &&
SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_array_body));
}
SPA_API_IMPL void *spa_pod_get_array(const struct spa_pod *pod, uint32_t *n_values)
SPA_API_POD_ITER void *spa_pod_get_array(const struct spa_pod *pod, uint32_t *n_values)
{
spa_return_val_if_fail(spa_pod_is_array(pod), NULL);
*n_values = SPA_POD_ARRAY_N_VALUES(pod);
return SPA_POD_ARRAY_VALUES(pod);
}
SPA_API_IMPL uint32_t spa_pod_copy_array(const struct spa_pod *pod, uint32_t type,
SPA_API_POD_ITER uint32_t spa_pod_copy_array(const struct spa_pod *pod, uint32_t type,
void *values, uint32_t max_values)
{
uint32_t n_values;
@ -339,13 +347,13 @@ SPA_API_IMPL uint32_t spa_pod_copy_array(const struct spa_pod *pod, uint32_t typ
return n_values;
}
SPA_API_IMPL int spa_pod_is_choice(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_choice(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Choice &&
SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_choice_body));
}
SPA_API_IMPL struct spa_pod *spa_pod_get_values(const struct spa_pod *pod, uint32_t *n_vals, uint32_t *choice)
SPA_API_POD_ITER struct spa_pod *spa_pod_get_values(const struct spa_pod *pod, uint32_t *n_vals, uint32_t *choice)
{
if (pod->type == SPA_TYPE_Choice) {
*n_vals = SPA_POD_CHOICE_N_VALUES(pod);
@ -359,34 +367,34 @@ SPA_API_IMPL struct spa_pod *spa_pod_get_values(const struct spa_pod *pod, uint3
}
}
SPA_API_IMPL int spa_pod_is_struct(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_struct(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Struct);
}
SPA_API_IMPL int spa_pod_is_object(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_object(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Object &&
SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_object_body));
}
SPA_API_IMPL bool spa_pod_is_object_type(const struct spa_pod *pod, uint32_t type)
SPA_API_POD_ITER bool spa_pod_is_object_type(const struct spa_pod *pod, uint32_t type)
{
return (pod && spa_pod_is_object(pod) && SPA_POD_OBJECT_TYPE(pod) == type);
}
SPA_API_IMPL bool spa_pod_is_object_id(const struct spa_pod *pod, uint32_t id)
SPA_API_POD_ITER bool spa_pod_is_object_id(const struct spa_pod *pod, uint32_t id)
{
return (pod && spa_pod_is_object(pod) && SPA_POD_OBJECT_ID(pod) == id);
}
SPA_API_IMPL int spa_pod_is_sequence(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_sequence(const struct spa_pod *pod)
{
return (SPA_POD_TYPE(pod) == SPA_TYPE_Sequence &&
SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_sequence_body));
}
SPA_API_IMPL const struct spa_pod_prop *spa_pod_object_find_prop(const struct spa_pod_object *pod,
SPA_API_POD_ITER const struct spa_pod_prop *spa_pod_object_find_prop(const struct spa_pod_object *pod,
const struct spa_pod_prop *start, uint32_t key)
{
const struct spa_pod_prop *first, *res;
@ -406,7 +414,7 @@ SPA_API_IMPL const struct spa_pod_prop *spa_pod_object_find_prop(const struct sp
return NULL;
}
SPA_API_IMPL const struct spa_pod_prop *spa_pod_find_prop(const struct spa_pod *pod,
SPA_API_POD_ITER const struct spa_pod_prop *spa_pod_find_prop(const struct spa_pod *pod,
const struct spa_pod_prop *start, uint32_t key)
{
if (!spa_pod_is_object(pod))
@ -414,7 +422,7 @@ SPA_API_IMPL const struct spa_pod_prop *spa_pod_find_prop(const struct spa_pod *
return spa_pod_object_find_prop((const struct spa_pod_object *)pod, start, key);
}
SPA_API_IMPL int spa_pod_object_fixate(struct spa_pod_object *pod)
SPA_API_POD_ITER int spa_pod_object_fixate(struct spa_pod_object *pod)
{
struct spa_pod_prop *res;
SPA_POD_OBJECT_FOREACH(pod, res) {
@ -425,14 +433,14 @@ SPA_API_IMPL int spa_pod_object_fixate(struct spa_pod_object *pod)
return 0;
}
SPA_API_IMPL int spa_pod_fixate(struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_fixate(struct spa_pod *pod)
{
if (!spa_pod_is_object(pod))
return -EINVAL;
return spa_pod_object_fixate((struct spa_pod_object *)pod);
}
SPA_API_IMPL int spa_pod_object_is_fixated(const struct spa_pod_object *pod)
SPA_API_POD_ITER int spa_pod_object_is_fixated(const struct spa_pod_object *pod)
{
struct spa_pod_prop *res;
SPA_POD_OBJECT_FOREACH(pod, res) {
@ -443,7 +451,7 @@ SPA_API_IMPL int spa_pod_object_is_fixated(const struct spa_pod_object *pod)
return 1;
}
SPA_API_IMPL int spa_pod_object_has_props(const struct spa_pod_object *pod)
SPA_API_POD_ITER int spa_pod_object_has_props(const struct spa_pod_object *pod)
{
struct spa_pod_prop *res;
SPA_POD_OBJECT_FOREACH(pod, res)
@ -451,7 +459,7 @@ SPA_API_IMPL int spa_pod_object_has_props(const struct spa_pod_object *pod)
return 0;
}
SPA_API_IMPL int spa_pod_is_fixated(const struct spa_pod *pod)
SPA_API_POD_ITER int spa_pod_is_fixated(const struct spa_pod *pod)
{
if (!spa_pod_is_object(pod))
return -EINVAL;

66
spa/include/spa/pod/parser.h
View file

@ -15,6 +15,14 @@ extern "C" {
#include <spa/pod/iter.h>
#include <spa/pod/vararg.h>
#ifndef SPA_API_POD_PARSER
#ifdef SPA_API_IMPL
#define SPA_API_POD_PARSER SPA_API_IMPL
#else
#define SPA_API_POD_PARSER static inline
#endif
#endif
/**
* \addtogroup spa_pod
* \{
@ -35,31 +43,31 @@ struct spa_pod_parser {
#define SPA_POD_PARSER_INIT(buffer,size) ((struct spa_pod_parser){ (buffer), (size), 0, {0,0,NULL}})
SPA_API_IMPL void spa_pod_parser_init(struct spa_pod_parser *parser,
SPA_API_POD_PARSER void spa_pod_parser_init(struct spa_pod_parser *parser,
const void *data, uint32_t size)
{
*parser = SPA_POD_PARSER_INIT(data, size);
}
SPA_API_IMPL void spa_pod_parser_pod(struct spa_pod_parser *parser,
SPA_API_POD_PARSER void spa_pod_parser_pod(struct spa_pod_parser *parser,
const struct spa_pod *pod)
{
spa_pod_parser_init(parser, pod, SPA_POD_SIZE(pod));
}
SPA_API_IMPL void
SPA_API_POD_PARSER void
spa_pod_parser_get_state(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
{
*state = parser->state;
}
SPA_API_IMPL void
SPA_API_POD_PARSER void
spa_pod_parser_reset(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
{
parser->state = *state;
}
SPA_API_IMPL struct spa_pod *
SPA_API_POD_PARSER struct spa_pod *
spa_pod_parser_deref(struct spa_pod_parser *parser, uint32_t offset, uint32_t size)
{
/* Cast to uint64_t to avoid wraparound. Add 8 for the pod itself. */
@ -78,12 +86,12 @@ spa_pod_parser_deref(struct spa_pod_parser *parser, uint32_t offset, uint32_t si
return NULL;
}
SPA_API_IMPL struct spa_pod *spa_pod_parser_frame(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
SPA_API_POD_PARSER struct spa_pod *spa_pod_parser_frame(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
{
return SPA_PTROFF(parser->data, frame->offset, struct spa_pod);
}
SPA_API_IMPL void spa_pod_parser_push(struct spa_pod_parser *parser,
SPA_API_POD_PARSER void spa_pod_parser_push(struct spa_pod_parser *parser,
struct spa_pod_frame *frame, const struct spa_pod *pod, uint32_t offset)
{
frame->pod = *pod;
@ -93,19 +101,19 @@ SPA_API_IMPL void spa_pod_parser_push(struct spa_pod_parser *parser,
parser->state.frame = frame;
}
SPA_API_IMPL struct spa_pod *spa_pod_parser_current(struct spa_pod_parser *parser)
SPA_API_POD_PARSER struct spa_pod *spa_pod_parser_current(struct spa_pod_parser *parser)
{
struct spa_pod_frame *f = parser->state.frame;
uint32_t size = f ? f->offset + SPA_POD_SIZE(&f->pod) : parser->size;
return spa_pod_parser_deref(parser, parser->state.offset, size);
}
SPA_API_IMPL void spa_pod_parser_advance(struct spa_pod_parser *parser, const struct spa_pod *pod)
SPA_API_POD_PARSER void spa_pod_parser_advance(struct spa_pod_parser *parser, const struct spa_pod *pod)
{
parser->state.offset += SPA_ROUND_UP_N(SPA_POD_SIZE(pod), 8);
}
SPA_API_IMPL struct spa_pod *spa_pod_parser_next(struct spa_pod_parser *parser)
SPA_API_POD_PARSER struct spa_pod *spa_pod_parser_next(struct spa_pod_parser *parser)
{
struct spa_pod *pod = spa_pod_parser_current(parser);
if (pod)
@ -113,7 +121,7 @@ SPA_API_IMPL struct spa_pod *spa_pod_parser_next(struct spa_pod_parser *parser)
return pod;
}
SPA_API_IMPL int spa_pod_parser_pop(struct spa_pod_parser *parser,
SPA_API_POD_PARSER int spa_pod_parser_pop(struct spa_pod_parser *parser,
struct spa_pod_frame *frame)
{
parser->state.frame = frame->parent;
@ -121,7 +129,7 @@ SPA_API_IMPL int spa_pod_parser_pop(struct spa_pod_parser *parser,
return 0;
}
SPA_API_IMPL int spa_pod_parser_get_bool(struct spa_pod_parser *parser, bool *value)
SPA_API_POD_PARSER int spa_pod_parser_get_bool(struct spa_pod_parser *parser, bool *value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -130,7 +138,7 @@ SPA_API_IMPL int spa_pod_parser_get_bool(struct spa_pod_parser *parser, bool *va
return res;
}
SPA_API_IMPL int spa_pod_parser_get_id(struct spa_pod_parser *parser, uint32_t *value)
SPA_API_POD_PARSER int spa_pod_parser_get_id(struct spa_pod_parser *parser, uint32_t *value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -139,7 +147,7 @@ SPA_API_IMPL int spa_pod_parser_get_id(struct spa_pod_parser *parser, uint32_t *
return res;
}
SPA_API_IMPL int spa_pod_parser_get_int(struct spa_pod_parser *parser, int32_t *value)
SPA_API_POD_PARSER int spa_pod_parser_get_int(struct spa_pod_parser *parser, int32_t *value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -148,7 +156,7 @@ SPA_API_IMPL int spa_pod_parser_get_int(struct spa_pod_parser *parser, int32_t *
return res;
}
SPA_API_IMPL int spa_pod_parser_get_long(struct spa_pod_parser *parser, int64_t *value)
SPA_API_POD_PARSER int spa_pod_parser_get_long(struct spa_pod_parser *parser, int64_t *value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -157,7 +165,7 @@ SPA_API_IMPL int spa_pod_parser_get_long(struct spa_pod_parser *parser, int64_t
return res;
}
SPA_API_IMPL int spa_pod_parser_get_float(struct spa_pod_parser *parser, float *value)
SPA_API_POD_PARSER int spa_pod_parser_get_float(struct spa_pod_parser *parser, float *value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -166,7 +174,7 @@ SPA_API_IMPL int spa_pod_parser_get_float(struct spa_pod_parser *parser, float *
return res;
}
SPA_API_IMPL int spa_pod_parser_get_double(struct spa_pod_parser *parser, double *value)
SPA_API_POD_PARSER int spa_pod_parser_get_double(struct spa_pod_parser *parser, double *value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -175,7 +183,7 @@ SPA_API_IMPL int spa_pod_parser_get_double(struct spa_pod_parser *parser, double
return res;
}
SPA_API_IMPL int spa_pod_parser_get_string(struct spa_pod_parser *parser, const char **value)
SPA_API_POD_PARSER int spa_pod_parser_get_string(struct spa_pod_parser *parser, const char **value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -184,7 +192,7 @@ SPA_API_IMPL int spa_pod_parser_get_string(struct spa_pod_parser *parser, const
return res;
}
SPA_API_IMPL int spa_pod_parser_get_bytes(struct spa_pod_parser *parser, const void **value, uint32_t *len)
SPA_API_POD_PARSER int spa_pod_parser_get_bytes(struct spa_pod_parser *parser, const void **value, uint32_t *len)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -193,7 +201,7 @@ SPA_API_IMPL int spa_pod_parser_get_bytes(struct spa_pod_parser *parser, const v
return res;
}
SPA_API_IMPL int spa_pod_parser_get_pointer(struct spa_pod_parser *parser, uint32_t *type, const void **value)
SPA_API_POD_PARSER int spa_pod_parser_get_pointer(struct spa_pod_parser *parser, uint32_t *type, const void **value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -202,7 +210,7 @@ SPA_API_IMPL int spa_pod_parser_get_pointer(struct spa_pod_parser *parser, uint3
return res;
}
SPA_API_IMPL int spa_pod_parser_get_fd(struct spa_pod_parser *parser, int64_t *value)
SPA_API_POD_PARSER int spa_pod_parser_get_fd(struct spa_pod_parser *parser, int64_t *value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -211,7 +219,7 @@ SPA_API_IMPL int spa_pod_parser_get_fd(struct spa_pod_parser *parser, int64_t *v
return res;
}
SPA_API_IMPL int spa_pod_parser_get_rectangle(struct spa_pod_parser *parser, struct spa_rectangle *value)
SPA_API_POD_PARSER int spa_pod_parser_get_rectangle(struct spa_pod_parser *parser, struct spa_rectangle *value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -220,7 +228,7 @@ SPA_API_IMPL int spa_pod_parser_get_rectangle(struct spa_pod_parser *parser, str
return res;
}
SPA_API_IMPL int spa_pod_parser_get_fraction(struct spa_pod_parser *parser, struct spa_fraction *value)
SPA_API_POD_PARSER int spa_pod_parser_get_fraction(struct spa_pod_parser *parser, struct spa_fraction *value)
{
int res = -EPIPE;
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -229,7 +237,7 @@ SPA_API_IMPL int spa_pod_parser_get_fraction(struct spa_pod_parser *parser, stru
return res;
}
SPA_API_IMPL int spa_pod_parser_get_pod(struct spa_pod_parser *parser, struct spa_pod **value)
SPA_API_POD_PARSER int spa_pod_parser_get_pod(struct spa_pod_parser *parser, struct spa_pod **value)
{
struct spa_pod *pod = spa_pod_parser_current(parser);
if (pod == NULL)
@ -238,7 +246,7 @@ SPA_API_IMPL int spa_pod_parser_get_pod(struct spa_pod_parser *parser, struct sp
spa_pod_parser_advance(parser, pod);
return 0;
}
SPA_API_IMPL int spa_pod_parser_push_struct(struct spa_pod_parser *parser,
SPA_API_POD_PARSER int spa_pod_parser_push_struct(struct spa_pod_parser *parser,
struct spa_pod_frame *frame)
{
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -251,7 +259,7 @@ SPA_API_IMPL int spa_pod_parser_push_struct(struct spa_pod_parser *parser,
return 0;
}
SPA_API_IMPL int spa_pod_parser_push_object(struct spa_pod_parser *parser,
SPA_API_POD_PARSER int spa_pod_parser_push_object(struct spa_pod_parser *parser,
struct spa_pod_frame *frame, uint32_t type, uint32_t *id)
{
const struct spa_pod *pod = spa_pod_parser_current(parser);
@ -268,7 +276,7 @@ SPA_API_IMPL int spa_pod_parser_push_object(struct spa_pod_parser *parser,
return 0;
}
SPA_API_IMPL bool spa_pod_parser_can_collect(const struct spa_pod *pod, char type)
SPA_API_POD_PARSER bool spa_pod_parser_can_collect(const struct spa_pod *pod, char type)
{
if (pod == NULL)
return false;
@ -443,7 +451,7 @@ do { \
} \
} while(false)
SPA_API_IMPL int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args)
SPA_API_POD_PARSER int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args)
{
struct spa_pod_frame *f = parser->state.frame;
uint32_t ftype = f ? f->pod.type : (uint32_t)SPA_TYPE_Struct;
@ -496,7 +504,7 @@ SPA_API_IMPL int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args
return count;
}
SPA_API_IMPL int spa_pod_parser_get(struct spa_pod_parser *parser, ...)
SPA_API_POD_PARSER int spa_pod_parser_get(struct spa_pod_parser *parser, ...)
{
int res;
va_list args;

22
spa/include/spa/support/cpu.h
View file

@ -15,6 +15,14 @@ extern "C" {
#include <spa/utils/defs.h>
#include <spa/utils/hook.h>
#ifndef SPA_API_CPU
#ifdef SPA_API_IMPL
#define SPA_API_CPU SPA_API_IMPL
#else
#define SPA_API_CPU static inline
#endif
#endif
/** \defgroup spa_cpu CPU
* Querying CPU properties
*/
@ -91,7 +99,7 @@ struct spa_cpu { struct spa_interface iface; };
#define SPA_CPU_VM_ACRN (1 << 13)
#define SPA_CPU_VM_POWERVM (1 << 14)
SPA_API_IMPL const char *spa_cpu_vm_type_to_string(uint32_t vm_type)
SPA_API_CPU const char *spa_cpu_vm_type_to_string(uint32_t vm_type)
{
switch(vm_type) {
case SPA_CPU_VM_NONE:
@ -160,27 +168,27 @@ struct spa_cpu_methods {
int (*zero_denormals) (void *object, bool enable);
};
SPA_API_IMPL uint32_t spa_cpu_get_flags(struct spa_cpu *c)
SPA_API_CPU uint32_t spa_cpu_get_flags(struct spa_cpu *c)
{
return spa_api_method_r(uint32_t, 0, spa_cpu, &c->iface, get_flags, 0);
}
SPA_API_IMPL int spa_cpu_force_flags(struct spa_cpu *c, uint32_t flags)
SPA_API_CPU int spa_cpu_force_flags(struct spa_cpu *c, uint32_t flags)
{
return spa_api_method_r(int, -ENOTSUP, spa_cpu, &c->iface, force_flags, 0, flags);
}
SPA_API_IMPL uint32_t spa_cpu_get_count(struct spa_cpu *c)
SPA_API_CPU uint32_t spa_cpu_get_count(struct spa_cpu *c)
{
return spa_api_method_r(uint32_t, 0, spa_cpu, &c->iface, get_count, 0);
}
SPA_API_IMPL uint32_t spa_cpu_get_max_align(struct spa_cpu *c)
SPA_API_CPU uint32_t spa_cpu_get_max_align(struct spa_cpu *c)
{
return spa_api_method_r(uint32_t, 0, spa_cpu, &c->iface, get_max_align, 0);
}
SPA_API_IMPL uint32_t spa_cpu_get_vm_type(struct spa_cpu *c)
SPA_API_CPU uint32_t spa_cpu_get_vm_type(struct spa_cpu *c)
{
return spa_api_method_r(uint32_t, 0, spa_cpu, &c->iface, get_vm_type, 1);
}
SPA_API_IMPL int spa_cpu_zero_denormals(struct spa_cpu *c, bool enable)
SPA_API_CPU int spa_cpu_zero_denormals(struct spa_cpu *c, bool enable)
{
return spa_api_method_r(int, -ENOTSUP, spa_cpu, &c->iface, zero_denormals, 2, enable);
}

16
spa/include/spa/support/dbus.h
View file

@ -11,6 +11,14 @@ extern "C" {
#include <spa/support/loop.h>
#ifndef SPA_API_DBUS
#ifdef SPA_API_IMPL
#define SPA_API_DBUS SPA_API_IMPL
#else
#define SPA_API_DBUS static inline
#endif
#endif
/** \defgroup spa_dbus DBus
* DBus communication
*/
@ -81,19 +89,19 @@ struct spa_dbus_connection {
/** \copydoc spa_dbus_connection.get
* \sa spa_dbus_connection.get */
SPA_API_IMPL void *spa_dbus_connection_get(struct spa_dbus_connection *conn)
SPA_API_DBUS void *spa_dbus_connection_get(struct spa_dbus_connection *conn)
{
return spa_api_func_r(void *, NULL, conn, get, 0);
}
/** \copydoc spa_dbus_connection.destroy
* \sa spa_dbus_connection.destroy */
SPA_API_IMPL void spa_dbus_connection_destroy(struct spa_dbus_connection *conn)
SPA_API_DBUS void spa_dbus_connection_destroy(struct spa_dbus_connection *conn)
{
spa_api_func_v(conn, destroy, 0);
}
/** \copydoc spa_dbus_connection.add_listener
* \sa spa_dbus_connection.add_listener */
SPA_API_IMPL void spa_dbus_connection_add_listener(struct spa_dbus_connection *conn,
SPA_API_DBUS void spa_dbus_connection_add_listener(struct spa_dbus_connection *conn,
struct spa_hook *listener,
const struct spa_dbus_connection_events *events,
void *data)
@ -124,7 +132,7 @@ struct spa_dbus_methods {
/** \copydoc spa_dbus_methods.get_connection
* \sa spa_dbus_methods.get_connection
*/
SPA_API_IMPL struct spa_dbus_connection *
SPA_API_DBUS struct spa_dbus_connection *
spa_dbus_get_connection(struct spa_dbus *dbus, enum spa_dbus_type type)
{
return spa_api_method_r(struct spa_dbus_connection *, NULL,

12
spa/include/spa/support/i18n.h
View file

@ -12,6 +12,14 @@ extern "C" {
#include <spa/utils/hook.h>
#include <spa/utils/defs.h>
#ifndef SPA_API_I18N
#ifdef SPA_API_IMPL
#define SPA_API_I18N SPA_API_IMPL
#else
#define SPA_API_I18N static inline
#endif
#endif
/** \defgroup spa_i18n I18N
* Gettext interface
*/
@ -53,14 +61,14 @@ struct spa_i18n_methods {
};
SPA_FORMAT_ARG_FUNC(2)
SPA_API_IMPL const char *
SPA_API_I18N const char *
spa_i18n_text(struct spa_i18n *i18n, const char *msgid)
{
return spa_api_method_null_r(const char *, msgid, spa_i18n, &i18n->iface,
text, 0, msgid);
}
SPA_API_IMPL const char *
SPA_API_I18N const char *
spa_i18n_ntext(struct spa_i18n *i18n, const char *msgid,
const char *msgid_plural, unsigned long int n)
{

10
spa/include/spa/support/log-impl.h
View file

@ -19,7 +19,7 @@ extern "C" {
* \{
*/
SPA_API_IMPL SPA_PRINTF_FUNC(7, 0) void spa_log_impl_logtv(void *object SPA_UNUSED,
static inline SPA_PRINTF_FUNC(7, 0) void spa_log_impl_logtv(void *object SPA_UNUSED,
enum spa_log_level level,
const struct spa_log_topic *topic,
const char *file,
@ -49,7 +49,7 @@ SPA_API_IMPL SPA_PRINTF_FUNC(7, 0) void spa_log_impl_logtv(void *object SPA_UNUS
fputs(location, stderr);
}
SPA_API_IMPL SPA_PRINTF_FUNC(7,8) void spa_log_impl_logt(void *object,
static inline SPA_PRINTF_FUNC(7,8) void spa_log_impl_logt(void *object,
enum spa_log_level level,
const struct spa_log_topic *topic,
const char *file,
@ -63,7 +63,7 @@ SPA_API_IMPL SPA_PRINTF_FUNC(7,8) void spa_log_impl_logt(void *object,
va_end(args);
}
SPA_API_IMPL SPA_PRINTF_FUNC(6, 0) void spa_log_impl_logv(void *object,
static inline SPA_PRINTF_FUNC(6, 0) void spa_log_impl_logv(void *object,
enum spa_log_level level,
const char *file,
int line,
@ -75,7 +75,7 @@ SPA_API_IMPL SPA_PRINTF_FUNC(6, 0) void spa_log_impl_logv(void *object,
spa_log_impl_logtv(object, level, NULL, file, line, func, fmt, args);
}
SPA_API_IMPL SPA_PRINTF_FUNC(6,7) void spa_log_impl_log(void *object,
static inline SPA_PRINTF_FUNC(6,7) void spa_log_impl_log(void *object,
enum spa_log_level level,
const char *file,
int line,
@ -88,7 +88,7 @@ SPA_API_IMPL SPA_PRINTF_FUNC(6,7) void spa_log_impl_log(void *object,
va_end(args);
}
SPA_API_IMPL void spa_log_impl_topic_init(void *object SPA_UNUSED, struct spa_log_topic *topic SPA_UNUSED)
static inline void spa_log_impl_topic_init(void *object SPA_UNUSED, struct spa_log_topic *topic SPA_UNUSED)
{
/* noop */
}

14
spa/include/spa/support/log.h
View file

@ -15,6 +15,14 @@ extern "C" {
#include <spa/utils/defs.h>
#include <spa/utils/hook.h>
#ifndef SPA_API_LOG
#ifdef SPA_API_IMPL
#define SPA_API_LOG SPA_API_IMPL
#else
#define SPA_API_LOG static inline
#endif
#endif
/** \defgroup spa_log Log
* Logging interface
*/
@ -213,7 +221,7 @@ struct spa_log_methods {
#define SPA_LOG_TOPIC(v, t) \
(struct spa_log_topic){ .version = (v), .topic = (t)}
SPA_API_IMPL void spa_log_topic_init(struct spa_log *log, struct spa_log_topic *topic)
SPA_API_LOG void spa_log_topic_init(struct spa_log *log, struct spa_log_topic *topic)
{
if (SPA_UNLIKELY(!log))
return;
@ -221,7 +229,7 @@ SPA_API_IMPL void spa_log_topic_init(struct spa_log *log, struct spa_log_topic *
spa_interface_call(&log->iface, struct spa_log_methods, topic_init, 1, topic);
}
SPA_API_IMPL bool spa_log_level_topic_enabled(const struct spa_log *log,
SPA_API_LOG bool spa_log_level_topic_enabled(const struct spa_log *log,
const struct spa_log_topic *topic,
enum spa_log_level level)
{
@ -256,7 +264,7 @@ SPA_API_IMPL bool spa_log_level_topic_enabled(const struct spa_log *log,
/* Transparently calls to version 0 logv if v1 is not supported */
SPA_PRINTF_FUNC(7, 0)
SPA_API_IMPL void spa_log_logtv(struct spa_log *l, enum spa_log_level level,
SPA_API_LOG void spa_log_logtv(struct spa_log *l, enum spa_log_level level,
const struct spa_log_topic *topic, const char *file, int line,
const char *func, const char *fmt, va_list args)
{

54
spa/include/spa/support/loop.h
View file

@ -15,6 +15,14 @@ extern "C" {
#include <spa/utils/hook.h>
#include <spa/support/system.h>
#ifndef SPA_API_LOOP
#ifdef SPA_API_IMPL
#define SPA_API_LOOP SPA_API_IMPL
#else
#define SPA_API_LOOP static inline
#endif
#endif
/** \defgroup spa_loop Loop
* Event loop interface
*/
@ -127,22 +135,22 @@ struct spa_loop_methods {
void *user_data);
};
SPA_API_IMPL int spa_loop_add_source(struct spa_loop *object, struct spa_source *source)
SPA_API_LOOP int spa_loop_add_source(struct spa_loop *object, struct spa_source *source)
{
return spa_api_method_r(int, -ENOTSUP,
spa_loop, &object->iface, add_source, 0, source);
}
SPA_API_IMPL int spa_loop_update_source(struct spa_loop *object, struct spa_source *source)
SPA_API_LOOP int spa_loop_update_source(struct spa_loop *object, struct spa_source *source)
{
return spa_api_method_r(int, -ENOTSUP,
spa_loop, &object->iface, update_source, 0, source);
}
SPA_API_IMPL int spa_loop_remove_source(struct spa_loop *object, struct spa_source *source)
SPA_API_LOOP int spa_loop_remove_source(struct spa_loop *object, struct spa_source *source)
{
return spa_api_method_r(int, -ENOTSUP,
spa_loop, &object->iface, remove_source, 0, source);
}
SPA_API_IMPL int spa_loop_invoke(struct spa_loop *object,
SPA_API_LOOP int spa_loop_invoke(struct spa_loop *object,
spa_invoke_func_t func, uint32_t seq, const void *data,
size_t size, bool block, void *user_data)
{
@ -165,14 +173,14 @@ struct spa_loop_control_hooks {
void (*after) (void *data);
};
SPA_API_IMPL void spa_loop_control_hook_before(struct spa_hook_list *l)
SPA_API_LOOP void spa_loop_control_hook_before(struct spa_hook_list *l)
{
struct spa_hook *h;
spa_list_for_each_reverse(h, &l->list, link)
spa_callbacks_call_fast(&h->cb, struct spa_loop_control_hooks, before, 0);
}
SPA_API_IMPL void spa_loop_control_hook_after(struct spa_hook_list *l)
SPA_API_LOOP void spa_loop_control_hook_after(struct spa_hook_list *l)
{
struct spa_hook *h;
spa_list_for_each(h, &l->list, link)
@ -239,39 +247,39 @@ struct spa_loop_control_methods {
int (*check) (void *object);
};
SPA_API_IMPL int spa_loop_control_get_fd(struct spa_loop_control *object)
SPA_API_LOOP int spa_loop_control_get_fd(struct spa_loop_control *object)
{
return spa_api_method_r(int, -ENOTSUP,
spa_loop_control, &object->iface, get_fd, 0);
}
SPA_API_IMPL void spa_loop_control_add_hook(struct spa_loop_control *object,
SPA_API_LOOP void spa_loop_control_add_hook(struct spa_loop_control *object,
struct spa_hook *hook, const struct spa_loop_control_hooks *hooks,
void *data)
{
spa_api_method_v(spa_loop_control, &object->iface, add_hook, 0,
hook, hooks, data);
}
SPA_API_IMPL void spa_loop_control_enter(struct spa_loop_control *object)
SPA_API_LOOP void spa_loop_control_enter(struct spa_loop_control *object)
{
spa_api_method_v(spa_loop_control, &object->iface, enter, 0);
}
SPA_API_IMPL void spa_loop_control_leave(struct spa_loop_control *object)
SPA_API_LOOP void spa_loop_control_leave(struct spa_loop_control *object)
{
spa_api_method_v(spa_loop_control, &object->iface, leave, 0);
}
SPA_API_IMPL int spa_loop_control_iterate(struct spa_loop_control *object,
SPA_API_LOOP int spa_loop_control_iterate(struct spa_loop_control *object,
int timeout)
{
return spa_api_method_r(int, -ENOTSUP,
spa_loop_control, &object->iface, iterate, 0, timeout);
}
SPA_API_IMPL int spa_loop_control_iterate_fast(struct spa_loop_control *object,
SPA_API_LOOP int spa_loop_control_iterate_fast(struct spa_loop_control *object,
int timeout)
{
return spa_api_method_fast_r(int, -ENOTSUP,
spa_loop_control, &object->iface, iterate, 0, timeout);
}
SPA_API_IMPL int spa_loop_control_check(struct spa_loop_control *object)
SPA_API_LOOP int spa_loop_control_check(struct spa_loop_control *object)
{
return spa_api_method_r(int, -ENOTSUP,
spa_loop_control, &object->iface, check, 1);
@ -326,51 +334,51 @@ struct spa_loop_utils_methods {
void (*destroy_source) (void *object, struct spa_source *source);
};
SPA_API_IMPL struct spa_source *
SPA_API_LOOP struct spa_source *
spa_loop_utils_add_io(struct spa_loop_utils *object, int fd, uint32_t mask,
bool close, spa_source_io_func_t func, void *data)
{
return spa_api_method_r(struct spa_source *, NULL,
spa_loop_utils, &object->iface, add_io, 0, fd, mask, close, func, data);
}
SPA_API_IMPL int spa_loop_utils_update_io(struct spa_loop_utils *object,
SPA_API_LOOP int spa_loop_utils_update_io(struct spa_loop_utils *object,
struct spa_source *source, uint32_t mask)
{
return spa_api_method_r(int, -ENOTSUP,
spa_loop_utils, &object->iface, update_io, 0, source, mask);
}
SPA_API_IMPL struct spa_source *
SPA_API_LOOP struct spa_source *
spa_loop_utils_add_idle(struct spa_loop_utils *object, bool enabled,
spa_source_idle_func_t func, void *data)
{
return spa_api_method_r(struct spa_source *, NULL,
spa_loop_utils, &object->iface, add_idle, 0, enabled, func, data);
}
SPA_API_IMPL int spa_loop_utils_enable_idle(struct spa_loop_utils *object,
SPA_API_LOOP int spa_loop_utils_enable_idle(struct spa_loop_utils *object,
struct spa_source *source, bool enabled)
{
return spa_api_method_r(int, -ENOTSUP,
spa_loop_utils, &object->iface, enable_idle, 0, source, enabled);
}
SPA_API_IMPL struct spa_source *
SPA_API_LOOP struct spa_source *
spa_loop_utils_add_event(struct spa_loop_utils *object, spa_source_event_func_t func, void *data)
{
return spa_api_method_r(struct spa_source *, NULL,
spa_loop_utils, &object->iface, add_event, 0, func, data);
}
SPA_API_IMPL int spa_loop_utils_signal_event(struct spa_loop_utils *object,
SPA_API_LOOP int spa_loop_utils_signal_event(struct spa_loop_utils *object,
struct spa_source *source)
{
return spa_api_method_r(int, -ENOTSUP,
spa_loop_utils, &object->iface, signal_event, 0, source);
}
SPA_API_IMPL struct spa_source *
SPA_API_LOOP struct spa_source *
spa_loop_utils_add_timer(struct spa_loop_utils *object, spa_source_timer_func_t func, void *data)
{
return spa_api_method_r(struct spa_source *, NULL,
spa_loop_utils, &object->iface, add_timer, 0, func, data);
}
SPA_API_IMPL int spa_loop_utils_update_timer(struct spa_loop_utils *object,
SPA_API_LOOP int spa_loop_utils_update_timer(struct spa_loop_utils *object,
struct spa_source *source, struct timespec *value,
struct timespec *interval, bool absolute)
{
@ -378,7 +386,7 @@ SPA_API_IMPL int spa_loop_utils_update_timer(struct spa_loop_utils *object,
spa_loop_utils, &object->iface, update_timer, 0, source,
value, interval, absolute);
}
SPA_API_IMPL struct spa_source *
SPA_API_LOOP struct spa_source *
spa_loop_utils_add_signal(struct spa_loop_utils *object, int signal_number,
spa_source_signal_func_t func, void *data)
{
@ -386,7 +394,7 @@ spa_loop_utils_add_signal(struct spa_loop_utils *object, int signal_number,
spa_loop_utils, &object->iface, add_signal, 0,
signal_number, func, data);
}
SPA_API_IMPL void spa_loop_utils_destroy_source(struct spa_loop_utils *object,
SPA_API_LOOP void spa_loop_utils_destroy_source(struct spa_loop_utils *object,
struct spa_source *source)
{
spa_api_method_v(spa_loop_utils, &object->iface, destroy_source, 0, source);

12
spa/include/spa/support/plugin-loader.h
View file

@ -12,6 +12,14 @@ extern "C" {
#include <spa/utils/hook.h>
#include <spa/utils/dict.h>
#ifndef SPA_API_PLUGIN_LOADER
#ifdef SPA_API_IMPL
#define SPA_API_PLUGIN_LOADER SPA_API_IMPL
#else
#define SPA_API_PLUGIN_LOADER static inline
#endif
#endif
/** \defgroup spa_plugin_loader Plugin Loader
* SPA plugin loader
*/
@ -48,14 +56,14 @@ struct spa_plugin_loader_methods {
int (*unload)(void *object, struct spa_handle *handle);
};
SPA_API_IMPL struct spa_handle *
SPA_API_PLUGIN_LOADER struct spa_handle *
spa_plugin_loader_load(struct spa_plugin_loader *loader, const char *factory_name, const struct spa_dict *info)
{
return spa_api_method_null_r(struct spa_handle *, NULL, spa_plugin_loader, &loader->iface,
load, 0, factory_name, info);
}
SPA_API_IMPL int
SPA_API_PLUGIN_LOADER int
spa_plugin_loader_unload(struct spa_plugin_loader *loader, struct spa_handle *handle)
{
return spa_api_method_null_r(int, -1, spa_plugin_loader, &loader->iface,

20
spa/include/spa/support/plugin.h
View file

@ -15,6 +15,14 @@ extern "C" {
#include <spa/utils/hook.h>
#include <spa/utils/dict.h>
#ifndef SPA_API_PLUGIN
#ifdef SPA_API_IMPL
#define SPA_API_PLUGIN SPA_API_IMPL
#else
#define SPA_API_PLUGIN static inline
#endif
#endif
/**
* \defgroup spa_handle Plugin Handle
* SPA plugin handle and factory interfaces
@ -54,13 +62,13 @@ struct spa_handle {
int (*clear) (struct spa_handle *handle);
};
SPA_API_IMPL int
SPA_API_PLUGIN int
spa_handle_get_interface(struct spa_handle *object,
const char *type, void **iface)
{
return spa_api_func_r(int, -ENOTSUP, object, get_interface, 0, type, iface);
}
SPA_API_IMPL int
SPA_API_PLUGIN int
spa_handle_clear(struct spa_handle *object)
{
return spa_api_func_r(int, -ENOTSUP, object, clear, 0);
@ -85,7 +93,7 @@ struct spa_support {
};
/** Find a support item of the given type */
SPA_API_IMPL void *spa_support_find(const struct spa_support *support,
SPA_API_PLUGIN void *spa_support_find(const struct spa_support *support,
uint32_t n_support,
const char *type)
{
@ -170,13 +178,13 @@ struct spa_handle_factory {
uint32_t *index);
};
SPA_API_IMPL size_t
SPA_API_PLUGIN size_t
spa_handle_factory_get_size(const struct spa_handle_factory *object,
const struct spa_dict *params)
{
return spa_api_func_r(size_t, 0, object, get_size, 1, params);
}
SPA_API_IMPL int
SPA_API_PLUGIN int
spa_handle_factory_init(const struct spa_handle_factory *object,
struct spa_handle *handle, const struct spa_dict *info,
const struct spa_support *support, uint32_t n_support)
@ -184,7 +192,7 @@ spa_handle_factory_init(const struct spa_handle_factory *object,
return spa_api_func_r(int, -ENOTSUP, object, init, 1, handle, info,
support, n_support);
}
SPA_API_IMPL int
SPA_API_PLUGIN int
spa_handle_factory_enum_interface_info(const struct spa_handle_factory *object,
const struct spa_interface_info **info, uint32_t *index)
{

46
spa/include/spa/support/system.h
View file

@ -18,6 +18,14 @@ struct itimerspec;
#include <spa/utils/defs.h>
#include <spa/utils/hook.h>
#ifndef SPA_API_SYSTEM
#ifdef SPA_API_IMPL
#define SPA_API_SYSTEM SPA_API_IMPL
#else
#define SPA_API_SYSTEM static inline
#endif
#endif
/** \defgroup spa_system System
* I/O, clock, polling, timer, and signal interfaces
*/
@ -98,60 +106,60 @@ struct spa_system_methods {
int (*signalfd_read) (void *object, int fd, int *signal);
};
SPA_API_IMPL ssize_t spa_system_read(struct spa_system *object, int fd, void *buf, size_t count)
SPA_API_SYSTEM ssize_t spa_system_read(struct spa_system *object, int fd, void *buf, size_t count)
{
return spa_api_method_fast_r(ssize_t, -ENOTSUP, spa_system, &object->iface, read, 0, fd, buf, count);
}
SPA_API_IMPL ssize_t spa_system_write(struct spa_system *object, int fd, const void *buf, size_t count)
SPA_API_SYSTEM ssize_t spa_system_write(struct spa_system *object, int fd, const void *buf, size_t count)
{
return spa_api_method_fast_r(ssize_t, -ENOTSUP, spa_system, &object->iface, write, 0, fd, buf, count);
}
#define spa_system_ioctl(object,fd,request,...) \
spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, ioctl, 0, fd, request, ##__VA_ARGS__)
SPA_API_IMPL int spa_system_close(struct spa_system *object, int fd)
SPA_API_SYSTEM int spa_system_close(struct spa_system *object, int fd)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, close, 0, fd);
}
SPA_API_IMPL int spa_system_clock_gettime(struct spa_system *object,
SPA_API_SYSTEM int spa_system_clock_gettime(struct spa_system *object,
int clockid, struct timespec *value)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, clock_gettime, 0, clockid, value);
}
SPA_API_IMPL int spa_system_clock_getres(struct spa_system *object,
SPA_API_SYSTEM int spa_system_clock_getres(struct spa_system *object,
int clockid, struct timespec *res)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, clock_getres, 0, clockid, res);
}
SPA_API_IMPL int spa_system_pollfd_create(struct spa_system *object, int flags)
SPA_API_SYSTEM int spa_system_pollfd_create(struct spa_system *object, int flags)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, pollfd_create, 0, flags);
}
SPA_API_IMPL int spa_system_pollfd_add(struct spa_system *object, int pfd, int fd, uint32_t events, void *data)
SPA_API_SYSTEM int spa_system_pollfd_add(struct spa_system *object, int pfd, int fd, uint32_t events, void *data)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, pollfd_add, 0, pfd, fd, events, data);
}
SPA_API_IMPL int spa_system_pollfd_mod(struct spa_system *object, int pfd, int fd, uint32_t events, void *data)
SPA_API_SYSTEM int spa_system_pollfd_mod(struct spa_system *object, int pfd, int fd, uint32_t events, void *data)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, pollfd_mod, 0, pfd, fd, events, data);
}
SPA_API_IMPL int spa_system_pollfd_del(struct spa_system *object, int pfd, int fd)
SPA_API_SYSTEM int spa_system_pollfd_del(struct spa_system *object, int pfd, int fd)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, pollfd_del, 0, pfd, fd);
}
SPA_API_IMPL int spa_system_pollfd_wait(struct spa_system *object, int pfd,
SPA_API_SYSTEM int spa_system_pollfd_wait(struct spa_system *object, int pfd,
struct spa_poll_event *ev, int n_ev, int timeout)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, pollfd_wait, 0, pfd, ev, n_ev, timeout);
}
SPA_API_IMPL int spa_system_timerfd_create(struct spa_system *object, int clockid, int flags)
SPA_API_SYSTEM int spa_system_timerfd_create(struct spa_system *object, int clockid, int flags)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, timerfd_create, 0, clockid, flags);
}
SPA_API_IMPL int spa_system_timerfd_settime(struct spa_system *object,
SPA_API_SYSTEM int spa_system_timerfd_settime(struct spa_system *object,
int fd, int flags,
const struct itimerspec *new_value,
struct itimerspec *old_value)
@ -160,40 +168,40 @@ SPA_API_IMPL int spa_system_timerfd_settime(struct spa_system *object,
fd, flags, new_value, old_value);
}
SPA_API_IMPL int spa_system_timerfd_gettime(struct spa_system *object,
SPA_API_SYSTEM int spa_system_timerfd_gettime(struct spa_system *object,
int fd, struct itimerspec *curr_value)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, timerfd_gettime, 0,
fd, curr_value);
}
SPA_API_IMPL int spa_system_timerfd_read(struct spa_system *object, int fd, uint64_t *expirations)
SPA_API_SYSTEM int spa_system_timerfd_read(struct spa_system *object, int fd, uint64_t *expirations)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, timerfd_read, 0,
fd, expirations);
}
SPA_API_IMPL int spa_system_eventfd_create(struct spa_system *object, int flags)
SPA_API_SYSTEM int spa_system_eventfd_create(struct spa_system *object, int flags)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, eventfd_create, 0, flags);
}
SPA_API_IMPL int spa_system_eventfd_write(struct spa_system *object, int fd, uint64_t count)
SPA_API_SYSTEM int spa_system_eventfd_write(struct spa_system *object, int fd, uint64_t count)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, eventfd_write, 0,
fd, count);
}
SPA_API_IMPL int spa_system_eventfd_read(struct spa_system *object, int fd, uint64_t *count)
SPA_API_SYSTEM int spa_system_eventfd_read(struct spa_system *object, int fd, uint64_t *count)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, eventfd_read, 0,
fd, count);
}
SPA_API_IMPL int spa_system_signalfd_create(struct spa_system *object, int signal, int flags)
SPA_API_SYSTEM int spa_system_signalfd_create(struct spa_system *object, int signal, int flags)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, signalfd_create, 0,
signal, flags);
}
SPA_API_IMPL int spa_system_signalfd_read(struct spa_system *object, int fd, int *signal)
SPA_API_SYSTEM int spa_system_signalfd_read(struct spa_system *object, int fd, int *signal)
{
return spa_api_method_fast_r(int, -ENOTSUP, spa_system, &object->iface, signalfd_read, 0,
fd, signal);

18
spa/include/spa/support/thread.h
View file

@ -16,6 +16,14 @@ extern "C" {
#include <spa/utils/hook.h>
#include <spa/utils/dict.h>
#ifndef SPA_API_THREAD
#ifdef SPA_API_IMPL
#define SPA_API_THREAD SPA_API_IMPL
#else
#define SPA_API_THREAD static inline
#endif
#endif
/** \defgroup spa_thread Thread
* Threading utility interfaces
*/
@ -58,7 +66,7 @@ struct spa_thread_utils_methods {
/** \copydoc spa_thread_utils_methods.create
* \sa spa_thread_utils_methods.create */
SPA_API_IMPL struct spa_thread *spa_thread_utils_create(struct spa_thread_utils *o,
SPA_API_THREAD struct spa_thread *spa_thread_utils_create(struct spa_thread_utils *o,
const struct spa_dict *props, void *(*start_routine)(void*), void *arg)
{
return spa_api_method_r(struct spa_thread *, NULL,
@ -68,7 +76,7 @@ SPA_API_IMPL struct spa_thread *spa_thread_utils_create(struct spa_thread_utils
/** \copydoc spa_thread_utils_methods.join
* \sa spa_thread_utils_methods.join */
SPA_API_IMPL int spa_thread_utils_join(struct spa_thread_utils *o,
SPA_API_THREAD int spa_thread_utils_join(struct spa_thread_utils *o,
struct spa_thread *thread, void **retval)
{
return spa_api_method_r(int, -ENOTSUP,
@ -78,7 +86,7 @@ SPA_API_IMPL int spa_thread_utils_join(struct spa_thread_utils *o,
/** \copydoc spa_thread_utils_methods.get_rt_range
* \sa spa_thread_utils_methods.get_rt_range */
SPA_API_IMPL int spa_thread_utils_get_rt_range(struct spa_thread_utils *o,
SPA_API_THREAD int spa_thread_utils_get_rt_range(struct spa_thread_utils *o,
const struct spa_dict *props, int *min, int *max)
{
return spa_api_method_r(int, -ENOTSUP,
@ -88,7 +96,7 @@ SPA_API_IMPL int spa_thread_utils_get_rt_range(struct spa_thread_utils *o,
/** \copydoc spa_thread_utils_methods.acquire_rt
* \sa spa_thread_utils_methods.acquire_rt */
SPA_API_IMPL int spa_thread_utils_acquire_rt(struct spa_thread_utils *o,
SPA_API_THREAD int spa_thread_utils_acquire_rt(struct spa_thread_utils *o,
struct spa_thread *thread, int priority)
{
return spa_api_method_r(int, -ENOTSUP,
@ -98,7 +106,7 @@ SPA_API_IMPL int spa_thread_utils_acquire_rt(struct spa_thread_utils *o,
/** \copydoc spa_thread_utils_methods.drop_rt
* \sa spa_thread_utils_methods.drop_rt */
SPA_API_IMPL int spa_thread_utils_drop_rt(struct spa_thread_utils *o,
SPA_API_THREAD int spa_thread_utils_drop_rt(struct spa_thread_utils *o,
struct spa_thread *thread)
{
return spa_api_method_r(int, -ENOTSUP,

13
spa/include/spa/utils/defs.h
View file

@ -259,6 +259,15 @@ struct spa_fraction {
#define SPA_API_IMPL static inline
#endif
#ifndef SPA_API_UTILS_DEFS
#ifdef SPA_API_IMPL
#define SPA_API_UTILS_DEFS SPA_API_IMPL
#else
#define SPA_API_UTILS_DEFS static inline
#endif
#endif
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define SPA_RESTRICT restrict
#elif defined(__GNUC__) && __GNUC__ >= 4
@ -305,7 +314,7 @@ struct spa_fraction {
#endif
#endif
SPA_API_IMPL bool spa_ptrinside(const void *p1, size_t s1, const void *p2, size_t s2,
SPA_API_UTILS_DEFS bool spa_ptrinside(const void *p1, size_t s1, const void *p2, size_t s2,
size_t *remaining)
{
if (SPA_LIKELY((uintptr_t)p1 <= (uintptr_t)p2 && s2 <= s1 &&
@ -320,7 +329,7 @@ SPA_API_IMPL bool spa_ptrinside(const void *p1, size_t s1, const void *p2, size_
}
}
SPA_API_IMPL bool spa_ptr_inside_and_aligned(const void *p1, size_t s1,
SPA_API_UTILS_DEFS bool spa_ptr_inside_and_aligned(const void *p1, size_t s1,
const void *p2, size_t s2, size_t align,
size_t *remaining)
{

16
spa/include/spa/utils/dict.h
View file

@ -13,6 +13,14 @@ extern "C" {
#include <spa/utils/defs.h>
#ifndef SPA_API_DICT
#ifdef SPA_API_IMPL
#define SPA_API_DICT SPA_API_IMPL
#else
#define SPA_API_DICT static inline
#endif
#endif
/**
* \defgroup spa_dict Dictionary
* Dictionary data structure
@ -50,14 +58,14 @@ struct spa_dict {
(item) < &(dict)->items[(dict)->n_items]; \
(item)++)
SPA_API_IMPL int spa_dict_item_compare(const void *i1, const void *i2)
SPA_API_DICT int spa_dict_item_compare(const void *i1, const void *i2)
{
const struct spa_dict_item *it1 = (const struct spa_dict_item *)i1,
*it2 = (const struct spa_dict_item *)i2;
return strcmp(it1->key, it2->key);
}
SPA_API_IMPL void spa_dict_qsort(struct spa_dict *dict)
SPA_API_DICT void spa_dict_qsort(struct spa_dict *dict)
{
if (dict->n_items > 0)
qsort((void*)dict->items, dict->n_items, sizeof(struct spa_dict_item),
@ -65,7 +73,7 @@ SPA_API_IMPL void spa_dict_qsort(struct spa_dict *dict)
SPA_FLAG_SET(dict->flags, SPA_DICT_FLAG_SORTED);
}
SPA_API_IMPL const struct spa_dict_item *spa_dict_lookup_item(const struct spa_dict *dict,
SPA_API_DICT const struct spa_dict_item *spa_dict_lookup_item(const struct spa_dict *dict,
const char *key)
{
const struct spa_dict_item *item;
@ -88,7 +96,7 @@ SPA_API_IMPL const struct spa_dict_item *spa_dict_lookup_item(const struct spa_d
return NULL;
}
SPA_API_IMPL const char *spa_dict_lookup(const struct spa_dict *dict, const char *key)
SPA_API_DICT const char *spa_dict_lookup(const struct spa_dict *dict, const char *key)
{
const struct spa_dict_item *item = spa_dict_lookup_item(dict, key);
return item ? item->value : NULL;

14
spa/include/spa/utils/dll.h
View file

@ -14,6 +14,14 @@ extern "C" {
#include <spa/utils/defs.h>
#ifndef SPA_API_DLL
#ifdef SPA_API_IMPL
#define SPA_API_DLL SPA_API_IMPL
#else
#define SPA_API_DLL static inline
#endif
#endif
#define SPA_DLL_BW_MAX 0.128
#define SPA_DLL_BW_MIN 0.016
@ -23,13 +31,13 @@ struct spa_dll {
double w0, w1, w2;
};
SPA_API_IMPL void spa_dll_init(struct spa_dll *dll)
SPA_API_DLL void spa_dll_init(struct spa_dll *dll)
{
dll->bw = 0.0;
dll->z1 = dll->z2 = dll->z3 = 0.0;
}
SPA_API_IMPL void spa_dll_set_bw(struct spa_dll *dll, double bw, unsigned period, unsigned rate)
SPA_API_DLL void spa_dll_set_bw(struct spa_dll *dll, double bw, unsigned period, unsigned rate)
{
double w = 2 * M_PI * bw * period / rate;
dll->w0 = 1.0 - exp (-20.0 * w);
@ -38,7 +46,7 @@ SPA_API_IMPL void spa_dll_set_bw(struct spa_dll *dll, double bw, unsigned period
dll->bw = bw;
}
SPA_API_IMPL double spa_dll_update(struct spa_dll *dll, double err)
SPA_API_DLL double spa_dll_update(struct spa_dll *dll, double err)
{
dll->z1 += dll->w0 * (dll->w1 * err - dll->z1);
dll->z2 += dll->w0 * (dll->z1 - dll->z2);

24
spa/include/spa/utils/hook.h
View file

@ -12,6 +12,14 @@ extern "C" {
#include <spa/utils/defs.h>
#include <spa/utils/list.h>
#ifndef SPA_API_HOOK
#ifdef SPA_API_IMPL
#define SPA_API_HOOK SPA_API_IMPL
#else
#define SPA_API_HOOK static inline
#endif
#endif
/** \defgroup spa_interfaces Interfaces
*
* \brief Generic implementation of implementation-independent interfaces
@ -411,18 +419,18 @@ struct spa_hook {
};
/** Initialize a hook list to the empty list*/
SPA_API_IMPL void spa_hook_list_init(struct spa_hook_list *list)
SPA_API_HOOK void spa_hook_list_init(struct spa_hook_list *list)
{
spa_list_init(&list->list);
}
SPA_API_IMPL bool spa_hook_list_is_empty(struct spa_hook_list *list)
SPA_API_HOOK bool spa_hook_list_is_empty(struct spa_hook_list *list)
{
return spa_list_is_empty(&list->list);
}
/** Append a hook. */
SPA_API_IMPL void spa_hook_list_append(struct spa_hook_list *list,
SPA_API_HOOK void spa_hook_list_append(struct spa_hook_list *list,
struct spa_hook *hook,
const void *funcs, void *data)
{
@ -432,7 +440,7 @@ SPA_API_IMPL void spa_hook_list_append(struct spa_hook_list *list,
}
/** Prepend a hook */
SPA_API_IMPL void spa_hook_list_prepend(struct spa_hook_list *list,
SPA_API_HOOK void spa_hook_list_prepend(struct spa_hook_list *list,
struct spa_hook *hook,
const void *funcs, void *data)
{
@ -442,7 +450,7 @@ SPA_API_IMPL void spa_hook_list_prepend(struct spa_hook_list *list,
}
/** Remove a hook */
SPA_API_IMPL void spa_hook_remove(struct spa_hook *hook)
SPA_API_HOOK void spa_hook_remove(struct spa_hook *hook)
{
if (spa_list_is_initialized(&hook->link))
spa_list_remove(&hook->link);
@ -451,14 +459,14 @@ SPA_API_IMPL void spa_hook_remove(struct spa_hook *hook)
}
/** Remove all hooks from the list */
SPA_API_IMPL void spa_hook_list_clean(struct spa_hook_list *list)
SPA_API_HOOK void spa_hook_list_clean(struct spa_hook_list *list)
{
struct spa_hook *h;
spa_list_consume(h, &list->list, link)
spa_hook_remove(h);
}
SPA_API_IMPL void
SPA_API_HOOK void
spa_hook_list_isolate(struct spa_hook_list *list,
struct spa_hook_list *save,
struct spa_hook *hook,
@ -472,7 +480,7 @@ spa_hook_list_isolate(struct spa_hook_list *list,
spa_hook_list_append(list, hook, funcs, data);
}
SPA_API_IMPL void
SPA_API_HOOK void
spa_hook_list_join(struct spa_hook_list *list,
struct spa_hook_list *save)
{

52
spa/include/spa/utils/json-core.h
View file

@ -20,6 +20,14 @@ extern "C" {
#include <spa/utils/defs.h>
#include <spa/utils/string.h>
#ifndef SPA_API_JSON
#ifdef SPA_API_IMPL
#define SPA_API_JSON SPA_API_IMPL
#else
#define SPA_API_JSON static inline
#endif
#endif
/** \defgroup spa_json JSON
* Relaxed JSON variant parsing
*/
@ -41,13 +49,13 @@ struct spa_json {
#define SPA_JSON_INIT(data,size) ((struct spa_json) { (data), (data)+(size), NULL, 0, 0 })
SPA_API_IMPL void spa_json_init(struct spa_json * iter, const char *data, size_t size)
SPA_API_JSON void spa_json_init(struct spa_json * iter, const char *data, size_t size)
{
*iter = SPA_JSON_INIT(data, size);
}
#define SPA_JSON_ENTER(iter) ((struct spa_json) { (iter)->cur, (iter)->end, (iter), (iter)->state & 0xff0, 0 })
SPA_API_IMPL void spa_json_enter(struct spa_json * iter, struct spa_json * sub)
SPA_API_JSON void spa_json_enter(struct spa_json * iter, struct spa_json * sub)
{
*sub = SPA_JSON_ENTER(iter);
}
@ -58,7 +66,7 @@ SPA_API_IMPL void spa_json_enter(struct spa_json * iter, struct spa_json * sub)
/** Get the next token. \a value points to the token and the return value
* is the length. Returns -1 on parse error, 0 on end of input. */
SPA_API_IMPL int spa_json_next(struct spa_json * iter, const char **value)
SPA_API_JSON int spa_json_next(struct spa_json * iter, const char **value)
{
int utf8_remain = 0, err = 0;
enum {
@ -312,7 +320,7 @@ error:
*
* \since 1.1.0
*/
SPA_API_IMPL bool spa_json_get_error(struct spa_json *iter, const char *start,
SPA_API_JSON bool spa_json_get_error(struct spa_json *iter, const char *start,
struct spa_error_location *loc)
{
static const char *reasons[] = {
@ -358,31 +366,31 @@ SPA_API_IMPL bool spa_json_get_error(struct spa_json *iter, const char *start,
return true;
}
SPA_API_IMPL int spa_json_is_container(const char *val, int len)
SPA_API_JSON int spa_json_is_container(const char *val, int len)
{
return len > 0 && (*val == '{' || *val == '[');
}
/* object */
SPA_API_IMPL int spa_json_is_object(const char *val, int len)
SPA_API_JSON int spa_json_is_object(const char *val, int len)
{
return len > 0 && *val == '{';
}
/* array */
SPA_API_IMPL bool spa_json_is_array(const char *val, int len)
SPA_API_JSON bool spa_json_is_array(const char *val, int len)
{
return len > 0 && *val == '[';
}
/* null */
SPA_API_IMPL bool spa_json_is_null(const char *val, int len)
SPA_API_JSON bool spa_json_is_null(const char *val, int len)
{
return len == 4 && strncmp(val, "null", 4) == 0;
}
/* float */
SPA_API_IMPL int spa_json_parse_float(const char *val, int len, float *result)
SPA_API_JSON int spa_json_parse_float(const char *val, int len, float *result)
{
char buf[96];
char *end;
@ -405,13 +413,13 @@ SPA_API_IMPL int spa_json_parse_float(const char *val, int len, float *result)
return len > 0 && end == buf + len;
}
SPA_API_IMPL bool spa_json_is_float(const char *val, int len)
SPA_API_JSON bool spa_json_is_float(const char *val, int len)
{
float dummy;
return spa_json_parse_float(val, len, &dummy);
}
SPA_API_IMPL char *spa_json_format_float(char *str, int size, float val)
SPA_API_JSON char *spa_json_format_float(char *str, int size, float val)
{
if (SPA_UNLIKELY(!isnormal(val))) {
if (isinf(val))
@ -423,7 +431,7 @@ SPA_API_IMPL char *spa_json_format_float(char *str, int size, float val)
}
/* int */
SPA_API_IMPL int spa_json_parse_int(const char *val, int len, int *result)
SPA_API_JSON int spa_json_parse_int(const char *val, int len, int *result)
{
char buf[64];
char *end;
@ -437,29 +445,29 @@ SPA_API_IMPL int spa_json_parse_int(const char *val, int len, int *result)
*result = strtol(buf, &end, 0);
return len > 0 && end == buf + len;
}
SPA_API_IMPL bool spa_json_is_int(const char *val, int len)
SPA_API_JSON bool spa_json_is_int(const char *val, int len)
{
int dummy;
return spa_json_parse_int(val, len, &dummy);
}
/* bool */
SPA_API_IMPL bool spa_json_is_true(const char *val, int len)
SPA_API_JSON bool spa_json_is_true(const char *val, int len)
{
return len == 4 && strncmp(val, "true", 4) == 0;
}
SPA_API_IMPL bool spa_json_is_false(const char *val, int len)
SPA_API_JSON bool spa_json_is_false(const char *val, int len)
{
return len == 5 && strncmp(val, "false", 5) == 0;
}
SPA_API_IMPL bool spa_json_is_bool(const char *val, int len)
SPA_API_JSON bool spa_json_is_bool(const char *val, int len)
{
return spa_json_is_true(val, len) || spa_json_is_false(val, len);
}
SPA_API_IMPL int spa_json_parse_bool(const char *val, int len, bool *result)
SPA_API_JSON int spa_json_parse_bool(const char *val, int len, bool *result)
{
if ((*result = spa_json_is_true(val, len)))
return 1;
@ -469,12 +477,12 @@ SPA_API_IMPL int spa_json_parse_bool(const char *val, int len, bool *result)
}
/* string */
SPA_API_IMPL bool spa_json_is_string(const char *val, int len)
SPA_API_JSON bool spa_json_is_string(const char *val, int len)
{
return len > 1 && *val == '"';
}
SPA_API_IMPL int spa_json_parse_hex(const char *p, int num, uint32_t *res)
SPA_API_JSON int spa_json_parse_hex(const char *p, int num, uint32_t *res)
{
int i;
*res = 0;
@ -493,7 +501,7 @@ SPA_API_IMPL int spa_json_parse_hex(const char *p, int num, uint32_t *res)
return 1;
}
SPA_API_IMPL int spa_json_parse_stringn(const char *val, int len, char *result, int maxlen)
SPA_API_JSON int spa_json_parse_stringn(const char *val, int len, char *result, int maxlen)
{
const char *p;
if (maxlen <= len)
@ -556,12 +564,12 @@ SPA_API_IMPL int spa_json_parse_stringn(const char *val, int len, char *result,
return 1;
}
SPA_API_IMPL int spa_json_parse_string(const char *val, int len, char *result)
SPA_API_JSON int spa_json_parse_string(const char *val, int len, char *result)
{
return spa_json_parse_stringn(val, len, result, len+1);
}
SPA_API_IMPL int spa_json_encode_string(char *str, int size, const char *val)
SPA_API_JSON int spa_json_encode_string(char *str, int size, const char *val)
{
int len = 0;
static const char hex[] = { "0123456789abcdef" };

14
spa/include/spa/utils/json-pod.h
View file

@ -15,6 +15,14 @@ extern "C" {
#include <spa/pod/builder.h>
#include <spa/debug/types.h>
#ifndef SPA_API_JSON_POD
#ifdef SPA_API_IMPL
#define SPA_API_JSON_POD SPA_API_IMPL
#else
#define SPA_API_JSON_POD static inline
#endif
#endif
/** \defgroup spa_json_pod JSON to POD
* JSON to POD conversion
*/
@ -24,7 +32,7 @@ extern "C" {
* \{
*/
SPA_API_IMPL int spa_json_to_pod_part(struct spa_pod_builder *b, uint32_t flags, uint32_t id,
SPA_API_JSON_POD int spa_json_to_pod_part(struct spa_pod_builder *b, uint32_t flags, uint32_t id,
const struct spa_type_info *info, struct spa_json *iter, const char *value, int len)
{
const struct spa_type_info *ti;
@ -135,7 +143,7 @@ SPA_API_IMPL int spa_json_to_pod_part(struct spa_pod_builder *b, uint32_t flags,
return 0;
}
SPA_API_IMPL int spa_json_to_pod_checked(struct spa_pod_builder *b, uint32_t flags,
SPA_API_JSON_POD int spa_json_to_pod_checked(struct spa_pod_builder *b, uint32_t flags,
const struct spa_type_info *info, const char *value, int len,
struct spa_error_location *loc)
{
@ -157,7 +165,7 @@ error:
return res;
}
SPA_API_IMPL int spa_json_to_pod(struct spa_pod_builder *b, uint32_t flags,
SPA_API_JSON_POD int spa_json_to_pod(struct spa_pod_builder *b, uint32_t flags,
const struct spa_type_info *info, const char *value, int len)
{
return spa_json_to_pod_checked(b, flags, info, value, len, NULL);

44
spa/include/spa/utils/json.h
View file

@ -19,6 +19,14 @@ extern "C" {
#include <spa/utils/json-core.h>
#ifndef SPA_API_JSON_UTILS
#ifdef SPA_API_IMPL
#define SPA_API_JSON_UTILS SPA_API_IMPL
#else
#define SPA_API_JSON_UTILS static inline
#endif
#endif
/** \defgroup spa_json_utils JSON Utils
* Relaxed JSON variant parsing Utils
*/
@ -28,14 +36,14 @@ extern "C" {
* \{
*/
SPA_API_IMPL int spa_json_begin(struct spa_json * iter, const char *data, size_t size, const char **val)
SPA_API_JSON_UTILS int spa_json_begin(struct spa_json * iter, const char *data, size_t size, const char **val)
{
spa_json_init(iter, data, size);
return spa_json_next(iter, val);
}
/* float */
SPA_API_IMPL int spa_json_get_float(struct spa_json *iter, float *res)
SPA_API_JSON_UTILS int spa_json_get_float(struct spa_json *iter, float *res)
{
const char *value;
int len;
@ -45,7 +53,7 @@ SPA_API_IMPL int spa_json_get_float(struct spa_json *iter, float *res)
}
/* int */
SPA_API_IMPL int spa_json_get_int(struct spa_json *iter, int *res)
SPA_API_JSON_UTILS int spa_json_get_int(struct spa_json *iter, int *res)
{
const char *value;
int len;
@ -55,7 +63,7 @@ SPA_API_IMPL int spa_json_get_int(struct spa_json *iter, int *res)
}
/* bool */
SPA_API_IMPL int spa_json_get_bool(struct spa_json *iter, bool *res)
SPA_API_JSON_UTILS int spa_json_get_bool(struct spa_json *iter, bool *res)
{
const char *value;
int len;
@ -65,7 +73,7 @@ SPA_API_IMPL int spa_json_get_bool(struct spa_json *iter, bool *res)
}
/* string */
SPA_API_IMPL int spa_json_get_string(struct spa_json *iter, char *res, int maxlen)
SPA_API_JSON_UTILS int spa_json_get_string(struct spa_json *iter, char *res, int maxlen)
{
const char *value;
int len;
@ -75,7 +83,7 @@ SPA_API_IMPL int spa_json_get_string(struct spa_json *iter, char *res, int maxle
}
SPA_API_IMPL int spa_json_enter_container(struct spa_json *iter, struct spa_json *sub, char type)
SPA_API_JSON_UTILS int spa_json_enter_container(struct spa_json *iter, struct spa_json *sub, char type)
{
const char *value;
int len;
@ -89,7 +97,7 @@ SPA_API_IMPL int spa_json_enter_container(struct spa_json *iter, struct spa_json
return 1;
}
SPA_API_IMPL int spa_json_begin_container(struct spa_json * iter,
SPA_API_JSON_UTILS int spa_json_begin_container(struct spa_json * iter,
const char *data, size_t size, char type, bool relax)
{
int res;
@ -106,7 +114,7 @@ SPA_API_IMPL int spa_json_begin_container(struct spa_json * iter,
*
* \return Length of container including {} or [], or 0 on error.
*/
SPA_API_IMPL int spa_json_container_len(struct spa_json *iter, const char *value, int len SPA_UNUSED)
SPA_API_JSON_UTILS int spa_json_container_len(struct spa_json *iter, const char *value, int len SPA_UNUSED)
{
const char *val;
struct spa_json sub;
@ -119,20 +127,20 @@ SPA_API_IMPL int spa_json_container_len(struct spa_json *iter, const char *value
}
/* object */
SPA_API_IMPL int spa_json_enter_object(struct spa_json *iter, struct spa_json *sub)
SPA_API_JSON_UTILS int spa_json_enter_object(struct spa_json *iter, struct spa_json *sub)
{
return spa_json_enter_container(iter, sub, '{');
}
SPA_API_IMPL int spa_json_begin_object_relax(struct spa_json * iter, const char *data, size_t size)
SPA_API_JSON_UTILS int spa_json_begin_object_relax(struct spa_json * iter, const char *data, size_t size)
{
return spa_json_begin_container(iter, data, size, '{', true);
}
SPA_API_IMPL int spa_json_begin_object(struct spa_json * iter, const char *data, size_t size)
SPA_API_JSON_UTILS int spa_json_begin_object(struct spa_json * iter, const char *data, size_t size)
{
return spa_json_begin_container(iter, data, size, '{', false);
}
SPA_API_IMPL int spa_json_object_next(struct spa_json *iter, char *key, int maxkeylen, const char **value)
SPA_API_JSON_UTILS int spa_json_object_next(struct spa_json *iter, char *key, int maxkeylen, const char **value)
{
int res1, res2;
while (true) {
@ -145,7 +153,7 @@ SPA_API_IMPL int spa_json_object_next(struct spa_json *iter, char *key, int maxk
}
}
SPA_API_IMPL int spa_json_object_find(struct spa_json *iter, const char *key, const char **value)
SPA_API_JSON_UTILS int spa_json_object_find(struct spa_json *iter, const char *key, const char **value)
{
struct spa_json obj = SPA_JSON_SAVE(iter);
int res, len = strlen(key) + 3;
@ -157,7 +165,7 @@ SPA_API_IMPL int spa_json_object_find(struct spa_json *iter, const char *key, co
return -ENOENT;
}
SPA_API_IMPL int spa_json_str_object_find(const char *obj, size_t obj_len,
SPA_API_JSON_UTILS int spa_json_str_object_find(const char *obj, size_t obj_len,
const char *key, char *value, size_t maxlen)
{
struct spa_json iter;
@ -172,15 +180,15 @@ SPA_API_IMPL int spa_json_str_object_find(const char *obj, size_t obj_len,
}
/* array */
SPA_API_IMPL int spa_json_enter_array(struct spa_json *iter, struct spa_json *sub)
SPA_API_JSON_UTILS int spa_json_enter_array(struct spa_json *iter, struct spa_json *sub)
{
return spa_json_enter_container(iter, sub, '[');
}
SPA_API_IMPL int spa_json_begin_array_relax(struct spa_json * iter, const char *data, size_t size)
SPA_API_JSON_UTILS int spa_json_begin_array_relax(struct spa_json * iter, const char *data, size_t size)
{
return spa_json_begin_container(iter, data, size, '[', true);
}
SPA_API_IMPL int spa_json_begin_array(struct spa_json * iter, const char *data, size_t size)
SPA_API_JSON_UTILS int spa_json_begin_array(struct spa_json * iter, const char *data, size_t size)
{
return spa_json_begin_container(iter, data, size, '[', false);
}
@ -197,7 +205,7 @@ SPA_API_IMPL int spa_json_begin_array(struct spa_json * iter, const char *data,
return count; \
}
SPA_API_IMPL int spa_json_str_array_uint32(const char *arr, size_t arr_len,
SPA_API_JSON_UTILS int spa_json_str_array_uint32(const char *arr, size_t arr_len,
uint32_t *values, size_t max)
{
spa_json_make_str_array_unpack(32,uint32_t, atoi);

18
spa/include/spa/utils/list.h
View file

@ -11,6 +11,14 @@ extern "C" {
#include <spa/utils/defs.h>
#ifndef SPA_API_LIST
#ifdef SPA_API_IMPL
#define SPA_API_LIST SPA_API_IMPL
#else
#define SPA_API_LIST static inline
#endif
#endif
/**
* \defgroup spa_list List
* Doubly linked list data structure
@ -28,19 +36,19 @@ struct spa_list {
#define SPA_LIST_INIT(list) ((struct spa_list){ (list), (list) })
SPA_API_IMPL void spa_list_init(struct spa_list *list)
SPA_API_LIST void spa_list_init(struct spa_list *list)
{
*list = SPA_LIST_INIT(list);
}
SPA_API_IMPL int spa_list_is_initialized(struct spa_list *list)
SPA_API_LIST int spa_list_is_initialized(struct spa_list *list)
{
return !!list->prev;
}
#define spa_list_is_empty(l) ((l)->next == (l))
SPA_API_IMPL void spa_list_insert(struct spa_list *list, struct spa_list *elem)
SPA_API_LIST void spa_list_insert(struct spa_list *list, struct spa_list *elem)
{
elem->prev = list;
elem->next = list->next;
@ -48,7 +56,7 @@ SPA_API_IMPL void spa_list_insert(struct spa_list *list, struct spa_list *elem)
elem->next->prev = elem;
}
SPA_API_IMPL void spa_list_insert_list(struct spa_list *list, struct spa_list *other)
SPA_API_LIST void spa_list_insert_list(struct spa_list *list, struct spa_list *other)
{
if (spa_list_is_empty(other))
return;
@ -58,7 +66,7 @@ SPA_API_IMPL void spa_list_insert_list(struct spa_list *list, struct spa_list *o
list->next = other->next;
}
SPA_API_IMPL void spa_list_remove(struct spa_list *elem)
SPA_API_LIST void spa_list_remove(struct spa_list *elem)
{
elem->prev->next = elem->next;
elem->next->prev = elem->prev;

10
spa/include/spa/utils/ratelimit.h
View file

@ -14,6 +14,14 @@ extern "C" {
#include <spa/utils/defs.h>
#ifndef SPA_API_RATELIMIT
#ifdef SPA_API_IMPL
#define SPA_API_RATELIMIT SPA_API_IMPL
#else
#define SPA_API_RATELIMIT static inline
#endif
#endif
struct spa_ratelimit {
uint64_t interval;
uint64_t begin;
@ -22,7 +30,7 @@ struct spa_ratelimit {
unsigned n_suppressed;
};
SPA_API_IMPL int spa_ratelimit_test(struct spa_ratelimit *r, uint64_t now)
SPA_API_RATELIMIT int spa_ratelimit_test(struct spa_ratelimit *r, uint64_t now)
{
unsigned suppressed = 0;
if (r->begin + r->interval < now) {

24
spa/include/spa/utils/ringbuffer.h
View file

@ -25,6 +25,14 @@ struct spa_ringbuffer;
#include <spa/utils/defs.h>
#ifndef SPA_API_RINGBUFFER
#ifdef SPA_API_IMPL
#define SPA_API_RINGBUFFER SPA_API_IMPL
#else
#define SPA_API_RINGBUFFER static inline
#endif
#endif
/**
* A ringbuffer type.
*/
@ -40,7 +48,7 @@ struct spa_ringbuffer {
*
* \param rbuf a spa_ringbuffer
*/
SPA_API_IMPL void spa_ringbuffer_init(struct spa_ringbuffer *rbuf)
SPA_API_RINGBUFFER void spa_ringbuffer_init(struct spa_ringbuffer *rbuf)
{
*rbuf = SPA_RINGBUFFER_INIT();
}
@ -51,7 +59,7 @@ SPA_API_IMPL void spa_ringbuffer_init(struct spa_ringbuffer *rbuf)
* \param rbuf a spa_ringbuffer
* \param size the target size of \a rbuf
*/
SPA_API_IMPL void spa_ringbuffer_set_avail(struct spa_ringbuffer *rbuf, uint32_t size)
SPA_API_RINGBUFFER void spa_ringbuffer_set_avail(struct spa_ringbuffer *rbuf, uint32_t size)
{
rbuf->readindex = 0;
rbuf->writeindex = size;
@ -67,7 +75,7 @@ SPA_API_IMPL void spa_ringbuffer_set_avail(struct spa_ringbuffer *rbuf, uint32_t
* there was an underrun. values > rbuf->size means there
* was an overrun.
*/
SPA_API_IMPL int32_t spa_ringbuffer_get_read_index(struct spa_ringbuffer *rbuf, uint32_t *index)
SPA_API_RINGBUFFER int32_t spa_ringbuffer_get_read_index(struct spa_ringbuffer *rbuf, uint32_t *index)
{
*index = __atomic_load_n(&rbuf->readindex, __ATOMIC_RELAXED);
return (int32_t) (__atomic_load_n(&rbuf->writeindex, __ATOMIC_ACQUIRE) - *index);
@ -84,7 +92,7 @@ SPA_API_IMPL int32_t spa_ringbuffer_get_read_index(struct spa_ringbuffer *rbuf,
* \param data destination memory
* \param len number of bytes to read
*/
SPA_API_IMPL void
SPA_API_RINGBUFFER void
spa_ringbuffer_read_data(struct spa_ringbuffer *rbuf SPA_UNUSED,
const void *buffer, uint32_t size,
uint32_t offset, void *data, uint32_t len)
@ -101,7 +109,7 @@ spa_ringbuffer_read_data(struct spa_ringbuffer *rbuf SPA_UNUSED,
* \param rbuf a spa_ringbuffer
* \param index new index
*/
SPA_API_IMPL void spa_ringbuffer_read_update(struct spa_ringbuffer *rbuf, int32_t index)
SPA_API_RINGBUFFER void spa_ringbuffer_read_update(struct spa_ringbuffer *rbuf, int32_t index)
{
__atomic_store_n(&rbuf->readindex, index, __ATOMIC_RELEASE);
}
@ -117,7 +125,7 @@ SPA_API_IMPL void spa_ringbuffer_read_update(struct spa_ringbuffer *rbuf, int32_
* was an overrun. Subtract from the buffer size to get
* the number of bytes available for writing.
*/
SPA_API_IMPL int32_t spa_ringbuffer_get_write_index(struct spa_ringbuffer *rbuf, uint32_t *index)
SPA_API_RINGBUFFER int32_t spa_ringbuffer_get_write_index(struct spa_ringbuffer *rbuf, uint32_t *index)
{
*index = __atomic_load_n(&rbuf->writeindex, __ATOMIC_RELAXED);
return (int32_t) (*index - __atomic_load_n(&rbuf->readindex, __ATOMIC_ACQUIRE));
@ -134,7 +142,7 @@ SPA_API_IMPL int32_t spa_ringbuffer_get_write_index(struct spa_ringbuffer *rbuf,
* \param data source memory
* \param len number of bytes to write
*/
SPA_API_IMPL void
SPA_API_RINGBUFFER void
spa_ringbuffer_write_data(struct spa_ringbuffer *rbuf SPA_UNUSED,
void *buffer, uint32_t size,
uint32_t offset, const void *data, uint32_t len)
@ -151,7 +159,7 @@ spa_ringbuffer_write_data(struct spa_ringbuffer *rbuf SPA_UNUSED,
* \param rbuf a spa_ringbuffer
* \param index new index
*/
SPA_API_IMPL void spa_ringbuffer_write_update(struct spa_ringbuffer *rbuf, int32_t index)
SPA_API_RINGBUFFER void spa_ringbuffer_write_update(struct spa_ringbuffer *rbuf, int32_t index)
{
__atomic_store_n(&rbuf->writeindex, index, __ATOMIC_RELEASE);
}

44
spa/include/spa/utils/string.h
View file

@ -17,6 +17,14 @@ extern "C" {
#include <spa/utils/defs.h>
#ifndef SPA_API_STRING
#ifdef SPA_API_IMPL
#define SPA_API_STRING SPA_API_IMPL
#else
#define SPA_API_STRING static inline
#endif
#endif
/**
* \defgroup spa_string String handling
* String handling utilities
@ -33,7 +41,7 @@ extern "C" {
* If both \a a and \a b are NULL, the two are considered equal.
*
*/
SPA_API_IMPL bool spa_streq(const char *s1, const char *s2)
SPA_API_STRING bool spa_streq(const char *s1, const char *s2)
{
return SPA_LIKELY(s1 && s2) ? strcmp(s1, s2) == 0 : s1 == s2;
}
@ -43,7 +51,7 @@ SPA_API_IMPL bool spa_streq(const char *s1, const char *s2)
*
* If both \a a and \a b are NULL, the two are considered equal.
*/
SPA_API_IMPL bool spa_strneq(const char *s1, const char *s2, size_t len)
SPA_API_STRING bool spa_strneq(const char *s1, const char *s2, size_t len)
{
return SPA_LIKELY(s1 && s2) ? strncmp(s1, s2, len) == 0 : s1 == s2;
}
@ -54,7 +62,7 @@ SPA_API_IMPL bool spa_strneq(const char *s1, const char *s2, size_t len)
* A \a s is NULL, it never starts with the given \a prefix. A \a prefix of
* NULL is a bug in the caller.
*/
SPA_API_IMPL bool spa_strstartswith(const char *s, const char *prefix)
SPA_API_STRING bool spa_strstartswith(const char *s, const char *prefix)
{
if (SPA_UNLIKELY(s == NULL))
return false;
@ -70,7 +78,7 @@ SPA_API_IMPL bool spa_strstartswith(const char *s, const char *prefix)
* A \a s is NULL, it never ends with the given \a suffix. A \a suffix of
* NULL is a bug in the caller.
*/
SPA_API_IMPL bool spa_strendswith(const char *s, const char *suffix)
SPA_API_STRING bool spa_strendswith(const char *s, const char *suffix)
{
size_t l1, l2;
@ -92,7 +100,7 @@ SPA_API_IMPL bool spa_strendswith(const char *s, const char *suffix)
*
* \return true on success, false otherwise
*/
SPA_API_IMPL bool spa_atoi32(const char *str, int32_t *val, int base)
SPA_API_STRING bool spa_atoi32(const char *str, int32_t *val, int base)
{
char *endptr;
long v;
@ -120,7 +128,7 @@ SPA_API_IMPL bool spa_atoi32(const char *str, int32_t *val, int base)
*
* \return true on success, false otherwise
*/
SPA_API_IMPL bool spa_atou32(const char *str, uint32_t *val, int base)
SPA_API_STRING bool spa_atou32(const char *str, uint32_t *val, int base)
{
char *endptr;
unsigned long long v;
@ -148,7 +156,7 @@ SPA_API_IMPL bool spa_atou32(const char *str, uint32_t *val, int base)
*
* \return true on success, false otherwise
*/
SPA_API_IMPL bool spa_atoi64(const char *str, int64_t *val, int base)
SPA_API_STRING bool spa_atoi64(const char *str, int64_t *val, int base)
{
char *endptr;
long long v;
@ -173,7 +181,7 @@ SPA_API_IMPL bool spa_atoi64(const char *str, int64_t *val, int base)
*
* \return true on success, false otherwise
*/
SPA_API_IMPL bool spa_atou64(const char *str, uint64_t *val, int base)
SPA_API_STRING bool spa_atou64(const char *str, uint64_t *val, int base)
{
char *endptr;
unsigned long long v;
@ -196,7 +204,7 @@ SPA_API_IMPL bool spa_atou64(const char *str, uint64_t *val, int base)
*
* \return true on success, false otherwise
*/
SPA_API_IMPL bool spa_atob(const char *str)
SPA_API_STRING bool spa_atob(const char *str)
{
return spa_streq(str, "true") || spa_streq(str, "1");
}
@ -210,7 +218,7 @@ SPA_API_IMPL bool spa_atob(const char *str)
* number on error.
*/
SPA_PRINTF_FUNC(3, 0)
SPA_API_IMPL int spa_vscnprintf(char *buffer, size_t size, const char *format, va_list args)
SPA_API_STRING int spa_vscnprintf(char *buffer, size_t size, const char *format, va_list args)
{
int r;
@ -233,7 +241,7 @@ SPA_API_IMPL int spa_vscnprintf(char *buffer, size_t size, const char *format, v
* number on error.
*/
SPA_PRINTF_FUNC(3, 4)
SPA_API_IMPL int spa_scnprintf(char *buffer, size_t size, const char *format, ...)
SPA_API_STRING int spa_scnprintf(char *buffer, size_t size, const char *format, ...)
{
int r;
va_list args;
@ -253,7 +261,7 @@ SPA_API_IMPL int spa_scnprintf(char *buffer, size_t size, const char *format, ..
*
* \return the result float.
*/
SPA_API_IMPL float spa_strtof(const char *str, char **endptr)
SPA_API_STRING float spa_strtof(const char *str, char **endptr)
{
#ifndef __LOCALE_C_ONLY
static locale_t locale = NULL;
@ -279,7 +287,7 @@ SPA_API_IMPL float spa_strtof(const char *str, char **endptr)
*
* \return true on success, false otherwise
*/
SPA_API_IMPL bool spa_atof(const char *str, float *val)
SPA_API_STRING bool spa_atof(const char *str, float *val)
{
char *endptr;
float v;
@ -303,7 +311,7 @@ SPA_API_IMPL bool spa_atof(const char *str, float *val)
*
* \return the result float.
*/
SPA_API_IMPL double spa_strtod(const char *str, char **endptr)
SPA_API_STRING double spa_strtod(const char *str, char **endptr)
{
#ifndef __LOCALE_C_ONLY
static locale_t locale = NULL;
@ -329,7 +337,7 @@ SPA_API_IMPL double spa_strtod(const char *str, char **endptr)
*
* \return true on success, false otherwise
*/
SPA_API_IMPL bool spa_atod(const char *str, double *val)
SPA_API_STRING bool spa_atod(const char *str, double *val)
{
char *endptr;
double v;
@ -346,7 +354,7 @@ SPA_API_IMPL bool spa_atod(const char *str, double *val)
return true;
}
SPA_API_IMPL char *spa_dtoa(char *str, size_t size, double val)
SPA_API_STRING char *spa_dtoa(char *str, size_t size, double val)
{
int i, l;
l = spa_scnprintf(str, size, "%f", val);
@ -362,7 +370,7 @@ struct spa_strbuf {
size_t pos;
};
SPA_API_IMPL void spa_strbuf_init(struct spa_strbuf *buf, char *buffer, size_t maxsize)
SPA_API_STRING void spa_strbuf_init(struct spa_strbuf *buf, char *buffer, size_t maxsize)
{
buf->buffer = buffer;
buf->maxsize = maxsize;
@ -372,7 +380,7 @@ SPA_API_IMPL void spa_strbuf_init(struct spa_strbuf *buf, char *buffer, size_t m
}
SPA_PRINTF_FUNC(2, 3)
SPA_API_IMPL int spa_strbuf_append(struct spa_strbuf *buf, const char *fmt, ...)
SPA_API_STRING int spa_strbuf_append(struct spa_strbuf *buf, const char *fmt, ...)
{
size_t remain = buf->maxsize - buf->pos;
ssize_t written;

18
spa/include/spa/utils/type.h
View file

@ -12,6 +12,14 @@ extern "C" {
#include <spa/utils/defs.h>
#include <spa/utils/string.h>
#ifndef SPA_API_TYPE
#ifdef SPA_API_IMPL
#define SPA_API_TYPE SPA_API_IMPL
#else
#define SPA_API_TYPE static inline
#endif
#endif
/** \defgroup spa_types Types
* Data type information enumerations
*/
@ -124,12 +132,12 @@ struct spa_type_info {
const struct spa_type_info *values;
};
SPA_API_IMPL bool spa_type_is_a(const char *type, const char *parent)
SPA_API_TYPE bool spa_type_is_a(const char *type, const char *parent)
{
return type != NULL && parent != NULL && strncmp(type, parent, strlen(parent)) == 0;
}
SPA_API_IMPL const char *spa_type_short_name(const char *name)
SPA_API_TYPE const char *spa_type_short_name(const char *name)
{
const char *h;
if ((h = strrchr(name, ':')) != NULL)
@ -137,7 +145,7 @@ SPA_API_IMPL const char *spa_type_short_name(const char *name)
return name;
}
SPA_API_IMPL uint32_t spa_type_from_short_name(const char *name,
SPA_API_TYPE uint32_t spa_type_from_short_name(const char *name,
const struct spa_type_info *info, uint32_t unknown)
{
int i;
@ -147,7 +155,7 @@ SPA_API_IMPL uint32_t spa_type_from_short_name(const char *name,
}
return unknown;
}
SPA_API_IMPL const char * spa_type_to_name(uint32_t type,
SPA_API_TYPE const char * spa_type_to_name(uint32_t type,
const struct spa_type_info *info, const char *unknown)
{
int i;
@ -158,7 +166,7 @@ SPA_API_IMPL const char * spa_type_to_name(uint32_t type,
return unknown;
}
SPA_API_IMPL const char * spa_type_to_short_name(uint32_t type,
SPA_API_TYPE const char * spa_type_to_short_name(uint32_t type,
const struct spa_type_info *info, const char *unknown)
{
const char *n = spa_type_to_name(type, info, unknown);

1
src/modules/module-profiler.c
View file

@ -18,6 +18,7 @@
#include <spa/utils/ringbuffer.h>
#include <spa/param/profiler.h>
#define PW_API_PROFILER SPA_EXPORT
#include <pipewire/private.h>
#include <pipewire/impl.h>
#include <pipewire/extensions/profiler.h>

2
src/modules/module-protocol-native/security-context.c
View file

@ -6,6 +6,8 @@
#include <pipewire/pipewire.h>
#include <pipewire/impl.h>
#include <pipewire/private.h>
#define PW_API_SECURITY_CONTEXT SPA_EXPORT
#include <pipewire/extensions/security-context.h>
PW_LOG_TOPIC_EXTERN(mod_topic);

19
src/pipewire/array.h
View file

@ -13,6 +13,11 @@ extern "C" {
#include <spa/utils/defs.h>
#ifndef PW_API_ARRAY
#define PW_API_ARRAY static inline
#endif
/** \defgroup pw_array Array
*
* \brief An array object
@ -71,7 +76,7 @@ struct pw_array {
/** Initialize the array with given extend. Extend needs to be > 0 or else
* the array will not be able to expand. */
SPA_API_IMPL void pw_array_init(struct pw_array *arr, size_t extend)
PW_API_ARRAY void pw_array_init(struct pw_array *arr, size_t extend)
{
arr->data = NULL;
arr->size = arr->alloc = 0;
@ -79,7 +84,7 @@ SPA_API_IMPL void pw_array_init(struct pw_array *arr, size_t extend)
}
/** Clear the array. This should be called when pw_array_init() was called. */
SPA_API_IMPL void pw_array_clear(struct pw_array *arr)
PW_API_ARRAY void pw_array_clear(struct pw_array *arr)
{
if (arr->extend > 0)
free(arr->data);
@ -87,7 +92,7 @@ SPA_API_IMPL void pw_array_clear(struct pw_array *arr)
}
/** Initialize a static array. */
SPA_API_IMPL void pw_array_init_static(struct pw_array *arr, void *data, size_t size)
PW_API_ARRAY void pw_array_init_static(struct pw_array *arr, void *data, size_t size)
{
arr->data = data;
arr->alloc = size;
@ -95,13 +100,13 @@ SPA_API_IMPL void pw_array_init_static(struct pw_array *arr, void *data, size_t
}
/** Reset the array */
SPA_API_IMPL void pw_array_reset(struct pw_array *arr)
PW_API_ARRAY void pw_array_reset(struct pw_array *arr)
{
arr->size = 0;
}
/** Make sure \a size bytes can be added to the array */
SPA_API_IMPL int pw_array_ensure_size(struct pw_array *arr, size_t size)
PW_API_ARRAY int pw_array_ensure_size(struct pw_array *arr, size_t size)
{
size_t alloc, need;
@ -124,7 +129,7 @@ SPA_API_IMPL int pw_array_ensure_size(struct pw_array *arr, size_t size)
/** Add \a ref size bytes to \a arr. A pointer to memory that can
* hold at least \a size bytes is returned or NULL when an error occurred
* and errno will be set.*/
SPA_API_IMPL void *pw_array_add(struct pw_array *arr, size_t size)
PW_API_ARRAY void *pw_array_add(struct pw_array *arr, size_t size)
{
void *p;
@ -139,7 +144,7 @@ SPA_API_IMPL void *pw_array_add(struct pw_array *arr, size_t size)
/** Add a pointer to array. Returns 0 on success and a negative errno style
* error on failure. */
SPA_API_IMPL int pw_array_add_ptr(struct pw_array *arr, void *ptr)
PW_API_ARRAY int pw_array_add_ptr(struct pw_array *arr, void *ptr)
{
void **p = (void **)pw_array_add(arr, sizeof(void*));
if (p == NULL)

6
src/pipewire/extensions/profiler.h
View file

@ -24,6 +24,10 @@ extern "C" {
#define PW_VERSION_PROFILER 3
struct pw_profiler;
#ifndef PW_API_PROFILER
#define PW_API_PROFILER static inline
#endif
#define PW_EXTENSION_MODULE_PROFILER PIPEWIRE_MODULE_PREFIX "module-profiler"
#define PW_PROFILER_PERM_MASK PW_PERM_R
@ -53,7 +57,7 @@ struct pw_profiler_methods {
void *data);
};
SPA_API_IMPL int pw_profiler_add_listener(struct pw_profiler *object,
PW_API_PROFILER int pw_profiler_add_listener(struct pw_profiler *object,
struct spa_hook *listener,
const struct pw_profiler_events *events,
void *data)

8
src/pipewire/extensions/security-context.h
View file

@ -26,6 +26,10 @@ extern "C" {
#define PW_VERSION_SECURITY_CONTEXT 3
struct pw_security_context;
#ifndef PW_API_SECURITY_CONTEXT
#define PW_API_SECURITY_CONTEXT static inline
#endif
#define PW_EXTENSION_MODULE_SECURITY_CONTEXT PIPEWIRE_MODULE_PREFIX "module-security-context"
#define PW_SECURITY_CONTEXT_EVENT_NUM 0
@ -94,7 +98,7 @@ struct pw_security_context_methods {
const struct spa_dict *props);
};
SPA_API_IMPL int pw_security_context_add_listener(struct pw_security_context *object,
PW_API_SECURITY_CONTEXT int pw_security_context_add_listener(struct pw_security_context *object,
struct spa_hook *listener,
const struct pw_security_context_events *events,
void *data)
@ -104,7 +108,7 @@ SPA_API_IMPL int pw_security_context_add_listener(struct pw_security_context *ob
listener, events, data);
}
SPA_API_IMPL int pw_security_context_create(struct pw_security_context *object,
PW_API_SECURITY_CONTEXT int pw_security_context_create(struct pw_security_context *object,
int listen_fd, int close_fd, const struct spa_dict *props)
{
return spa_api_method_r(int, -ENOTSUP,

20
src/pipewire/map.h
View file

@ -15,6 +15,10 @@ extern "C" {
#include <spa/utils/defs.h>
#include <pipewire/array.h>
#ifndef PW_API_MAP
#define PW_API_MAP static inline
#endif
/** \defgroup pw_map Map
*
* \brief A map that holds pointers to objects indexed by id
@ -93,7 +97,7 @@ struct pw_map {
* \param size the initial size of the map
* \param extend the amount to bytes to grow the map with when needed
*/
SPA_API_IMPL void pw_map_init(struct pw_map *map, size_t size, size_t extend)
PW_API_MAP void pw_map_init(struct pw_map *map, size_t size, size_t extend)
{
pw_array_init(&map->items, extend * sizeof(union pw_map_item));
pw_array_ensure_size(&map->items, size * sizeof(union pw_map_item));
@ -103,7 +107,7 @@ SPA_API_IMPL void pw_map_init(struct pw_map *map, size_t size, size_t extend)
/** Clear a map and free the data storage. All previously returned ids
* must be treated as invalid.
*/
SPA_API_IMPL void pw_map_clear(struct pw_map *map)
PW_API_MAP void pw_map_clear(struct pw_map *map)
{
pw_array_clear(&map->items);
}
@ -111,7 +115,7 @@ SPA_API_IMPL void pw_map_clear(struct pw_map *map)
/** Reset a map but keep previously allocated storage. All previously
* returned ids must be treated as invalid.
*/
SPA_API_IMPL void pw_map_reset(struct pw_map *map)
PW_API_MAP void pw_map_reset(struct pw_map *map)
{
pw_array_reset(&map->items);
map->free_list = SPA_ID_INVALID;
@ -123,7 +127,7 @@ SPA_API_IMPL void pw_map_reset(struct pw_map *map)
* \return the id where the item was inserted or SPA_ID_INVALID when the
* item can not be inserted.
*/
SPA_API_IMPL uint32_t pw_map_insert_new(struct pw_map *map, void *data)
PW_API_MAP uint32_t pw_map_insert_new(struct pw_map *map, void *data)
{
union pw_map_item *start, *item;
uint32_t id;
@ -150,7 +154,7 @@ SPA_API_IMPL uint32_t pw_map_insert_new(struct pw_map *map, void *data)
* \param data the data to insert
* \return 0 on success, -ENOSPC value when the index is invalid or a negative errno
*/
SPA_API_IMPL int pw_map_insert_at(struct pw_map *map, uint32_t id, void *data)
PW_API_MAP int pw_map_insert_at(struct pw_map *map, uint32_t id, void *data)
{
size_t size = pw_map_get_size(map);
union pw_map_item *item;
@ -175,7 +179,7 @@ SPA_API_IMPL int pw_map_insert_at(struct pw_map *map, uint32_t id, void *data)
* \param map the map to remove from
* \param id the index to remove
*/
SPA_API_IMPL void pw_map_remove(struct pw_map *map, uint32_t id)
PW_API_MAP void pw_map_remove(struct pw_map *map, uint32_t id)
{
if (pw_map_id_is_free(map, id))
return;
@ -189,7 +193,7 @@ SPA_API_IMPL void pw_map_remove(struct pw_map *map, uint32_t id)
* \param id the index to look at
* \return the item at \a id or NULL when no such item exists
*/
SPA_API_IMPL void *pw_map_lookup(const struct pw_map *map, uint32_t id)
PW_API_MAP void *pw_map_lookup(const struct pw_map *map, uint32_t id)
{
if (SPA_LIKELY(pw_map_check_id(map, id))) {
union pw_map_item *item = pw_map_get_item(map, id);
@ -207,7 +211,7 @@ SPA_API_IMPL void *pw_map_lookup(const struct pw_map *map, uint32_t id)
* \param data data to pass to \a func
* \return the result of the last call to \a func or 0 when all callbacks returned 0.
*/
SPA_API_IMPL int pw_map_for_each(const struct pw_map *map,
PW_API_MAP int pw_map_for_each(const struct pw_map *map,
int (*func) (void *item_data, void *data), void *data)
{
union pw_map_item *item;

1
src/pipewire/mem.c
View file

@ -18,6 +18,7 @@
#include <spa/utils/list.h>
#include <spa/buffer/buffer.h>
#define PW_API_MEM SPA_EXPORT
#include <pipewire/log.h>
#include <pipewire/map.h>
#include <pipewire/mem.h>

8
src/pipewire/mem.h
View file

@ -11,6 +11,10 @@
extern "C" {
#endif
#ifndef PW_API_MEM
#define PW_API_MEM static inline
#endif
/** \defgroup pw_memblock Memory Blocks
* Memory allocation and pools.
*/
@ -123,7 +127,7 @@ struct pw_memblock * pw_mempool_import(struct pw_mempool *pool,
void pw_memblock_free(struct pw_memblock *mem);
/** Unref a memblock */
SPA_API_IMPL void pw_memblock_unref(struct pw_memblock *mem)
PW_API_MEM void pw_memblock_unref(struct pw_memblock *mem)
{
if (--mem->ref == 0)
pw_memblock_free(mem);
@ -173,7 +177,7 @@ struct pw_map_range {
/** Calculate parameters to mmap() memory into \a range so that
* \a size bytes at \a offset can be mapped with mmap(). */
SPA_API_IMPL void pw_map_range_init(struct pw_map_range *range,
PW_API_MEM void pw_map_range_init(struct pw_map_range *range,
uint32_t offset, uint32_t size,
uint32_t page_size)
{

1
src/pipewire/properties.c
View file

@ -12,6 +12,7 @@
#include <spa/utils/result.h>
#include <spa/debug/log.h>
#define PW_API_PROPERTIES SPA_EXPORT
#include "pipewire/array.h"
#include "pipewire/log.h"
#include "pipewire/utils.h"

26
src/pipewire/properties.h
View file

@ -15,6 +15,10 @@ extern "C" {
#include <spa/utils/dict.h>
#include <spa/utils/string.h>
#ifndef PW_API_PROPERTIES
#define PW_API_PROPERTIES static inline
#endif
/** \defgroup pw_properties Properties
*
* Properties are used to pass around arbitrary key/value pairs.
@ -101,7 +105,7 @@ pw_properties_fetch_int64(const struct pw_properties *properties, const char *ke
int
pw_properties_fetch_bool(const struct pw_properties *properties, const char *key, bool *value);
SPA_API_IMPL uint32_t
PW_API_PROPERTIES uint32_t
pw_properties_get_uint32(const struct pw_properties *properties, const char *key, uint32_t deflt)
{
uint32_t val = deflt;
@ -109,7 +113,7 @@ pw_properties_get_uint32(const struct pw_properties *properties, const char *key
return val;
}
SPA_API_IMPL int32_t
PW_API_PROPERTIES int32_t
pw_properties_get_int32(const struct pw_properties *properties, const char *key, int32_t deflt)
{
int32_t val = deflt;
@ -117,7 +121,7 @@ pw_properties_get_int32(const struct pw_properties *properties, const char *key,
return val;
}
SPA_API_IMPL uint64_t
PW_API_PROPERTIES uint64_t
pw_properties_get_uint64(const struct pw_properties *properties, const char *key, uint64_t deflt)
{
uint64_t val = deflt;
@ -125,7 +129,7 @@ pw_properties_get_uint64(const struct pw_properties *properties, const char *key
return val;
}
SPA_API_IMPL int64_t
PW_API_PROPERTIES int64_t
pw_properties_get_int64(const struct pw_properties *properties, const char *key, int64_t deflt)
{
int64_t val = deflt;
@ -134,7 +138,7 @@ pw_properties_get_int64(const struct pw_properties *properties, const char *key,
}
SPA_API_IMPL bool
PW_API_PROPERTIES bool
pw_properties_get_bool(const struct pw_properties *properties, const char *key, bool deflt)
{
bool val = deflt;
@ -152,31 +156,31 @@ pw_properties_iterate(const struct pw_properties *properties, void **state);
#define PW_PROPERTIES_FLAG_COLORS (1<<4)
int pw_properties_serialize_dict(FILE *f, const struct spa_dict *dict, uint32_t flags);
SPA_API_IMPL bool pw_properties_parse_bool(const char *value) {
PW_API_PROPERTIES bool pw_properties_parse_bool(const char *value) {
return spa_atob(value);
}
SPA_API_IMPL int pw_properties_parse_int(const char *value) {
PW_API_PROPERTIES int pw_properties_parse_int(const char *value) {
int v;
return spa_atoi32(value, &v, 0) ? v: 0;
}
SPA_API_IMPL int64_t pw_properties_parse_int64(const char *value) {
PW_API_PROPERTIES int64_t pw_properties_parse_int64(const char *value) {
int64_t v;
return spa_atoi64(value, &v, 0) ? v : 0;
}
SPA_API_IMPL uint64_t pw_properties_parse_uint64(const char *value) {
PW_API_PROPERTIES uint64_t pw_properties_parse_uint64(const char *value) {
uint64_t v;
return spa_atou64(value, &v, 0) ? v : 0;
}
SPA_API_IMPL float pw_properties_parse_float(const char *value) {
PW_API_PROPERTIES float pw_properties_parse_float(const char *value) {
float v;
return spa_atof(value, &v) ? v : 0.0f;
}
SPA_API_IMPL double pw_properties_parse_double(const char *value) {
PW_API_PROPERTIES double pw_properties_parse_double(const char *value) {
double v;
return spa_atod(value, &v) ? v : 0.0;
}