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

stream: remove conversion

Browse source 
Improve audioconvert to also split the output.
Remove the format conversion from the stream and move into the
server client-stream.
This commit is contained in:
Wim Taymans 2018-06-15 11:31:42 +02:00
parent acfd07c504
commit 4ac21aea53
6 changed files with 478 additions and 514 deletions
Download patch file Download diff file Expand all files Collapse all files

363
spa/plugins/audioconvert/audioconvert.c
View file

@ -38,6 +38,7 @@
#define NAME "audioconvert"
#define MAX_BUFFERS 32
#define MAX_PORTS 128
#define PROP_DEFAULT_TRUNCATE false
#define PROP_DEFAULT_DITHER 0
@ -99,17 +100,6 @@ struct buffer {
struct spa_meta_header *h;
};
struct port {
uint32_t id;
struct spa_io_buffers *io;
bool have_format;
struct spa_audio_info format;
struct spa_node *node;
};
struct link {
struct spa_node *out_node;
uint32_t out_port;
@ -137,30 +127,22 @@ struct impl {
const struct spa_node_callbacks *callbacks;
void *user_data;
struct port in_port;
struct port out_port;
int n_links;
struct link links[8];
int n_nodes;
struct spa_node *nodes[8];
bool started;
struct spa_handle *hnd_fmt_in;
struct spa_handle *hnd_fmt[2];
struct spa_handle *hnd_channelmix;
struct spa_handle *hnd_resample;
struct spa_handle *hnd_fmt_out;
struct spa_node *fmt_in;
struct spa_node *fmt[2];
struct spa_node *channelmix;
struct spa_node *resample;
struct spa_node *fmt_out;
};
#define CHECK_PORT(this,d,id) (id == 0)
#define GET_IN_PORT(this,id) (&this->in_port)
#define GET_OUT_PORT(this,id) (&this->out_port)
#define GET_PORT(this,d,id) (d == SPA_DIRECTION_INPUT ? GET_IN_PORT(this,id) : GET_OUT_PORT(this,id))
static int make_link(struct impl *this,
struct spa_node *out_node, uint32_t out_port,
struct spa_node *in_node, uint32_t in_port,
@ -219,6 +201,42 @@ static void clean_link(struct impl *this, struct link *link)
link->buffers = NULL;
}
static int debug_params(struct impl *this, struct spa_node *node,
enum spa_direction direction, uint32_t port_id, uint32_t id, struct spa_pod *filter)
{
struct type *t = &this->type;
struct spa_pod_builder b = { 0 };
uint8_t buffer[4096];
uint32_t state, flag;
struct spa_pod *format;
int res;
flag = 0;
if (id == t->param.idEnumFormat)
flag |= SPA_DEBUG_FLAG_FORMAT;
spa_log_error(this->log, "formats:");
state = 0;
while (true) {
spa_pod_builder_init(&b, buffer, sizeof(buffer));
res = spa_node_port_enum_params(node,
direction, port_id,
id, &state,
NULL, &format, &b);
if (res <= 0)
break;
spa_debug_pod(format, flag);
}
spa_log_error(this->log, "failed filter:");
if (filter)
spa_debug_pod(filter, flag);
return 0;
}
static int negotiate_link_format(struct impl *this, struct link *link)
{
struct type *t = &this->type;
@ -250,8 +268,11 @@ static int negotiate_link_format(struct impl *this, struct link *link)
if ((res = spa_node_port_enum_params(link->out_node,
SPA_DIRECTION_OUTPUT, link->out_port,
t->param.idEnumFormat, &state,
filter, &format, &b)) <= 0)
filter, &format, &b)) <= 0) {
debug_params(this, link->out_node, SPA_DIRECTION_OUTPUT, link->out_port,
t->param.idEnumFormat, filter);
return -ENOTSUP;
}
filter = format;
}
@ -260,13 +281,16 @@ static int negotiate_link_format(struct impl *this, struct link *link)
if ((res = spa_node_port_enum_params(link->in_node,
SPA_DIRECTION_INPUT, link->in_port,
t->param.idEnumFormat, &state,
filter, &format, &b)) <= 0)
filter, &format, &b)) <= 0) {
debug_params(this, link->in_node, SPA_DIRECTION_INPUT, link->in_port,
t->param.idEnumFormat, filter);
return -ENOTSUP;
}
filter = format;
}
spa_pod_fixate(filter);
spa_debug_pod(filter, SPA_DEBUG_FLAG_FORMAT);
if (link->out_node != NULL) {
if ((res = spa_node_port_set_param(link->out_node,
@ -289,53 +313,34 @@ static int negotiate_link_format(struct impl *this, struct link *link)
static int setup_convert(struct impl *this)
{
struct port *inport, *outport;
struct spa_node *prev = NULL;
int i, j, res;
struct type *t = &this->type;
inport = GET_PORT(this, SPA_DIRECTION_INPUT, 0);
outport = GET_PORT(this, SPA_DIRECTION_OUTPUT, 0);
struct spa_audio_info informat, outformat;
spa_log_info(this->log, NAME " %p: %d/%d@%d.%d->%d/%d@%d.%d", this,
inport->format.info.raw.format,
inport->format.info.raw.channels,
inport->format.info.raw.rate,
inport->format.info.raw.layout,
outport->format.info.raw.format,
outport->format.info.raw.channels,
outport->format.info.raw.rate,
outport->format.info.raw.layout);
informat.info.raw.format,
informat.info.raw.channels,
informat.info.raw.rate,
informat.info.raw.layout,
outformat.info.raw.format,
outformat.info.raw.channels,
outformat.info.raw.rate,
outformat.info.raw.layout);
if (this->n_links > 0)
return 0;
this->n_nodes = 0;
/* unpack */
make_link(this, NULL, 0, this->fmt_in, 0, &inport->format);
prev = this->fmt_in;
this->nodes[this->n_nodes++] = this->fmt[SPA_DIRECTION_INPUT];
/* down mix */
if (inport->format.info.raw.channels > outport->format.info.raw.channels) {
make_link(this, prev, 0, this->channelmix, 0, NULL);
prev = this->channelmix;
}
this->nodes[this->n_nodes++] = this->channelmix;
/* resample */
if (inport->format.info.raw.rate != outport->format.info.raw.rate) {
make_link(this, prev, 0, this->resample, 0, NULL);
prev = this->resample;
}
/* up mix */
if (inport->format.info.raw.channels < outport->format.info.raw.channels) {
make_link(this, prev, 0, this->channelmix, 0, NULL);
prev = this->channelmix;
}
make_link(this, prev, 0, this->fmt_out, 0, NULL);
this->nodes[this->n_nodes++] = this->resample;
/* pack */
make_link(this, this->fmt_out, 0, NULL, 0, &outport->format);
this->nodes[this->n_nodes++] = this->fmt[SPA_DIRECTION_OUTPUT];
for (i = 0; i < this->n_nodes - 1; i++)
make_link(this, this->nodes[i], 0, this->nodes[i+1], 0, NULL);
for (i = 0, j = this->n_links - 1; j >= i; i++, j--) {
if ((res = negotiate_link_format(this, &this->links[i])) < 0)
@ -343,13 +348,6 @@ static int setup_convert(struct impl *this)
if ((res = negotiate_link_format(this, &this->links[j])) < 0)
return res;
}
spa_node_port_set_io(inport->node, SPA_DIRECTION_INPUT, 0,
t->io.Buffers, inport->io, sizeof(struct spa_io_buffers));
spa_node_port_set_io(outport->node, SPA_DIRECTION_OUTPUT, 0,
t->io.Buffers, outport->io, sizeof(struct spa_io_buffers));
return 0;
}
@ -374,17 +372,23 @@ static int negotiate_link_buffers(struct impl *this, struct link *link)
if ((res = spa_node_port_enum_params(link->out_node,
SPA_DIRECTION_OUTPUT, link->out_port,
t->param.idBuffers, &state,
param, &param, &b)) <= 0)
param, &param, &b)) <= 0) {
debug_params(this, link->out_node, SPA_DIRECTION_OUTPUT, link->out_port,
t->param.idBuffers, param);
return -ENOTSUP;
}
}
if (link->in_node != NULL) {
state = 0;
if ((res = spa_node_port_enum_params(link->in_node,
SPA_DIRECTION_INPUT, link->in_port,
t->param.idBuffers, &state,
param, &param, &b)) <= 0)
param, &param, &b)) <= 0) {
debug_params(this, link->in_node, SPA_DIRECTION_INPUT, link->in_port,
t->param.idBuffers, param);
return -ENOTSUP;
}
}
spa_pod_fixate(param);
@ -415,6 +419,9 @@ static int negotiate_link_buffers(struct impl *this, struct link *link)
NULL) < 0)
return -EINVAL;
spa_log_debug(this->log, "%p: buffers %d, blocks %d, size %d, align %d",
this, buffers, blocks, size, align);
datas = alloca(sizeof(struct spa_data) * blocks);
memset(datas, 0, sizeof(struct spa_data) * blocks);
aligns = alloca(sizeof(uint32_t) * blocks);
@ -480,13 +487,13 @@ static int setup_buffers(struct impl *this, enum spa_direction direction)
spa_log_debug(this->log, NAME " %p: %d", this, direction);
if (direction == SPA_DIRECTION_INPUT) {
for (i = 1; i < this->n_links-1; i++) {
for (i = 0; i < this->n_links; i++) {
if ((res = negotiate_link_buffers(this, &this->links[i])) < 0)
spa_log_error(this->log, NAME " %p: buffers %d failed %s",
this, i, spa_strerror(res));
}
} else {
for (i = this->n_links-2; i > 0 ; i--) {
for (i = this->n_links-1; i >= 0 ; i--) {
if ((res = negotiate_link_buffers(this, &this->links[i])) < 0)
spa_log_error(this->log, NAME " %p: buffers %d failed %s",
this, i, spa_strerror(res));
@ -514,6 +521,7 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
static int impl_node_send_command(struct spa_node *node, const struct spa_command *command)
{
struct impl *this;
int res;
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(command != NULL, -EINVAL);
@ -521,6 +529,9 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
this = SPA_CONTAINER_OF(node, struct impl, node);
if (SPA_COMMAND_TYPE(command) == this->type.command_node.Start) {
if ((res = setup_convert(this)) < 0)
goto error;
setup_buffers(this, SPA_DIRECTION_INPUT);
this->started = true;
} else if (SPA_COMMAND_TYPE(command) == this->type.command_node.Pause) {
this->started = false;
@ -528,6 +539,10 @@ static int impl_node_send_command(struct spa_node *node, const struct spa_comman
return -ENOTSUP;
return 0;
error:
spa_log_error(this->log, "error %s", spa_strerror(res));
return res;
}
static int
@ -554,16 +569,14 @@ impl_node_get_n_ports(struct spa_node *node,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
struct impl *this;
spa_return_val_if_fail(node != NULL, -EINVAL);
if (n_input_ports)
*n_input_ports = 1;
if (max_input_ports)
*max_input_ports = 1;
if (n_output_ports)
*n_output_ports = 1;
if (max_output_ports)
*max_output_ports = 1;
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_node_get_n_ports(this->fmt[SPA_DIRECTION_INPUT], n_input_ports, max_input_ports, NULL, NULL);
spa_node_get_n_ports(this->fmt[SPA_DIRECTION_OUTPUT], NULL, NULL, n_output_ports, max_output_ports);
return 0;
}
@ -575,25 +588,39 @@ impl_node_get_port_ids(struct spa_node *node,
uint32_t *output_ids,
uint32_t n_output_ids)
{
struct impl *this;
spa_return_val_if_fail(node != NULL, -EINVAL);
if (n_input_ids && input_ids)
input_ids[0] = 0;
if (n_output_ids > 0 && output_ids)
output_ids[0] = 0;
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_node_get_port_ids(this->fmt[SPA_DIRECTION_INPUT], input_ids, n_input_ids, NULL, 0);
spa_node_get_port_ids(this->fmt[SPA_DIRECTION_OUTPUT], NULL, 0, output_ids, n_output_ids);
return 0;
}
static int impl_node_add_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id)
{
return -ENOTSUP;
struct impl *this;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
return spa_node_add_port(this->fmt[direction], direction, port_id);
}
static int
impl_node_remove_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id)
{
return -ENOTSUP;
struct impl *this;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
return spa_node_remove_port(this->fmt[direction], direction, port_id);
}
static int
@ -603,18 +630,13 @@ impl_node_port_get_info(struct spa_node *node,
const struct spa_port_info **info)
{
struct impl *this;
struct port *port;
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(info != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
return spa_node_port_get_info(port->node, direction, port_id, info);
return spa_node_port_get_info(this->fmt[direction], direction, port_id, info);
}
static int
@ -626,61 +648,13 @@ impl_node_port_enum_params(struct spa_node *node,
struct spa_pod_builder *builder)
{
struct impl *this;
struct port *port;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
return spa_node_port_enum_params(port->node, direction, port_id, id, index,
filter, result, builder);
}
static int port_set_format(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t flags,
const struct spa_pod *format)
{
struct impl *this = SPA_CONTAINER_OF(node, struct impl, node);
struct port *port, *other;
struct type *t = &this->type;
int res = 0;
port = GET_PORT(this, direction, port_id);
other = GET_PORT(this, SPA_DIRECTION_REVERSE(direction), port_id);
if (format == NULL) {
clean_convert(this);
port->have_format = false;
} else {
struct spa_audio_info info = { 0 };
spa_pod_object_parse(format,
"I", &info.media_type,
"I", &info.media_subtype);
if (info.media_type != t->media_type.audio ||
info.media_subtype != t->media_subtype.raw)
return -EINVAL;
if (spa_format_audio_raw_parse(format, &info.info.raw, &t->format_audio) < 0)
return -EINVAL;
clean_convert(this);
port->have_format = true;
port->format = info;
if (other->have_format)
res = setup_convert(this);
spa_log_debug(this->log, NAME " %p: set format on port %d %d", this, port_id, res);
}
return res;
return spa_node_port_enum_params(this->fmt[direction], direction, port_id,
id, index, filter, result, builder);
}
static int
@ -690,22 +664,12 @@ impl_node_port_set_param(struct spa_node *node,
const struct spa_pod *param)
{
struct impl *this;
struct port *port;
struct type *t;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
t = &this->type;
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
if (id == t->param.idFormat)
return port_set_format(node, direction, port_id, flags, param);
else
return spa_node_port_set_param(port->node, direction, port_id, id, flags, param);
return spa_node_port_set_param(this->fmt[direction], direction, port_id, id, flags, param);
}
static int
@ -716,22 +680,12 @@ impl_node_port_use_buffers(struct spa_node *node,
uint32_t n_buffers)
{
struct impl *this;
struct port *port;
int res;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
res = spa_node_port_use_buffers(port->node, direction, port_id, buffers, n_buffers);
if (res < 0)
return res;
return setup_buffers(this, direction);
return spa_node_port_use_buffers(this->fmt[direction], direction, port_id, buffers, n_buffers);
}
static int
@ -744,17 +698,12 @@ impl_node_port_alloc_buffers(struct spa_node *node,
uint32_t *n_buffers)
{
struct impl *this;
struct port *port;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
return spa_node_port_alloc_buffers(port->node, direction, port_id,
return spa_node_port_alloc_buffers(this->fmt[direction], direction, port_id,
params, n_params, buffers, n_buffers);
}
@ -764,38 +713,23 @@ impl_node_port_set_io(struct spa_node *node,
uint32_t id, void *data, size_t size)
{
struct impl *this;
struct port *port;
struct type *t;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
t = &this->type;
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
if (id == t->io.Buffers)
port->io = data;
return spa_node_port_set_io(port->node, direction, port_id, id, data, size);
return spa_node_port_set_io(this->fmt[direction], direction, port_id, id, data, size);
}
static int impl_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id)
{
struct impl *this;
struct port *port;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_return_val_if_fail(CHECK_PORT(this, SPA_DIRECTION_OUTPUT, port_id), -EINVAL);
port = GET_PORT(this, SPA_DIRECTION_OUTPUT, port_id);
return spa_node_port_reuse_buffer(port->node, port_id, buffer_id);
return spa_node_port_reuse_buffer(this->fmt[SPA_DIRECTION_OUTPUT], port_id, buffer_id);
}
static int
@ -805,23 +739,18 @@ impl_node_port_send_command(struct spa_node *node,
const struct spa_command *command)
{
struct impl *this;
struct port *port;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_return_val_if_fail(CHECK_PORT(this, SPA_DIRECTION_OUTPUT, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
return spa_node_port_send_command(port->node, direction, port_id, command);
return spa_node_port_send_command(this->fmt[direction], direction, port_id, command);
}
static int impl_node_process(struct spa_node *node)
{
struct impl *this;
int i, res = SPA_STATUS_OK;
int r, i, res = SPA_STATUS_OK;
spa_return_val_if_fail(node != NULL, -EINVAL);
@ -829,17 +758,20 @@ static int impl_node_process(struct spa_node *node)
spa_log_trace(this->log, NAME " %p: process %d", this, this->n_links);
for (i = 1; i < this->n_links; i++) {
int r = spa_node_process(this->links[i].out_node);
if (i == 1)
for (i = 0; i < this->n_nodes; i++) {
r = spa_node_process(this->nodes[i]);
spa_log_trace(this->log, NAME " %p: process %d %d", this, i, r);
if (i == 0)
res |= r & SPA_STATUS_NEED_BUFFER;
if (i == this->n_links - 1)
if (i == this->n_nodes-1)
res |= r & SPA_STATUS_HAVE_BUFFER;
if (!SPA_FLAG_CHECK(r, SPA_STATUS_HAVE_BUFFER)) {
if (SPA_FLAG_CHECK(r, SPA_STATUS_NEED_BUFFER) && i == 1)
if (SPA_FLAG_CHECK(r, SPA_STATUS_NEED_BUFFER) && i == 0)
break;
i = res = SPA_STATUS_OK;
res = SPA_STATUS_OK;
i = -1;
continue;
}
}
@ -926,7 +858,6 @@ impl_init(const struct spa_handle_factory *factory,
uint32_t n_support)
{
struct impl *this;
struct port *port;
uint32_t i;
size_t size;
void *iface;
@ -953,47 +884,39 @@ impl_init(const struct spa_handle_factory *factory,
this->node = impl_node;
this->hnd_fmt_in = SPA_MEMBER(this, sizeof(struct impl), struct spa_handle);
this->hnd_fmt[SPA_DIRECTION_INPUT] = SPA_MEMBER(this, sizeof(struct impl), struct spa_handle);
spa_handle_factory_init(&spa_fmtconvert_factory,
this->hnd_fmt_in,
this->hnd_fmt[SPA_DIRECTION_INPUT],
info, support, n_support);
size = spa_handle_factory_get_size(&spa_fmtconvert_factory, info);
this->hnd_channelmix = SPA_MEMBER(this->hnd_fmt_in, size, struct spa_handle);
this->hnd_channelmix = SPA_MEMBER(this->hnd_fmt[SPA_DIRECTION_INPUT], size, struct spa_handle);
spa_handle_factory_init(&spa_channelmix_factory,
this->hnd_channelmix,
info, support, n_support);
size = spa_handle_factory_get_size(&spa_channelmix_factory, info);
this->hnd_fmt_out = SPA_MEMBER(this->hnd_channelmix, size, struct spa_handle);
this->hnd_fmt[SPA_DIRECTION_OUTPUT] = SPA_MEMBER(this->hnd_channelmix, size, struct spa_handle);
spa_handle_factory_init(&spa_fmtconvert_factory,
this->hnd_fmt_out,
this->hnd_fmt[SPA_DIRECTION_OUTPUT],
info, support, n_support);
size = spa_handle_factory_get_size(&spa_fmtconvert_factory, info);
this->hnd_resample = SPA_MEMBER(this->hnd_fmt_out, size, struct spa_handle);
this->hnd_resample = SPA_MEMBER(this->hnd_fmt[SPA_DIRECTION_OUTPUT], size, struct spa_handle);
spa_handle_factory_init(&spa_resample_factory,
this->hnd_resample,
info, support, n_support);
size = spa_handle_factory_get_size(&spa_resample_factory, info);
spa_handle_get_interface(this->hnd_fmt_in, this->type.node, &iface);
this->fmt_in = iface;
spa_handle_get_interface(this->hnd_fmt_out, this->type.node, &iface);
this->fmt_out = iface;
spa_handle_get_interface(this->hnd_fmt[SPA_DIRECTION_INPUT], this->type.node, &iface);
this->fmt[SPA_DIRECTION_INPUT] = iface;
spa_handle_get_interface(this->hnd_fmt[SPA_DIRECTION_OUTPUT], this->type.node, &iface);
this->fmt[SPA_DIRECTION_OUTPUT] = iface;
spa_handle_get_interface(this->hnd_channelmix, this->type.node, &iface);
this->channelmix = iface;
spa_handle_get_interface(this->hnd_resample, this->type.node, &iface);
this->resample = iface;
port = GET_OUT_PORT(this, 0);
port->id = 0;
port->node = this->fmt_out;
port = GET_IN_PORT(this, 0);
port->id = 0;
port->node = this->fmt_in;
props_reset(&this->props);
return 0;

2
spa/plugins/audioconvert/channelmix.c
View file

@ -474,7 +474,7 @@ impl_node_port_enum_params(struct spa_node *node,
":", t->param_buffers.buffers, "iru", 1,
SPA_POD_PROP_MIN_MAX(1, MAX_BUFFERS),
":", t->param_buffers.blocks, "i", port->blocks,
":", t->param_buffers.size, "iru", 1024 * port->stride,
":", t->param_buffers.size, "iru", 2048 * port->stride,
SPA_POD_PROP_MIN_MAX(16 * port->stride, INT32_MAX / port->stride),
":", t->param_buffers.stride, "i", port->stride,
":", t->param_buffers.align, "i", 16);

394
spa/plugins/audioconvert/fmtconvert.c
View file

@ -39,6 +39,7 @@
#define DEFAULT_CHANNELS 2
#define MAX_BUFFERS 32
#define MAX_PORTS 128
#define PROP_DEFAULT_TRUNCATE false
#define PROP_DEFAULT_DITHER 0
@ -64,10 +65,19 @@ struct buffer {
struct spa_meta_header *h;
};
struct format {
struct spa_audio_info format;
uint32_t stride;
uint32_t blocks;
uint32_t size;
};
struct port {
uint32_t id;
bool valid;
struct spa_io_buffers *io;
struct spa_io_control_range *ctrl;
struct spa_port_info info;
bool have_format;
@ -139,8 +149,11 @@ struct impl {
const struct spa_node_callbacks *callbacks;
void *user_data;
struct port in_port;
struct port out_port;
struct port ports[2][MAX_PORTS];
uint32_t n_ports[2];
struct format formats[2];
uint32_t n_formats[2];
bool started;
@ -149,50 +162,73 @@ struct impl {
convert_func_t convert;
};
#define CHECK_PORT(this,d,id) (id == 0)
#define GET_IN_PORT(this,id) (&this->in_port)
#define GET_OUT_PORT(this,id) (&this->out_port)
#define GET_PORT(this,d,id) (d == SPA_DIRECTION_INPUT ? GET_IN_PORT(this,id) : GET_OUT_PORT(this,id))
#define CHECK_FREE_PORT(this,d,id) (id < MAX_PORTS && !GET_PORT(this,d,id)->valid)
#define CHECK_PORT(this,d,id) (id < MAX_PORTS && GET_PORT(this,d,id)->valid)
#define GET_PORT(this,d,id) (&this->ports[d][id])
#define GET_IN_PORT(this,id) GET_PORT(this,SPA_DIRECTION_INPUT,id)
#define GET_OUT_PORT(this,id) GET_PORT(this,SPA_DIRECTION_OUTPUT,id)
static int collect_format(struct impl *this, enum spa_direction direction, struct format *fmt)
{
int i, idx, ch = 0;
*fmt = this->formats[direction];
for (i = 0, idx = 0; idx < this->n_ports[direction] && i < MAX_PORTS; i++) {
struct port *p = GET_PORT(this, direction, i);
if (!p->valid)
continue;
idx++;
if (!p->have_format)
return -1;
fmt->format = p->format;
ch += p->format.info.raw.channels;
}
fmt->format.info.raw.channels = ch;
return 0;
}
static int setup_convert(struct impl *this)
{
struct port *inport, *outport;
uint32_t src_fmt, dst_fmt;
struct type *t = &this->type;
struct format informat, outformat;
inport = GET_PORT(this, SPA_DIRECTION_INPUT, 0);
outport = GET_PORT(this, SPA_DIRECTION_OUTPUT, 0);
if (collect_format(this, SPA_DIRECTION_INPUT, &informat) < 0)
return -1;
if (collect_format(this, SPA_DIRECTION_OUTPUT, &outformat) < 0)
return -1;
src_fmt = inport->format.info.raw.format;
dst_fmt = outport->format.info.raw.format;
src_fmt = informat.format.info.raw.format;
dst_fmt = outformat.format.info.raw.format;
spa_log_info(this->log, NAME " %p: %s/%d@%d.%d->%s/%d@%d.%d", this,
spa_type_map_get_type(this->map, src_fmt),
inport->format.info.raw.channels,
inport->format.info.raw.rate,
inport->format.info.raw.layout,
informat.format.info.raw.channels,
informat.format.info.raw.rate,
informat.format.info.raw.layout,
spa_type_map_get_type(this->map, dst_fmt),
outport->format.info.raw.channels,
outport->format.info.raw.rate,
outport->format.info.raw.layout);
outformat.format.info.raw.channels,
outformat.format.info.raw.rate,
outformat.format.info.raw.layout);
if (inport->format.info.raw.channels != outport->format.info.raw.channels)
if (informat.format.info.raw.channels != outformat.format.info.raw.channels)
return -EINVAL;
if (inport->format.info.raw.rate != outport->format.info.raw.rate)
if (informat.format.info.raw.rate != outformat.format.info.raw.rate)
return -EINVAL;
/* find fast path */
this->conv[0] = find_conv_info(&t->audio_format, src_fmt, dst_fmt);
if (this->conv[0] != NULL) {
if (inport->format.info.raw.layout == SPA_AUDIO_LAYOUT_INTERLEAVED) {
if (outport->format.info.raw.layout == SPA_AUDIO_LAYOUT_INTERLEAVED)
if (informat.format.info.raw.layout == SPA_AUDIO_LAYOUT_INTERLEAVED) {
if (outformat.format.info.raw.layout == SPA_AUDIO_LAYOUT_INTERLEAVED)
this->convert = this->conv[0]->i2i;
else
this->convert = this->conv[0]->i2d;
}
else {
if (outport->format.info.raw.layout == SPA_AUDIO_LAYOUT_INTERLEAVED)
if (outformat.format.info.raw.layout == SPA_AUDIO_LAYOUT_INTERLEAVED)
this->convert = this->conv[0]->d2i;
else
this->convert = this->conv[0]->i2i;
@ -260,17 +296,43 @@ impl_node_get_n_ports(struct spa_node *node,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
struct impl *this;
spa_return_val_if_fail(node != NULL, -EINVAL);
if (n_input_ports)
*n_input_ports = 1;
if (max_input_ports)
*max_input_ports = 1;
if (n_output_ports)
*n_output_ports = 1;
if (max_output_ports)
*max_output_ports = 1;
this = SPA_CONTAINER_OF(node, struct impl, node);
if (n_input_ports)
*n_input_ports = this->n_ports[SPA_DIRECTION_INPUT];
if (max_input_ports)
*max_input_ports = MAX_PORTS;
if (n_output_ports)
*n_output_ports = this->n_ports[SPA_DIRECTION_OUTPUT];
if (max_output_ports)
*max_output_ports = MAX_PORTS;
return 0;
}
static inline struct port *iterate_ports(struct impl *this, enum spa_direction direction, uint32_t max, uint32_t *state)
{
for (; (*state & 0xffff) < MAX_PORTS && (*state >> 16) < max; (*state)++) {
struct port *p = &this->ports[direction][(*state) & 0xffff];
if (p->valid) {
(*state) += 0x10001;
return p;
}
}
return NULL;
}
static int collect_ports(struct impl *this, enum spa_direction direction, uint32_t *ids, uint32_t n_ids)
{
int i, idx;
for (i = 0, idx = 0; i < MAX_PORTS && idx < n_ids; i++) {
if (this->ports[direction][i].valid)
ids[idx++] = i;
}
return 0;
}
@ -281,25 +343,76 @@ impl_node_get_port_ids(struct spa_node *node,
uint32_t *output_ids,
uint32_t n_output_ids)
{
struct impl *this;
spa_return_val_if_fail(node != NULL, -EINVAL);
if (n_input_ids && input_ids)
input_ids[0] = 0;
if (n_output_ids > 0 && output_ids)
output_ids[0] = 0;
this = SPA_CONTAINER_OF(node, struct impl, node);
if (input_ids)
collect_ports(this, SPA_DIRECTION_INPUT, input_ids, n_input_ids);
if (output_ids)
collect_ports(this, SPA_DIRECTION_OUTPUT, output_ids, n_output_ids);
return 0;
}
static int init_port(struct impl *this, enum spa_direction direction, uint32_t port_id, uint32_t flags)
{
struct port *port;
port = GET_PORT(this, direction, port_id);
port->valid = true;
port->id = port_id;
spa_list_init(&port->queue);
port->info.flags = flags;
this->n_ports[direction]++;
port->have_format = false;
return 0;
}
static int impl_node_add_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id)
{
return -ENOTSUP;
struct impl *this;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_return_val_if_fail(CHECK_FREE_PORT(this, direction, port_id), -EINVAL);
init_port(this, direction, port_id,
SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS |
SPA_PORT_INFO_FLAG_REMOVABLE);
spa_log_debug(this->log, NAME " %p: add port %d", this, port_id);
return 0;
}
static int
impl_node_remove_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id)
{
return -ENOTSUP;
struct impl *this;
struct port *port;
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT (this, direction, port_id);
this->n_ports[direction]--;
if (port->have_format)
this->n_formats[direction]--;
spa_memzero(port, sizeof(struct port));
spa_log_debug(this->log, NAME " %p: remove port %d", this, port_id);
return 0;
}
static int
@ -332,26 +445,26 @@ static int port_enum_formats(struct spa_node *node,
{
struct impl *this = SPA_CONTAINER_OF(node, struct impl, node);
struct type *t = &this->type;
struct port *other;
struct spa_audio_info *other;
other = GET_PORT(this, SPA_DIRECTION_REVERSE(direction), 0);
other = &this->formats[SPA_DIRECTION_REVERSE(direction)].format;
switch (*index) {
case 0:
if (other->have_format) {
if (other->info.raw.channels > 0) {
*param = spa_pod_builder_object(builder,
t->param.idEnumFormat, t->format,
"I", t->media_type.audio,
"I", t->media_subtype.raw,
":", t->format_audio.format, "Ieu", other->format.info.raw.format,
SPA_POD_PROP_ENUM(3, other->format.info.raw.format,
":", t->format_audio.format, "Ieu", other->info.raw.format,
SPA_POD_PROP_ENUM(3, other->info.raw.format,
t->audio_format.F32,
t->audio_format.F32_OE),
":", t->format_audio.layout, "ieu", other->format.info.raw.layout,
":", t->format_audio.layout, "ieu", other->info.raw.layout,
SPA_POD_PROP_ENUM(2, SPA_AUDIO_LAYOUT_INTERLEAVED,
SPA_AUDIO_LAYOUT_NON_INTERLEAVED),
":", t->format_audio.rate, "i", other->format.info.raw.rate,
":", t->format_audio.channels, "i", other->format.info.raw.channels);
":", t->format_audio.rate, "i", other->info.raw.rate,
":", t->format_audio.channels, "i", other->info.raw.channels);
} else {
*param = spa_pod_builder_object(builder,
t->param.idEnumFormat, t->format,
@ -465,34 +578,31 @@ impl_node_port_enum_params(struct spa_node *node,
return res;
}
else if (id == t->param.idBuffers) {
uint32_t buffers, size;
if (!port->have_format)
return -EIO;
if (*index > 0)
return 0;
if (other->n_buffers > 0) {
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.buffers, "iru", other->n_buffers,
SPA_POD_PROP_MIN_MAX(1, MAX_BUFFERS),
":", t->param_buffers.blocks, "i", port->blocks,
":", t->param_buffers.size, "i", (other->size / other->stride) *
port->stride,
":", t->param_buffers.stride, "i", port->stride,
":", t->param_buffers.align, "i", 16);
buffers = other->n_buffers;
size = other->size / other->stride;
} else {
buffers = 1;
size = 1024;
}
else {
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.buffers, "iru", 1,
SPA_POD_PROP_MIN_MAX(1, MAX_BUFFERS),
":", t->param_buffers.buffers, "iru", buffers,
SPA_POD_PROP_MIN_MAX(2, MAX_BUFFERS),
":", t->param_buffers.blocks, "i", port->blocks,
":", t->param_buffers.size, "iru", 1024 * port->stride,
":", t->param_buffers.size, "iru", size * port->stride,
SPA_POD_PROP_MIN_MAX(16 * port->stride, INT32_MAX / port->stride),
":", t->param_buffers.stride, "i", port->stride,
":", t->param_buffers.align, "i", 16);
}
}
else if (id == t->param.idMeta) {
if (!port->have_format)
return -EIO;
@ -554,6 +664,14 @@ static int clear_buffers(struct impl *this, struct port *port)
}
return 0;
}
static int compatible_format(struct spa_audio_info *info, struct spa_audio_info *info2)
{
if (info->info.raw.format != info2->info.raw.format ||
info->info.raw.layout != info2->info.raw.layout ||
info->info.raw.rate != info2->info.raw.rate)
return -EINVAL;
return 0;
}
static int port_set_format(struct spa_node *node,
enum spa_direction direction,
@ -562,19 +680,20 @@ static int port_set_format(struct spa_node *node,
const struct spa_pod *format)
{
struct impl *this = SPA_CONTAINER_OF(node, struct impl, node);
struct port *port, *other;
struct port *port;
struct type *t = &this->type;
int res = 0;
port = GET_PORT(this, direction, port_id);
other = GET_PORT(this, SPA_DIRECTION_REVERSE(direction), port_id);
if (format == NULL) {
if (port->have_format) {
port->have_format = false;
this->n_formats[direction]--;
this->formats[direction].format.info.raw.channels -= port->format.info.raw.channels;
clear_buffers(this, port);
}
this->convert = NULL;
}
} else {
struct spa_audio_info info = { 0 };
@ -589,6 +708,16 @@ static int port_set_format(struct spa_node *node,
if (spa_format_audio_raw_parse(format, &info.info.raw, &t->format_audio) < 0)
return -EINVAL;
if (this->n_formats[direction] > 0) {
if (compatible_format(&info, &this->formats[direction].format) < 0)
return -EINVAL;
this->formats[direction].format.info.raw.channels += info.info.raw.channels;
}
else {
this->formats[direction].format = info;
}
this->n_formats[direction]++;
port->have_format = true;
port->format = info;
@ -602,11 +731,12 @@ static int port_set_format(struct spa_node *node,
port->blocks = info.info.raw.channels;
}
if (other->have_format)
if (this->n_formats[SPA_DIRECTION_INPUT] == this->n_ports[SPA_DIRECTION_INPUT] &&
this->n_formats[SPA_DIRECTION_OUTPUT] == this->n_ports[SPA_DIRECTION_OUTPUT])
res = setup_convert(this);
spa_log_debug(this->log, NAME " %p: set format on port %d %d %d %d",
this, port_id, res, port->stride, other->stride);
spa_log_debug(this->log, NAME " %p: set format on port %d %d %d",
this, port_id, res, port->stride);
}
return res;
}
@ -724,20 +854,21 @@ impl_node_port_set_io(struct spa_node *node,
port = GET_PORT(this, direction, port_id);
if (id == t->io.Buffers) {
spa_log_trace(this->log, NAME " %p: port %d update buffer io %p",
this, port_id, data);
spa_log_trace(this->log, NAME " %p: port %d:%d update io %d %p",
this, direction, port_id, id, data);
if (id == t->io.Buffers)
port->io = data;
}
else if (id == t->io.ControlRange)
port->ctrl = data;
else
return -ENOENT;
return 0;
}
static void recycle_buffer(struct impl *this, uint32_t id)
static void recycle_buffer(struct impl *this, struct port *port, uint32_t id)
{
struct port *port = GET_OUT_PORT(this, 0);
struct buffer *b = &port->buffers[id];
if (SPA_FLAG_CHECK(b->flags, BUFFER_FLAG_OUT)) {
@ -765,6 +896,7 @@ static struct buffer *dequeue_buffer(struct impl *this, struct port *port)
static int impl_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id)
{
struct impl *this;
struct port *port;
spa_return_val_if_fail(node != NULL, -EINVAL);
@ -772,7 +904,9 @@ static int impl_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id,
spa_return_val_if_fail(CHECK_PORT(this, SPA_DIRECTION_OUTPUT, port_id), -EINVAL);
recycle_buffer(this, buffer_id);
port = GET_OUT_PORT(this, port_id);
recycle_buffer(this, port, buffer_id);
return 0;
}
@ -786,18 +920,119 @@ impl_node_port_send_command(struct spa_node *node,
return -ENOTSUP;
}
static int process_split(struct impl *this)
{
struct port *inport, *outport;
struct spa_io_buffers *inio, *outio;
struct buffer *inbuf, *outbuf;
struct spa_buffer *inb, *outb;
const void **src_datas;
void **dst_datas;
uint32_t n_src_datas, n_outs, n_dst_datas;
int i, j, res = 0, n_bytes = 0, maxsize;
uint32_t size;
inport = GET_IN_PORT(this, 0);
inio = inport->io;
spa_return_val_if_fail(inio != NULL, -EIO);
spa_log_trace(this->log, NAME " %p: status %p %d", this, inio, inio->status);
if (inio->status != SPA_STATUS_HAVE_BUFFER)
return SPA_STATUS_NEED_BUFFER;
if (inio->buffer_id >= inport->n_buffers)
return inio->status = -EINVAL;
inbuf = &inport->buffers[inio->buffer_id];
inb = inbuf->outbuf;
n_src_datas = inb->n_datas;
src_datas = alloca(sizeof(void*) * n_src_datas);
size = inb->datas[0].chunk->size;
for (i = 0; i < n_src_datas; i++)
src_datas[i] = SPA_MEMBER(inb->datas[i].data, inport->offset, void);
n_outs = this->n_ports[SPA_DIRECTION_OUTPUT];
dst_datas = alloca(sizeof(void*) * MAX_PORTS);
n_dst_datas = 0;
for (i = 0; i < n_outs; i++) {
outport = GET_OUT_PORT(this, i);
outio = outport->io;
if (outio == NULL)
continue;
spa_log_trace(this->log, NAME " %p: %d %p %d %d %d", this, i,
outio, outio->status, outio->buffer_id, outport->stride);
if (outio->status == SPA_STATUS_HAVE_BUFFER) {
res |= SPA_STATUS_HAVE_BUFFER;
continue;
}
if (outio->buffer_id < outport->n_buffers) {
recycle_buffer(this, outport, outio->buffer_id);
outio->buffer_id = SPA_ID_INVALID;
}
if ((outbuf = dequeue_buffer(this, outport)) == NULL)
return outio->status = -EPIPE;
outb = outbuf->outbuf;
maxsize = outb->datas[0].maxsize;
if (outport->ctrl)
maxsize = SPA_MIN(outport->ctrl->max_size, maxsize);
maxsize = (maxsize / outport->stride) * inport->stride;
n_bytes = SPA_MIN(size - inport->offset, maxsize);
for (j = 0; j < outb->n_datas; j++) {
dst_datas[n_dst_datas++] = outb->datas[j].data;
outb->datas[j].chunk->offset = 0;
outb->datas[j].chunk->size = (n_bytes / inport->stride) * outport->stride;
}
outio->status = SPA_STATUS_HAVE_BUFFER;
outio->buffer_id = outb->id;
res |= SPA_STATUS_HAVE_BUFFER;
}
spa_log_trace(this->log, NAME " %p: %d %d %d %d %d %d", this,
n_src_datas, n_dst_datas, n_bytes, inport->offset, size, inport->stride);
if (n_dst_datas > 0) {
this->convert(this, n_dst_datas, dst_datas, n_src_datas, src_datas, n_bytes);
inport->offset += n_bytes;
if (inport->offset >= size) {
inio->status = SPA_STATUS_NEED_BUFFER;
inport->offset = 0;
res |= SPA_STATUS_NEED_BUFFER;
}
}
return res;
}
static int impl_node_process(struct spa_node *node)
{
struct impl *this;
#if 0
struct port *outport, *inport;
struct spa_io_buffers *outio, *inio;
struct buffer *sbuf, *dbuf;
int res = 0;
#endif
spa_return_val_if_fail(node != NULL, -EINVAL);
this = SPA_CONTAINER_OF(node, struct impl, node);
if (this->n_ports[SPA_DIRECTION_OUTPUT] >= 1)
return process_split(this);
else
return -ENOTSUP;
#if 0
outport = GET_OUT_PORT(this, 0);
inport = GET_IN_PORT(this, 0);
@ -818,7 +1053,7 @@ static int impl_node_process(struct spa_node *node)
/* recycle */
if (outio->buffer_id < outport->n_buffers) {
recycle_buffer(this, outio->buffer_id);
recycle_buffer(this, outport, outio->buffer_id);
outio->buffer_id = SPA_ID_INVALID;
}
@ -832,12 +1067,12 @@ static int impl_node_process(struct spa_node *node)
{
int i, n_bytes, maxsize;
uint32_t size;
struct spa_buffer *sb = sbuf->outbuf, *db = dbuf->outbuf;
uint32_t n_src_datas = sb->n_datas;
uint32_t n_dst_datas = db->n_datas;
const void *src_datas[n_src_datas];
void *dst_datas[n_dst_datas];
uint32_t size;
size = sb->datas[0].chunk->size;
maxsize = (db->datas[0].maxsize / outport->stride) * inport->stride;
@ -868,6 +1103,7 @@ static int impl_node_process(struct spa_node *node)
res |= SPA_STATUS_HAVE_BUFFER;
return res;
#endif
}
static const struct spa_node impl_node = {
@ -929,7 +1165,6 @@ impl_init(const struct spa_handle_factory *factory,
uint32_t n_support)
{
struct impl *this;
struct port *port;
uint32_t i;
spa_return_val_if_fail(factory != NULL, -EINVAL);
@ -954,15 +1189,8 @@ impl_init(const struct spa_handle_factory *factory,
this->node = impl_node;
port = GET_OUT_PORT(this, 0);
port->id = 0;
port->info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
spa_list_init(&port->queue);
port = GET_IN_PORT(this, 0);
port->id = 0;
port->info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
spa_list_init(&port->queue);
init_port(this, SPA_DIRECTION_OUTPUT, 0, SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS);
init_port(this, SPA_DIRECTION_INPUT, 0, SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS);
props_reset(&this->props);

3
spa/plugins/audioconvert/resample.c
View file

@ -440,8 +440,9 @@ impl_node_port_enum_params(struct spa_node *node,
":", t->param_buffers.buffers, "iru", other->n_buffers,
SPA_POD_PROP_MIN_MAX(1, MAX_BUFFERS),
":", t->param_buffers.blocks, "i", port->blocks,
":", t->param_buffers.size, "i", (other->size / other->stride) *
":", t->param_buffers.size, "iru", (other->size / other->stride) *
port->stride,
SPA_POD_PROP_MIN_MAX(16 * port->stride, INT32_MAX / port->stride),
":", t->param_buffers.stride, "i", port->stride,
":", t->param_buffers.align, "i", 16);
} else {

2
src/modules/module-client-node/client-stream.c
View file

@ -906,7 +906,7 @@ static void client_node_initialized(void *data)
media_type == impl->type.media_type.audio &&
media_subtype == impl->type.media_subtype.raw) {
if ((impl->adapter = pw_load_spa_interface("audioconvert/libspa-audioconvert",
"splitter", SPA_TYPE__Node, NULL, 0, NULL)) == NULL)
"audioconvert", SPA_TYPE__Node, NULL, 0, NULL)) == NULL)
return;
impl->use_converter = true;

204
src/pipewire/stream.c
View file

@ -105,7 +105,6 @@ struct stream {
struct queue dequeued;
struct queue queued;
uint32_t n_orig_params;
uint32_t n_init_params;
struct spa_pod **init_params;
@ -113,6 +112,7 @@ struct stream {
struct spa_pod **params;
struct spa_pod *format;
struct spa_pod *conv_format;
uint32_t pending_seq;
bool disconnecting;
@ -123,10 +123,6 @@ struct stream {
bool free_data;
struct data data;
bool use_converter;
struct spa_node *convert;
struct spa_io_buffers conv_io;
};
@ -166,80 +162,6 @@ static inline struct buffer *pop_queue(struct stream *stream, struct queue *queu
return buffer;
}
/* check if the server format is compatible with the requested
* formats, if not, set up converters when allowed */
static int configure_converter(struct stream *impl)
{
struct pw_type *t = impl->t;
int i, res;
struct spa_pod *param;
impl->use_converter = false;
/* check if format compatible with filter */
for (i = 0; i < impl->n_orig_params; i++) {
uint8_t buffer[4096];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, 4096);
struct spa_pod *filtered;
param = impl->init_params[i];
if (spa_pod_is_object_type(param, t->spa_format)) {
if (spa_pod_filter(&b, &filtered, impl->format, param) >= 0) {
pw_log_debug("stream %p: format matches filter", impl);
return 0;
}
}
}
if (impl->convert == NULL)
return -ENOTSUP;
/* configure the converter */
if ((res = spa_node_port_set_param(impl->convert,
impl->direction, 0,
t->param.idFormat, 0,
impl->format)) < 0)
return res;
/* try to configure the other end */
for (i = 0; i < impl->n_orig_params; i++) {
param = impl->init_params[i];
if (spa_pod_is_object_type(param, t->spa_format)) {
if ((res = spa_node_port_set_param(impl->convert,
SPA_DIRECTION_REVERSE(impl->direction), 0,
t->param.idFormat,
SPA_NODE_PARAM_FLAG_FIXATE,
param)) < 0)
continue;
/* other end set and fixated */
impl->use_converter = true;
break;
}
}
/* when we get here without valid configured converter we fail */
if (!impl->use_converter)
return -ENOTSUP;
if (impl->io != &impl->conv_io) {
pw_log_debug("stream %p: update io %p %p", impl, impl->io, &impl->conv_io);
res = spa_node_port_set_io(impl->convert,
impl->direction, 0,
t->io.Buffers,
impl->io, sizeof(struct spa_io_buffers));
impl->io = &impl->conv_io;
res = spa_node_port_set_io(impl->convert,
SPA_DIRECTION_REVERSE(impl->direction), 0,
t->io.Buffers,
impl->io, sizeof(struct spa_io_buffers));
}
return 0;
}
static bool stream_set_state(struct pw_stream *stream, enum pw_stream_state state, const char *error)
{
enum pw_stream_state old = stream->state;
@ -307,8 +229,6 @@ static int impl_send_command(struct spa_node *node, const struct spa_command *co
if (impl->direction == SPA_DIRECTION_INPUT) {
impl->io->status = SPA_STATUS_NEED_BUFFER;
impl->io->buffer_id = SPA_ID_INVALID;
impl->conv_io.status = SPA_STATUS_NEED_BUFFER;
impl->conv_io.buffer_id = SPA_ID_INVALID;
}
else {
call_process(impl);
@ -390,16 +310,6 @@ static int impl_port_set_io(struct spa_node *node, enum spa_direction direction,
if (id == t->io.Buffers && size >= sizeof(struct spa_io_buffers)) {
pw_log_debug("stream %p: set io %d %p %zd", impl, id, data, size);
if (impl->use_converter) {
impl->io = &impl->conv_io;
res = spa_node_port_set_io(impl->convert,
direction, 0, id, data, size);
res = spa_node_port_set_io(impl->convert,
SPA_DIRECTION_REVERSE(direction), 0,
id, impl->io, size);
}
else
impl->io = data;
}
else
@ -481,9 +391,11 @@ static int port_set_format(struct spa_node *node,
struct stream *impl = SPA_CONTAINER_OF(node, struct stream, impl_node);
struct pw_stream *stream = &impl->this;
struct pw_type *t = impl->t;
int res, count;
int count;
pw_log_debug("stream %p: format changed", impl);
pw_log_debug("stream %p: format changed:", impl);
if (pw_log_level >= SPA_LOG_LEVEL_DEBUG)
spa_debug_pod(format, SPA_DEBUG_FLAG_FORMAT);
if (impl->format)
free(impl->format);
@ -491,18 +403,14 @@ static int port_set_format(struct spa_node *node,
if (spa_pod_is_object_type(format, t->spa_format)) {
impl->format = pw_spa_pod_copy(format);
((struct spa_pod_object*)impl->format)->body.id = t->param.idFormat;
if ((res = configure_converter(impl)) < 0) {
pw_stream_finish_format(stream, res, NULL, 0);
return res;
}
}
else
impl->format = NULL;
count = spa_hook_list_call(&stream->listener_list,
struct pw_stream_events,
format_changed, impl->format);
format_changed,
impl->format);
if (count == 0)
pw_stream_finish_format(stream, 0, NULL, 0);
@ -603,9 +511,6 @@ static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direc
clear_buffers(stream);
if (impl->use_converter)
SPA_FLAG_SET(flags, PW_STREAM_FLAG_MAP_BUFFERS);
for (i = 0; i < n_buffers; i++) {
int buf_size = 0;
struct buffer *b = &impl->buffers[i];
@ -639,35 +544,6 @@ static int impl_port_use_buffers(struct spa_node *node, enum spa_direction direc
buffers[i]->n_datas, size);
}
if (impl->use_converter) {
struct spa_data datas[1];
uint32_t data_aligns[1];
if ((res = spa_node_port_use_buffers(impl->convert,
impl->direction, 0,
buffers,
n_buffers)) < 0)
return res;
n_buffers = 6;
datas[0].type = t->data.MemPtr;
datas[0].maxsize = size;
data_aligns[0] = 16;
buffers = spa_buffer_alloc_array(n_buffers, 0,
0, NULL,
1, datas,
data_aligns);
if (buffers == NULL)
return -ENOMEM;
if ((res = spa_node_port_use_buffers(impl->convert,
SPA_DIRECTION_REVERSE(impl->direction), 0,
buffers, n_buffers)) < 0)
return res;
}
for (i = 0; i < n_buffers; i++) {
struct buffer *b = &impl->buffers[i];
@ -760,14 +636,6 @@ static int impl_node_process_output(struct spa_node *node)
pw_log_trace("stream %p: no more buffers %p", stream, io);
}
}
if (io->status == SPA_STATUS_HAVE_BUFFER && impl->use_converter) {
res = spa_node_process(impl->convert);
if (SPA_FLAG_CHECK(res, SPA_STATUS_NEED_BUFFER))
call_process(impl);
if (!SPA_FLAG_CHECK(res, SPA_STATUS_HAVE_BUFFER))
goto again;
} else {
if (!SPA_FLAG_CHECK(impl->flags, PW_STREAM_FLAG_DRIVER)) {
call_process(impl);
if (spa_ringbuffer_get_read_index(&impl->queued.ring, &index) > 0 &&
@ -775,8 +643,6 @@ static int impl_node_process_output(struct spa_node *node)
goto again;
}
res = io->status;
}
pw_log_trace("stream %p: res %d", stream, res);
return res;
@ -975,10 +841,6 @@ set_init_params(struct pw_stream *stream,
const struct spa_pod **init_params)
{
struct stream *impl = SPA_CONTAINER_OF(stream, struct stream, this);
struct pw_type *t = impl->t;
#define CONVERT_AUDIO (1<<0)
#define CONVERT_VIDEO (1<<1)
uint32_t convert_mask = 0;
int i;
if (impl->init_params) {
@ -989,59 +851,9 @@ set_init_params(struct pw_stream *stream,
}
if (n_init_params > 0) {
impl->init_params = malloc(n_init_params * sizeof(struct spa_pod *));
for (i = 0; i < n_init_params; i++) {
for (i = 0; i < n_init_params; i++)
impl->init_params[i] = pw_spa_pod_copy(init_params[i]);
if (spa_pod_is_object_type(impl->init_params[i], t->spa_format)) {
uint32_t media_type, media_subtype;
spa_pod_object_parse(impl->init_params[i],
"I", &media_type,
"I", &media_subtype);
if (media_type == impl->type.media_type.audio &&
media_subtype == impl->type.media_subtype.raw)
SPA_FLAG_SET(convert_mask, CONVERT_AUDIO);
else if (media_type == impl->type.media_type.video &&
media_subtype == impl->type.media_subtype.raw)
SPA_FLAG_SET(convert_mask, CONVERT_VIDEO);
}
}
}
impl->n_orig_params = n_init_params;
if (convert_mask && !SPA_FLAG_CHECK(impl->flags, PW_STREAM_FLAG_NO_CONVERT)) {
uint32_t state = 0;
int res;
if (SPA_FLAG_CHECK(convert_mask, CONVERT_AUDIO)) {
if ((impl->convert = pw_load_spa_interface("audioconvert/libspa-audioconvert",
"audioconvert", SPA_TYPE__Node, NULL, 0, NULL)) == NULL)
goto done;
}
if (SPA_FLAG_CHECK(convert_mask, CONVERT_VIDEO)) {
if ((impl->convert = pw_load_spa_interface("videoconvert/libspa-videoconvert",
"videoconvert", SPA_TYPE__Node, NULL, 0, NULL)) == NULL)
goto done;
}
while (true) {
uint8_t buffer[4096];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, 4096);
struct spa_pod *param;
if ((res = spa_node_port_enum_params(impl->convert,
impl->direction, 0,
t->param.idEnumFormat, &state,
NULL, &param, &b)) <= 0)
break;
impl->init_params = realloc(impl->init_params,
(n_init_params + 1) * sizeof(struct spa_pod *));
impl->init_params[n_init_params++] = pw_spa_pod_copy(param);
}
}
done:
impl->n_init_params = n_init_params;
}