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 control properties to audiotestsrc

Browse source 
Add control properties to audiotestsrc for frequency and volume
and add a test program.
Add size parameter to set_io for additional checks and to make it
easy to know how much control data we can write.
This commit is contained in:
Wim Taymans 2017-11-22 14:30:04 +01:00
parent 8efea3e1ea
commit a092b9312a
28 changed files with 774 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -34,9 +34,13 @@ extern "C" {
#define SPA_TYPE_IO__Control SPA_TYPE_IO_BASE "Control"
#define SPA_TYPE_IO_CONTROL_BASE SPA_TYPE_IO__Control ":"
/** Base for controlable properties */
#define SPA_TYPE_IO__Prop SPA_TYPE_IO_BASE "Prop"
#define SPA_TYPE_IO_PROP_BASE SPA_TYPE_IO__Prop ":"
/** Base for controlable input properties */
#define SPA_TYPE_IO__InputProp SPA_TYPE_IO_BASE "InputProp"
#define SPA_TYPE_IO_INPUT_PROP_BASE SPA_TYPE_IO__InputProp ":"
/** Base for controlable output properties */
#define SPA_TYPE_IO__OutputProp SPA_TYPE_IO_BASE "OutputProp"
#define SPA_TYPE_IO_OUTPUT_PROP_BASE SPA_TYPE_IO__OutputProp ":"
/** An io area to exchange buffers with a port */
#define SPA_TYPE_IO__Buffers SPA_TYPE_IO_BASE "Buffers"
@ -72,6 +76,8 @@ struct spa_io_control_range {
struct spa_type_io {
uint32_t Buffers;
uint32_t ControlRange;
uint32_t InputProp;
uint32_t OutputProp;
};
static inline void spa_type_io_map(struct spa_type_map *map, struct spa_type_io *type)
@ -79,6 +85,8 @@ static inline void spa_type_io_map(struct spa_type_map *map, struct spa_type_io
if (type->Buffers == 0) {
type->Buffers = spa_type_map_get_id(map, SPA_TYPE_IO__Buffers);
type->ControlRange = spa_type_map_get_id(map, SPA_TYPE_IO_CONTROL__Range);
type->InputProp = spa_type_map_get_id(map, SPA_TYPE_IO__InputProp);
type->OutputProp = spa_type_map_get_id(map, SPA_TYPE_IO__OutputProp);
}
}

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

@ -432,16 +432,18 @@ struct spa_node {
* \param port_id a port id
* \param id the id of the io area, the available ids can be
* enumerated with the port parameters.
* \param io a io area memory
* \param data a io area memory
* \param size the size of \a data
* \return 0 on success
* -EINVAL when node is NULL the port is not valid
* -ENOENT when \id is unknown
* -EINVAL when invalid input is given
* -ENOENT when \a id is unknown
* -ENOSPC when \a size is too small
*/
int (*port_set_io) (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io);
void *data, size_t size);
/**
* Tell an output port to reuse a buffer.

7
spa/include/spa/param/io.h
View file

@ -31,15 +31,21 @@ extern "C" {
#define SPA_TYPE_PARAM__IO SPA_TYPE_PARAM_BASE "IO"
#define SPA_TYPE_PARAM_IO_BASE SPA_TYPE_PARAM__IO ":"
/** type ID of property, uniquely identifies the io area for a port */
#define SPA_TYPE_PARAM_IO__id SPA_TYPE_PARAM_IO_BASE "id"
/** size of the io area for a port */
#define SPA_TYPE_PARAM_IO__size SPA_TYPE_PARAM_IO_BASE "size"
/** associated property if any */
#define SPA_TYPE_PARAM_IO__propId SPA_TYPE_PARAM_IO_BASE "propId"
/** associated type of property if any */
#define SPA_TYPE_PARAM_IO__propType SPA_TYPE_PARAM_IO_BASE "propType"
struct spa_type_param_io {
uint32_t IO;
uint32_t id;
uint32_t size;
uint32_t propId;
uint32_t propType;
};
static inline void
@ -51,6 +57,7 @@ spa_type_param_io_map(struct spa_type_map *map,
type->id = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__id);
type->size = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__size);
type->propId = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__propId);
type->propType = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__propType);
}
}

6
spa/plugins/alsa/alsa-sink.c
View file

