mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-31 22:25:38 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

spa: don't use typedef for struct and enum

Browse source
This commit is contained in:
Wim Taymans 2017-05-25 13:28:15 +02:00
parent 83964cec87
commit 11f23a3ffa
163 changed files with 6510 additions and 8264 deletions
Download patch file Download diff file Expand all files Collapse all files

2
spa/tests/stress-ringbuffer.c
View file

@ -9,7 +9,7 @@
#define ARRAY_SIZE 64
#define MAX_VALUE 0x10000
SpaRingbuffer rb;
struct spa_ringbuffer rb;
uint8_t *data;
static int

196
spa/tests/test-graph.c
View file

@ -39,7 +39,7 @@
#include <lib/debug.h>
#include <lib/props.h>
typedef struct {
struct type {
uint32_t node;
uint32_t props;
uint32_t format;
@ -48,18 +48,18 @@ typedef struct {
uint32_t props_volume;
uint32_t props_min_latency;
uint32_t props_live;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeFormatAudio format_audio;
SpaTypeAudioFormat audio_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
} Type;
struct spa_type_meta meta;
struct spa_type_data data;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_format_audio format_audio;
struct spa_type_audio_format audio_format;
struct spa_type_event_node event_node;
struct spa_type_command_node command_node;
};
static inline void
init_type (Type *type, SpaTypeMap *map)
init_type (struct type *type, struct spa_type_map *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
@ -79,66 +79,66 @@ init_type (Type *type, SpaTypeMap *map)
spa_type_command_node_map (map, &type->command_node);
}
typedef struct {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaChunk chunks[1];
} Buffer;
struct buffer {
struct spa_buffer buffer;
struct spa_meta metas[1];
struct spa_meta_header header;
struct spa_data datas[1];
struct spa_chunk chunks[1];
};
typedef struct {
SpaTypeMap *map;
SpaLog *log;
SpaLoop data_loop;
Type type;
struct data {
struct spa_type_map *map;
struct spa_log *log;
struct spa_loop data_loop;
struct type type;
SpaSupport support[4];
struct spa_support support[4];
uint32_t n_support;
SpaGraph graph;
SpaGraphNode source_node;
SpaGraphPort source_out;
SpaGraphPort volume_in;
SpaGraphNode volume_node;
SpaGraphPort volume_out;
SpaGraphPort sink_in;
SpaGraphNode sink_node;
struct spa_graph graph;
struct spa_graph_node source_node;
struct spa_graph_port source_out;
struct spa_graph_port volume_in;
struct spa_graph_node volume_node;
struct spa_graph_port volume_out;
struct spa_graph_port sink_in;
struct spa_graph_node sink_node;
SpaNode *sink;
SpaPortIO volume_sink_io[1];
struct spa_node *sink;
struct spa_port_io volume_sink_io[1];
SpaNode *volume;
SpaBuffer *volume_buffers[1];
Buffer volume_buffer[1];
struct spa_node *volume;
struct spa_buffer *volume_buffers[1];
struct buffer volume_buffer[1];
SpaNode *source;
SpaPortIO source_volume_io[1];
SpaBuffer *source_buffers[1];
Buffer source_buffer[1];
struct spa_node *source;
struct spa_port_io source_volume_io[1];
struct spa_buffer *source_buffers[1];
struct buffer source_buffer[1];
bool running;
pthread_t thread;
SpaSource sources[16];
struct spa_source sources[16];
unsigned int n_sources;
bool rebuild_fds;
struct pollfd fds[16];
unsigned int n_fds;
} AppData;
};
#define MIN_LATENCY 64
#define BUFFER_SIZE MIN_LATENCY
static void
init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t size)
init_buffer (struct data *data, struct spa_buffer **bufs, struct buffer *ba, int n_buffers, size_t size)
{
int i;
for (i = 0; i < n_buffers; i++) {
Buffer *b = &ba[i];
struct buffer *b = &ba[i];
bufs[i] = &b->buffer;
b->buffer.id = i;
@ -168,13 +168,13 @@ init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t
}
}
static SpaResult
make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
static int
make_node (struct data *data, struct spa_node **node, const char *lib, const char *name)
{
SpaHandle *handle;
SpaResult res;
struct spa_handle *handle;
int res;
void *hnd;
SpaEnumHandleFactoryFunc enum_func;
spa_handle_factory_enum_func_t enum_func;
unsigned int i;
uint32_t state = 0;
@ -182,13 +182,13 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
printf ("can't load %s: %s\n", lib, dlerror());
return SPA_RESULT_ERROR;
}
if ((enum_func = dlsym (hnd, "spa_enum_handle_factory")) == NULL) {
if ((enum_func = dlsym (hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) {
printf ("can't find enum function\n");
return SPA_RESULT_ERROR;
}
for (i = 0; ;i++) {
const SpaHandleFactory *factory;
const struct spa_handle_factory *factory;
void *iface;
if ((res = enum_func (&factory, state++)) < 0) {
@ -215,15 +215,15 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
}
static void
on_sink_event (SpaNode *node, SpaEvent *event, void *user_data)
on_sink_event (struct spa_node *node, struct spa_event *event, void *user_data)
{
printf ("got event %d\n", SPA_EVENT_TYPE (event));
}
static void
on_sink_need_input (SpaNode *node, void *user_data)
on_sink_need_input (struct spa_node *node, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
data->sink_node.action = SPA_GRAPH_ACTION_CHECK;
data->sink_node.state = SPA_RESULT_NEED_BUFFER;
@ -232,14 +232,14 @@ on_sink_need_input (SpaNode *node, void *user_data)
}
static void
on_sink_reuse_buffer (SpaNode *node, uint32_t port_id, uint32_t buffer_id, void *user_data)
on_sink_reuse_buffer (struct spa_node *node, uint32_t port_id, uint32_t buffer_id, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
data->volume_sink_io[0].buffer_id = buffer_id;
}
static const SpaNodeCallbacks sink_callbacks =
static const struct spa_node_callbacks sink_callbacks =
{
&on_sink_event,
&on_sink_need_input,
@ -247,11 +247,11 @@ static const SpaNodeCallbacks sink_callbacks =
&on_sink_reuse_buffer
};
static SpaResult
do_add_source (SpaLoop *loop,
SpaSource *source)
static int
do_add_source (struct spa_loop *loop,
struct spa_source *source)
{
AppData *data = SPA_CONTAINER_OF (loop, AppData, data_loop);
struct data *data = SPA_CONTAINER_OF (loop, struct data, data_loop);
data->sources[data->n_sources] = *source;
data->n_sources++;
@ -260,35 +260,35 @@ do_add_source (SpaLoop *loop,
return SPA_RESULT_OK;
}
static SpaResult
do_update_source (SpaSource *source)
static int
do_update_source (struct spa_source *source)
{
return SPA_RESULT_OK;
}
static void
do_remove_source (SpaSource *source)
do_remove_source (struct spa_source *source)
{
}
static SpaResult
do_invoke (SpaLoop *loop,
SpaInvokeFunc func,
uint32_t seq,
size_t size,
void *data,
void *user_data)
static int
do_invoke (struct spa_loop *loop,
spa_invoke_func_t func,
uint32_t seq,
size_t size,
void *data,
void *user_data)
{
return func (loop, false, seq, size, data, user_data);
}
static SpaResult
make_nodes (AppData *data, const char *device)
static int
make_nodes (struct data *data, const char *device)
{
SpaResult res;
SpaProps *props;
SpaPODBuilder b = { 0 };
SpaPODFrame f[2];
int res;
struct spa_props *props;
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[2];
uint8_t buffer[128];
if ((res = make_node (data, &data->sink,
@ -303,7 +303,7 @@ make_nodes (AppData *data, const char *device)
spa_pod_builder_props (&b, &f[0], data->type.props,
SPA_POD_PROP (&f[1], data->type.props_device, 0, SPA_POD_TYPE_STRING, 1, device ? device : "hw:0"),
SPA_POD_PROP (&f[1], data->type.props_min_latency, 0, SPA_POD_TYPE_INT, 1, MIN_LATENCY));
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_props);
if ((res = spa_node_set_props (data->sink, props)) < 0)
printf ("got set_props error %d\n", res);
@ -327,7 +327,7 @@ make_nodes (AppData *data, const char *device)
SPA_POD_PROP (&f[1], data->type.props_freq, 0, SPA_POD_TYPE_DOUBLE, 1, 600.0),
SPA_POD_PROP (&f[1], data->type.props_volume, 0, SPA_POD_TYPE_DOUBLE, 1, 0.5),
SPA_POD_PROP (&f[1], data->type.props_live, 0, SPA_POD_TYPE_BOOL, 1, false));
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_props);
if ((res = spa_node_set_props (data->source, props)) < 0)
printf ("got set_props error %d\n", res);
@ -366,14 +366,14 @@ make_nodes (AppData *data, const char *device)
return res;
}
static SpaResult
negotiate_formats (AppData *data)
static int
negotiate_formats (struct data *data)
{
SpaResult res;
SpaFormat *format, *filter;
int res;
struct spa_format *format, *filter;
uint32_t state = 0;
SpaPODBuilder b = { 0 };
SpaPODFrame f[2];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[2];
uint8_t buffer[256];
spa_pod_builder_init (&b, buffer, sizeof (buffer));
@ -391,7 +391,7 @@ negotiate_formats (AppData *data)
SPA_POD_PROP (&f[1], data->type.format_audio.channels, 0,
SPA_POD_TYPE_INT, 1,
2));
filter = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
filter = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_format);
if ((res = spa_node_port_enum_formats (data->sink, SPA_DIRECTION_INPUT, 0, &format, filter, state)) < 0)
return res;
@ -426,7 +426,7 @@ negotiate_formats (AppData *data)
static void *
loop (void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
printf ("enter thread %d\n", data->n_sources);
while (data->running) {
@ -435,7 +435,7 @@ loop (void *user_data)
/* rebuild */
if (data->rebuild_fds) {
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
data->fds[i].fd = p->fd;
data->fds[i].events = p->mask;
}
@ -456,7 +456,7 @@ loop (void *user_data)
/* after */
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
p->rmask = 0;
if (data->fds[i].revents & POLLIN)
p->rmask |= SPA_IO_IN;
@ -468,7 +468,7 @@ loop (void *user_data)
p->rmask |= SPA_IO_ERR;
}
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
if (p->rmask)
p->func (p);
}
@ -479,13 +479,13 @@ loop (void *user_data)
}
static void
run_async_sink (AppData *data)
run_async_sink (struct data *data)
{
SpaResult res;
int res;
int err;
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
printf ("got source error %d\n", res);
if ((res = spa_node_send_command (data->volume, &cmd)) < 0)
@ -509,7 +509,7 @@ run_async_sink (AppData *data)
}
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
if ((res = spa_node_send_command (data->sink, &cmd)) < 0)
printf ("got error %d\n", res);
if ((res = spa_node_send_command (data->volume, &cmd)) < 0)
@ -522,8 +522,8 @@ run_async_sink (AppData *data)
int
main (int argc, char *argv[])
{
AppData data = { NULL };
SpaResult res;
struct data data = { NULL };
int res;
const char *str;
@ -531,7 +531,7 @@ main (int argc, char *argv[])
data.map = spa_type_map_get_default();
data.log = spa_log_get_default();
data.data_loop.size = sizeof (SpaLoop);
data.data_loop.size = sizeof (struct spa_loop);
data.data_loop.add_source = do_add_source;
data.data_loop.update_source = do_update_source;
data.data_loop.remove_source = do_remove_source;

204
spa/tests/test-mixer.c
View file

@ -40,7 +40,7 @@
#undef USE_GRAPH
typedef struct {
struct type {
uint32_t node;
uint32_t props;
uint32_t format;
@ -49,18 +49,18 @@ typedef struct {
uint32_t props_volume;
uint32_t props_min_latency;
uint32_t props_live;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeFormatAudio format_audio;
SpaTypeAudioFormat audio_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
} Type;
struct spa_type_meta meta;
struct spa_type_data data;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_format_audio format_audio;
struct spa_type_audio_format audio_format;
struct spa_type_event_node event_node;
struct spa_type_command_node command_node;
};
static inline void
init_type (Type *type, SpaTypeMap *map)
init_type (struct type *type, struct spa_type_map *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
@ -80,62 +80,62 @@ init_type (Type *type, SpaTypeMap *map)
spa_type_command_node_map (map, &type->command_node);
}
typedef struct {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaChunk chunks[1];
} Buffer;
struct buffer {
struct spa_buffer buffer;
struct spa_meta metas[1];
struct spa_meta_header header;
struct spa_data datas[1];
struct spa_chunk chunks[1];
};
typedef struct {
SpaTypeMap *map;
SpaLog *log;
SpaLoop data_loop;
Type type;
struct data {
struct spa_type_map *map;
struct spa_log *log;
struct spa_loop data_loop;
struct type type;
SpaSupport support[4];
struct spa_support support[4];
uint32_t n_support;
SpaGraph graph;
SpaGraphNode source1_node;
SpaGraphPort source1_out;
SpaGraphNode source2_node;
SpaGraphPort source2_out;
SpaGraphPort mix_in[2];
SpaGraphNode mix_node;
SpaGraphPort mix_out;
SpaGraphPort sink_in;
SpaGraphNode sink_node;
struct spa_graph graph;
struct spa_graph_node source1_node;
struct spa_graph_port source1_out;
struct spa_graph_node source2_node;
struct spa_graph_port source2_out;
struct spa_graph_port mix_in[2];
struct spa_graph_node mix_node;
struct spa_graph_port mix_out;
struct spa_graph_port sink_in;
struct spa_graph_node sink_node;
SpaNode *sink;
SpaPortIO mix_sink_io[1];
struct spa_node *sink;
struct spa_port_io mix_sink_io[1];
SpaNode *mix;
struct spa_node *mix;
uint32_t mix_ports[2];
SpaBuffer *mix_buffers[1];
Buffer mix_buffer[1];
struct spa_buffer *mix_buffers[1];
struct buffer mix_buffer[1];
SpaNode *source1;
SpaPortIO source1_mix_io[1];
SpaBuffer *source1_buffers[2];
Buffer source1_buffer[2];
struct spa_node *source1;
struct spa_port_io source1_mix_io[1];
struct spa_buffer *source1_buffers[2];
struct buffer source1_buffer[2];
SpaNode *source2;
SpaPortIO source2_mix_io[1];
SpaBuffer *source2_buffers[2];
Buffer source2_buffer[2];
struct spa_node *source2;
struct spa_port_io source2_mix_io[1];
struct spa_buffer *source2_buffers[2];
struct buffer source2_buffer[2];
bool running;
pthread_t thread;
SpaSource sources[16];
struct spa_source sources[16];
unsigned int n_sources;
bool rebuild_fds;
struct pollfd fds[16];
unsigned int n_fds;
} AppData;
};
#define MIN_LATENCY 64
@ -143,12 +143,12 @@ typedef struct {
#define BUFFER_SIZE2 MIN_LATENCY - 4
static void
init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t size)
init_buffer (struct data *data, struct spa_buffer **bufs, struct buffer *ba, int n_buffers, size_t size)
{
int i;
for (i = 0; i < n_buffers; i++) {
Buffer *b = &ba[i];
struct buffer *b = &ba[i];
bufs[i] = &b->buffer;
b->buffer.id = i;
@ -178,13 +178,13 @@ init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t
}
}
static SpaResult
make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
static int
make_node (struct data *data, struct spa_node **node, const char *lib, const char *name)
{
SpaHandle *handle;
SpaResult res;
struct spa_handle *handle;
int res;
void *hnd;
SpaEnumHandleFactoryFunc enum_func;
spa_handle_factory_enum_func_t enum_func;
unsigned int i;
uint32_t state = 0;
@ -192,13 +192,13 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
printf ("can't load %s: %s\n", lib, dlerror());
return SPA_RESULT_ERROR;
}
if ((enum_func = dlsym (hnd, "spa_enum_handle_factory")) == NULL) {
if ((enum_func = dlsym (hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) {
printf ("can't find enum function\n");
return SPA_RESULT_ERROR;
}
for (i = 0; ;i++) {
const SpaHandleFactory *factory;
const struct spa_handle_factory *factory;
void *iface;
if ((res = enum_func (&factory, state++)) < 0) {
@ -225,22 +225,22 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
}
static void
on_sink_event (SpaNode *node, SpaEvent *event, void *user_data)
on_sink_event (struct spa_node *node, struct spa_event *event, void *user_data)
{
printf ("got event %d\n", SPA_EVENT_TYPE (event));
}
static void
on_sink_need_input (SpaNode *node, void *user_data)
on_sink_need_input (struct spa_node *node, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
#ifdef USE_GRAPH
data->sink_node.action = PROCESS_CHECK;
data->sink_node.state = SPA_RESULT_NEED_BUFFER;
spa_graph_node_schedule (&data->graph, &data->sink_node);
#else
SpaResult res;
int res;
res = spa_node_process_output (data->mix);
if (res == SPA_RESULT_NEED_BUFFER) {
@ -273,14 +273,14 @@ push:
}
static void
on_sink_reuse_buffer (SpaNode *node, uint32_t port_id, uint32_t buffer_id, void *user_data)
on_sink_reuse_buffer (struct spa_node *node, uint32_t port_id, uint32_t buffer_id, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
data->mix_sink_io[0].buffer_id = buffer_id;
}
static const SpaNodeCallbacks sink_callbacks =
static const struct spa_node_callbacks sink_callbacks =
{
&on_sink_event,
&on_sink_need_input,
@ -288,11 +288,11 @@ static const SpaNodeCallbacks sink_callbacks =
&on_sink_reuse_buffer
};
static SpaResult
do_add_source (SpaLoop *loop,
SpaSource *source)
static int
do_add_source (struct spa_loop *loop,
struct spa_source *source)
{
AppData *data = SPA_CONTAINER_OF (loop, AppData, data_loop);
struct data *data = SPA_CONTAINER_OF (loop, struct data, data_loop);
data->sources[data->n_sources] = *source;
data->n_sources++;
@ -301,20 +301,20 @@ do_add_source (SpaLoop *loop,
return SPA_RESULT_OK;
}
static SpaResult
do_update_source (SpaSource *source)
static int
do_update_source (struct spa_source *source)
{
return SPA_RESULT_OK;
}
static void
do_remove_source (SpaSource *source)
do_remove_source (struct spa_source *source)
{
}
static SpaResult
do_invoke (SpaLoop *loop,
SpaInvokeFunc func,
static int
do_invoke (struct spa_loop *loop,
spa_invoke_func_t func,
uint32_t seq,
size_t size,
void *data,
@ -323,13 +323,13 @@ do_invoke (SpaLoop *loop,
return func (loop, false, seq, size, data, user_data);
}
static SpaResult
make_nodes (AppData *data, const char *device)
static int
make_nodes (struct data *data, const char *device)
{
SpaResult res;
SpaProps *props;
SpaPODBuilder b = { 0 };
SpaPODFrame f[2];
int res;
struct spa_props *props;
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[2];
uint8_t buffer[128];
if ((res = make_node (data, &data->sink,
@ -344,7 +344,7 @@ make_nodes (AppData *data, const char *device)
spa_pod_builder_props (&b, &f[0], data->type.props,
SPA_POD_PROP (&f[1], data->type.props_device, 0, SPA_POD_TYPE_STRING, 1, device ? device : "hw:0"),
SPA_POD_PROP (&f[1], data->type.props_min_latency, 0, SPA_POD_TYPE_INT, 1, MIN_LATENCY));
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_props);
if ((res = spa_node_set_props (data->sink, props)) < 0)
printf ("got set_props error %d\n", res);
@ -368,7 +368,7 @@ make_nodes (AppData *data, const char *device)
SPA_POD_PROP (&f[1], data->type.props_freq, 0, SPA_POD_TYPE_DOUBLE, 1, 600.0),
SPA_POD_PROP (&f[1], data->type.props_volume, 0, SPA_POD_TYPE_DOUBLE, 1, 0.5),
SPA_POD_PROP (&f[1], data->type.props_live, 0, SPA_POD_TYPE_BOOL, 1, false));
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_props);
if ((res = spa_node_set_props (data->source1, props)) < 0)
printf ("got set_props error %d\n", res);
@ -385,7 +385,7 @@ make_nodes (AppData *data, const char *device)
SPA_POD_PROP (&f[1], data->type.props_freq, 0, SPA_POD_TYPE_DOUBLE, 1, 440.0),
SPA_POD_PROP (&f[1], data->type.props_volume, 0, SPA_POD_TYPE_DOUBLE, 1, 0.5),
SPA_POD_PROP (&f[1], data->type.props_live, 0, SPA_POD_TYPE_BOOL, 1, false));
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_props);
if ((res = spa_node_set_props (data->source2, props)) < 0)
printf ("got set_props error %d\n", res);
@ -446,14 +446,14 @@ make_nodes (AppData *data, const char *device)
return res;
}
static SpaResult
negotiate_formats (AppData *data)
static int
negotiate_formats (struct data *data)
{
SpaResult res;
SpaFormat *format, *filter;
int res;
struct spa_format *format, *filter;
uint32_t state = 0;
SpaPODBuilder b = { 0 };
SpaPODFrame f[2];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[2];
uint8_t buffer[256];
spa_pod_builder_init (&b, buffer, sizeof (buffer));
@ -471,7 +471,7 @@ negotiate_formats (AppData *data)
SPA_POD_PROP (&f[1], data->type.format_audio.channels, 0,
SPA_POD_TYPE_INT, 1,
2));
filter = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
filter = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_format);
if ((res = spa_node_port_enum_formats (data->sink, SPA_DIRECTION_INPUT, 0, &format, filter, state)) < 0)
return res;
@ -518,7 +518,7 @@ negotiate_formats (AppData *data)
static void *
loop (void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
printf ("enter thread %d\n", data->n_sources);
while (data->running) {
@ -527,7 +527,7 @@ loop (void *user_data)
/* rebuild */
if (data->rebuild_fds) {
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
data->fds[i].fd = p->fd;
data->fds[i].events = p->mask;
}
@ -548,7 +548,7 @@ loop (void *user_data)
/* after */
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
p->rmask = 0;
if (data->fds[i].revents & POLLIN)
p->rmask |= SPA_IO_IN;
@ -560,7 +560,7 @@ loop (void *user_data)
p->rmask |= SPA_IO_ERR;
}
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
if (p->rmask)
p->func (p);
}
@ -571,13 +571,13 @@ loop (void *user_data)
}
static void
run_async_sink (AppData *data)
run_async_sink (struct data *data)
{
SpaResult res;
int res;
int err;
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
if ((res = spa_node_send_command (data->source1, &cmd)) < 0)
printf ("got source1 error %d\n", res);
if ((res = spa_node_send_command (data->source2, &cmd)) < 0)
@ -603,7 +603,7 @@ run_async_sink (AppData *data)
}
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
if ((res = spa_node_send_command (data->sink, &cmd)) < 0)
printf ("got error %d\n", res);
if ((res = spa_node_send_command (data->mix, &cmd)) < 0)
@ -618,13 +618,13 @@ run_async_sink (AppData *data)
int
main (int argc, char *argv[])
{
AppData data = { NULL };
SpaResult res;
struct data data = { NULL };
int res;
const char *str;
data.map = spa_type_map_get_default();
data.log = spa_log_get_default();
data.data_loop.size = sizeof (SpaLoop);
data.data_loop.size = sizeof (struct spa_loop);
data.data_loop.add_source = do_add_source;
data.data_loop.update_source = do_update_source;
data.data_loop.remove_source = do_remove_source;

176
spa/tests/test-perf.c
View file

@ -46,7 +46,7 @@
#define MODE_ASYNC_BOTH (MODE_ASYNC_PUSH|MODE_ASYNC_PULL)
#define MODE_DIRECT (1<<4)
typedef struct {
struct type {
uint32_t node;
uint32_t props;
uint32_t format;
@ -55,16 +55,16 @@ typedef struct {
uint32_t props_volume;
uint32_t props_min_latency;
uint32_t props_live;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
} Type;
struct spa_type_meta meta;
struct spa_type_data data;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_event_node event_node;
struct spa_type_command_node command_node;
};
static inline void
init_type (Type *type, SpaTypeMap *map)
init_type (struct type *type, struct spa_type_map *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
@ -82,44 +82,44 @@ init_type (Type *type, SpaTypeMap *map)
spa_type_command_node_map (map, &type->command_node);
}
typedef struct {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaChunk chunks[1];
} Buffer;
struct buffer {
struct spa_buffer buffer;
struct spa_meta metas[1];
struct spa_meta_header header;
struct spa_data datas[1];
struct spa_chunk chunks[1];
};
typedef struct {
SpaTypeMap *map;
SpaLog *log;
SpaLoop data_loop;
Type type;
struct data {
struct spa_type_map *map;
struct spa_log *log;
struct spa_loop data_loop;
struct type type;
int mode;
SpaSupport support[4];
struct spa_support support[4];
uint32_t n_support;
int iterations;
SpaGraph graph;
SpaGraphNode source_node;
SpaGraphPort source_out;
SpaGraphPort sink_in;
SpaGraphNode sink_node;
struct spa_graph graph;
struct spa_graph_node source_node;
struct spa_graph_port source_out;
struct spa_graph_port sink_in;
struct spa_graph_node sink_node;
SpaNode *sink;
SpaPortIO source_sink_io[1];
struct spa_node *sink;
struct spa_port_io source_sink_io[1];
SpaNode *source;
SpaBuffer *source_buffers[1];
Buffer source_buffer[1];
struct spa_node *source;
struct spa_buffer *source_buffers[1];
struct buffer source_buffer[1];
bool running;
pthread_t thread;
SpaSource sources[16];
struct spa_source sources[16];
unsigned int n_sources;
bool rebuild_fds;
@ -127,19 +127,19 @@ typedef struct {
unsigned int n_fds;
void *hnd;
} AppData;
};
#define MIN_LATENCY 64
#define BUFFER_SIZE MIN_LATENCY
static void
init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t size)
init_buffer (struct data *data, struct spa_buffer **bufs, struct buffer *ba, int n_buffers, size_t size)
{
int i;
for (i = 0; i < n_buffers; i++) {
Buffer *b = &ba[i];
struct buffer *b = &ba[i];
bufs[i] = &b->buffer;
b->buffer.id = i;
@ -169,12 +169,12 @@ init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t
}
}
static SpaResult
make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
static int
make_node (struct data *data, struct spa_node **node, const char *lib, const char *name)
{
SpaHandle *handle;
SpaResult res;
SpaEnumHandleFactoryFunc enum_func;
struct spa_handle *handle;
int res;
spa_handle_factory_enum_func_t enum_func;
unsigned int i;
uint32_t state = 0;
@ -184,13 +184,13 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
return SPA_RESULT_ERROR;
}
}
if ((enum_func = dlsym (data->hnd, "spa_enum_handle_factory")) == NULL) {
if ((enum_func = dlsym (data->hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) {
printf ("can't find enum function\n");
return SPA_RESULT_ERROR;
}
for (i = 0; ;i++) {
const SpaHandleFactory *factory;
const struct spa_handle_factory *factory;
void *iface;
if ((res = enum_func (&factory, state++)) < 0) {
@ -217,7 +217,7 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
}
static void
on_sink_pull (AppData *data)
on_sink_pull (struct data *data)
{
spa_log_trace (data->log, "do sink pull");
data->sink_node.state = SPA_RESULT_NEED_BUFFER;
@ -232,7 +232,7 @@ on_sink_pull (AppData *data)
}
static void
on_source_push (AppData *data)
on_source_push (struct data *data)
{
spa_log_trace (data->log, "do source push");
if (data->mode & MODE_DIRECT) {
@ -246,16 +246,16 @@ on_source_push (AppData *data)
}
static void
on_sink_event (SpaNode *node, SpaEvent *event, void *user_data)
on_sink_event (struct spa_node *node, struct spa_event *event, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
spa_log_trace (data->log, "got sink event %d", SPA_EVENT_TYPE (event));
}
static void
on_sink_need_input (SpaNode *node, void *user_data)
on_sink_need_input (struct spa_node *node, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
spa_log_trace (data->log, "need input");
on_sink_pull (data);
if (--data->iterations == 0)
@ -263,14 +263,14 @@ on_sink_need_input (SpaNode *node, void *user_data)
}
static void
on_sink_reuse_buffer (SpaNode *node, uint32_t port_id, uint32_t buffer_id, void *user_data)
on_sink_reuse_buffer (struct spa_node *node, uint32_t port_id, uint32_t buffer_id, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
data->source_sink_io[0].buffer_id = buffer_id;
}
static const SpaNodeCallbacks sink_callbacks =
static const struct spa_node_callbacks sink_callbacks =
{
&on_sink_event,
&on_sink_need_input,
@ -279,23 +279,23 @@ static const SpaNodeCallbacks sink_callbacks =
};
static void
on_source_event (SpaNode *node, SpaEvent *event, void *user_data)
on_source_event (struct spa_node *node, struct spa_event *event, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
spa_log_trace (data->log, "got source event %d", SPA_EVENT_TYPE (event));
}
static void
on_source_have_output (SpaNode *node, void *user_data)
on_source_have_output (struct spa_node *node, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
spa_log_trace (data->log, "have_output");
on_source_push (data);
if (--data->iterations == 0)
data->running = false;
}
static const SpaNodeCallbacks source_callbacks =
static const struct spa_node_callbacks source_callbacks =
{
&on_source_event,
NULL,
@ -304,11 +304,11 @@ static const SpaNodeCallbacks source_callbacks =
};
static SpaResult
do_add_source (SpaLoop *loop,
SpaSource *source)
static int
do_add_source (struct spa_loop *loop,
struct spa_source *source)
{
AppData *data = SPA_CONTAINER_OF (loop, AppData, data_loop);
struct data *data = SPA_CONTAINER_OF (loop, struct data, data_loop);
data->sources[data->n_sources] = *source;
data->n_sources++;
@ -317,20 +317,20 @@ do_add_source (SpaLoop *loop,
return SPA_RESULT_OK;
}
static SpaResult
do_update_source (SpaSource *source)
static int
do_update_source (struct spa_source *source)
{
return SPA_RESULT_OK;
}
static void
do_remove_source (SpaSource *source)
do_remove_source (struct spa_source *source)
{
}
static SpaResult
do_invoke (SpaLoop *loop,
SpaInvokeFunc func,
static int
do_invoke (struct spa_loop *loop,
spa_invoke_func_t func,
uint32_t seq,
size_t size,
void *data,
@ -339,10 +339,10 @@ do_invoke (SpaLoop *loop,
return func (loop, false, seq, size, data, user_data);
}
static SpaResult
make_nodes (AppData *data)
static int
make_nodes (struct data *data)
{
SpaResult res;
int res;
if ((res = make_node (data, &data->sink,
"build/spa/plugins/test/libspa-test.so",
@ -388,19 +388,19 @@ make_nodes (AppData *data)
return res;
}
static SpaResult
negotiate_formats (AppData *data)
static int
negotiate_formats (struct data *data)
{
SpaResult res;
SpaFormat *format;
SpaPODBuilder b = { 0 };
SpaPODFrame f[2];
int res;
struct spa_format *format;
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[2];
uint8_t buffer[256];
spa_pod_builder_init (&b, buffer, sizeof (buffer));
spa_pod_builder_format (&b, &f[0], data->type.format,
data->type.media_type.binary, data->type.media_subtype.raw, 0);
format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_format);
if ((res = spa_node_port_set_format (data->sink, SPA_DIRECTION_INPUT, 0, 0, format)) < 0)
return res;
@ -421,7 +421,7 @@ negotiate_formats (AppData *data)
static void *
loop (void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
printf ("enter thread %d\n", data->n_sources);
while (data->running) {
@ -430,7 +430,7 @@ loop (void *user_data)
/* rebuild */
if (data->rebuild_fds) {
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
data->fds[i].fd = p->fd;
data->fds[i].events = p->mask;
}
@ -451,7 +451,7 @@ loop (void *user_data)
/* after */
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
p->rmask = 0;
if (data->fds[i].revents & POLLIN)
p->rmask |= SPA_IO_IN;
@ -463,7 +463,7 @@ loop (void *user_data)
p->rmask |= SPA_IO_ERR;
}
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
if (p->rmask)
p->func (p);
}
@ -474,15 +474,15 @@ loop (void *user_data)
}
static void
run_graph (AppData *data)
run_graph (struct data *data)
{
SpaResult res;
int res;
int err, i;
struct timespec now;
int64_t start, stop;
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
printf ("got source error %d\n", res);
if ((res = spa_node_send_command (data->sink, &cmd)) < 0)
@ -519,7 +519,7 @@ run_graph (AppData *data)
printf ("stopping, elapsed %"PRIi64"\n", stop - start);
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
if ((res = spa_node_send_command (data->sink, &cmd)) < 0)
printf ("got error %d\n", res);
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
@ -530,15 +530,15 @@ run_graph (AppData *data)
int
main (int argc, char *argv[])
{
AppData data = { NULL };
SpaResult res;
struct data data = { NULL };
int res;
const char *str;
spa_graph_init (&data.graph);
data.map = spa_type_map_get_default();
data.log = spa_log_get_default();
data.data_loop.size = sizeof (SpaLoop);
data.data_loop.size = sizeof (struct spa_loop);
data.data_loop.add_source = do_add_source;
data.data_loop.update_source = do_update_source;
data.data_loop.remove_source = do_remove_source;

66
spa/tests/test-props.c
View file

@ -62,14 +62,14 @@ spa_build (SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
static struct {
uint32_t format;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeFormatVideo format_video;
SpaTypeVideoFormat video_format;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_format_video format_video;
struct spa_type_video_format video_format;
} type = { 0, };
static inline void
type_init (SpaTypeMap *map)
type_init (struct spa_type_map *map)
{
type.format = spa_type_map_get_id (map, SPA_TYPE__Format);
spa_type_media_type_map (map, &type.media_type);
@ -79,58 +79,58 @@ type_init (SpaTypeMap *map)
}
static void
do_static_struct (SpaTypeMap *map)
do_static_struct (struct spa_type_map *map)
{
struct _test_format {
SpaFormat fmt;
struct spa_format fmt;
struct {
SpaPODProp prop_format;
struct spa_pod_prop prop_format;
struct {
uint32_t def_format;
uint32_t enum_format[2];
} format_vals;
uint32_t pad;
SpaPODProp prop_size;
struct spa_pod_prop prop_size;
struct {
SpaRectangle def_size;
SpaRectangle min_size;
SpaRectangle max_size;
struct spa_rectangle def_size;
struct spa_rectangle min_size;
struct spa_rectangle max_size;
} size_vals;
SpaPODProp prop_framerate;
struct spa_pod_prop prop_framerate;
struct {
SpaFraction def_framerate;
SpaFraction min_framerate;
SpaFraction max_framerate;
struct spa_fraction def_framerate;
struct spa_fraction min_framerate;
struct spa_fraction max_framerate;
} framerate_vals;
} props;
} test_format = {
{ { sizeof (test_format.props) + sizeof (SpaFormatBody), SPA_POD_TYPE_OBJECT },
{ { sizeof (test_format.props) + sizeof (struct spa_format), SPA_POD_TYPE_OBJECT },
{ { 0, type.format },
{ { sizeof (uint32_t), SPA_POD_TYPE_ID }, type.media_type.video },
{ { sizeof (uint32_t), SPA_POD_TYPE_ID }, type.media_subtype.raw } },
}, {
{ { sizeof (test_format.props.format_vals) + sizeof (SpaPODPropBody),
{ { sizeof (test_format.props.format_vals) + sizeof (struct spa_pod_prop_body),
SPA_POD_TYPE_PROP } ,
{ type.format_video.format, SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (uint32_t), SPA_POD_TYPE_ID } }, },
{ type.video_format.I420,
{ type.video_format.I420, type.video_format.YUY2 } }, 0,
{ { sizeof (test_format.props.size_vals) + sizeof (SpaPODPropBody),
{ { sizeof (test_format.props.size_vals) + sizeof (struct spa_pod_prop_body),
SPA_POD_TYPE_PROP } ,
{ type.format_video.size, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (SpaRectangle), SPA_POD_TYPE_RECTANGLE } }, },
{ sizeof (struct spa_rectangle), SPA_POD_TYPE_RECTANGLE } }, },
{ { 320, 243 },
{ 1, 1 },
{ INT32_MAX, INT32_MAX } },
{ { sizeof (test_format.props.framerate_vals) + sizeof (SpaPODPropBody),
{ { sizeof (test_format.props.framerate_vals) + sizeof (struct spa_pod_prop_body),
SPA_POD_TYPE_PROP } ,
{ type.format_video.framerate, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (SpaFraction), SPA_POD_TYPE_FRACTION } }, },
{ sizeof (struct spa_fraction), SPA_POD_TYPE_FRACTION } }, },
{ { 25, 1 },
{ 0, 1 },
{ INT32_MAX, 1 } },
@ -142,9 +142,9 @@ do_static_struct (SpaTypeMap *map)
{
uint32_t format = 0, match;
SpaFraction frac = { 0, 0 };
struct spa_fraction frac = { 0, 0 };
match = spa_pod_contents_query (&test_format.fmt.pod, sizeof (SpaFormat),
match = spa_pod_contents_query (&test_format.fmt.pod, sizeof (struct spa_format),
type.format_video.format, SPA_POD_TYPE_INT, &format,
type.format_video.framerate, SPA_POD_TYPE_FRACTION, &frac,
0);
@ -157,11 +157,11 @@ do_static_struct (SpaTypeMap *map)
int
main (int argc, char *argv[])
{
SpaPODBuilder b = { NULL, };
SpaPODFrame frame[4];
struct spa_pod_builder b = { NULL, };
struct spa_pod_frame frame[4];
uint8_t buffer[1024];
SpaFormat *fmt;
SpaTypeMap *map = spa_type_map_get_default();
struct spa_format *fmt;
struct spa_type_map *map = spa_type_map_get_default();
type_init (map);
@ -169,7 +169,7 @@ main (int argc, char *argv[])
fmt = SPA_MEMBER (buffer, spa_pod_builder_push_format (&b, &frame[0], type.format,
type.media_type.video,
type.media_subtype.raw), SpaFormat);
type.media_subtype.raw), struct spa_format);
spa_pod_builder_push_prop (&b, &frame[1],
type.format_video.format,
SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET);
@ -178,7 +178,7 @@ main (int argc, char *argv[])
spa_pod_builder_id (&b, type.video_format.YUY2);
spa_pod_builder_pop (&b, &frame[1]);
SpaRectangle size_min_max[] = { { 1, 1 }, { INT32_MAX, INT32_MAX } };
struct spa_rectangle size_min_max[] = { { 1, 1 }, { INT32_MAX, INT32_MAX } };
spa_pod_builder_push_prop (&b, &frame[1],
type.format_video.size,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET);
@ -186,7 +186,7 @@ main (int argc, char *argv[])
spa_pod_builder_raw (&b, size_min_max, sizeof(size_min_max));
spa_pod_builder_pop (&b, &frame[1]);
SpaFraction rate_min_max[] = { { 0, 1 }, { INT32_MAX, 1 } };
struct spa_fraction rate_min_max[] = { { 0, 1 }, { INT32_MAX, 1 } };
spa_pod_builder_push_prop (&b, &frame[1],
type.format_video.framerate,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET);
@ -227,7 +227,7 @@ main (int argc, char *argv[])
INT32_MAX, 1,
-SPA_POD_TYPE_PROP, &frame[1]);
fmt = SPA_MEMBER (buffer, frame[0].ref, SpaFormat);
fmt = SPA_MEMBER (buffer, frame[0].ref, struct spa_format);
spa_debug_pod (&fmt->pod, map);
spa_debug_format (fmt, map);
@ -264,7 +264,7 @@ main (int argc, char *argv[])
-SPA_POD_TYPE_OBJECT, &frame[0],
0);
fmt = SPA_MEMBER (buffer, frame[0].ref, SpaFormat);
fmt = SPA_MEMBER (buffer, frame[0].ref, struct spa_format);
spa_debug_pod (&fmt->pod, map);
spa_debug_format (fmt, map);

24
spa/tests/test-props2.c
View file

@ -37,12 +37,12 @@
int
main (int argc, char *argv[])
{
SpaPODBuilder b = { NULL, };
SpaPODFrame frame[4];
struct spa_pod_builder b = { NULL, };
struct spa_pod_frame frame[4];
uint8_t buffer[1024];
SpaPOD *obj;
SpaPODIter i;
SpaTypeMap *map = spa_type_map_get_default ();
struct spa_pod *obj;
struct spa_pod_iter i;
struct spa_type_map *map = spa_type_map_get_default ();
b.data = buffer;
b.size = 1024;
@ -61,7 +61,7 @@ main (int argc, char *argv[])
spa_pod_builder_int (&b, 42);
spa_pod_builder_pop (&b, &frame[1]);
SpaRectangle sizes[] = { { 0, 0 }, { 1024, 1024} };
struct spa_rectangle sizes[] = { { 0, 0 }, { 1024, 1024} };
spa_pod_builder_push_prop (&b, &frame[1],
3, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET);
spa_pod_builder_rectangle (&b, 320, 240);
@ -86,23 +86,23 @@ main (int argc, char *argv[])
spa_pod_builder_pop (&b, &frame[1]);
spa_pod_builder_pop (&b, &frame[0]);
obj = SPA_POD_BUILDER_DEREF (&b, frame[0].ref, SpaPOD);
obj = SPA_POD_BUILDER_DEREF (&b, frame[0].ref, struct spa_pod);
spa_debug_pod (obj, map);
SpaPODProp *p = spa_pod_object_find_prop ((SpaPODObject *)obj, 4);
struct spa_pod_prop *p = spa_pod_object_find_prop ((struct spa_pod_object *)obj, 4);
printf ("%d %d\n", p->body.key, p->body.flags);
spa_debug_pod (&p->body.value, map);
obj = SPA_POD_BUILDER_DEREF (&b, frame[2].ref, SpaPOD);
obj = SPA_POD_BUILDER_DEREF (&b, frame[2].ref, struct spa_pod);
int32_t vi, *pi;
int64_t vl;
float vf;
double vd;
char *vs;
SpaRectangle vr;
SpaFraction vfr;
SpaPODArray *va;
struct spa_rectangle vr;
struct spa_fraction vfr;
struct spa_pod_array *va;
spa_pod_iter_pod (&i, obj);
spa_pod_iter_get (&i, SPA_POD_TYPE_INT, &vi,
SPA_POD_TYPE_LONG, &vl,

168
spa/tests/test-ringbuffer.c
View file

@ -37,7 +37,7 @@
#include <lib/debug.h>
#include <lib/props.h>
typedef struct {
struct type {
uint32_t node;
uint32_t props;
uint32_t format;
@ -46,18 +46,18 @@ typedef struct {
uint32_t props_volume;
uint32_t props_min_latency;
uint32_t props_live;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeFormatAudio format_audio;
SpaTypeAudioFormat audio_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
} Type;
struct spa_type_meta meta;
struct spa_type_data data;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_format_audio format_audio;
struct spa_type_audio_format audio_format;
struct spa_type_event_node event_node;
struct spa_type_command_node command_node;
};
static inline void
init_type (Type *type, SpaTypeMap *map)
init_type (struct type *type, struct spa_type_map *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
@ -77,51 +77,51 @@ init_type (Type *type, SpaTypeMap *map)
spa_type_command_node_map (map, &type->command_node);
}
typedef struct {
SpaBuffer buffer;
SpaMeta metas[2];
SpaMetaHeader header;
SpaMetaRingbuffer rb;
SpaData datas[1];
SpaChunk chunks[1];
} Buffer;
struct buffer {
struct spa_buffer buffer;
struct spa_meta metas[2];
struct spa_meta_header header;
struct spa_meta_ringbuffer rb;
struct spa_data datas[1];
struct spa_chunk chunks[1];
};
typedef struct {
SpaTypeMap *map;
SpaLog *log;
SpaLoop data_loop;
Type type;
struct data {
struct spa_type_map *map;
struct spa_log *log;
struct spa_loop data_loop;
struct type type;
SpaSupport support[4];
struct spa_support support[4];
uint32_t n_support;
SpaNode *sink;
SpaPortIO source_sink_io[1];
struct spa_node *sink;
struct spa_port_io source_sink_io[1];
SpaNode *source;
SpaBuffer *source_buffers[1];
Buffer source_buffer[1];
struct spa_node *source;
struct spa_buffer *source_buffers[1];
struct buffer source_buffer[1];
bool running;
pthread_t thread;
SpaSource sources[16];
struct spa_source sources[16];
unsigned int n_sources;
bool rebuild_fds;
struct pollfd fds[16];
unsigned int n_fds;
} AppData;
};
#define BUFFER_SIZE 4096
static void
init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t size)
init_buffer (struct data *data, struct spa_buffer **bufs, struct buffer *ba, int n_buffers, size_t size)
{
int i;
for (i = 0; i < n_buffers; i++) {
Buffer *b = &ba[i];
struct buffer *b = &ba[i];
bufs[i] = &b->buffer;
b->buffer.id = i;
@ -156,13 +156,13 @@ init_buffer (AppData *data, SpaBuffer **bufs, Buffer *ba, int n_buffers, size_t
}
}
static SpaResult
make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
static int
make_node (struct data *data, struct spa_node **node, const char *lib, const char *name)
{
SpaHandle *handle;
SpaResult res;
struct spa_handle *handle;
int res;
void *hnd;
SpaEnumHandleFactoryFunc enum_func;
spa_handle_factory_enum_func_t enum_func;
unsigned int i;
uint32_t state = 0;
@ -170,13 +170,13 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
printf ("can't load %s: %s\n", lib, dlerror());
return SPA_RESULT_ERROR;
}
if ((enum_func = dlsym (hnd, "spa_enum_handle_factory")) == NULL) {
if ((enum_func = dlsym (hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) {
printf ("can't find enum function\n");
return SPA_RESULT_ERROR;
}
for (i = 0; ;i++) {
const SpaHandleFactory *factory;
const struct spa_handle_factory *factory;
void *iface;
if ((res = enum_func (&factory, state++)) < 0) {
@ -203,16 +203,16 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
}
static void
on_sink_event (SpaNode *node, SpaEvent *event, void *user_data)
on_sink_event (struct spa_node *node, struct spa_event *event, void *user_data)
{
printf ("got event %d\n", SPA_EVENT_TYPE (event));
}
static void
on_sink_need_input (SpaNode *node, void *user_data)
on_sink_need_input (struct spa_node *node, void *user_data)
{
AppData *data = user_data;
SpaResult res;
struct data *data = user_data;
int res;
res = spa_node_process_output (data->source);
if (res != SPA_RESULT_HAVE_BUFFER)
@ -223,24 +223,24 @@ on_sink_need_input (SpaNode *node, void *user_data)
}
static void
on_sink_reuse_buffer (SpaNode *node, uint32_t port_id, uint32_t buffer_id, void *user_data)
on_sink_reuse_buffer (struct spa_node *node, uint32_t port_id, uint32_t buffer_id, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
data->source_sink_io[0].buffer_id = buffer_id;
}
static const SpaNodeCallbacks sink_callbacks = {
static const struct spa_node_callbacks sink_callbacks = {
&on_sink_event,
&on_sink_need_input,
NULL,
&on_sink_reuse_buffer
};
static SpaResult
do_add_source (SpaLoop *loop,
SpaSource *source)
static int
do_add_source (struct spa_loop *loop,
struct spa_source *source)
{
AppData *data = SPA_CONTAINER_OF (loop, AppData, data_loop);
struct data *data = SPA_CONTAINER_OF (loop, struct data, data_loop);
data->sources[data->n_sources] = *source;
data->n_sources++;
@ -249,20 +249,20 @@ do_add_source (SpaLoop *loop,
return SPA_RESULT_OK;
}
static SpaResult
do_update_source (SpaSource *source)
static int
do_update_source (struct spa_source *source)
{
return SPA_RESULT_OK;
}
static void
do_remove_source (SpaSource *source)
do_remove_source (struct spa_source *source)
{
}
static SpaResult
do_invoke (SpaLoop *loop,
SpaInvokeFunc func,
static int
do_invoke (struct spa_loop *loop,
spa_invoke_func_t func,
uint32_t seq,
size_t size,
void *data,
@ -271,13 +271,13 @@ do_invoke (SpaLoop *loop,
return func (loop, false, seq, size, data, user_data);
}
static SpaResult
make_nodes (AppData *data, const char *device)
static int
make_nodes (struct data *data, const char *device)
{
SpaResult res;
SpaProps *props;
SpaPODBuilder b = { 0 };
SpaPODFrame f[2];
int res;
struct spa_props *props;
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[2];
uint8_t buffer[128];
if ((res = make_node (data, &data->sink,
@ -292,7 +292,7 @@ make_nodes (AppData *data, const char *device)
spa_pod_builder_props (&b, &f[0], data->type.props,
SPA_POD_PROP (&f[1], data->type.props_device, 0, SPA_POD_TYPE_STRING, 1, device ? device : "hw:0"),
SPA_POD_PROP (&f[1], data->type.props_min_latency, 0, SPA_POD_TYPE_INT, 1, 64));
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_props);
if ((res = spa_node_set_props (data->sink, props)) < 0)
printf ("got set_props error %d\n", res);
@ -307,21 +307,21 @@ make_nodes (AppData *data, const char *device)
spa_pod_builder_init (&b, buffer, sizeof (buffer));
spa_pod_builder_props (&b, &f[0], data->type.props,
SPA_POD_PROP (&f[1], data->type.props_live, 0, SPA_POD_TYPE_BOOL, 1, false));
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_props);
if ((res = spa_node_set_props (data->source, props)) < 0)
printf ("got set_props error %d\n", res);
return res;
}
static SpaResult
negotiate_formats (AppData *data)
static int
negotiate_formats (struct data *data)
{
SpaResult res;
SpaFormat *format, *filter;
int res;
struct spa_format *format, *filter;
uint32_t state = 0;
SpaPODBuilder b = { 0 };
SpaPODFrame f[2];
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[2];
uint8_t buffer[256];
spa_pod_builder_init (&b, buffer, sizeof (buffer));
@ -339,7 +339,7 @@ negotiate_formats (AppData *data)
SPA_POD_PROP (&f[1], data->type.format_audio.channels, 0,
SPA_POD_TYPE_INT, 1,
2));
filter = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
filter = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_format);
if ((res = spa_node_port_enum_formats (data->sink, SPA_DIRECTION_INPUT, 0, &format, filter, state)) < 0)
return res;
@ -368,7 +368,7 @@ negotiate_formats (AppData *data)
static void *
loop (void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
printf ("enter thread %d\n", data->n_sources);
while (data->running) {
@ -377,7 +377,7 @@ loop (void *user_data)
/* rebuild */
if (data->rebuild_fds) {
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
data->fds[i].fd = p->fd;
data->fds[i].events = p->mask;
}
@ -398,7 +398,7 @@ loop (void *user_data)
/* after */
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
p->rmask = 0;
if (data->fds[i].revents & POLLIN)
p->rmask |= SPA_IO_IN;
@ -410,7 +410,7 @@ loop (void *user_data)
p->rmask |= SPA_IO_ERR;
}
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
if (p->rmask)
p->func (p);
}
@ -421,13 +421,13 @@ loop (void *user_data)
}
static void
run_async_sink (AppData *data)
run_async_sink (struct data *data)
{
SpaResult res;
int res;
int err;
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
printf ("got source error %d\n", res);
if ((res = spa_node_send_command (data->sink, &cmd)) < 0)
@ -449,7 +449,7 @@ run_async_sink (AppData *data)
}
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
if ((res = spa_node_send_command (data->sink, &cmd)) < 0)
printf ("got sink error %d\n", res);
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
@ -460,13 +460,13 @@ run_async_sink (AppData *data)
int
main (int argc, char *argv[])
{
AppData data = { NULL };
SpaResult res;
struct data data = { NULL };
int res;
const char *str;
data.map = spa_type_map_get_default();
data.log = spa_log_get_default();
data.data_loop.size = sizeof (SpaLoop);
data.data_loop.size = sizeof (struct spa_loop);
data.data_loop.add_source = do_add_source;
data.data_loop.update_source = do_update_source;
data.data_loop.remove_source = do_remove_source;

180
spa/tests/test-v4l2.c
View file

@ -38,24 +38,24 @@
#include <lib/props.h>
#include <lib/mapper.h>
typedef struct {
struct type {
uint32_t node;
uint32_t props;
uint32_t format;
uint32_t props_device;
uint32_t SDL_Texture;
SpaTypeMeta meta;
SpaTypeData data;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeFormatVideo format_video;
SpaTypeVideoFormat video_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
} Type;
struct spa_type_meta meta;
struct spa_type_data data;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_format_video format_video;
struct spa_type_video_format video_format;
struct spa_type_event_node event_node;
struct spa_type_command_node command_node;
};
static inline void
init_type (Type *type, SpaTypeMap *map)
init_type (struct type *type, struct spa_type_map *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
@ -74,27 +74,27 @@ init_type (Type *type, SpaTypeMap *map)
#define MAX_BUFFERS 8
typedef struct {
SpaBuffer buffer;
SpaMeta metas[2];
SpaMetaHeader header;
SpaMetaPointer ptr;
SpaData datas[1];
SpaChunk chunks[1];
} SDLBuffer;
struct buffer {
struct spa_buffer buffer;
struct spa_meta metas[2];
struct spa_meta_header header;
struct spa_meta_pointer ptr;
struct spa_data datas[1];
struct spa_chunk chunks[1];
};
typedef struct {
Type type;
struct data {
struct type type;
SpaTypeMap *map;
SpaLog *log;
SpaLoop data_loop;
struct spa_type_map *map;
struct spa_log *log;
struct spa_loop data_loop;
SpaSupport support[4];
struct spa_support support[4];
uint32_t n_support;
SpaNode *source;
SpaPortIO source_output[1];
struct spa_node *source;
struct spa_port_io source_output[1];
SDL_Renderer *renderer;
SDL_Window *window;
@ -105,25 +105,25 @@ typedef struct {
bool running;
pthread_t thread;
SpaSource sources[16];
struct spa_source sources[16];
unsigned int n_sources;
bool rebuild_fds;
struct pollfd fds[16];
unsigned int n_fds;
SpaBuffer *bp[MAX_BUFFERS];
SDLBuffer buffers[MAX_BUFFERS];
struct spa_buffer *bp[MAX_BUFFERS];
struct buffer buffers[MAX_BUFFERS];
unsigned int n_buffers;
} AppData;
};
static SpaResult
make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
static int
make_node (struct data *data, struct spa_node **node, const char *lib, const char *name)
{
SpaHandle *handle;
SpaResult res;
struct spa_handle *handle;
int res;
void *hnd;
SpaEnumHandleFactoryFunc enum_func;
spa_handle_factory_enum_func_t enum_func;
unsigned int i;
uint32_t state = 0;
@ -131,13 +131,13 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
printf ("can't load %s: %s\n", lib, dlerror());
return SPA_RESULT_ERROR;
}
if ((enum_func = dlsym (hnd, "spa_enum_handle_factory")) == NULL) {
if ((enum_func = dlsym (hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) {
printf ("can't find enum function\n");
return SPA_RESULT_ERROR;
}
for (i = 0; ;i++) {
const SpaHandleFactory *factory;
const struct spa_handle_factory *factory;
void *iface;
if ((res = enum_func (&factory, state)) < 0) {
@ -164,7 +164,7 @@ make_node (AppData *data, SpaNode **node, const char *lib, const char *name)
}
static void
handle_events (AppData *data)
handle_events (struct data *data)
{
SDL_Event event;
while (SDL_PollEvent (&event)) {
@ -177,9 +177,9 @@ handle_events (AppData *data)
}
static void
on_source_event (SpaNode *node, SpaEvent *event, void *user_data)
on_source_event (struct spa_node *node, struct spa_event *event, void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
handle_events (data);
@ -187,18 +187,18 @@ on_source_event (SpaNode *node, SpaEvent *event, void *user_data)
}
static void
on_source_have_output (SpaNode *node, void *user_data)
on_source_have_output (struct spa_node *node, void *user_data)
{
AppData *data = user_data;
SpaResult res;
SpaBuffer *b;
struct data *data = user_data;
int res;
struct spa_buffer *b;
void *sdata, *ddata;
int sstride, dstride;
int i;
uint8_t *src, *dst;
SpaMeta *metas;
SpaData *datas;
SpaPortIO *io = &data->source_output[0];
struct spa_meta *metas;
struct spa_data *datas;
struct spa_port_io *io = &data->source_output[0];
handle_events (data);
@ -208,9 +208,9 @@ on_source_have_output (SpaNode *node, void *user_data)
datas = b->datas;
if (metas[1].type == data->type.meta.Pointer &&
((SpaMetaPointer *)metas[1].data)->type == data->type.SDL_Texture) {
((struct spa_meta_pointer *)metas[1].data)->type == data->type.SDL_Texture) {
SDL_Texture *texture;
texture = ((SpaMetaPointer *)metas[1].data)->ptr;
texture = ((struct spa_meta_pointer *)metas[1].data)->ptr;
SDL_UnlockTexture(texture);
@ -257,18 +257,18 @@ on_source_have_output (SpaNode *node, void *user_data)
printf ("got pull error %d\n", res);
}
static const SpaNodeCallbacks source_callbacks = {
static const struct spa_node_callbacks source_callbacks = {
&on_source_event,
NULL,
&on_source_have_output,
NULL
};
static SpaResult
do_add_source (SpaLoop *loop,
SpaSource *source)
static int
do_add_source (struct spa_loop *loop,
struct spa_source *source)
{
AppData *data = SPA_CONTAINER_OF (loop, AppData, data_loop);
struct data *data = SPA_CONTAINER_OF (loop, struct data, data_loop);
data->sources[data->n_sources] = *source;
data->n_sources++;
@ -277,20 +277,20 @@ do_add_source (SpaLoop *loop,
return SPA_RESULT_OK;
}
static SpaResult
do_update_source (SpaSource *source)
static int
do_update_source (struct spa_source *source)
{
return SPA_RESULT_OK;
}
static void
do_remove_source (SpaSource *source)
do_remove_source (struct spa_source *source)
{
}
static SpaResult
do_invoke (SpaLoop *loop,
SpaInvokeFunc func,
static int
do_invoke (struct spa_loop *loop,
spa_invoke_func_t func,
uint32_t seq,
size_t size,
void *data,
@ -299,13 +299,13 @@ do_invoke (SpaLoop *loop,
return func (loop, false, seq, size, data, user_data);
}
static SpaResult
make_nodes (AppData *data, const char *device)
static int
make_nodes (struct data *data, const char *device)
{
SpaResult res;
SpaProps *props;
SpaPODBuilder b = { 0 };
SpaPODFrame f[2];
int res;
struct spa_props *props;
struct spa_pod_builder b = { 0 };
struct spa_pod_frame f[2];
uint8_t buffer[256];
if ((res = make_node (data, &data->source, "build/spa/plugins/v4l2/libspa-v4l2.so", "v4l2-source")) < 0) {
@ -319,7 +319,7 @@ make_nodes (AppData *data, const char *device)
SPA_POD_PROP (&f[1], data->type.props_device, 0,
SPA_POD_TYPE_STRING, 1,
device ? device : "/dev/video0"));
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_props);
if ((res = spa_node_set_props (data->source, props)) < 0)
printf ("got set_props error %d\n", res);
@ -327,13 +327,13 @@ make_nodes (AppData *data, const char *device)
return res;
}
static SpaResult
alloc_buffers (AppData *data)
static int
alloc_buffers (struct data *data)
{
int i;
for (i = 0; i < MAX_BUFFERS; i++) {
SDLBuffer *b = &data->buffers[i];
struct buffer *b = &data->buffers[i];
SDL_Texture *texture;
void *ptr;
int stride;
@ -389,15 +389,15 @@ alloc_buffers (AppData *data)
return spa_node_port_use_buffers (data->source, SPA_DIRECTION_OUTPUT, 0, data->bp, data->n_buffers);
}
static SpaResult
negotiate_formats (AppData *data)
static int
negotiate_formats (struct data *data)
{
SpaResult res;
const SpaPortInfo *info;
SpaFormat *format;
SpaPODFrame f[2];
int res;
const struct spa_port_info *info;
struct spa_format *format;
struct spa_pod_frame f[2];
uint8_t buffer[256];
SpaPODBuilder b = SPA_POD_BUILDER_INIT (buffer, sizeof (buffer));
struct spa_pod_builder b = SPA_POD_BUILDER_INIT (buffer, sizeof (buffer));
data->source_output[0] = SPA_PORT_IO_INIT;
@ -422,7 +422,7 @@ negotiate_formats (AppData *data)
SPA_POD_PROP (&f[1], data->type.format_video.framerate, 0,
SPA_POD_TYPE_FRACTION, 1,
25, 1));
format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_format);
#endif
if ((res = spa_node_port_set_format (data->source, SPA_DIRECTION_OUTPUT, 0, 0, format)) < 0)
@ -458,7 +458,7 @@ negotiate_formats (AppData *data)
static void *
loop (void *user_data)
{
AppData *data = user_data;
struct data *data = user_data;
printf ("enter thread\n");
while (data->running) {
@ -467,7 +467,7 @@ loop (void *user_data)
/* rebuild */
if (data->rebuild_fds) {
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
data->fds[i].fd = p->fd;
data->fds[i].events = p->mask;
}
@ -488,7 +488,7 @@ loop (void *user_data)
/* after */
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
p->rmask = 0;
if (data->fds[i].revents & POLLIN)
p->rmask |= SPA_IO_IN;
@ -500,7 +500,7 @@ loop (void *user_data)
p->rmask |= SPA_IO_ERR;
}
for (i = 0; i < data->n_sources; i++) {
SpaSource *p = &data->sources[i];
struct spa_source *p = &data->sources[i];
if (p->rmask)
p->func (p);
}
@ -510,13 +510,13 @@ loop (void *user_data)
}
static void
run_async_source (AppData *data)
run_async_source (struct data *data)
{
SpaResult res;
int res;
int err;
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Start);
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
printf ("got error %d\n", res);
}
@ -535,7 +535,7 @@ run_async_source (AppData *data)
}
{
SpaCommand cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
struct spa_command cmd = SPA_COMMAND_INIT (data->type.command_node.Pause);
if ((res = spa_node_send_command (data->source, &cmd)) < 0)
printf ("got error %d\n", res);
}
@ -544,8 +544,8 @@ run_async_source (AppData *data)
int
main (int argc, char *argv[])
{
AppData data = { 0 };
SpaResult res;
struct data data = { 0 };
int res;
const char *str;
data.use_buffer = true;
@ -556,7 +556,7 @@ main (int argc, char *argv[])
if ((str = getenv ("SPA_DEBUG")))
data.log->level = atoi (str);
data.data_loop.size = sizeof (SpaLoop);
data.data_loop.size = sizeof (struct spa_loop);
data.data_loop.add_source = do_add_source;
data.data_loop.update_source = do_update_source;
data.data_loop.remove_source = do_remove_source;