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

clean up pod_builder

Browse source 
Remove the frame argument from the builder, we can use the builder
allocated frames.
Add deref function to builder to make it more flexible later.
Add some more recursion depth checks in the parser.
Improve props filter, also filter other types.
This commit is contained in:
Wim Taymans 2017-11-08 15:48:31 +01:00
parent 30a4651c51
commit cc47fb7e3a
31 changed files with 246 additions and 218 deletions
Download patch file Download diff file Expand all files Collapse all files

84
spa/include/spa/pod-builder.h
View file

@ -27,12 +27,7 @@ extern "C" {
#include <stdarg.h>
#include <spa/pod-utils.h>
#ifndef SPA_POD_MAX_LEVEL
#define SPA_POD_MAX_LEVEL 16
#endif
struct spa_pod_frame {
struct spa_pod_frame *parent;
struct spa_pod pod;
uint32_t ref;
};
@ -41,38 +36,43 @@ struct spa_pod_builder {
void *data;
uint32_t size;
uint32_t offset;
struct spa_pod_frame *stack;
uint32_t (*write) (struct spa_pod_builder *builder, uint32_t ref, const void *data,
uint32_t size);
void * (*deref) (struct spa_pod_builder *builder, uint32_t ref);
bool in_array;
bool first;
struct spa_pod_frame frame[SPA_POD_MAX_LEVEL];
int depth;
int depth;
struct spa_pod_frame frame[SPA_POD_MAX_DEPTH];
};
#define SPA_POD_BUILDER_INIT(buffer,size) { buffer, size, }
#define SPA_POD_BUILDER_DEREF(b,ref,type) SPA_MEMBER((b)->data, (ref), type)
static inline void spa_pod_builder_init(struct spa_pod_builder *builder, void *data, uint32_t size)
{
builder->data = data;
builder->size = size;
builder->offset = 0;
builder->stack = NULL;
builder->depth = 0;
builder->in_array = builder->first = false;
}
static inline void *
spa_pod_builder_deref(struct spa_pod_builder *builder, uint32_t ref)
{
if (builder->deref)
return builder->deref(builder, ref);
else
return SPA_MEMBER(builder->data, ref, void);
}
static inline uint32_t
spa_pod_builder_push(struct spa_pod_builder *builder,
struct spa_pod_frame *frame,
const struct spa_pod *pod,
uint32_t ref)
{
frame->parent = builder->stack;
struct spa_pod_frame *frame = &builder->frame[builder->depth++];
frame->pod = *pod;
frame->ref = ref;
builder->stack = frame;
builder->in_array = builder->first = (pod->type == SPA_POD_TYPE_ARRAY ||
pod->type == SPA_POD_TYPE_PROP);
return ref;
@ -82,7 +82,7 @@ static inline uint32_t
spa_pod_builder_raw(struct spa_pod_builder *builder, const void *data, uint32_t size)
{
uint32_t ref;
struct spa_pod_frame *f;
int i;
if (builder->write) {
ref = builder->write(builder, -1, data, size);
@ -95,8 +95,9 @@ spa_pod_builder_raw(struct spa_pod_builder *builder, const void *data, uint32_t
}
builder->offset += size;
for (f = builder->stack; f; f = f->parent)
f->pod.size += size;
for (i = 0; i < builder->depth; i++)
builder->frame[i].pod.size += size;
return ref;
}
@ -117,20 +118,27 @@ spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, ui
return ref;
}
static inline void spa_pod_builder_pop(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
static inline uint32_t spa_pod_builder_pop(struct spa_pod_builder *builder)
{
struct spa_pod_frame *frame = &builder->frame[--builder->depth], *top;
if (frame->ref != -1) {
if (builder->write)
builder->write(builder, frame->ref, &frame->pod, sizeof(struct spa_pod));
else
memcpy(builder->data + frame->ref, &frame->pod, sizeof(struct spa_pod));
}
builder->stack = frame->parent;
builder->in_array = (builder->stack && (builder->stack->pod.type == SPA_POD_TYPE_ARRAY ||
builder->stack->pod.type == SPA_POD_TYPE_PROP));
top = builder->depth > 0 ? &builder->frame[builder->depth-1] : NULL;
builder->in_array = (top && (top->pod.type == SPA_POD_TYPE_ARRAY ||
top->pod.type == SPA_POD_TYPE_PROP));
spa_pod_builder_pad(builder, builder->offset);
return frame->ref;
}
#define spa_pod_builder_pop_deref(b) \
spa_pod_builder_deref((b), spa_pod_builder_pop(b))
static inline uint32_t
spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod *p)
{
@ -285,12 +293,12 @@ spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t
}
static inline uint32_t
spa_pod_builder_push_array(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
spa_pod_builder_push_array(struct spa_pod_builder *builder)
{
const struct spa_pod_array p =
{ {sizeof(struct spa_pod_array_body) - sizeof(struct spa_pod), SPA_POD_TYPE_ARRAY},
{{0, 0}} };
return spa_pod_builder_push(builder, frame, &p.pod,
return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p,
sizeof(p) - sizeof(struct spa_pod)));
}
@ -312,10 +320,10 @@ spa_pod_builder_array(struct spa_pod_builder *builder,
#define SPA_POD_STRUCT_INIT(size) { { size, SPA_POD_TYPE_STRUCT } }
static inline uint32_t
spa_pod_builder_push_struct(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
spa_pod_builder_push_struct(struct spa_pod_builder *builder)
{
const struct spa_pod_struct p = SPA_POD_STRUCT_INIT(0);
return spa_pod_builder_push(builder, frame, &p.pod,
return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p, sizeof(p)));
}
@ -323,12 +331,11 @@ spa_pod_builder_push_struct(struct spa_pod_builder *builder, struct spa_pod_fram
#define SPA_POD_OBJECT_INIT_COMPLEX(size,id,type,...) { { size, SPA_POD_TYPE_OBJECT }, { id, type }, __VA_ARGS__ }
static inline uint32_t
spa_pod_builder_push_object(struct spa_pod_builder *builder,
struct spa_pod_frame *frame, uint32_t id, uint32_t type)
spa_pod_builder_push_object(struct spa_pod_builder *builder, uint32_t id, uint32_t type)
{
const struct spa_pod_object p =
SPA_POD_OBJECT_INIT(sizeof(struct spa_pod_object_body), id, type);
return spa_pod_builder_push(builder, frame, &p.pod,
return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p, sizeof(p)));
}
@ -336,12 +343,11 @@ spa_pod_builder_push_object(struct spa_pod_builder *builder,
{ { size, SPA_POD_TYPE_PROP}, {key, flags, { val_size, val_type } } }
static inline uint32_t
spa_pod_builder_push_prop(struct spa_pod_builder *builder,
struct spa_pod_frame *frame, uint32_t key, uint32_t flags)
spa_pod_builder_push_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t flags)
{
const struct spa_pod_prop p = SPA_POD_PROP_INIT (sizeof(struct spa_pod_prop_body) -
sizeof(struct spa_pod), key, flags, 0, 0);
return spa_pod_builder_push(builder, frame, &p.pod,
return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p,
sizeof(p) - sizeof(struct spa_pod)));
}
@ -480,14 +486,14 @@ spa_pod_builder_addv(struct spa_pod_builder *builder,
{
uint32_t id = va_arg(args, uint32_t);
uint32_t type = va_arg(args, uint32_t);
spa_pod_builder_push_object(builder, &builder->frame[builder->depth++], id, type);
spa_pod_builder_push_object(builder, id, type);
break;
}
case '[':
spa_pod_builder_push_struct(builder, &builder->frame[builder->depth++]);
spa_pod_builder_push_struct(builder);
break;
case '(':
spa_pod_builder_push_array(builder, &builder->frame[builder->depth++]);
spa_pod_builder_push_array(builder);
break;
case ':':
{
@ -507,7 +513,7 @@ spa_pod_builder_addv(struct spa_pod_builder *builder,
for (;*spec;spec++)
flags |= spa_pod_flag_from_id(*spec);
spa_pod_builder_push_prop(builder, &builder->frame[builder->depth++], key, flags);
spa_pod_builder_push_prop(builder, key, flags);
if (type == '{' || type == '[')
continue;
@ -522,14 +528,14 @@ spa_pod_builder_addv(struct spa_pod_builder *builder,
if (n_values == -2)
n_values = va_arg(args, int);
}
spa_pod_builder_pop(builder, &builder->frame[--builder->depth]);
spa_pod_builder_pop(builder);
break;
}
case ']': case ')': case '>':
spa_pod_builder_pop(builder, &builder->frame[--builder->depth]);
spa_pod_builder_pop(builder);
if (builder->depth > 0 &&
builder->frame[builder->depth-1].pod.type == SPA_POD_TYPE_PROP)
spa_pod_builder_pop(builder, &builder->frame[--builder->depth]);
spa_pod_builder_pop(builder);
break;
case ' ': case '\n': case '\t': case '\r':
break;
@ -542,7 +548,7 @@ spa_pod_builder_addv(struct spa_pod_builder *builder,
}
format++;
}
return SPA_POD_BUILDER_DEREF(builder, builder->frame[builder->depth].ref, void);
return spa_pod_builder_deref(builder, builder->frame[builder->depth].ref);
}
static inline void *spa_pod_builder_add(struct spa_pod_builder *builder, const char *format, ...)

16
spa/include/spa/pod-parser.h
View file

@ -27,13 +27,9 @@ extern "C" {
#include <stdarg.h>
#include <spa/pod-iter.h>
#ifndef SPA_POD_MAX_LEVEL
#define SPA_POD_MAX_LEVEL 16
#endif
struct spa_pod_parser {
struct spa_pod_iter iter[SPA_POD_MAX_LEVEL];
int depth;
struct spa_pod_iter iter[SPA_POD_MAX_DEPTH];
};
static inline void spa_pod_parser_init(struct spa_pod_parser *parser,
@ -210,13 +206,19 @@ static inline int spa_pod_parser_getv(struct spa_pod_parser *parser,
case '<':
if (pod == NULL || SPA_POD_TYPE(pod) != SPA_POD_TYPE_OBJECT)
return SPA_RESULT_ERROR;
it = &parser->iter[++parser->depth];
if (++parser->depth >= SPA_POD_MAX_DEPTH)
return SPA_RESULT_INVALID_ARGUMENTS;
it = &parser->iter[parser->depth];
spa_pod_iter_init(it, pod, SPA_POD_SIZE(pod), sizeof(struct spa_pod_object));
goto read_pod;
case '[':
if (pod == NULL || SPA_POD_TYPE(pod) != SPA_POD_TYPE_STRUCT)
return SPA_RESULT_ERROR;
it = &parser->iter[++parser->depth];
if (++parser->depth >= SPA_POD_MAX_DEPTH)
return SPA_RESULT_INVALID_ARGUMENTS;
it = &parser->iter[parser->depth];
spa_pod_iter_init(it, pod, SPA_POD_SIZE(pod), sizeof(struct spa_pod_struct));
goto read_pod;
case ']': case '>':

17
spa/include/spa/pod-utils.h
View file

@ -46,6 +46,15 @@ static inline bool spa_pod_is_object_type(struct spa_pod *pod, uint32_t type)
return (pod->type == SPA_POD_TYPE_OBJECT
&& ((struct spa_pod_object *) pod)->body.type == type);
}
static inline bool spa_pod_has_next(const void *pod, uint32_t size, const struct spa_pod *iter)
{
return iter < SPA_MEMBER(pod, size, struct spa_pod);
}
static inline struct spa_pod *spa_pod_next(const struct spa_pod *iter)
{
return SPA_MEMBER(iter, SPA_ROUND_UP_N (SPA_POD_SIZE (iter), 8), struct spa_pod);
}
#define SPA_POD_ARRAY_BODY_FOREACH(body, _size, iter) \
for ((iter) = SPA_MEMBER((body), sizeof(struct spa_pod_array_body), __typeof__(*(iter))); \
@ -54,16 +63,16 @@ static inline bool spa_pod_is_object_type(struct spa_pod *pod, uint32_t type)
#define SPA_POD_FOREACH(pod, size, iter) \
for ((iter) = (pod); \
(iter) < SPA_MEMBER((pod), (size), struct spa_pod); \
(iter) = SPA_MEMBER((iter), SPA_ROUND_UP_N (SPA_POD_SIZE (iter), 8), struct spa_pod))
spa_pod_has_next(pod, size, iter); \
(iter) = spa_pod_next(iter))
#define SPA_POD_CONTENTS_FOREACH(pod, offset, iter) \
SPA_POD_FOREACH(SPA_MEMBER((pod), (offset), struct spa_pod),SPA_POD_SIZE (pod)-(offset),iter)
#define SPA_POD_OBJECT_BODY_FOREACH(body, size, iter) \
for ((iter) = SPA_MEMBER((body), sizeof(struct spa_pod_object_body), struct spa_pod); \
(iter) < SPA_MEMBER((body), (size), struct spa_pod); \
(iter) = SPA_MEMBER((iter), SPA_ROUND_UP_N(SPA_POD_SIZE (iter), 8), struct spa_pod))
spa_pod_has_next(body, size, iter); \
(iter) = spa_pod_next(iter))
#define SPA_POD_OBJECT_FOREACH(obj, iter) \
SPA_POD_OBJECT_BODY_FOREACH(&obj->body, SPA_POD_BODY_SIZE(obj), iter)

4
spa/include/spa/pod.h
View file

@ -37,6 +37,10 @@ extern "C" {
#define SPA_TYPE_POD__Struct SPA_TYPE_POD_BASE "Struct"
#define SPA_TYPE_POD_STRUCT_BASE SPA_TYPE_POD__Struct ":"
#ifndef SPA_POD_MAX_DEPTH
#define SPA_POD_MAX_DEPTH 16
#endif
/**
* spa_pod_type:
*/

5
spa/lib/format.c
View file

@ -29,7 +29,6 @@ spa_pod_object_filter(const struct spa_pod_object *obj,
struct spa_pod_object *filter,
struct spa_pod_builder *result)
{
struct spa_pod_frame f;
int res;
if (obj == NULL || result == NULL)
@ -40,13 +39,13 @@ spa_pod_object_filter(const struct spa_pod_object *obj,
return SPA_RESULT_OK;
}
spa_pod_builder_push_object(result, &f, obj->body.id, obj->body.type);
spa_pod_builder_push_object(result, obj->body.id, obj->body.type);
res = spa_props_filter(result,
SPA_POD_CONTENTS(struct spa_pod_object, obj),
SPA_POD_CONTENTS_SIZE(struct spa_pod_object, obj),
SPA_POD_CONTENTS(struct spa_pod_object, filter),
SPA_POD_CONTENTS_SIZE(struct spa_pod_object, filter));
spa_pod_builder_pop(result, &f);
spa_pod_builder_pop(result);
return res;
}

34
spa/lib/props.c
View file

@ -138,19 +138,34 @@ spa_props_filter(struct spa_pod_builder *b,
uint32_t filter_size)
{
int j, k;
const struct spa_pod *pr;
const struct spa_pod *pp, *pf;
SPA_POD_FOREACH(props, props_size, pr) {
struct spa_pod_frame f;
pf = filter;
SPA_POD_FOREACH(props, props_size, pp) {
struct spa_pod_prop *p1, *p2, *np;
int nalt1, nalt2;
void *alt1, *alt2, *a1, *a2;
uint32_t rt1, rt2;
if (pr->type != SPA_POD_TYPE_PROP)
continue;
if (pp->type != SPA_POD_TYPE_PROP) {
if (pf != NULL) {
if (SPA_POD_SIZE(pp) != SPA_POD_SIZE(pf))
return SPA_RESULT_INCOMPATIBLE_PROPS;
p1 = (struct spa_pod_prop *) pr;
if (memcmp(pf, pp, SPA_POD_SIZE(pp)) != 0)
return SPA_RESULT_INCOMPATIBLE_PROPS;
if (spa_pod_has_next(filter, filter_size, pf))
pf = spa_pod_next(pf);
else
pf = NULL;
}
spa_pod_builder_raw_padded(b, pp, SPA_POD_SIZE(pp));
continue;
}
p1 = (struct spa_pod_prop *) pp;
if (filter == NULL || (p2 = find_prop(filter, filter_size, p1->body.key)) == NULL) {
/* no filter, copy the complete property */
@ -166,8 +181,8 @@ spa_props_filter(struct spa_pod_builder *b,
rt2 = p2->body.flags & SPA_POD_PROP_RANGE_MASK;
/* else we filter. start with copying the property */
spa_pod_builder_push_prop(b, &f, p1->body.key, 0),
np = SPA_POD_BUILDER_DEREF(b, f.ref, struct spa_pod_prop);
np = spa_pod_builder_deref(b,
spa_pod_builder_push_prop(b, p1->body.key, 0));
/* default value */
spa_pod_builder_raw(b, &p1->body.value,
@ -306,7 +321,7 @@ spa_props_filter(struct spa_pod_builder *b,
if (rt1 == SPA_POD_PROP_RANGE_FLAGS && rt2 == SPA_POD_PROP_RANGE_FLAGS)
return SPA_RESULT_NOT_IMPLEMENTED;
spa_pod_builder_pop(b, &f);
spa_pod_builder_pop(b);
fix_default(np);
}
return SPA_RESULT_OK;
@ -346,5 +361,4 @@ int spa_props_compare(const struct spa_pod *props1,
return SPA_RESULT_INCOMPATIBLE_PROPS;
}
return SPA_RESULT_OK;
}

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

@ -402,9 +402,10 @@ static int port_set_format(struct spa_node *node,
} else {
struct spa_audio_info info = { 0 };
spa_pod_object_parse(format,
if ((err = spa_pod_object_parse(format,
"I", &info.media_type,
"I", &info.media_subtype);
"I", &info.media_subtype)) < 0)
return err;
if (info.media_type != this->type.media_type.audio ||
info.media_subtype != this->type.media_subtype.raw)

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

@ -128,25 +128,24 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
unsigned int min, max;
uint8_t buffer[4096];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
struct spa_pod_frame f[2];
struct spa_pod_prop *prop;
struct spa_pod_object *fmt;
int res;
bool opened;
if (*index > 0)
return SPA_RESULT_ENUM_END;
opened = state->opened;
if ((err = spa_alsa_open(state)) < 0)
return err;
next:
if (*index > 0)
return SPA_RESULT_ENUM_END;
hndl = state->hndl;
snd_pcm_hw_params_alloca(&params);
CHECK(snd_pcm_hw_params_any(hndl, params), "Broken configuration: no configurations available");
spa_pod_builder_push_object(&b, &f[0],
state->type.param.idEnumFormat, state->type.format);
spa_pod_builder_push_object(&b, state->type.param.idEnumFormat, state->type.format);
spa_pod_builder_add(&b,
"I", state->type.media_type.audio,
"I", state->type.media_subtype.raw, 0);
@ -154,8 +153,8 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
snd_pcm_format_mask_alloca(&fmask);
snd_pcm_hw_params_get_format_mask(params, fmask);
spa_pod_builder_push_prop(&b, &f[1], state->type.format_audio.format, SPA_POD_PROP_RANGE_NONE);
prop = SPA_POD_BUILDER_DEREF(&b, f[1].ref, struct spa_pod_prop);
prop = spa_pod_builder_deref(&b,
spa_pod_builder_push_prop(&b, state->type.format_audio.format, SPA_POD_PROP_RANGE_NONE));
for (i = 1, j = 0; i < SPA_N_ELEMENTS(format_info); i++) {
const struct format_info *fi = &format_info[i];
@ -169,13 +168,13 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
}
if (j > 1)
prop->body.flags |= SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET;
spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(&b);
CHECK(snd_pcm_hw_params_get_rate_min(params, &min, &dir), "get_rate_min");
CHECK(snd_pcm_hw_params_get_rate_max(params, &max, &dir), "get_rate_max");
spa_pod_builder_push_prop(&b, &f[1], state->type.format_audio.rate, SPA_POD_PROP_RANGE_NONE);
prop = SPA_POD_BUILDER_DEREF(&b, f[1].ref, struct spa_pod_prop);
prop = spa_pod_builder_deref(&b,
spa_pod_builder_push_prop(&b, state->type.format_audio.rate, SPA_POD_PROP_RANGE_NONE));
spa_pod_builder_int(&b, SPA_CLAMP(44100, min, max));
if (min != max) {
@ -183,13 +182,13 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
spa_pod_builder_int(&b, max);
prop->body.flags |= SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET;
}
spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(&b);
CHECK(snd_pcm_hw_params_get_channels_min(params, &min), "get_channels_min");
CHECK(snd_pcm_hw_params_get_channels_max(params, &max), "get_channels_max");
spa_pod_builder_push_prop(&b, &f[1], state->type.format_audio.channels, SPA_POD_PROP_RANGE_NONE);
prop = SPA_POD_BUILDER_DEREF(&b, f[1].ref, struct spa_pod_prop);
prop = spa_pod_builder_deref(&b,
spa_pod_builder_push_prop(&b, state->type.format_audio.channels, SPA_POD_PROP_RANGE_NONE));
spa_pod_builder_int(&b, SPA_CLAMP(2, min, max));
if (min != max) {
@ -197,15 +196,14 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
spa_pod_builder_int(&b, max);
prop->body.flags |= SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET;
}
spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(&b, &f[0]);
spa_pod_builder_pop(&b);
fmt = SPA_POD_BUILDER_DEREF(&b, f[0].ref, struct spa_pod_object);
fmt = spa_pod_builder_pop_deref(&b);
(*index)++;
if ((res = spa_pod_object_filter(fmt, filter, builder)) < 0)
return res;
goto next;
if (!opened)
spa_alsa_close(state);

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

@ -462,7 +462,6 @@ static int port_get_format(struct spa_node *node,
struct spa_pod_builder *builder)
{
struct impl *this = SPA_CONTAINER_OF(node, struct impl, node);
struct spa_pod_frame f[1];
struct type *t = &this->type;
struct port *port = &this->out_ports[port_id];
@ -471,8 +470,7 @@ static int port_get_format(struct spa_node *node,
if (*index > 0)
return SPA_RESULT_ENUM_END;
spa_pod_builder_push_object(builder, &f[0],
t->param.idFormat, t->format);
spa_pod_builder_push_object(builder, t->param.idFormat, t->format);
spa_pod_builder_add(builder,
"I", port->current_format.media_type,
@ -495,7 +493,7 @@ static int port_get_format(struct spa_node *node,
} else
return SPA_RESULT_NO_FORMAT;
spa_pod_builder_pop(builder, &f[0]);
spa_pod_builder_pop(builder);
return SPA_RESULT_OK;
}

45
spa/plugins/v4l2/v4l2-utils.c
View file

@ -530,10 +530,10 @@ spa_v4l2_enum_format(struct impl *this,
struct port *port = &this->out_ports[0];
int res, n_fractions;
const struct format_info *info;
struct spa_pod_frame f[2];
struct spa_pod_prop *prop;
uint32_t media_type, media_subtype, video_format;
uint32_t filter_media_type, filter_media_subtype;
struct type *t = &this->type;
if (spa_v4l2_open(this) < 0)
return SPA_RESULT_ERROR;
@ -562,15 +562,15 @@ spa_v4l2_enum_format(struct impl *this,
while (port->next_fmtdesc) {
if (filter) {
video_format = enum_filter_format(&this->type,
video_format = enum_filter_format(t,
filter_media_type,
filter_media_subtype,
filter, port->fmtdesc.index);
if (video_format == this->type.video_format.UNKNOWN)
if (video_format == t->video_format.UNKNOWN)
return SPA_RESULT_ENUM_END;
info = find_format_info_by_media_type(&this->type,
info = find_format_info_by_media_type(t,
filter_media_type,
filter_media_subtype,
video_format, 0);
@ -599,7 +599,7 @@ spa_v4l2_enum_format(struct impl *this,
struct spa_pod_prop *p;
/* check if we have a fixed frame size */
if (!(p = spa_pod_object_find_prop(filter, this->type.format_video.size)))
if (!(p = spa_pod_object_find_prop(filter, t->format_video.size)))
goto do_frmsize;
if (p->body.value.type != SPA_POD_TYPE_RECTANGLE)
@ -633,7 +633,7 @@ spa_v4l2_enum_format(struct impl *this,
uint32_t i, n_values;
/* check if we have a fixed frame size */
if (!(p = spa_pod_object_find_prop(filter, this->type.format_video.size)))
if (!(p = spa_pod_object_find_prop(filter, t->format_video.size)))
goto have_size;
range = p->body.flags & SPA_POD_PROP_RANGE_MASK;
@ -679,28 +679,26 @@ spa_v4l2_enum_format(struct impl *this,
}
}
media_type = *SPA_MEMBER(&this->type, info->media_type_offset, uint32_t);
media_subtype = *SPA_MEMBER(&this->type, info->media_subtype_offset, uint32_t);
video_format = *SPA_MEMBER(&this->type, info->format_offset, uint32_t);
media_type = *SPA_MEMBER(t, info->media_type_offset, uint32_t);
media_subtype = *SPA_MEMBER(t, info->media_subtype_offset, uint32_t);
video_format = *SPA_MEMBER(t, info->format_offset, uint32_t);
spa_pod_builder_push_object(builder, &f[0],
this->type.param.idEnumFormat, this->type.format);
spa_pod_builder_push_object(builder, t->param.idEnumFormat, t->format);
spa_pod_builder_add(builder,
"I", media_type,
"I", media_subtype, 0);
if (media_subtype == this->type.media_subtype.raw) {
if (media_subtype == t->media_subtype.raw) {
spa_pod_builder_add(builder,
":", this->type.format_video.format, "I", video_format, 0);
":", t->format_video.format, "I", video_format, 0);
}
spa_pod_builder_add(builder,
":", this->type.format_video.size, "R", &SPA_RECTANGLE(port->frmsize.discrete.width,
port->frmsize.discrete.height), 0);
":", t->format_video.size, "R", &SPA_RECTANGLE(port->frmsize.discrete.width,
port->frmsize.discrete.height), 0);
spa_pod_builder_push_prop(builder, &f[1], this->type.format_video.framerate,
SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_UNSET);
prop = SPA_POD_BUILDER_DEREF(builder, f[1].ref, struct spa_pod_prop);
prop = spa_pod_builder_deref(builder,
spa_pod_builder_push_prop(builder, t->format_video.framerate,
SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_UNSET));
n_fractions = 0;
port->frmival.index = 0;
@ -723,7 +721,7 @@ spa_v4l2_enum_format(struct impl *this,
uint32_t i, n_values;
const struct spa_fraction step = { 1, 1 }, *values;
if (!(p = spa_pod_object_find_prop(filter, this->type.format_video.framerate)))
if (!(p = spa_pod_object_find_prop(filter, t->format_video.framerate)))
goto have_framerate;
if (p->body.value.type != SPA_POD_TYPE_FRACTION)
@ -790,8 +788,8 @@ spa_v4l2_enum_format(struct impl *this,
if (n_fractions <= 1) {
prop->body.flags &= ~(SPA_POD_PROP_RANGE_MASK | SPA_POD_PROP_FLAG_UNSET);
}
spa_pod_builder_pop(builder, &f[1]);
spa_pod_builder_pop(builder, &f[0]);
spa_pod_builder_pop(builder);
spa_pod_builder_pop(builder);
(*index)++;
@ -808,6 +806,7 @@ static int spa_v4l2_set_format(struct impl *this, struct spa_video_info *format,
uint32_t video_format;
struct spa_rectangle *size = NULL;
struct spa_fraction *framerate = NULL;
struct type *t = &this->type;
spa_zero(fmt);
spa_zero(streamparm);
@ -831,7 +830,7 @@ static int spa_v4l2_set_format(struct impl *this, struct spa_video_info *format,
video_format = this->type.video_format.ENCODED;
}
info = find_format_info_by_media_type(&this->type,
info = find_format_info_by_media_type(t,
format->media_type,
format->media_subtype, video_format, 0);
if (info == NULL || size == NULL || framerate == NULL) {

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

@ -386,20 +386,25 @@ static int negotiate_formats(struct data *data)
ref = b.offset;
spa_debug_pod(&filter->pod, 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, &b)) < 0)
return res;
format = SPA_POD_BUILDER_DEREF(&b, ref, struct spa_pod_object);
format = spa_pod_builder_deref(&b, ref);
spa_debug_pod(&format->pod, 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;
spa_log_debug(&default_log.log, "volume set_param");
if ((res = spa_node_port_set_param(data->volume,
SPA_DIRECTION_OUTPUT, 0,
data->type.param.idFormat, 0, format)) < 0)

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

@ -475,7 +475,7 @@ static int negotiate_formats(struct data *data)
filter, &b)) < 0)
return res;
format = SPA_POD_BUILDER_DEREF(&b, ref, struct spa_pod_object);
format = spa_pod_builder_deref(&b, ref);
if ((res = spa_node_port_set_param(data->sink,
SPA_DIRECTION_INPUT, 0,

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

@ -278,7 +278,6 @@ static void do_static_struct(struct spa_type_map *map)
int main(int argc, char *argv[])
{
struct spa_pod_builder b = { NULL, };
struct spa_pod_frame f[2];
uint8_t buffer[1024];
struct spa_pod_object *fmt;
struct spa_type_map *map = &default_map.map;
@ -288,36 +287,35 @@ int main(int argc, char *argv[])
spa_pod_builder_init(&b, buffer, sizeof(buffer));
fmt = SPA_MEMBER(buffer, spa_pod_builder_push_object(&b, &f[0], 0, type.format),
struct spa_pod_object);
spa_pod_builder_push_object(&b, 0, type.format);
spa_pod_builder_id(&b, type.media_type.video);
spa_pod_builder_id(&b, type.media_subtype.raw);
spa_pod_builder_push_prop(&b, &f[1], type.format_video.format,
spa_pod_builder_push_prop(&b, type.format_video.format,
SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET);
spa_pod_builder_id(&b, type.video_format.I420);
spa_pod_builder_id(&b, type.video_format.I420);
spa_pod_builder_id(&b, type.video_format.YUY2);
spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(&b);
struct spa_rectangle size_min_max[] = { {1, 1}, {INT32_MAX, INT32_MAX} };
spa_pod_builder_push_prop(&b, &f[1],
spa_pod_builder_push_prop(&b,
type.format_video.size,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET);
spa_pod_builder_rectangle(&b, 320, 240);
spa_pod_builder_raw(&b, size_min_max, sizeof(size_min_max));
spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(&b);
struct spa_fraction rate_min_max[] = { {0, 1}, {INT32_MAX, 1} };
spa_pod_builder_push_prop(&b, &f[1],
spa_pod_builder_push_prop(&b,
type.format_video.framerate,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET);
spa_pod_builder_fraction(&b, 25, 1);
spa_pod_builder_raw(&b, rate_min_max, sizeof(rate_min_max));
spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(&b);
spa_pod_builder_pop(&b, &f[0]);
fmt = spa_pod_builder_pop_deref(&b);
spa_debug_pod(&fmt->pod, 0);

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

@ -39,8 +39,8 @@ static SPA_TYPE_MAP_IMPL(default_map, 4096);
int main(int argc, char *argv[])
{
struct spa_pod_builder b = { NULL, };
struct spa_pod_frame frame[4];
uint8_t buffer[1024];
uint32_t ref;
struct spa_pod *obj;
struct spa_pod_parser prs;
struct spa_type_map *map = &default_map.map;
@ -50,28 +50,28 @@ int main(int argc, char *argv[])
b.data = buffer;
b.size = 1024;
spa_pod_builder_push_object(&b, &frame[0], 0, 0);
spa_pod_builder_push_object(&b, 0, 0);
uint32_t formats[] = { 1, 2 };
spa_pod_builder_push_prop(&b, &frame[1], 1, SPA_POD_PROP_RANGE_ENUM);
spa_pod_builder_push_prop(&b, 1, SPA_POD_PROP_RANGE_ENUM);
spa_pod_builder_int(&b, 1);
spa_pod_builder_int(&b, formats[0]);
spa_pod_builder_int(&b, formats[1]);
spa_pod_builder_pop(&b, &frame[1]);
spa_pod_builder_pop(&b);
spa_pod_builder_push_prop(&b, &frame[1], 2, 0);
spa_pod_builder_push_prop(&b, 2, 0);
spa_pod_builder_int(&b, 42);
spa_pod_builder_pop(&b, &frame[1]);
spa_pod_builder_pop(&b);
struct spa_rectangle sizes[] = { {0, 0}, {1024, 1024} };
spa_pod_builder_push_prop(&b, &frame[1],
spa_pod_builder_push_prop(&b,
3, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET);
spa_pod_builder_rectangle(&b, 320, 240);
spa_pod_builder_raw(&b, sizes, sizeof(sizes));
spa_pod_builder_pop(&b, &frame[1]);
spa_pod_builder_pop(&b);
spa_pod_builder_push_prop(&b, &frame[1], 4, SPA_POD_PROP_FLAG_READONLY);
spa_pod_builder_push_struct(&b, &frame[2]);
spa_pod_builder_push_prop(&b, 4, SPA_POD_PROP_FLAG_READONLY);
ref = spa_pod_builder_push_struct(&b);
spa_pod_builder_int(&b, 4);
spa_pod_builder_long(&b, 6000);
spa_pod_builder_float(&b, 4.0);
@ -79,23 +79,22 @@ int main(int argc, char *argv[])
spa_pod_builder_string(&b, "test123");
spa_pod_builder_rectangle(&b, 320, 240);
spa_pod_builder_fraction(&b, 25, 1);
spa_pod_builder_push_array(&b, &frame[3]);
spa_pod_builder_push_array(&b);
spa_pod_builder_int(&b, 4);
spa_pod_builder_int(&b, 5);
spa_pod_builder_int(&b, 6);
spa_pod_builder_pop(&b, &frame[3]);
spa_pod_builder_pop(&b, &frame[2]);
spa_pod_builder_pop(&b, &frame[1]);
spa_pod_builder_pop(&b, &frame[0]);
spa_pod_builder_pop(&b);
spa_pod_builder_pop(&b);
spa_pod_builder_pop(&b);
obj = spa_pod_builder_pop_deref(&b);
obj = SPA_POD_BUILDER_DEREF(&b, frame[0].ref, struct spa_pod);
spa_debug_pod(obj, 0);
struct spa_pod_prop *p = spa_pod_object_find_prop((struct spa_pod_object *) obj, 4);
printf("%d %d\n", p->body.key, p->body.flags);
spa_debug_pod(&p->body.value, 0);
obj = SPA_POD_BUILDER_DEREF(&b, frame[2].ref, struct spa_pod);
obj = spa_pod_builder_deref(&b, ref);
int32_t vi, *pi;
int64_t vl;

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

@ -64,11 +64,11 @@
*/
#endif
#define SPA_POD_MAX_LEVEL 16
#define SPA_POD_MAX_DEPTH 16
struct spa_pod_maker {
struct spa_pod_builder b;
struct spa_pod_frame frame[SPA_POD_MAX_LEVEL];
struct spa_pod_frame frame[SPA_POD_MAX_DEPTH];
int depth;
};
@ -392,7 +392,7 @@ static inline int
spa_pod_match(struct spa_pod *pod,
const char *templ, ...)
{
struct spa_pod_iter it[SPA_POD_MAX_LEVEL];
struct spa_pod_iter it[SPA_POD_MAX_DEPTH];
int depth = 0, collected = 0;
va_list args;
const char *start;

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

@ -340,7 +340,7 @@ static int negotiate_formats(struct data *data)
filter, &b)) < 0)
return res;
format = SPA_POD_BUILDER_DEREF(&b, ref, struct spa_pod_object);
format = spa_pod_builder_deref(&b, ref);
if ((res = spa_node_port_set_param(data->sink,
SPA_DIRECTION_INPUT, 0,

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

@ -417,7 +417,7 @@ static int negotiate_formats(struct data *data)
if ((res = spa_node_port_set_param(data->source,
SPA_DIRECTION_OUTPUT, 0,
data->type.param.idFormat, 0,
(struct spa_pod_object*)format)) < 0)
format)) < 0)
return res;
if ((res = spa_node_port_get_info(data->source, SPA_DIRECTION_OUTPUT, 0, &info)) < 0)

8
spa/tools/spa-inspect.c
View file

@ -71,7 +71,7 @@ inspect_node_params(struct data *data, struct spa_node *node)
printf("enum_params error %d\n", res);
break;
}
param = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
param = spa_pod_builder_deref(&b, 0);
spa_pod_object_parse(param,
":", data->type.param.listId, "I", &id,
@ -89,7 +89,7 @@ inspect_node_params(struct data *data, struct spa_node *node)
printf("enum_params %id error %d\n", id, res);
break;
}
param = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
param = spa_pod_builder_deref(&b, 0);
spa_debug_pod(&param->pod, flags);
}
}
@ -117,7 +117,7 @@ inspect_port_params(struct data *data, struct spa_node *node,
printf("port_enum_params error %d\n", res);
break;
}
param = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
param = spa_pod_builder_deref(&b, 0);
spa_pod_object_parse(param,
":", data->type.param.listId, "I", &id,
NULL);
@ -135,7 +135,7 @@ inspect_port_params(struct data *data, struct spa_node *node,
printf("port_enum_params error %d\n", res);
break;
}
param = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
param = spa_pod_builder_deref(&b, 0);
if (param->body.type == data->type.format)
flags |= SPA_DEBUG_FLAG_FORMAT;
spa_debug_pod(&param->pod, flags);

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

@ -242,7 +242,6 @@ static int port_enum_formats(struct spa_node *node,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct spa_pod_frame f[2];
SDL_RendererInfo info;
int i, c;
@ -251,12 +250,12 @@ static int port_enum_formats(struct spa_node *node,
SDL_GetRendererInfo(d->renderer, &info);
spa_pod_builder_push_object(builder, &f[0],
spa_pod_builder_push_object(builder,
d->t->param.idEnumFormat, d->type.format);
spa_pod_builder_id(builder, d->type.media_type.video);
spa_pod_builder_id(builder, d->type.media_subtype.raw);
spa_pod_builder_push_prop(builder, &f[1], d->type.format_video.format,
spa_pod_builder_push_prop(builder, d->type.format_video.format,
SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM);
for (i = 0, c = 0; i < info.num_texture_formats; i++) {
@ -274,7 +273,7 @@ static int port_enum_formats(struct spa_node *node,
if (id != d->type.video_format.UNKNOWN)
spa_pod_builder_id(builder, id);
}
spa_pod_builder_pop(builder, &f[1]);
spa_pod_builder_pop(builder);
spa_pod_builder_add(builder,
":", d->type.format_video.size, "Rru", &SPA_RECTANGLE(WIDTH, HEIGHT),
2, &SPA_RECTANGLE(1,1),
@ -284,7 +283,7 @@ static int port_enum_formats(struct spa_node *node,
2, &SPA_FRACTION(0,1),
&SPA_FRACTION(30,1),
NULL);
spa_pod_builder_pop(builder, &f[0]);
spa_pod_builder_pop(builder);
(*index)++;

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

@ -238,7 +238,6 @@ static int port_enum_formats(struct spa_node *node,
struct spa_pod_builder *builder)
{
struct data *d = SPA_CONTAINER_OF(node, struct data, impl_node);
struct spa_pod_frame f[2];
SDL_RendererInfo info;
int i, c;
@ -247,12 +246,12 @@ static int port_enum_formats(struct spa_node *node,
SDL_GetRendererInfo(d->renderer, &info);
spa_pod_builder_push_object(builder, &f[0],
spa_pod_builder_push_object(builder,
d->t->param.idEnumFormat, d->type.format);
spa_pod_builder_id(builder, d->type.media_type.video);
spa_pod_builder_id(builder, d->type.media_subtype.raw);
spa_pod_builder_push_prop(builder, &f[1], d->type.format_video.format,
spa_pod_builder_push_prop(builder, d->type.format_video.format,
SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM);
for (i = 0, c = 0; i < info.num_texture_formats; i++) {
@ -270,7 +269,7 @@ static int port_enum_formats(struct spa_node *node,
if (id != d->type.video_format.UNKNOWN)
spa_pod_builder_id(builder, id);
}
spa_pod_builder_pop(builder, &f[1]);
spa_pod_builder_pop(builder);
spa_pod_builder_add(builder,
":", d->type.format_video.size, "Rru", &SPA_RECTANGLE(WIDTH, HEIGHT),
@ -281,7 +280,7 @@ static int port_enum_formats(struct spa_node *node,
2, &SPA_FRACTION(0,1),
&SPA_FRACTION(30,1),
NULL);
spa_pod_builder_pop(builder, &f[0]);
spa_pod_builder_pop(builder);
(*index)++;

10
src/examples/video-play.c
View file

@ -306,7 +306,6 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
const struct spa_pod_object *params[1];
uint8_t buffer[1024];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
struct spa_pod_frame f[2];
SDL_RendererInfo info;
int i, c;
@ -317,12 +316,12 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
SDL_GetRendererInfo(data->renderer, &info);
spa_pod_builder_push_object(&b, &f[0],
spa_pod_builder_push_object(&b,
data->type.param.idEnumFormat, data->type.format);
spa_pod_builder_id(&b, data->type.media_type.video);
spa_pod_builder_id(&b, data->type.media_subtype.raw);
spa_pod_builder_push_prop(&b, &f[1], data->type.format_video.format,
spa_pod_builder_push_prop(&b, data->type.format_video.format,
SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM);
for (i = 0, c = 0; i < info.num_texture_formats; i++) {
@ -340,7 +339,7 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
if (id != data->type.video_format.UNKNOWN)
spa_pod_builder_id(&b, id);
}
spa_pod_builder_pop(&b, &f[1]);
spa_pod_builder_pop(&b);
spa_pod_builder_add(&b,
":", data->type.format_video.size, "Rru", &SPA_RECTANGLE(WIDTH, HEIGHT),
2, &SPA_RECTANGLE(1,1),
@ -350,8 +349,7 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
2, &SPA_RECTANGLE(0,1),
&SPA_RECTANGLE(30,1),
NULL);
spa_pod_builder_pop(&b, &f[0]);
params[0] = SPA_POD_BUILDER_DEREF(&b, f[0].ref, struct spa_pod_object);
params[0] = spa_pod_builder_pop_deref(&b);
printf("supported formats:\n");
spa_debug_pod(&params[0]->pod, SPA_DEBUG_FLAG_FORMAT);

57
src/gst/gstpipewireformat.c
View file

@ -372,9 +372,9 @@ get_range_type2 (const GValue *v1, const GValue *v2)
static gboolean
handle_video_fields (ConvertData *d)
{
struct spa_pod_frame f;
const GValue *value, *value2;
int i;
struct spa_pod_prop *prop;
value = gst_structure_get_value (d->cs, "format");
if (value) {
@ -382,7 +382,7 @@ handle_video_fields (ConvertData *d)
int idx;
for (i = 0; (v = get_nth_string (value, i)); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
spa_pod_builder_push_prop (&d->b,
type.format_video.format,
get_range_type (value));
@ -390,9 +390,9 @@ handle_video_fields (ConvertData *d)
if (idx < SPA_N_ELEMENTS (video_format_map))
spa_pod_builder_id (&d->b, *video_format_map[idx]);
}
prop = spa_pod_builder_pop_deref(&d->b);
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, struct spa_pod_prop)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
spa_pod_builder_pop (&d->b, &f);
prop->body.flags |= SPA_POD_PROP_FLAG_UNSET;
}
value = gst_structure_get_value (d->cs, "width");
value2 = gst_structure_get_value (d->cs, "height");
@ -400,15 +400,15 @@ handle_video_fields (ConvertData *d)
struct spa_rectangle v;
for (i = 0; get_nth_rectangle (value, value2, i, &v); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
spa_pod_builder_push_prop (&d->b,
type.format_video.size,
get_range_type2 (value, value2));
spa_pod_builder_rectangle (&d->b, v.width, v.height);
}
prop = spa_pod_builder_pop_deref(&d->b);
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, struct spa_pod_prop)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
spa_pod_builder_pop (&d->b, &f);
prop->body.flags |= SPA_POD_PROP_FLAG_UNSET;
}
value = gst_structure_get_value (d->cs, "framerate");
@ -416,15 +416,15 @@ handle_video_fields (ConvertData *d)
struct spa_fraction v;
for (i = 0; get_nth_fraction (value, i, &v); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
spa_pod_builder_push_prop (&d->b,
type.format_video.framerate,
get_range_type (value));
spa_pod_builder_fraction (&d->b, v.num, v.denom);
}
prop = spa_pod_builder_pop_deref(&d->b);
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, struct spa_pod_prop)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
spa_pod_builder_pop (&d->b, &f);
prop->body.flags |= SPA_POD_PROP_FLAG_UNSET;
}
value = gst_structure_get_value (d->cs, "max-framerate");
@ -432,15 +432,15 @@ handle_video_fields (ConvertData *d)
struct spa_fraction v;
for (i = 0; get_nth_fraction (value, i, &v); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
spa_pod_builder_push_prop (&d->b,
type.format_video.max_framerate,
get_range_type (value));
spa_pod_builder_fraction (&d->b, v.num, v.denom);
}
prop = spa_pod_builder_pop_deref(&d->b);
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, struct spa_pod_prop)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
spa_pod_builder_pop (&d->b, &f);
prop->body.flags |= SPA_POD_PROP_FLAG_UNSET;
}
return TRUE;
}
@ -448,8 +448,8 @@ handle_video_fields (ConvertData *d)
static gboolean
handle_audio_fields (ConvertData *d)
{
struct spa_pod_frame f;
const GValue *value;
struct spa_pod_prop *prop;
int i = 0;
value = gst_structure_get_value (d->cs, "format");
@ -458,7 +458,7 @@ handle_audio_fields (ConvertData *d)
int idx;
for (i = 0; (v = get_nth_string (value, i)); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
spa_pod_builder_push_prop (&d->b,
type.format_audio.format,
get_range_type (value));
@ -466,9 +466,9 @@ handle_audio_fields (ConvertData *d)
if (idx < SPA_N_ELEMENTS (audio_format_map))
spa_pod_builder_id (&d->b, *audio_format_map[idx]);
}
prop = spa_pod_builder_pop_deref(&d->b);
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, struct spa_pod_prop)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
spa_pod_builder_pop (&d->b, &f);
prop->body.flags |= SPA_POD_PROP_FLAG_UNSET;
}
value = gst_structure_get_value (d->cs, "layout");
@ -485,45 +485,45 @@ handle_audio_fields (ConvertData *d)
break;
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
spa_pod_builder_push_prop (&d->b,
type.format_audio.layout,
get_range_type (value));
spa_pod_builder_int (&d->b, layout);
}
prop = spa_pod_builder_pop_deref(&d->b);
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, struct spa_pod_prop)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
spa_pod_builder_pop (&d->b, &f);
prop->body.flags |= SPA_POD_PROP_FLAG_UNSET;
}
value = gst_structure_get_value (d->cs, "rate");
if (value) {
int v;
for (i = 0; get_nth_int (value, i, &v); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
spa_pod_builder_push_prop (&d->b,
type.format_audio.rate,
get_range_type (value));
spa_pod_builder_int (&d->b, v);
}
prop = spa_pod_builder_pop_deref(&d->b);
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, struct spa_pod_prop)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
spa_pod_builder_pop (&d->b, &f);
prop->body.flags |= SPA_POD_PROP_FLAG_UNSET;
}
value = gst_structure_get_value (d->cs, "channels");
if (value) {
int v;
for (i = 0; get_nth_int (value, i, &v); i++) {
if (i == 0)
spa_pod_builder_push_prop (&d->b, &f,
spa_pod_builder_push_prop (&d->b,
type.format_audio.channels,
get_range_type (value));
spa_pod_builder_int (&d->b, v);
}
prop = spa_pod_builder_pop_deref(&d->b);
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, struct spa_pod_prop)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
spa_pod_builder_pop (&d->b, &f);
prop->body.flags |= SPA_POD_PROP_FLAG_UNSET;
}
return TRUE;
}
@ -546,7 +546,6 @@ static struct spa_pod_object *
convert_1 (GstCapsFeatures *cf, GstStructure *cs)
{
ConvertData d;
struct spa_pod_frame f;
spa_zero (d);
d.cf = cf;
@ -557,7 +556,7 @@ convert_1 (GstCapsFeatures *cf, GstStructure *cs)
d.b.write = write_pod;
spa_pod_builder_push_object (&d.b, &f, 0, type.format);
spa_pod_builder_push_object (&d.b, 0, type.format);
spa_pod_builder_id(&d.b, *d.type->media_type);
spa_pod_builder_id(&d.b, *d.type->media_subtype);
@ -566,7 +565,7 @@ convert_1 (GstCapsFeatures *cf, GstStructure *cs)
else if (*d.type->media_type == type.media_type.audio)
handle_audio_fields (&d);
spa_pod_builder_pop (&d.b, &f);
spa_pod_builder_pop (&d.b);
return SPA_MEMBER (d.b.data, 0, struct spa_pod_object);
}

6
src/gst/gstpipewiresink.c
View file

@ -231,13 +231,12 @@ pool_activated (GstPipeWirePool *pool, GstPipeWireSink *sink)
struct spa_pod_object *port_params[3];
struct spa_pod_builder b = { NULL };
uint8_t buffer[1024];
struct spa_pod_frame f[1];
config = gst_buffer_pool_get_config (GST_BUFFER_POOL (pool));
gst_buffer_pool_config_get_params (config, &caps, &size, &min_buffers, &max_buffers);
spa_pod_builder_init (&b, buffer, sizeof (buffer));
spa_pod_builder_push_object (&b, &f[0], t->param.idBuffers, t->param_alloc_buffers.Buffers);
spa_pod_builder_push_object (&b, t->param.idBuffers, t->param_alloc_buffers.Buffers);
if (size == 0)
spa_pod_builder_add (&b,
":", t->param_alloc_buffers.size, "iru", 0, SPA_PROP_RANGE(0, INT32_MAX), NULL);
@ -252,8 +251,7 @@ pool_activated (GstPipeWirePool *pool, GstPipeWireSink *sink)
max_buffers ? max_buffers : INT32_MAX),
":", t->param_alloc_buffers.align, "i", 16,
NULL);
spa_pod_builder_pop (&b, &f[0]);
port_params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, struct spa_pod_object);
port_params[0] = spa_pod_builder_pop_deref (&b);
port_params[1] = spa_pod_builder_object (&b,
t->param.idMeta, t->param_alloc_meta_enable.MetaEnable,

2
src/modules/module-jack.c
View file

@ -1327,7 +1327,7 @@ static bool on_global(void *data, struct pw_global *global)
if (spa_node_enum_params(node->node, SPA_ID_INVALID, &index, NULL, &b) == SPA_RESULT_OK) {
int min_latency = -1;
struct spa_pod_object *props = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
struct spa_pod_object *props = spa_pod_builder_deref(&b, 0);
spa_pod_object_parse(props,
":", impl->prop_min_latency, "?i", &min_latency, NULL);

4
src/modules/module-protocol-native/connection.c
View file

@ -378,7 +378,7 @@ pw_protocol_native_connection_begin_resource(struct pw_protocol_native_connectio
impl->dest_id = resource->id;
impl->opcode = opcode;
impl->builder = (struct spa_pod_builder) { NULL, 0, 0, NULL, write_pod };
impl->builder = (struct spa_pod_builder) { NULL, 0, 0, write_pod };
return &impl->builder;
}
@ -407,7 +407,7 @@ pw_protocol_native_connection_begin_proxy(struct pw_protocol_native_connection *
impl->dest_id = proxy->id;
impl->opcode = opcode;
impl->builder = (struct spa_pod_builder) { NULL, 0, 0, NULL, write_pod };
impl->builder = (struct spa_pod_builder) { NULL, 0, 0, write_pod };
return &impl->builder;
}

2
src/modules/spa/spa-node.c
View file

@ -166,7 +166,7 @@ setup_props(struct pw_core *core, struct spa_node *spa_node, struct pw_propertie
pw_log_debug("spa_node_get_props failed: %d", res);
return SPA_RESULT_ERROR;
}
props = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
props = spa_pod_builder_deref(&b, 0);
while ((key = pw_properties_iterate(pw_props, &state))) {
struct spa_pod_prop *prop;

4
src/pipewire/core.c
View file

@ -771,7 +771,7 @@ int pw_core_find_format(struct pw_core *core,
asprintf(error, "no more input formats");
goto error;
}
format = SPA_POD_BUILDER_DEREF(&fb, 0, struct spa_pod_object);
format = spa_pod_builder_deref(&fb, 0);
pw_log_debug("enum output %d with filter: %p", oidx, format);
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(&format->pod, SPA_DEBUG_FLAG_FORMAT);
@ -787,7 +787,7 @@ int pw_core_find_format(struct pw_core *core,
asprintf(error, "error output enum formats: %d", res);
goto error;
}
format = SPA_POD_BUILDER_DEREF(&fb, 0, struct spa_pod_object);
format = spa_pod_builder_deref(&fb, 0);
pw_log_debug("Got filtered:");
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))

17
src/pipewire/link.c
View file

@ -136,7 +136,7 @@ static int do_negotiate(struct pw_link *this, uint32_t in_state, uint32_t out_st
if ((res = pw_core_find_format(this->core, output, input, NULL, 0, NULL, &b, &error)) < 0)
goto error;
format = spa_pod_object_copy(SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object));
format = spa_pod_object_copy(spa_pod_builder_deref(&b, 0));
spa_pod_object_fixate(format);
if (out_state > PW_PORT_STATE_CONFIGURE && output->node->info.state == PW_NODE_STATE_IDLE) {
@ -147,7 +147,7 @@ static int do_negotiate(struct pw_link *this, uint32_t in_state, uint32_t out_st
asprintf(&error, "error get output format: %d", res);
goto error;
}
current = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
current = spa_pod_builder_deref(&b, 0);
if (spa_pod_object_compare(current, format) < 0) {
pw_log_debug("link %p: output format change, renegotiate", this);
pw_node_set_state(output->node, PW_NODE_STATE_SUSPENDED);
@ -166,7 +166,7 @@ static int do_negotiate(struct pw_link *this, uint32_t in_state, uint32_t out_st
asprintf(&error, "error get input format: %d", res);
goto error;
}
current = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
current = spa_pod_builder_deref(&b, 0);
if (spa_pod_object_compare(current, format) < 0) {
pw_log_debug("link %p: input format change, renegotiate", this);
pw_node_set_state(input->node, PW_NODE_STATE_SUSPENDED);
@ -410,10 +410,9 @@ param_filter(struct pw_link *this,
if (spa_node_port_enum_params(in_port->node->node, in_port->direction, in_port->port_id,
id, &iidx, NULL, &ib) < 0)
break;
iparam = SPA_POD_BUILDER_DEREF(&ib, 0, struct spa_pod_object);
iparam = spa_pod_builder_deref(&ib, 0);
for (oidx = 0;;) {
struct spa_pod_frame f;
uint32_t offset;
spa_pod_builder_init(&ob, obuf, sizeof(obuf));
@ -421,7 +420,7 @@ param_filter(struct pw_link *this,
out_port->port_id, id, &oidx,
NULL, &ob) < 0)
break;
oparam = SPA_POD_BUILDER_DEREF(&ob, 0, struct spa_pod_object);
oparam = spa_pod_builder_deref(&ob, 0);
if (iidx == 1 && pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(&oparam->pod, 0);
@ -430,17 +429,17 @@ param_filter(struct pw_link *this,
continue;
offset = result->offset;
spa_pod_builder_push_object(result, &f, id, iparam->body.type);
spa_pod_builder_push_object(result, id, iparam->body.type);
if ((res = spa_props_filter(result,
SPA_POD_CONTENTS(struct spa_pod_object, iparam),
SPA_POD_CONTENTS_SIZE(struct spa_pod_object, iparam),
SPA_POD_CONTENTS(struct spa_pod_object, oparam),
SPA_POD_CONTENTS_SIZE(struct spa_pod_object, oparam))) < 0) {
result->offset = offset;
result->stack = NULL;
result->depth = 0;
continue;
}
spa_pod_builder_pop(result, &f);
spa_pod_builder_pop(result);
num++;
}
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))

4
src/pipewire/node.c
View file

@ -239,7 +239,7 @@ update_info(struct pw_node *this)
this->core->type.param.idEnumFormat, &state,
NULL, &b) < 0)
break;
fmt = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
fmt = spa_pod_builder_deref(&b, 0);
this->info.input_params =
realloc(this->info.input_params,
@ -262,7 +262,7 @@ update_info(struct pw_node *this)
this->core->type.param.idEnumFormat, &state,
NULL, &b) < 0)
break;
fmt = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
fmt = spa_pod_builder_deref(&b, 0);
this->info.output_params =
realloc(this->info.output_params,

4
src/pipewire/remote.c
View file

@ -658,7 +658,7 @@ static void add_port_update(struct pw_proxy *proxy, struct pw_port *port, uint32
data->t->param.idList, &idx1,
NULL, &b) < 0)
break;
param = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
param = spa_pod_builder_deref(&b, 0);
spa_pod_object_parse(param,
":", data->t->param.listId, "I", &id, NULL);
@ -670,7 +670,7 @@ static void add_port_update(struct pw_proxy *proxy, struct pw_port *port, uint32
id, &idx2,
NULL, &b) < 0)
break;
param = SPA_POD_BUILDER_DEREF(&b, 0, struct spa_pod_object);
param = spa_pod_builder_deref(&b, 0);
params = realloc(params, sizeof(struct spa_pod_object *) * (n_params + 1));
params[n_params] = spa_pod_object_copy(param);

6
src/pipewire/utils.h
View file

@ -54,7 +54,11 @@ pw_spa_pod_copy(const struct spa_pod *pod)
return pod ? memcpy(malloc(SPA_POD_SIZE(pod)), pod, SPA_POD_SIZE(pod)) : NULL;
}
#define spa_pod_object_copy(p) ((struct spa_pod_object*)pw_spa_pod_copy(&(p)->pod))
static inline struct spa_pod_object *
spa_pod_object_copy(const struct spa_pod_object *pod)
{
return (struct spa_pod_object*) pw_spa_pod_copy(&pod->pod);
}
#ifdef __cplusplus
} /* extern "C" */