@ -521,7 +521,7 @@ impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct state *this;
struct type *t;
@ -534,9 +534,9 @@ impl_node_port_set_io(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
if (id == t->io.Buffers)
this->io = io;
this->io = data;
else if (id == t->io.ControlRange)
this->range = io;
this->range = data;
else
return -ENOENT;

4
spa/plugins/alsa/alsa-source.c
View file

@ -556,7 +556,7 @@ impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct state *this;
struct type *t;
@ -569,7 +569,7 @@ impl_node_port_set_io(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
if (id == t->io.Buffers)
this->io = io;
this->io = data;
else
return -ENOENT;

6
spa/plugins/audiomixer/audiomixer.c
View file

@ -630,7 +630,7 @@ impl_node_port_alloc_buffers(struct spa_node *node,
static int
impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, void *io)
uint32_t id, void *data, size_t size)
{
struct impl *this;
struct port *port;
@ -646,9 +646,9 @@ impl_node_port_set_io(struct spa_node *node,
port = GET_PORT(this, direction, port_id);
if (id == t->io.Buffers)
port->io = io;
port->io = data;
else if (id == t->io.ControlRange)
port->range = io;
port->range = data;
else
return -ENOENT;

82
spa/plugins/audiotestsrc/audiotestsrc.c
View file

@ -34,6 +34,7 @@
#include <spa/param/audio/format-utils.h>
#include <spa/param/buffers.h>
#include <spa/param/meta.h>
#include <spa/param/io.h>
#include <lib/pod.h>
@ -52,6 +53,9 @@ struct type {
uint32_t prop_wave;
uint32_t prop_freq;
uint32_t prop_volume;
uint32_t io_prop_wave;
uint32_t io_prop_freq;
uint32_t io_prop_volume;
uint32_t wave_sine;
uint32_t wave_square;
struct spa_type_io io;
@ -66,6 +70,7 @@ struct type {
struct spa_type_command_node command_node;
struct spa_type_param_buffers param_buffers;
struct spa_type_param_meta param_meta;
struct spa_type_param_io param_io;
};
static inline void init_type(struct type *type, struct spa_type_map *map)
@ -78,6 +83,9 @@ static inline void init_type(struct type *type, struct spa_type_map *map)
type->prop_wave = spa_type_map_get_id(map, SPA_TYPE_PROPS__waveType);
type->prop_freq = spa_type_map_get_id(map, SPA_TYPE_PROPS__frequency);
type->prop_volume = spa_type_map_get_id(map, SPA_TYPE_PROPS__volume);
type->io_prop_wave = spa_type_map_get_id(map, SPA_TYPE_IO_INPUT_PROP_BASE "waveType");
type->io_prop_freq = spa_type_map_get_id(map, SPA_TYPE_IO_INPUT_PROP_BASE "frequency");
type->io_prop_volume = spa_type_map_get_id(map, SPA_TYPE_IO_INPUT_PROP_BASE "volume");
type->wave_sine = spa_type_map_get_id(map, SPA_TYPE_PROPS__waveType ":sine");
type->wave_square = spa_type_map_get_id(map, SPA_TYPE_PROPS__waveType ":square");
spa_type_io_map(map, &type->io);
@ -92,6 +100,7 @@ static inline void init_type(struct type *type, struct spa_type_map *map)
spa_type_command_node_map(map, &type->command_node);
spa_type_param_buffers_map(map, &type->param_buffers);
spa_type_param_meta_map(map, &type->param_meta);
spa_type_param_io_map(map, &type->param_io);
}
struct props {
@ -136,7 +145,11 @@ struct impl {
struct spa_port_info info;
struct spa_io_buffers *io;
struct spa_io_control_range *range;
struct spa_io_control_range *io_range;
uint32_t *io_wave;
double *io_freq;
double *io_volume;
bool have_format;
struct spa_audio_info current_format;
@ -300,7 +313,7 @@ static int make_buffer(struct impl *this)
{
struct buffer *b;
struct spa_io_buffers *io = this->io;
struct spa_io_control_range *range = this->range;
struct spa_io_control_range *range = this->io_range;
int n_bytes, n_samples;
uint32_t maxsize;
void *data;
@ -599,7 +612,8 @@ impl_node_port_enum_params(struct spa_node *node,
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
t->param.idBuffers,
t->param.idMeta };
t->param.idMeta,
t->param.idIO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b, id, t->param.List,
@ -646,6 +660,52 @@ impl_node_port_enum_params(struct spa_node *node,
return 0;
}
}
else if (id == t->param.idIO) {
struct props *p = &this->props;
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
id, t->param_io.IO,
":", t->param_io.id, "I", t->io.Buffers,
":", t->param_io.size, "i", sizeof(struct spa_io_buffers));
break;
case 1:
param = spa_pod_builder_object(&b,
id, t->param_io.IO,
":", t->param_io.id, "I", t->io.ControlRange,
":", t->param_io.size, "i", sizeof(struct spa_io_control_range));
break;
case 2:
param = spa_pod_builder_object(&b,
id, t->param_io.IO,
":", t->param_io.id, "I", t->io_prop_wave,
":", t->param_io.size, "i", sizeof(uint32_t),
":", t->param_io.propId, "I", t->prop_wave,
":", t->param_io.propType, "Ie", p->wave,
2, t->wave_sine,
t->wave_square);
break;
case 3:
param = spa_pod_builder_object(&b,
id, t->param_io.IO,
":", t->param_io.id, "I", t->io_prop_freq,
":", t->param_io.size, "i", sizeof(double),
":", t->param_io.propId, "I", t->prop_freq,
":", t->param_io.propType, "dr", p->freq, 2, 0.0, 50000000.0);
break;
case 4:
param = spa_pod_builder_object(&b,
id, t->param_io.IO,
":", t->param_io.id, "I", t->io_prop_volume,
":", t->param_io.size, "i", sizeof(double),
":", t->param_io.propId, "I", t->prop_volume,
":", t->param_io.propType, "dr", p->volume, 2, 0.0, 10.0);
break;
default:
return 0;
}
}
else
return -ENOENT;
@ -814,7 +874,7 @@ impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct impl *this;
struct type *t;
@ -827,9 +887,15 @@ impl_node_port_set_io(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
if (id == t->io.Buffers)
this->io = io;
this->io = data;
else if (id == t->io.ControlRange)
this->range = io;
this->io_range = data;
else if (id == t->io_prop_wave)
this->io_wave = data;
else if (id == t->io_prop_freq)
this->io_freq = data;
else if (id == t->io_prop_volume)
this->io_volume = data;
else
return -ENOENT;
@ -1053,6 +1119,10 @@ impl_init(const struct spa_handle_factory *factory,
this->clock = impl_clock;
reset_props(this, &this->props);
this->io_wave = &this->props.wave;
this->io_freq = &this->props.freq;
this->io_volume = &this->props.volume;
spa_list_init(&this->empty);
this->timer_source.func = on_output;

6
spa/plugins/audiotestsrc/render.c
View file

@ -27,10 +27,12 @@ audio_test_src_create_sine_##type (struct impl *this, type *samples, size_t n_sa
{ \
int i, c, channels; \
double step, amp; \
double freq = *this->io_freq; \
double volume = *this->io_volume; \
\
channels = this->current_format.info.raw.channels; \
step = M_PI_M2 * this->props.freq / this->current_format.info.raw.rate; \
amp = this->props.volume * scale; \
step = M_PI_M2 * freq / this->current_format.info.raw.rate; \
amp = volume * scale; \
\
for (i = 0; i < n_samples; i++) { \
type val; \

4
spa/plugins/ffmpeg/ffmpeg-dec.c
View file

@ -412,7 +412,7 @@ spa_ffmpeg_dec_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct impl *this;
struct port *port;
@ -430,7 +430,7 @@ spa_ffmpeg_dec_node_port_set_io(struct spa_node *node,
port = GET_PORT(this, direction, port_id);
if (id == t->io.Buffers)
port->io = io;
port->io = data;
else
return -ENOENT;

4
spa/plugins/ffmpeg/ffmpeg-enc.c
View file

@ -397,7 +397,7 @@ spa_ffmpeg_enc_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct impl *this;
struct port *port;
@ -415,7 +415,7 @@ spa_ffmpeg_enc_node_port_set_io(struct spa_node *node,
port = GET_PORT(this, direction, port_id);
if (id == t->io.Buffers)
port->io = io;
port->io = data;
else
return -ENOENT;

4
spa/plugins/test/fakesink.c
View file

@ -669,7 +669,7 @@ impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct impl *this;
struct type *t;
@ -682,7 +682,7 @@ impl_node_port_set_io(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
if (id == t->io.Buffers)
this->io = io;
this->io = data;
else
return -ENOENT;

4
spa/plugins/test/fakesrc.c
View file

@ -686,7 +686,7 @@ impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct impl *this;
struct type *t;
@ -699,7 +699,7 @@ impl_node_port_set_io(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
if (id == t->io.Buffers)
this->io = io;
this->io = data;
else
return -ENOENT;

4
spa/plugins/v4l2/v4l2-source.c
View file

@ -763,7 +763,7 @@ static int impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct impl *this;
struct type *t;
@ -776,7 +776,7 @@ static int impl_node_port_set_io(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
if (id == t->io.Buffers)
this->out_ports[port_id].io = io;
this->out_ports[port_id].io = data;
else
return -ENOENT;

4
spa/plugins/videotestsrc/videotestsrc.c
View file

@ -757,7 +757,7 @@ impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct impl *this;
struct type *t;
@ -770,7 +770,7 @@ impl_node_port_set_io(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
if (id == t->io.Buffers)
this->io = io;
this->io = data;
else
return -ENOENT;

6
spa/plugins/volume/volume.c
View file

@ -634,7 +634,7 @@ impl_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct impl *this;
struct port *port;
@ -650,9 +650,9 @@ impl_node_port_set_io(struct spa_node *node,
port = GET_PORT(this, direction, port_id);
if (id == t->io.Buffers)
port->io = io;
port->io = data;
else if (id == t->io.ControlRange)
port->range = io;
port->range = data;
else
return -ENOENT;

5
spa/tests/meson.build
View file

@ -55,3 +55,8 @@ executable('test-props5', 'test-props5.c',
dependencies : [],
link_with : spalib,
install : false)
executable('test-control', 'test-control.c',
include_directories : [spa_inc, spa_libinc ],
dependencies : [dl_lib, pthread_lib, libm],
link_with : spalib,
install : false)

600
spa/tests/test-control.c Normal file
View file

@ -0,0 +1,600 @@
/* Spa
* Copyright (C) 2017 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <math.h>
#include <error.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#include <errno.h>
#include <pthread.h>
#include <poll.h>
#include <spa/support/log-impl.h>
#include <spa/support/loop.h>
#include <spa/support/type-map-impl.h>
#include <spa/node/node.h>
#include <spa/node/io.h>
#include <spa/param/param.h>
#include <spa/param/props.h>
#include <spa/param/audio/format-utils.h>
#include <spa/param/format-utils.h>
#include <spa/param/io.h>
#define M_PI_M2 ( M_PI + M_PI )
static SPA_TYPE_MAP_IMPL(default_map, 4096);
static SPA_LOG_IMPL(default_log);
#define spa_debug(f,...) spa_log_trace(&default_log.log, f, __VA_ARGS__)
#include <spa/graph/graph.h>
#include <spa/graph/graph-scheduler6.h>
#include <lib/debug.h>
struct type {
uint32_t node;
uint32_t props;
uint32_t format;
uint32_t props_device;
uint32_t props_freq;
uint32_t props_volume;
uint32_t props_min_latency;
uint32_t props_live;
struct spa_type_io io;
struct spa_type_param param;
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;
struct spa_type_param_io param_io;
};
static inline void 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);
type->format = spa_type_map_get_id(map, SPA_TYPE__Format);
type->props_device = spa_type_map_get_id(map, SPA_TYPE_PROPS__device);
type->props_freq = spa_type_map_get_id(map, SPA_TYPE_PROPS__frequency);
type->props_volume = spa_type_map_get_id(map, SPA_TYPE_PROPS__volume);
type->props_min_latency = spa_type_map_get_id(map, SPA_TYPE_PROPS__minLatency);
type->props_live = spa_type_map_get_id(map, SPA_TYPE_PROPS__live);
spa_type_io_map(map, &type->io);
spa_type_param_map(map, &type->param);
spa_type_meta_map(map, &type->meta);
spa_type_data_map(map, &type->data);
spa_type_media_type_map(map, &type->media_type);
spa_type_media_subtype_map(map, &type->media_subtype);
spa_type_format_audio_map(map, &type->format_audio);
spa_type_audio_format_map(map, &type->audio_format);
spa_type_event_node_map(map, &type->event_node);
spa_type_command_node_map(map, &type->command_node);
spa_type_param_io_map(map, &type->param_io);
}
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];
};
struct data {
struct spa_type_map *map;
struct spa_log *log;
struct spa_loop data_loop;
struct type type;
struct spa_support support[4];
uint32_t n_support;
struct spa_graph graph;
struct spa_graph_data graph_data;
struct spa_graph_node source_node;
struct spa_graph_port source_out;
struct spa_graph_port sink_in;
struct spa_graph_node sink_node;
struct spa_node *sink;
struct spa_node *source;
struct spa_io_buffers source_sink_io[1];
struct spa_buffer *source_buffers[1];
struct buffer source_buffer[1];
double ctrl_source_freq;
double freq_accum;
double ctrl_source_volume;
double volume_accum;
bool running;
pthread_t thread;
struct spa_source sources[16];
unsigned int n_sources;
bool rebuild_fds;
struct pollfd fds[16];
unsigned int n_fds;
};
#define MIN_LATENCY 64
#define BUFFER_SIZE MIN_LATENCY
static void
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++) {
struct buffer *b = &ba[i];
bufs[i] = &b->buffer;
b->buffer.id = i;
b->buffer.metas = b->metas;
b->buffer.n_metas = 1;
b->buffer.datas = b->datas;
b->buffer.n_datas = 1;
b->header.flags = 0;
b->header.seq = 0;
b->header.pts = 0;
b->header.dts_offset = 0;
b->metas[0].type = data->type.meta.Header;
b->metas[0].data = &b->header;
b->metas[0].size = sizeof(b->header);
b->datas[0].type = data->type.data.MemPtr;
b->datas[0].flags = 0;
b->datas[0].fd = -1;
b->datas[0].mapoffset = 0;
b->datas[0].maxsize = size;
b->datas[0].data = malloc(size);
b->datas[0].chunk = &b->chunks[0];
b->datas[0].chunk->offset = 0;
b->datas[0].chunk->size = 0;
b->datas[0].chunk->stride = 0;
}
}
static int make_node(struct data *data, struct spa_node **node, const char *lib, const char *name)
{
struct spa_handle *handle;
int res;
void *hnd;
spa_handle_factory_enum_func_t enum_func;
uint32_t i;
if ((hnd = dlopen(lib, RTLD_NOW)) == NULL) {
printf("can't load %s: %s\n", lib, dlerror());
return -errno;
}
if ((enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME)) == NULL) {
printf("can't find enum function\n");
return -errno;
}
for (i = 0;;) {
const struct spa_handle_factory *factory;
void *iface;
if ((res = enum_func(&factory, &i)) <= 0) {
if (res != 0)
printf("can't enumerate factories: %s\n", spa_strerror(res));
break;
}
if (strcmp(factory->name, name))
continue;
handle = calloc(1, factory->size);
if ((res =
spa_handle_factory_init(factory, handle, NULL, data->support,
data->n_support)) < 0) {
printf("can't make factory instance: %d\n", res);
return res;
}
if ((res = spa_handle_get_interface(handle, data->type.node, &iface)) < 0) {
printf("can't get interface %d\n", res);
return res;
}
*node = iface;
return 0;
}
return -EBADF;
}
static void on_sink_done(void *data, int seq, int res)
{
printf("got done %d %d\n", seq, res);
}
static void on_sink_event(void *data, struct spa_event *event)
{
printf("got event %d\n", SPA_EVENT_TYPE(event));
}
static void update_props(struct data *data)
{
data->ctrl_source_freq = ((sin(data->freq_accum) + 1.0) * 200.0) + 440.0;
data->freq_accum += M_PI_M2 / 880.0;
if (data->freq_accum >= M_PI_M2)
data->freq_accum -= M_PI_M2;
data->ctrl_source_volume = (sin(data->volume_accum) / 2.0) + 0.5;
data->volume_accum += M_PI_M2 / 2000.0;
if (data->volume_accum >= M_PI_M2)
data->volume_accum -= M_PI_M2;
}
static void on_sink_need_input(void *_data)
{
struct data *data = _data;
update_props(data);
spa_graph_need_input(&data->graph, &data->sink_node);
}
static void
on_sink_reuse_buffer(void *_data, uint32_t port_id, uint32_t buffer_id)
{
struct data *data = _data;
data->source_sink_io[0].buffer_id = buffer_id;
}
static const struct spa_node_callbacks sink_callbacks = {
SPA_VERSION_NODE_CALLBACKS,
.done = on_sink_done,
.event = on_sink_event,
.need_input = on_sink_need_input,
.reuse_buffer = on_sink_reuse_buffer
};
static int do_add_source(struct spa_loop *loop, struct spa_source *source)
{
struct data *data = SPA_CONTAINER_OF(loop, struct data, data_loop);
data->sources[data->n_sources] = *source;
data->n_sources++;
data->rebuild_fds = true;
return 0;
}
static int do_update_source(struct spa_source *source)
{
return 0;
}
static void do_remove_source(struct spa_source *source)
{
}
static int
do_invoke(struct spa_loop *loop,
spa_invoke_func_t func, uint32_t seq, const void *data, size_t size, bool block, void *user_data)
{
return func(loop, false, seq, data, size, user_data);
}
static int make_nodes(struct data *data, const char *device)
{
int res;
struct spa_pod *props;
struct spa_pod_builder b = { 0 };
uint8_t buffer[512];
uint32_t idx;
if ((res = make_node(data, &data->sink,
"build/spa/plugins/alsa/libspa-alsa.so", "alsa-sink")) < 0) {
printf("can't create alsa-sink: %d\n", res);
return res;
}
spa_node_set_callbacks(data->sink, &sink_callbacks, data);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
0, data->type.props,
":", data->type.props_device, "s", device ? device : "hw:0",
":", data->type.props_min_latency, "i", MIN_LATENCY);
spa_debug_pod(props, 0);
if ((res = spa_node_set_param(data->sink, data->type.param.idProps, 0, props)) < 0)
printf("got set_props error %d\n", res);
if ((res = make_node(data, &data->source,
"build/spa/plugins/audiotestsrc/libspa-audiotestsrc.so",
"audiotestsrc")) < 0) {
printf("can't create audiotestsrc: %d\n", res);
return res;
}
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
0, data->type.props,
":", data->type.props_freq, "d", 600.0,
":", data->type.props_volume, "d", 0.5,
":", data->type.props_live, "b", false);
data->ctrl_source_freq = 600.0;
if ((res = spa_node_set_param(data->source, data->type.param.idProps, 0, props)) < 0)
printf("got set_props error %d\n", res);
for (idx = 0;;) {
struct spa_pod *param;
uint32_t id = 0, propId = 0;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if ((res = spa_node_port_enum_params(data->source, SPA_DIRECTION_OUTPUT, 0,
data->type.param.idIO, &idx, NULL, &param, &b)) < 1) {
if (res < 0)
error(0, -res, "port_enum_params");
break;
}
spa_pod_object_parse(param,
":", data->type.param_io.id, "I", &id,
":", data->type.param_io.propId, "?I", &propId,
NULL);
if (propId == data->type.props_freq) {
spa_node_port_set_io(data->source,
SPA_DIRECTION_OUTPUT, 0,
id,
&data->ctrl_source_freq, sizeof(data->ctrl_source_freq));
}
else if (propId == data->type.props_volume) {
spa_node_port_set_io(data->source,
SPA_DIRECTION_OUTPUT, 0,
id,
&data->ctrl_source_volume, sizeof(data->ctrl_source_volume));
}
}
data->source_sink_io[0] = SPA_IO_BUFFERS_INIT;
spa_node_port_set_io(data->source,
SPA_DIRECTION_OUTPUT, 0,
data->type.io.Buffers,
&data->source_sink_io[0], sizeof(data->source_sink_io[0]));
spa_node_port_set_io(data->sink,
SPA_DIRECTION_INPUT, 0,
data->type.io.Buffers,
&data->source_sink_io[0], sizeof(data->source_sink_io[0]));
spa_graph_node_init(&data->source_node);
spa_graph_node_set_implementation(&data->source_node, data->source);
spa_graph_node_add(&data->graph, &data->source_node);
spa_graph_port_init(&data->source_out, SPA_DIRECTION_OUTPUT, 0, 0, &data->source_sink_io[0]);
spa_graph_port_add(&data->source_node, &data->source_out);
spa_graph_node_init(&data->sink_node);
spa_graph_node_set_implementation(&data->sink_node, data->sink);
spa_graph_node_add(&data->graph, &data->sink_node);
spa_graph_port_init(&data->sink_in, SPA_DIRECTION_INPUT, 0, 0, &data->source_sink_io[0]);
spa_graph_port_add(&data->sink_node, &data->sink_in);
spa_graph_port_link(&data->source_out, &data->sink_in);
return res;
}
static int negotiate_formats(struct data *data)
{
int res;
struct spa_pod *format, *filter;
uint32_t state = 0;
struct spa_pod_builder b = { 0 };
uint8_t buffer[4096];
spa_pod_builder_init(&b, buffer, sizeof(buffer));
filter = spa_pod_builder_object(&b,
0, data->type.format,
"I", data->type.media_type.audio,
"I", data->type.media_subtype.raw,
":", data->type.format_audio.format, "I", data->type.audio_format.S16,
":", data->type.format_audio.layout, "i", SPA_AUDIO_LAYOUT_INTERLEAVED,
":", data->type.format_audio.rate, "i", 44100,
":", data->type.format_audio.channels, "i", 2);
spa_debug_pod(filter, 0);
spa_log_debug(&default_log.log, "enum_params");
if ((res = spa_node_port_enum_params(data->sink,
SPA_DIRECTION_INPUT, 0,
data->type.param.idEnumFormat, &state,
filter, &format, &b)) <= 0)
return -EBADF;
spa_debug_pod(format, 0);
spa_log_debug(&default_log.log, "sink set_param");
if ((res = spa_node_port_set_param(data->sink,
SPA_DIRECTION_INPUT, 0,
data->type.param.idFormat, 0, format)) < 0)
return res;
if ((res = spa_node_port_set_param(data->source,
SPA_DIRECTION_OUTPUT, 0,
data->type.param.idFormat, 0, format)) < 0)
return res;
init_buffer(data, data->source_buffers, data->source_buffer, 1, BUFFER_SIZE);
if ((res =
spa_node_port_use_buffers(data->sink, SPA_DIRECTION_INPUT, 0, data->source_buffers,
1)) < 0)
return res;
if ((res =
spa_node_port_use_buffers(data->source, SPA_DIRECTION_OUTPUT, 0, data->source_buffers,
1)) < 0)
return res;
return 0;
}
static void *loop(void *user_data)
{
struct data *data = user_data;
printf("enter thread %d\n", data->n_sources);
while (data->running) {
int i, r;
/* rebuild */
if (data->rebuild_fds) {
for (i = 0; i < data->n_sources; i++) {
struct spa_source *p = &data->sources[i];
data->fds[i].fd = p->fd;
data->fds[i].events = p->mask;
}
data->n_fds = data->n_sources;
data->rebuild_fds = false;
}
r = poll(data->fds, data->n_fds, -1);
if (r < 0) {
if (errno == EINTR)
continue;
break;
}
if (r == 0) {
fprintf(stderr, "select timeout");
break;
}
/* after */
for (i = 0; i < data->n_sources; i++) {
struct spa_source *p = &data->sources[i];
p->rmask = 0;
if (data->fds[i].revents & POLLIN)
p->rmask |= SPA_IO_IN;
if (data->fds[i].revents & POLLOUT)
p->rmask |= SPA_IO_OUT;
if (data->fds[i].revents & POLLHUP)
p->rmask |= SPA_IO_HUP;
if (data->fds[i].revents & POLLERR)
p->rmask |= SPA_IO_ERR;
}
for (i = 0; i < data->n_sources; i++) {
struct spa_source *p = &data->sources[i];
if (p->rmask)
p->func(p);
}
}
printf("leave thread\n");
return NULL;
}
static void run_async_sink(struct data *data)
{
int res;
int err;
{
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)
printf("got sink error %d\n", res);
}
data->running = true;
if ((err = pthread_create(&data->thread, NULL, loop, data)) != 0) {
printf("can't create thread: %d %s", err, strerror(err));
data->running = false;
}
printf("sleeping for 1000 seconds\n");
sleep(1000);
if (data->running) {
data->running = false;
pthread_join(data->thread, NULL);
}
{
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)
printf("got source error %d\n", res);
}
}
int main(int argc, char *argv[])
{
struct data data = { NULL };
int res;
const char *str;
spa_graph_init(&data.graph);
spa_graph_data_init(&data.graph_data, &data.graph);
spa_graph_set_callbacks(&data.graph, &spa_graph_impl_default, &data.graph_data);
data.map = &default_map.map;
data.log = &default_log.log;
data.data_loop.version = SPA_VERSION_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;
data.data_loop.invoke = do_invoke;
spa_debug_set_type_map(data.map);
if ((str = getenv("SPA_DEBUG")))
data.log->level = atoi(str);
data.support[0].type = SPA_TYPE__TypeMap;
data.support[0].data = data.map;
data.support[1].type = SPA_TYPE__Log;
data.support[1].data = data.log;
data.support[2].type = SPA_TYPE_LOOP__DataLoop;
data.support[2].data = &data.data_loop;
data.support[3].type = SPA_TYPE_LOOP__MainLoop;
data.support[3].data = &data.data_loop;
data.n_support = 4;
init_type(&data.type, data.map);
if ((res = make_nodes(&data, argc > 1 ? argv[1] : NULL)) < 0) {
printf("can't make nodes: %d\n", res);
return -1;
}
if ((res = negotiate_formats(&data)) < 0) {
printf("can't negotiate nodes: %d\n", res);
return -1;
}
run_async_sink(&data);
}

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

@ -338,16 +338,20 @@ static int make_nodes(struct data *data, const char *device)
spa_node_port_set_io(data->source,
SPA_DIRECTION_OUTPUT, 0,
data->type.io.Buffers, &data->source_volume_io[0]);
data->type.io.Buffers,
&data->source_volume_io[0], sizeof(data->source_volume_io[0]));
spa_node_port_set_io(data->volume,
SPA_DIRECTION_INPUT, 0,
data->type.io.Buffers, &data->source_volume_io[0]);
data->type.io.Buffers,
&data->source_volume_io[0], sizeof(data->source_volume_io[0]));
spa_node_port_set_io(data->volume,
SPA_DIRECTION_OUTPUT, 0,
data->type.io.Buffers, &data->volume_sink_io[0]);
data->type.io.Buffers,
&data->volume_sink_io[0], sizeof(data->volume_sink_io[0]));
spa_node_port_set_io(data->sink,
SPA_DIRECTION_INPUT, 0,
data->type.io.Buffers, &data->volume_sink_io[0]);
data->type.io.Buffers,
&data->volume_sink_io[0], sizeof(data->volume_sink_io[0]));
spa_graph_node_init(&data->source_node);
spa_graph_node_set_implementation(&data->source_node, data->source);

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

@ -407,22 +407,28 @@ static int make_nodes(struct data *data, const char *device)
spa_node_port_set_io(data->source1,
SPA_DIRECTION_OUTPUT, 0,
data->type.io.Buffers, &data->source1_mix_io[0]);
data->type.io.Buffers,
&data->source1_mix_io[0], sizeof(data->source1_mix_io[0]));
spa_node_port_set_io(data->source2,
SPA_DIRECTION_OUTPUT, 0,
data->type.io.Buffers, &data->source2_mix_io[0]);
data->type.io.Buffers,
&data->source2_mix_io[0], sizeof(data->source2_mix_io[0]));
spa_node_port_set_io(data->mix,
SPA_DIRECTION_INPUT, 0,
data->type.io.Buffers, &data->source1_mix_io[0]);
data->type.io.Buffers,
&data->source1_mix_io[0], sizeof(data->source1_mix_io[0]));
spa_node_port_set_io(data->mix,
SPA_DIRECTION_INPUT, 1,
data->type.io.Buffers, &data->source2_mix_io[0]);
data->type.io.Buffers,
&data->source2_mix_io[0], sizeof(data->source2_mix_io[0]));
spa_node_port_set_io(data->mix,
SPA_DIRECTION_OUTPUT, 0,
data->type.io.Buffers, &data->mix_sink_io[0]);
data->type.io.Buffers,
&data->mix_sink_io[0], sizeof(data->mix_sink_io[0]));
spa_node_port_set_io(data->sink,
SPA_DIRECTION_INPUT, 0,
data->type.io.Buffers, &data->mix_sink_io[0]);
data->type.io.Buffers,
&data->mix_sink_io[0], sizeof(data->mix_sink_io[0]));
#ifdef USE_GRAPH
spa_graph_node_init(&data->source1_node);

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

