From cc47fb7e3addeef7c0bc9dee5ed8a37c5dc0d1b0 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Wed, 8 Nov 2017 15:48:31 +0100 Subject: [PATCH] clean up pod_builder 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. --- spa/include/spa/pod-builder.h | 84 ++++++++++--------- spa/include/spa/pod-parser.h | 16 ++-- spa/include/spa/pod-utils.h | 17 +++- spa/include/spa/pod.h | 4 + spa/lib/format.c | 5 +- spa/lib/props.c | 34 +++++--- spa/plugins/alsa/alsa-sink.c | 5 +- spa/plugins/alsa/alsa-utils.c | 34 ++++---- spa/plugins/v4l2/v4l2-source.c | 6 +- spa/plugins/v4l2/v4l2-utils.c | 45 +++++----- spa/tests/test-graph.c | 9 +- spa/tests/test-mixer.c | 2 +- spa/tests/test-props.c | 18 ++-- spa/tests/test-props2.c | 33 ++++---- spa/tests/test-props4.c | 6 +- spa/tests/test-ringbuffer.c | 2 +- spa/tests/test-v4l2.c | 2 +- spa/tools/spa-inspect.c | 8 +- src/examples/export-sink.c | 9 +- src/examples/local-v4l2.c | 9 +- src/examples/video-play.c | 10 +-- src/gst/gstpipewireformat.c | 57 +++++++------ src/gst/gstpipewiresink.c | 6 +- src/modules/module-jack.c | 2 +- .../module-protocol-native/connection.c | 4 +- src/modules/spa/spa-node.c | 2 +- src/pipewire/core.c | 4 +- src/pipewire/link.c | 17 ++-- src/pipewire/node.c | 4 +- src/pipewire/remote.c | 4 +- src/pipewire/utils.h | 6 +- 31 files changed, 246 insertions(+), 218 deletions(-) diff --git a/spa/include/spa/pod-builder.h b/spa/include/spa/pod-builder.h index b5c9999f5..320c7ce85 100644 --- a/spa/include/spa/pod-builder.h +++ b/spa/include/spa/pod-builder.h @@ -27,12 +27,7 @@ extern "C" { #include #include -#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, ...) diff --git a/spa/include/spa/pod-parser.h b/spa/include/spa/pod-parser.h index a4608876d..ad5242d8d 100644 --- a/spa/include/spa/pod-parser.h +++ b/spa/include/spa/pod-parser.h @@ -27,13 +27,9 @@ extern "C" { #include #include -#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 '>': diff --git a/spa/include/spa/pod-utils.h b/spa/include/spa/pod-utils.h index bad8dc731..091337da9 100644 --- a/spa/include/spa/pod-utils.h +++ b/spa/include/spa/pod-utils.h @@ -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) diff --git a/spa/include/spa/pod.h b/spa/include/spa/pod.h index 04039a1c2..0827c38c3 100644 --- a/spa/include/spa/pod.h +++ b/spa/include/spa/pod.h @@ -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: */ diff --git a/spa/lib/format.c b/spa/lib/format.c index 0230fc153..cf5ffe594 100644 --- a/spa/lib/format.c +++ b/spa/lib/format.c @@ -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; } diff --git a/spa/lib/props.c b/spa/lib/props.c index 513d1d21a..40494edf1 100644 --- a/spa/lib/props.c +++ b/spa/lib/props.c @@ -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; - } diff --git a/spa/plugins/alsa/alsa-sink.c b/spa/plugins/alsa/alsa-sink.c index 0ab8fc27a..5c1430baa 100644 --- a/spa/plugins/alsa/alsa-sink.c +++ b/spa/plugins/alsa/alsa-sink.c @@ -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) diff --git a/spa/plugins/alsa/alsa-utils.c b/spa/plugins/alsa/alsa-utils.c index 58e82794d..191ced23f 100644 --- a/spa/plugins/alsa/alsa-utils.c +++ b/spa/plugins/alsa/alsa-utils.c @@ -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(¶ms); 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); diff --git a/spa/plugins/v4l2/v4l2-source.c b/spa/plugins/v4l2/v4l2-source.c index 8d2d87202..5a76fb603 100644 --- a/spa/plugins/v4l2/v4l2-source.c +++ b/spa/plugins/v4l2/v4l2-source.c @@ -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; } diff --git a/spa/plugins/v4l2/v4l2-utils.c b/spa/plugins/v4l2/v4l2-utils.c index b2908085b..4d8e55946 100644 --- a/spa/plugins/v4l2/v4l2-utils.c +++ b/spa/plugins/v4l2/v4l2-utils.c @@ -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) { diff --git a/spa/tests/test-graph.c b/spa/tests/test-graph.c index bdea80aa0..b7286698f 100644 --- a/spa/tests/test-graph.c +++ b/spa/tests/test-graph.c @@ -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) diff --git a/spa/tests/test-mixer.c b/spa/tests/test-mixer.c index 2838e452c..37f53d4c9 100644 --- a/spa/tests/test-mixer.c +++ b/spa/tests/test-mixer.c @@ -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, diff --git a/spa/tests/test-props.c b/spa/tests/test-props.c index 81f63c338..cb2f308b8 100644 --- a/spa/tests/test-props.c +++ b/spa/tests/test-props.c @@ -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); diff --git a/spa/tests/test-props2.c b/spa/tests/test-props2.c index 691a7f9c5..38fe969cf 100644 --- a/spa/tests/test-props2.c +++ b/spa/tests/test-props2.c @@ -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; diff --git a/spa/tests/test-props4.c b/spa/tests/test-props4.c index b8a314696..4f477418b 100644 --- a/spa/tests/test-props4.c +++ b/spa/tests/test-props4.c @@ -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; diff --git a/spa/tests/test-ringbuffer.c b/spa/tests/test-ringbuffer.c index bc75197d7..38b9e00b8 100644 --- a/spa/tests/test-ringbuffer.c +++ b/spa/tests/test-ringbuffer.c @@ -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, diff --git a/spa/tests/test-v4l2.c b/spa/tests/test-v4l2.c index 9a41e1164..032b1fc74 100644 --- a/spa/tests/test-v4l2.c +++ b/spa/tests/test-v4l2.c @@ -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) diff --git a/spa/tools/spa-inspect.c b/spa/tools/spa-inspect.c index e4cd7b4b8..ce07d804e 100644 --- a/spa/tools/spa-inspect.c +++ b/spa/tools/spa-inspect.c @@ -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(¶m->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(¶m->pod, flags); diff --git a/src/examples/export-sink.c b/src/examples/export-sink.c index 47500bc31..ddbffb239 100644 --- a/src/examples/export-sink.c +++ b/src/examples/export-sink.c @@ -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)++; diff --git a/src/examples/local-v4l2.c b/src/examples/local-v4l2.c index b5a99123e..e60dfa397 100644 --- a/src/examples/local-v4l2.c +++ b/src/examples/local-v4l2.c @@ -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)++; diff --git a/src/examples/video-play.c b/src/examples/video-play.c index 733c0c862..478e23829 100644 --- a/src/examples/video-play.c +++ b/src/examples/video-play.c @@ -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(¶ms[0]->pod, SPA_DEBUG_FLAG_FORMAT); diff --git a/src/gst/gstpipewireformat.c b/src/gst/gstpipewireformat.c index 01c835fb3..54a8329ad 100644 --- a/src/gst/gstpipewireformat.c +++ b/src/gst/gstpipewireformat.c @@ -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); } diff --git a/src/gst/gstpipewiresink.c b/src/gst/gstpipewiresink.c index ed08c055a..ddb4cde2d 100644 --- a/src/gst/gstpipewiresink.c +++ b/src/gst/gstpipewiresink.c @@ -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, diff --git a/src/modules/module-jack.c b/src/modules/module-jack.c index 55ee02014..3d8b3afff 100644 --- a/src/modules/module-jack.c +++ b/src/modules/module-jack.c @@ -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); diff --git a/src/modules/module-protocol-native/connection.c b/src/modules/module-protocol-native/connection.c index 3ab708072..73b8b4bd4 100644 --- a/src/modules/module-protocol-native/connection.c +++ b/src/modules/module-protocol-native/connection.c @@ -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; } diff --git a/src/modules/spa/spa-node.c b/src/modules/spa/spa-node.c index 083a11dd0..0a80b823a 100644 --- a/src/modules/spa/spa-node.c +++ b/src/modules/spa/spa-node.c @@ -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; diff --git a/src/pipewire/core.c b/src/pipewire/core.c index bac98c013..b0efd9310 100644 --- a/src/pipewire/core.c +++ b/src/pipewire/core.c @@ -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)) diff --git a/src/pipewire/link.c b/src/pipewire/link.c index cb32f96e9..e7bc3a804 100644 --- a/src/pipewire/link.c +++ b/src/pipewire/link.c @@ -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)) diff --git a/src/pipewire/node.c b/src/pipewire/node.c index 3a58c6b0a..1de831458 100644 --- a/src/pipewire/node.c +++ b/src/pipewire/node.c @@ -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, diff --git a/src/pipewire/remote.c b/src/pipewire/remote.c index a8c483e0d..ac3d037e9 100644 --- a/src/pipewire/remote.c +++ b/src/pipewire/remote.c @@ -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); diff --git a/src/pipewire/utils.h b/src/pipewire/utils.h index 7d5f0badc..6d7479789 100644 --- a/src/pipewire/utils.h +++ b/src/pipewire/utils.h @@ -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" */