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

Improve pod filter

Browse source 
Reset the builder when the filter failed.
Make the plugins create their params in a temporary buffer, we
don't want to do in-place filtering because that is not always
possible. Because the filter now resets on error, we can remove
the reset from the plugins.
This commit is contained in:
Wim Taymans 2017-11-14 10:17:45 +01:00
parent 7a7c011b00
commit 52e1dad93e
15 changed files with 193 additions and 226 deletions
Download patch file Download diff file Expand all files Collapse all files

107
spa/lib/pod.c
View file

@ -295,10 +295,8 @@ filter_prop(struct spa_pod_builder *b,
}
int pod_filter(struct spa_pod_builder *b,
const struct spa_pod *pod,
uint32_t pod_size,
const struct spa_pod *filter,
uint32_t filter_size)
const struct spa_pod *pod, uint32_t pod_size,
const struct spa_pod *filter, uint32_t filter_size)
{
const struct spa_pod *pp, *pf, *tmp;
int res = 0;
@ -306,42 +304,24 @@ int pod_filter(struct spa_pod_builder *b,
pf = filter;
SPA_POD_FOREACH_SAFE(pod, pod_size, pp, tmp) {
bool do_copy = false, do_filter = false, do_advance = false;
void *pc, *fc;
uint32_t pcs, fcs;
bool do_copy = false, do_advance = false;
uint32_t filter_offset = 0;
switch (SPA_POD_TYPE(pp)) {
case SPA_POD_TYPE_STRUCT:
if (pf != NULL) {
if (SPA_POD_TYPE(pf) != SPA_POD_TYPE_STRUCT)
return -EINVAL;
pc = SPA_POD_CONTENTS(struct spa_pod_struct, pp);
pcs = SPA_POD_CONTENTS_SIZE(struct spa_pod_struct, pp);
fc = SPA_POD_CONTENTS(struct spa_pod_struct, pf);
fcs = SPA_POD_CONTENTS_SIZE(struct spa_pod_struct, pf);
spa_pod_builder_push_struct(b);
do_filter = true;
do_advance = true;
}
else
do_copy = true;
break;
case SPA_POD_TYPE_OBJECT:
if (pf != NULL) {
struct spa_pod_object *p1 = (struct spa_pod_object *) pp;
if (SPA_POD_TYPE(pf) != SPA_POD_TYPE_OBJECT)
if (SPA_POD_TYPE(pf) != SPA_POD_TYPE(pp))
return -EINVAL;
pc = SPA_POD_CONTENTS(struct spa_pod_object, pp);
pcs = SPA_POD_CONTENTS_SIZE(struct spa_pod_object, pp);
fc = SPA_POD_CONTENTS(struct spa_pod_object, pf);
fcs = SPA_POD_CONTENTS_SIZE(struct spa_pod_object, pf);
spa_pod_builder_push_object(b, p1->body.id, p1->body.type);
do_filter = true;
if (SPA_POD_TYPE(pp) == SPA_POD_TYPE_STRUCT) {
filter_offset = sizeof(struct spa_pod_struct);
spa_pod_builder_push_struct(b);
} else {
struct spa_pod_object *p1 = (struct spa_pod_object *) pp;
filter_offset = sizeof(struct spa_pod_object);
spa_pod_builder_push_object(b, p1->body.id, p1->body.type);
}
do_advance = true;
}
else
@ -374,8 +354,12 @@ int pod_filter(struct spa_pod_builder *b,
}
if (do_copy)
spa_pod_builder_raw_padded(b, pp, SPA_POD_SIZE(pp));
else if (do_filter) {
res = pod_filter(b, pc, pcs, fc, fcs);
else if (filter_offset) {
res = pod_filter(b,
SPA_MEMBER(pp,filter_offset,void),
SPA_POD_SIZE(pp) - filter_offset,
SPA_MEMBER(pf,filter_offset,void),
SPA_POD_SIZE(pf) - filter_offset);
spa_pod_builder_pop(b);
}
if (do_advance) {
@ -397,7 +381,7 @@ spa_pod_filter(struct spa_pod_builder *b,
const struct spa_pod *filter)
{
int res;
uint32_t offset;
struct spa_pod_builder_state state;
spa_return_val_if_fail(pod != NULL, -EINVAL);
spa_return_val_if_fail(b != NULL, -EINVAL);
@ -408,18 +392,17 @@ spa_pod_filter(struct spa_pod_builder *b,
return 0;
}
offset = b->state.offset;
if ((res = pod_filter(b, pod, SPA_POD_SIZE(pod), filter, SPA_POD_SIZE(filter))) == 0)
*result = spa_pod_builder_deref(b, offset);
spa_pod_builder_get_state(b, &state);
if ((res = pod_filter(b, pod, SPA_POD_SIZE(pod), filter, SPA_POD_SIZE(filter))) < 0)
spa_pod_builder_reset(b, &state);
else
*result = spa_pod_builder_deref(b, state.offset);
return res;
}
int pod_compare(const struct spa_pod *pod1,
uint32_t pod1_size,
const struct spa_pod *pod2,
uint32_t pod2_size)
int pod_compare(const struct spa_pod *pod1, uint32_t pod1_size,
const struct spa_pod *pod2, uint32_t pod2_size)
{
const struct spa_pod *p1, *p2;
int res;
@ -427,40 +410,29 @@ int pod_compare(const struct spa_pod *pod1,
p2 = pod2;
SPA_POD_FOREACH(pod1, pod1_size, p1) {
bool do_recurse = false, do_advance = true;
void *a1, *a2;
void *p1c, *p2c;
uint32_t p1cs, p2cs;
bool do_advance = true;
uint32_t recurse_offset = 0;
if (p2 == NULL)
return -EINVAL;
switch (SPA_POD_TYPE(p1)) {
case SPA_POD_TYPE_STRUCT:
if (SPA_POD_TYPE(p2) != SPA_POD_TYPE_STRUCT)
return -EINVAL;
p1c = SPA_POD_CONTENTS(struct spa_pod_struct, p1);
p1cs = SPA_POD_CONTENTS_SIZE(struct spa_pod_struct, p1);
p2c = SPA_POD_CONTENTS(struct spa_pod_struct, p2);
p2cs = SPA_POD_CONTENTS_SIZE(struct spa_pod_struct, p2);
do_recurse = true;
do_advance = true;
break;
case SPA_POD_TYPE_OBJECT:
if (SPA_POD_TYPE(p2) != SPA_POD_TYPE_OBJECT)
if (SPA_POD_TYPE(p2) != SPA_POD_TYPE(p1))
return -EINVAL;
p1c = SPA_POD_CONTENTS(struct spa_pod_object, p1);
p1cs = SPA_POD_CONTENTS_SIZE(struct spa_pod_object, p1);
p2c = SPA_POD_CONTENTS(struct spa_pod_object, p2);
p2cs = SPA_POD_CONTENTS_SIZE(struct spa_pod_object, p2);
do_recurse = true;
if (SPA_POD_TYPE(p1) == SPA_POD_TYPE_STRUCT)
recurse_offset = sizeof(struct spa_pod_struct);
else
recurse_offset = sizeof(struct spa_pod_object);
do_advance = true;
break;
case SPA_POD_TYPE_PROP:
{
struct spa_pod_prop *pr1, *pr2;
void *a1, *a2;
pr1 = (struct spa_pod_prop *) p1;
pr2 = find_prop(pod2, pod2_size, pr1->body.key);
@ -495,8 +467,11 @@ int pod_compare(const struct spa_pod *pod1,
if (!spa_pod_is_inside(pod2, pod2_size, p2))
p2 = NULL;
}
if (do_recurse) {
res = pod_compare(p1c, p1cs, p2c, p2cs);
if (recurse_offset) {
res = pod_compare(SPA_MEMBER(p1,recurse_offset,void),
SPA_POD_SIZE(p1) - recurse_offset,
SPA_MEMBER(p2,recurse_offset,void),
SPA_POD_SIZE(p2) - recurse_offset);
}
if (res != 0)
return res;

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

@ -52,7 +52,8 @@ static int impl_node_enum_params(struct spa_node *node,
struct state *this;
struct type *t;
struct spa_pod *param;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
@ -61,14 +62,14 @@ static int impl_node_enum_params(struct spa_node *node,
this = SPA_CONTAINER_OF(node, struct state, node);
t = &this->type;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param.List,
":", t->param.listId, "I", t->param.idProps);
}
@ -78,7 +79,7 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->props,
":", t->prop_device, "S", p->device, sizeof(p->device),
":", t->prop_device_name, "S-r", p->device_name, sizeof(p->device_name),
@ -93,7 +94,6 @@ static int impl_node_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;
@ -283,7 +283,8 @@ impl_node_port_enum_params(struct spa_node *node,
struct state *this;
struct type *t;
struct spa_pod *param;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
@ -294,9 +295,9 @@ impl_node_port_enum_params(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
@ -304,7 +305,7 @@ impl_node_port_enum_params(struct spa_node *node,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
@ -318,7 +319,7 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
t->param.idFormat, t->format,
"I", t->media_type.audio,
"I", t->media_subtype.raw,
@ -332,7 +333,7 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.size, "iru", this->props.min_latency * this->frame_size,
2, this->props.min_latency * this->frame_size,
@ -348,13 +349,13 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
break;
case 1:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Ringbuffer,
":", t->param_meta.size, "i", sizeof(struct spa_meta_ringbuffer),
@ -375,7 +376,6 @@ impl_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -51,7 +51,8 @@ static int impl_node_enum_params(struct spa_node *node,
struct state *this;
struct type *t;
struct spa_pod *param;
struct spa_pod_builder_state state;
uint8_t buffer[1024];
struct spa_pod_builder b = { 0 };
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
@ -60,14 +61,14 @@ static int impl_node_enum_params(struct spa_node *node,
this = SPA_CONTAINER_OF(node, struct state, node);
t = &this->type;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param.List,
":", t->param.listId, "I", t->param.idProps);
}
@ -77,7 +78,7 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->props,
":", t->prop_device, "S", p->device, sizeof(p->device),
":", t->prop_device_name, "S-r", p->device_name, sizeof(p->device_name),
@ -90,7 +91,6 @@ static int impl_node_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;
@ -332,7 +332,8 @@ impl_node_port_enum_params(struct spa_node *node,
struct state *this;
struct type *t;
struct spa_pod *param;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
int res;
spa_return_val_if_fail(node != NULL, -EINVAL);
@ -344,9 +345,9 @@ impl_node_port_enum_params(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
@ -354,7 +355,7 @@ impl_node_port_enum_params(struct spa_node *node,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
@ -363,7 +364,7 @@ impl_node_port_enum_params(struct spa_node *node,
return spa_alsa_enum_format(this, index, filter, result, builder);
}
else if (id == t->param.idFormat) {
if ((res = port_get_format(node, direction, port_id, index, &param, builder)) <= 0)
if ((res = port_get_format(node, direction, port_id, index, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idBuffers) {
@ -372,7 +373,7 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.size, "i", this->props.min_latency * this->frame_size,
":", t->param_buffers.stride, "i", 0,
@ -386,7 +387,7 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
@ -400,7 +401,6 @@ impl_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -119,7 +119,7 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
int err, i, j, dir;
unsigned int min, max;
uint8_t buffer[4096];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
struct spa_pod_builder b = { 0 };
struct spa_pod_prop *prop;
struct spa_pod *fmt;
int res;
@ -130,6 +130,8 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
return err;
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (*index > 0)
return 0;

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

@ -389,7 +389,8 @@ impl_node_port_enum_params(struct spa_node *node,
struct type *t;
struct port *port;
struct spa_pod *param;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
int res;
spa_return_val_if_fail(node != NULL, -EINVAL);
@ -403,9 +404,9 @@ impl_node_port_enum_params(struct spa_node *node,
port = GET_PORT(this, direction, port_id);
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
@ -413,17 +414,17 @@ impl_node_port_enum_params(struct spa_node *node,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
}
else if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, &param, builder)) <= 0)
if ((res = port_enum_formats(node, direction, port_id, index, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_get_format(node, direction, port_id, index, &param, builder)) <= 0)
if ((res = port_get_format(node, direction, port_id, index, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idBuffers) {
@ -432,7 +433,7 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.size, "iru", 1024 * this->bpf,
2, 16 * this->bpf,
@ -448,13 +449,13 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
break;
case 1:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Ringbuffer,
":", t->param_meta.size, "i", sizeof(struct spa_meta_ringbuffer),
@ -473,7 +474,6 @@ impl_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -175,8 +175,9 @@ static int impl_node_enum_params(struct spa_node *node,
{
struct impl *this;
struct type *t;
struct spa_pod_builder_state state;
struct spa_pod *param;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
@ -185,14 +186,14 @@ static int impl_node_enum_params(struct spa_node *node,
this = SPA_CONTAINER_OF(node, struct impl, node);
t = &this->type;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param.List,
":", t->param.listId, "I", t->param.idProps);
}
@ -202,7 +203,7 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->props,
":", t->prop_live, "b", p->live,
":", t->prop_wave, "Ie", p->wave,
@ -218,7 +219,6 @@ static int impl_node_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;
@ -579,7 +579,8 @@ impl_node_port_enum_params(struct spa_node *node,
{
struct impl *this;
struct type *t;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
int res;
@ -592,9 +593,9 @@ impl_node_port_enum_params(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
@ -602,17 +603,17 @@ impl_node_port_enum_params(struct spa_node *node,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
}
else if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(this, direction, port_id, index, &param, builder)) <= 0)
if ((res = port_enum_formats(this, direction, port_id, index, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_get_format(this, direction, port_id, index, &param, builder)) <= 0)
if ((res = port_get_format(this, direction, port_id, index, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idBuffers) {
@ -621,7 +622,7 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.size, "iru", 1024 * this->bpf,
2, 16 * this->bpf,
@ -637,13 +638,13 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
break;
case 1:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Ringbuffer,
":", t->param_meta.size, "i", sizeof(struct spa_meta_ringbuffer),
@ -662,7 +663,6 @@ impl_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -277,29 +277,30 @@ spa_ffmpeg_dec_node_port_enum_params(struct spa_node *node,
{
struct impl *this = SPA_CONTAINER_OF(node, struct impl, node);
struct type *t = &this->type;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
int res;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
}
else if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_get_format(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_get_format(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else
@ -307,7 +308,6 @@ spa_ffmpeg_dec_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -273,29 +273,30 @@ spa_ffmpeg_enc_node_port_enum_params(struct spa_node *node,
{
struct impl *this = SPA_CONTAINER_OF(node, struct impl, node);
struct type *t = &this->type;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
int res;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
}
else if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_get_format(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_get_format(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else
@ -303,7 +304,6 @@ spa_ffmpeg_enc_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -136,7 +136,8 @@ static int impl_node_enum_params(struct spa_node *node,
{
struct impl *this;
struct type *t;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
spa_return_val_if_fail(node != NULL, -EINVAL);
@ -145,14 +146,14 @@ static int impl_node_enum_params(struct spa_node *node,
this = SPA_CONTAINER_OF(node, struct impl, node);
t = &this->type;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param.List,
":", t->param.listId, "I", t->param.idProps);
}
@ -160,7 +161,7 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->props,
":", t->prop_live, "b", this->props.live);
}
@ -169,7 +170,6 @@ static int impl_node_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;
@ -470,7 +470,8 @@ impl_node_port_enum_params(struct spa_node *node,
{
struct impl *this;
struct type *t;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
int res;
@ -483,9 +484,9 @@ impl_node_port_enum_params(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
@ -493,24 +494,24 @@ impl_node_port_enum_params(struct spa_node *node,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
}
else if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_get_format(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_get_format(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idBuffers) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.size, "i", 128,
":", t->param_buffers.stride, "i", 1,
@ -521,7 +522,7 @@ impl_node_port_enum_params(struct spa_node *node,
else if (id == t->param.idMeta) {
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
@ -535,7 +536,6 @@ impl_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -142,7 +142,8 @@ static int impl_node_enum_params(struct spa_node *node,
{
struct impl *this;
struct type *t;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
spa_return_val_if_fail(node != NULL, -EINVAL);
@ -152,14 +153,14 @@ static int impl_node_enum_params(struct spa_node *node,
this = SPA_CONTAINER_OF(node, struct impl, node);
t = &this->type;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param.List,
":", t->param.listId, "I", t->param.idProps);
}
@ -169,7 +170,7 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->props,
":", t->prop_live, "b", p->live,
":", t->prop_pattern, "Ie", p->pattern,
@ -180,7 +181,6 @@ static int impl_node_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;
@ -485,7 +485,8 @@ impl_node_port_enum_params(struct spa_node *node,
{
struct impl *this;
struct type *t;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
int res;
@ -498,9 +499,9 @@ impl_node_port_enum_params(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
@ -508,24 +509,24 @@ impl_node_port_enum_params(struct spa_node *node,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
}
else if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_get_format(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_get_format(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idBuffers) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.size, "i", 128,
":", t->param_buffers.stride, "i", 1,
@ -536,7 +537,7 @@ impl_node_port_enum_params(struct spa_node *node,
else if (id == t->param.idMeta) {
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
@ -550,7 +551,6 @@ impl_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -177,7 +177,8 @@ static int impl_node_enum_params(struct spa_node *node,
struct impl *this;
struct type *t;
struct spa_pod *param;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
@ -186,14 +187,14 @@ static int impl_node_enum_params(struct spa_node *node,
this = SPA_CONTAINER_OF(node, struct impl, node);
t = &this->type;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param.List,
":", t->param.listId, "I", t->param.idProps);
}
@ -203,7 +204,7 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder, t->param.idProps, t->props,
param = spa_pod_builder_object(&b, t->param.idProps, t->props,
":", t->prop_device, "S", p->device, sizeof(p->device),
":", t->prop_device_name, "S-r", p->device_name, sizeof(p->device_name),
":", t->prop_device_fd, "i-r", p->device_fd);
@ -213,7 +214,6 @@ static int impl_node_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;
@ -522,7 +522,8 @@ static int impl_node_port_enum_params(struct spa_node *node,
struct port *port;
struct type *t;
struct spa_pod *param;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
int res;
spa_return_val_if_fail(node != NULL, -EINVAL);
@ -536,9 +537,9 @@ static int impl_node_port_enum_params(struct spa_node *node,
port = &this->out_ports[port_id];
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
@ -546,7 +547,7 @@ static int impl_node_port_enum_params(struct spa_node *node,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
@ -555,7 +556,7 @@ static int impl_node_port_enum_params(struct spa_node *node,
return spa_v4l2_enum_format(this, index, filter, result, builder);
}
else if (id == t->param.idFormat) {
if((res = port_get_format(node, direction, port_id, index, filter, &param, builder)) <= 0)
if((res = port_get_format(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idBuffers) {
@ -564,7 +565,7 @@ static int impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.size, "i", port->fmt.fmt.pix.sizeimage,
":", t->param_buffers.stride, "i", port->fmt.fmt.pix.bytesperline,
@ -575,7 +576,7 @@ static int impl_node_port_enum_params(struct spa_node *node,
else if (id == t->param.idMeta) {
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
@ -589,7 +590,6 @@ static int impl_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -160,7 +160,8 @@ static int impl_node_enum_params(struct spa_node *node,
struct impl *this;
struct type *t;
struct spa_pod *param;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(builder != NULL, -EINVAL);
@ -168,14 +169,14 @@ static int impl_node_enum_params(struct spa_node *node,
this = SPA_CONTAINER_OF(node, struct impl, node);
t = &this->type;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param.List,
":", t->param.listId, "I", t->param.idProps);
}
@ -185,7 +186,7 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->props,
":", t->prop_live, "b", p->live,
":", t->prop_pattern, "Ie", p->pattern,
@ -197,7 +198,6 @@ static int impl_node_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;
@ -524,7 +524,8 @@ impl_node_port_enum_params(struct spa_node *node,
{
struct impl *this;
struct type *t;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
int res;
@ -537,9 +538,9 @@ impl_node_port_enum_params(struct spa_node *node,
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
@ -547,17 +548,17 @@ impl_node_port_enum_params(struct spa_node *node,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
}
else if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_get_format(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_get_format(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idBuffers) {
@ -568,7 +569,7 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.size, "i", this->stride * raw_info->size.height,
":", t->param_buffers.stride, "i", this->stride,
@ -582,7 +583,7 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
@ -597,7 +598,6 @@ impl_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -146,7 +146,8 @@ static int impl_node_enum_params(struct spa_node *node,
{
struct impl *this;
struct type *t;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
spa_return_val_if_fail(node != NULL, -EINVAL);
@ -156,14 +157,14 @@ static int impl_node_enum_params(struct spa_node *node,
this = SPA_CONTAINER_OF(node, struct impl, node);
t = &this->type;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param.List,
":", t->param.listId, "I", t->param.idProps);
}
@ -173,7 +174,7 @@ static int impl_node_enum_params(struct spa_node *node,
if(*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->props,
":", t->prop_volume, "dr", p->volume, 2, 0.0, 10.0,
":", t->prop_mute, "b", p->mute);
@ -183,7 +184,6 @@ static int impl_node_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;
@ -394,7 +394,8 @@ impl_node_port_enum_params(struct spa_node *node,
struct impl *this;
struct type *t;
struct port *port;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_pod *param;
int res;
@ -409,9 +410,9 @@ impl_node_port_enum_params(struct spa_node *node,
port = GET_PORT(this, direction, port_id);
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idList) {
uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat,
@ -419,17 +420,17 @@ impl_node_port_enum_params(struct spa_node *node,
t->param.idMeta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder, id, t->param.List,
param = spa_pod_builder_object(&b, id, t->param.List,
":", t->param.listId, "I", list[*index]);
else
return 0;
}
else if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_get_format(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_get_format(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idBuffers) {
@ -438,7 +439,7 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_buffers.Buffers,
":", t->param_buffers.size, "iru", 1024 * this->bpf,
2, 16 * this->bpf,
@ -451,7 +452,7 @@ impl_node_port_enum_params(struct spa_node *node,
else if (id == t->param.idMeta) {
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_object(&b,
id, t->param_meta.Meta,
":", t->param_meta.type, "I", t->meta.Header,
":", t->param_meta.size, "i", sizeof(struct spa_meta_header));
@ -465,7 +466,6 @@ impl_node_port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if (spa_pod_filter(builder, result, param, filter) < 0)
goto next;

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

@ -157,7 +157,6 @@ static int spa_proxy_node_enum_params(struct spa_node *node,
struct spa_pod_builder *builder)
{
struct proxy *this;
struct spa_pod_builder_state state;
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
@ -165,8 +164,6 @@ static int spa_proxy_node_enum_params(struct spa_node *node,
this = SPA_CONTAINER_OF(node, struct proxy, node);
spa_pod_builder_get_state(builder, &state);
while (true) {
struct spa_pod *param;
@ -180,8 +177,6 @@ static int spa_proxy_node_enum_params(struct spa_node *node,
if (spa_pod_filter(builder, result, param, filter) == 0)
break;
spa_pod_builder_reset(builder, &state);
}
return 1;
}
@ -458,7 +453,6 @@ spa_proxy_node_port_enum_params(struct spa_node *node,
{
struct proxy *this;
struct proxy_port *port;
struct spa_pod_builder_state state;
spa_return_val_if_fail(node != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
@ -470,8 +464,6 @@ spa_proxy_node_port_enum_params(struct spa_node *node,
port = GET_PORT(this, direction, port_id);
spa_pod_builder_get_state(builder, &state);
while (true) {
struct spa_pod *param;
@ -485,8 +477,6 @@ spa_proxy_node_port_enum_params(struct spa_node *node,
if (spa_pod_filter(builder, result, param, filter) == 0)
break;
spa_pod_builder_reset(builder, &state);
}
return 1;
}

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

@ -449,18 +449,19 @@ static int port_enum_params(struct spa_node *node,
struct node_data *nd = SPA_CONTAINER_OF(node, struct node_data, node_impl);
struct type *t = &nd->type;
struct spa_pod *param;
struct spa_pod_builder_state state;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
int res;
spa_pod_builder_get_state(builder, &state);
next:
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if (id == t->param.idEnumFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else if (id == t->param.idFormat) {
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, builder)) <= 0)
if ((res = port_enum_formats(node, direction, port_id, index, filter, &param, &b)) <= 0)
return res;
}
else
@ -468,7 +469,6 @@ static int port_enum_params(struct spa_node *node,
(*index)++;
spa_pod_builder_reset(builder, &state);
if ((res = spa_pod_filter(builder, result, param, filter)) < 0)
goto next;