@ -366,10 +366,12 @@ static int make_nodes(struct data *data)
spa_node_port_set_io(data->source,
SPA_DIRECTION_OUTPUT, 0,
data->type.io.Buffers, &data->source_sink_io[0]);
data->type.io.Buffers,
&data->source_sink_io[0], sizeof(data->source_sink_io[0]));
spa_node_port_set_io(data->sink,
SPA_DIRECTION_INPUT, 0,
data->type.io.Buffers, &data->source_sink_io[0]);
data->type.io.Buffers,
&data->source_sink_io[0], sizeof(data->source_sink_io[0]));
spa_graph_node_init(&data->source_node);
spa_graph_node_set_implementation(&data->source_node, data->source);

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

@ -346,10 +346,12 @@ static int negotiate_formats(struct data *data)
spa_node_port_set_io(data->source,
SPA_DIRECTION_OUTPUT, 0,
data->type.io.Buffers, &data->source_sink_io[0]);
data->type.io.Buffers,
&data->source_sink_io[0], sizeof(data->source_sink_io[0]));
spa_node_port_set_io(data->sink,
SPA_DIRECTION_INPUT, 0,
data->type.io.Buffers, &data->source_sink_io[0]);
data->type.io.Buffers,
&data->source_sink_io[0], sizeof(data->source_sink_io[0]));
if ((res = spa_node_port_set_param(data->source,
SPA_DIRECTION_OUTPUT, 0,

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

@ -427,7 +427,8 @@ static int negotiate_formats(struct data *data)
if ((res =
spa_node_port_set_io(data->source,
SPA_DIRECTION_OUTPUT, 0,
data->type.io.Buffers, &data->source_output[0])) < 0)
data->type.io.Buffers,
&data->source_output[0], sizeof(data->source_output[0]))) < 0)
return res;
format = spa_pod_builder_object(&b,

4
src/examples/export-sink.c
View file

@ -217,12 +217,12 @@ static int impl_get_port_ids(struct spa_node *node,
static int impl_port_set_io(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, void *io)
uint32_t id, void *data, size_t size)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (id == d->t->io.Buffers)
d->io = io;
d->io = data;
else
return -ENOENT;

4
src/examples/export-source.c
View file

@ -132,12 +132,12 @@ static int impl_get_port_ids(struct spa_node *node,
}
static int impl_port_set_io(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
uint32_t id, void *io)
uint32_t id, void *data, size_t size)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (id == d->t->io.Buffers)
d->io = io;
d->io = data;
else
return -ENOENT;

4
src/examples/local-v4l2.c
View file

@ -211,12 +211,12 @@ static int impl_get_port_ids(struct spa_node *node,
}
static int impl_port_set_io(struct spa_node *node, enum spa_direction direction, uint32_t port_id,
uint32_t id, void *io)
uint32_t id, void *data, size_t size)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
if (id == d->t->io.Buffers)
d->io = io;
d->io = data;
else
return -ENOENT;

4
src/modules/module-client-node/client-node.c
View file

@ -514,7 +514,7 @@ spa_proxy_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t id,
void *io)
void *data, size_t size)
{
struct proxy *this;
struct proxy_port *port;
@ -532,7 +532,7 @@ spa_proxy_node_port_set_io(struct spa_node *node,
port = GET_PORT(this, direction, port_id);
if (id == t->io.Buffers)
port->io = io;
port->io = data;
else
return -ENOENT;

4
src/modules/module-jack/jack-node.c
View file

@ -374,14 +374,14 @@ static int node_process_output(struct spa_node *node)
static int port_set_io(struct spa_node *node,
enum spa_direction direction, uint32_t port_id,
uint32_t id, void *io)
uint32_t id, void *data, size_t size)
{
struct node_data *nd = SPA_CONTAINER_OF(node, struct node_data, node_impl);
struct port_data *pd = nd->port_data[direction][port_id];
struct type *t = &pd->node->type;
if (id == t->io.Buffers)
pd->io = io;
pd->io = data;
else
return -ENOENT;

3
src/pipewire/port.c
View file

@ -289,7 +289,8 @@ bool pw_port_add(struct pw_port *port, struct pw_node *node)
spa_node_port_set_io(node->node,
port->direction, port_id,
node->core->type.io.Buffers, port->rt.port.io);
node->core->type.io.Buffers,
port->rt.port.io, sizeof(*port->rt.port.io));
port->rt.graph = node->rt.graph;
pw_loop_invoke(node->data_loop, do_add_port, SPA_ID_INVALID, NULL, 0, false, port);