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

pod: improve the vararg pod builder and parser

Browse source 
Automatically parse and build key/value when in objects without having
to prefix the key with ":"
Automatically build control/value when in sequence without the "."
prefix.
Remove the builder with key/pod, taking a reference to the stack built
temporary pods is not allowed in c++. We can use the varargs version
with the same convenient syntax.
Remove the parser "*" option, it is unused.
Improve spa_pod_builder_add_* and spa_pod_parser_get_* and make them
look similar.
This commit is contained in:
Wim Taymans 2019-01-16 11:05:12 +01:00
parent 79d68ace68
commit 80cfda89c1
59 changed files with 1833 additions and 2005 deletions
Download patch file Download diff file Expand all files Collapse all files

2
pipewire-alsa

@ -1 +1 @@
Subproject commit 5a8c6d457e846639e4e949461ecf3f494cabba39
Subproject commit ea1f9e18f7a61d7632c2d65248f99b6abf33f140

2
pipewire-jack

@ -1 +1 @@
Subproject commit 16874536363649535cfdda5227e9108ec158127a
Subproject commit c1da362a24351c8827d5b964d24ef5176e87ca95

2
pipewire-pulseaudio

@ -1 +1 @@
Subproject commit f509e8552d1836268c6f85a3d8e78aadcdfec197
Subproject commit 386e5c966c7c44086cb81e3649e7d58193cde43d

34
spa/include/spa/param/audio/format-utils.h
View file

@ -39,13 +39,16 @@ static inline int
spa_format_audio_raw_parse(const struct spa_pod *format, struct spa_audio_info_raw *info)
{
struct spa_pod *position = NULL;
struct spa_pod_parser prs;
int res;
res = spa_pod_object_parse(format,
":", SPA_FORMAT_AUDIO_format, "I", &info->format,
":", SPA_FORMAT_AUDIO_rate, "i", &info->rate,
":", SPA_FORMAT_AUDIO_channels, "i", &info->channels,
":", SPA_FORMAT_AUDIO_flags, "?i", &info->flags,
":", SPA_FORMAT_AUDIO_position, "?P", &position, NULL);
spa_pod_parser_pod(&prs, format);
res = spa_pod_parser_get_object(&prs,
SPA_TYPE_OBJECT_Format, NULL,
SPA_FORMAT_AUDIO_format, SPA_POD_Id(&info->format),
SPA_FORMAT_AUDIO_rate, SPA_POD_Int(&info->rate),
SPA_FORMAT_AUDIO_channels, SPA_POD_Int(&info->channels),
SPA_FORMAT_AUDIO_flags, SPA_POD_OPT_Int(&info->flags),
SPA_FORMAT_AUDIO_position, SPA_POD_OPT_Pod(&position));
if (position && position->type == SPA_TYPE_Array &&
SPA_POD_ARRAY_TYPE(position) == SPA_TYPE_Id) {
uint32_t *values = (uint32_t*)SPA_POD_ARRAY_VALUES(position);
@ -61,19 +64,13 @@ spa_format_audio_raw_parse(const struct spa_pod *format, struct spa_audio_info_r
static inline struct spa_pod *
spa_format_audio_raw_build(struct spa_pod_builder *builder, uint32_t id, struct spa_audio_info_raw *info)
{
const struct spa_pod_id media_type = SPA_POD_Id(SPA_MEDIA_TYPE_audio);
const struct spa_pod_id media_subtype = SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw);
const struct spa_pod_id format = SPA_POD_Id(info->format);
const struct spa_pod_int rate = SPA_POD_Int(info->rate);
const struct spa_pod_int channels = SPA_POD_Int(info->channels);
spa_pod_builder_push_object(builder, SPA_TYPE_OBJECT_Format, id);
spa_pod_builder_props(builder,
SPA_FORMAT_mediaType, &media_type,
SPA_FORMAT_mediaSubtype, &media_subtype,
SPA_FORMAT_AUDIO_format, &format,
SPA_FORMAT_AUDIO_rate, &rate,
SPA_FORMAT_AUDIO_channels, &channels,
spa_pod_builder_add(builder,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_Id(info->format),
SPA_FORMAT_AUDIO_rate, SPA_POD_Int(info->rate),
SPA_FORMAT_AUDIO_channels, SPA_POD_Int(info->channels),
0);
if (!SPA_FLAG_CHECK(info->flags, SPA_AUDIO_FLAG_UNPOSITIONED)) {
@ -81,7 +78,6 @@ spa_format_audio_raw_build(struct spa_pod_builder *builder, uint32_t id, struct
spa_pod_builder_array(builder, sizeof(uint32_t), SPA_TYPE_Id,
info->channels, info->position);
}
return (struct spa_pod*)spa_pod_builder_pop(builder);
}

7
spa/include/spa/param/format-utils.h
View file

@ -36,9 +36,10 @@ extern "C" {
static inline int
spa_format_parse(const struct spa_pod *format, uint32_t *media_type, uint32_t *media_subtype)
{
return spa_pod_object_parse(format,
":", SPA_FORMAT_mediaType, "I", media_type,
":", SPA_FORMAT_mediaSubtype, "I", media_subtype, NULL);
return spa_pod_parse_object(format,
SPA_TYPE_OBJECT_Format, NULL,
SPA_FORMAT_mediaType, SPA_POD_Id(media_type),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(media_subtype));
}
#ifdef __cplusplus

72
spa/include/spa/param/video/format-utils.h
View file

@ -38,63 +38,59 @@ static inline int
spa_format_video_raw_parse(const struct spa_pod *format,
struct spa_video_info_raw *info)
{
return spa_pod_object_parse(format,
":", SPA_FORMAT_VIDEO_format, "I", &info->format,
":", SPA_FORMAT_VIDEO_size, "R", &info->size,
":", SPA_FORMAT_VIDEO_framerate, "F", &info->framerate,
":", SPA_FORMAT_VIDEO_maxFramerate, "?F", &info->max_framerate,
":", SPA_FORMAT_VIDEO_views, "?i", &info->views,
":", SPA_FORMAT_VIDEO_interlaceMode, "?I", &info->interlace_mode,
":", SPA_FORMAT_VIDEO_pixelAspectRatio, "?F", &info->pixel_aspect_ratio,
":", SPA_FORMAT_VIDEO_multiviewMode, "?I", &info->multiview_mode,
":", SPA_FORMAT_VIDEO_multiviewFlags, "?I", &info->multiview_flags,
":", SPA_FORMAT_VIDEO_chromaSite, "?I", &info->chroma_site,
":", SPA_FORMAT_VIDEO_colorRange, "?I", &info->color_range,
":", SPA_FORMAT_VIDEO_colorMatrix, "?I", &info->color_matrix,
":", SPA_FORMAT_VIDEO_transferFunction, "?I", &info->transfer_function,
":", SPA_FORMAT_VIDEO_colorPrimaries, "?I", &info->color_primaries, NULL);
return spa_pod_parse_object(format,
SPA_TYPE_OBJECT_Format, NULL,
SPA_FORMAT_VIDEO_format, SPA_POD_Id(&info->format),
SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(&info->size),
SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&info->framerate),
SPA_FORMAT_VIDEO_maxFramerate, SPA_POD_OPT_Fraction(&info->max_framerate),
SPA_FORMAT_VIDEO_views, SPA_POD_OPT_Int(&info->views),
SPA_FORMAT_VIDEO_interlaceMode, SPA_POD_OPT_Id(&info->interlace_mode),
SPA_FORMAT_VIDEO_pixelAspectRatio, SPA_POD_OPT_Fraction(&info->pixel_aspect_ratio),
SPA_FORMAT_VIDEO_multiviewMode, SPA_POD_OPT_Id(&info->multiview_mode),
SPA_FORMAT_VIDEO_multiviewFlags, SPA_POD_OPT_Id(&info->multiview_flags),
SPA_FORMAT_VIDEO_chromaSite, SPA_POD_OPT_Id(&info->chroma_site),
SPA_FORMAT_VIDEO_colorRange, SPA_POD_OPT_Id(&info->color_range),
SPA_FORMAT_VIDEO_colorMatrix, SPA_POD_OPT_Id(&info->color_matrix),
SPA_FORMAT_VIDEO_transferFunction, SPA_POD_OPT_Id(&info->transfer_function),
SPA_FORMAT_VIDEO_colorPrimaries, SPA_POD_OPT_Id(&info->color_primaries));
}
static inline struct spa_pod *
spa_format_video_raw_build(struct spa_pod_builder *builder, uint32_t id,
struct spa_video_info_raw *info)
{
const struct spa_pod_id media_type = SPA_POD_Id(SPA_MEDIA_TYPE_video);
const struct spa_pod_id media_subtype = SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw);
const struct spa_pod_id format = SPA_POD_Id(info->format);
const struct spa_pod_rectangle size = SPA_POD_Rectangle(info->size);
const struct spa_pod_fraction framerate = SPA_POD_Fraction(info->framerate);
return (struct spa_pod *) spa_pod_builder_object(builder,
return (struct spa_pod *) spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, id,
SPA_FORMAT_mediaType, &media_type,
SPA_FORMAT_mediaSubtype, &media_subtype,
SPA_FORMAT_VIDEO_format, &format,
SPA_FORMAT_VIDEO_size, &size,
SPA_FORMAT_VIDEO_framerate, &framerate,
0);
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, SPA_POD_Id(info->format),
SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(&info->size),
SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&info->framerate));
}
static inline int
spa_format_video_h264_parse(const struct spa_pod *format,
struct spa_video_info_h264 *info)
{
return spa_pod_object_parse(format,
":", SPA_FORMAT_VIDEO_size, "?R", &info->size,
":", SPA_FORMAT_VIDEO_framerate, "?F", &info->framerate,
":", SPA_FORMAT_VIDEO_maxFramerate, "?F", &info->max_framerate,
":", SPA_FORMAT_VIDEO_streamFormat, "?I", &info->stream_format,
":", SPA_FORMAT_VIDEO_alignment, "?I", &info->alignment, NULL);
return spa_pod_parse_object(format,
SPA_TYPE_OBJECT_Format, NULL,
SPA_FORMAT_VIDEO_size, SPA_POD_OPT_Rectangle(&info->size),
SPA_FORMAT_VIDEO_framerate, SPA_POD_OPT_Fraction(&info->framerate),
SPA_FORMAT_VIDEO_maxFramerate, SPA_POD_OPT_Fraction(&info->max_framerate),
SPA_FORMAT_VIDEO_streamFormat, SPA_POD_OPT_Id(&info->stream_format),
SPA_FORMAT_VIDEO_alignment, SPA_POD_OPT_Id(&info->alignment));
}
static inline int
spa_format_video_mjpg_parse(const struct spa_pod *format,
struct spa_video_info_mjpg *info)
{
return spa_pod_object_parse(format,
":", SPA_FORMAT_VIDEO_size, "?R", &info->size,
":", SPA_FORMAT_VIDEO_framerate, "?F", &info->framerate,
":", SPA_FORMAT_VIDEO_maxFramerate, "?F", &info->max_framerate, NULL);
return spa_pod_parse_object(format,
SPA_TYPE_OBJECT_Format, NULL,
SPA_FORMAT_VIDEO_size, SPA_POD_OPT_Rectangle(&info->size),
SPA_FORMAT_VIDEO_framerate, SPA_POD_OPT_Fraction(&info->framerate),
SPA_FORMAT_VIDEO_maxFramerate, SPA_POD_OPT_Fraction(&info->max_framerate));
}
#ifdef __cplusplus

387
spa/include/spa/pod/builder.h
View file

@ -40,8 +40,11 @@ struct spa_pod_frame {
struct spa_pod_builder_state {
uint32_t offset;
bool in_array;
bool first;
#define SPA_POD_BUILDER_FLAG_BODY (1<<0)
#define SPA_POD_BUILDER_FLAG_FIRST (1<<1)
#define SPA_POD_BUILDER_FLAG_OBJECT (1<<2)
#define SPA_POD_BUILDER_FLAG_SEQUENCE (1<<3)
uint32_t flags;
int depth;
};
@ -79,6 +82,12 @@ static inline void spa_pod_builder_init(struct spa_pod_builder *builder, void *d
*builder = SPA_POD_BUILDER_INIT(data, size);
}
static inline struct spa_pod_frame *
spa_pod_builder_top(struct spa_pod_builder *builder)
{
return builder->state.depth > 0 ? &builder->frame[builder->state.depth-1] : NULL;
}
static inline void *
spa_pod_builder_deref_checked(struct spa_pod_builder *builder, uint32_t ref, bool safe)
{
@ -100,6 +109,23 @@ spa_pod_builder_deref(struct spa_pod_builder *builder, uint32_t ref)
return spa_pod_builder_deref_checked(builder, ref, false);
}
static inline void
spa_pod_builder_update_frame(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
{
switch (frame->pod.type) {
case SPA_TYPE_Array:
case SPA_TYPE_Choice:
builder->state.flags |= SPA_POD_BUILDER_FLAG_BODY;
break;
case SPA_TYPE_Object:
builder->state.flags |= SPA_POD_BUILDER_FLAG_OBJECT;
break;
case SPA_TYPE_Sequence:
builder->state.flags |= SPA_POD_BUILDER_FLAG_SEQUENCE;
break;
}
}
static inline uint32_t
spa_pod_builder_push(struct spa_pod_builder *builder,
const struct spa_pod *pod,
@ -108,8 +134,8 @@ spa_pod_builder_push(struct spa_pod_builder *builder,
struct spa_pod_frame *frame = &builder->frame[builder->state.depth++];
frame->pod = *pod;
frame->ref = ref;
builder->state.in_array = builder->state.first =
(pod->type == SPA_TYPE_Array || pod->type == SPA_TYPE_Choice);
builder->state.flags = SPA_POD_BUILDER_FLAG_FIRST;
spa_pod_builder_update_frame(builder, frame);
return ref;
}
@ -155,134 +181,102 @@ spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, ui
static inline void *spa_pod_builder_pop(struct spa_pod_builder *builder)
{
struct spa_pod_frame *frame, *top;
struct spa_pod_frame *frame;
struct spa_pod *pod;
frame = &builder->frame[--builder->state.depth];
if ((pod = (struct spa_pod *) spa_pod_builder_deref_checked(builder, frame->ref, true)) != NULL)
*pod = frame->pod;
top = builder->state.depth > 0 ? &builder->frame[builder->state.depth-1] : NULL;
builder->state.in_array = (top &&
(top->pod.type == SPA_TYPE_Array || top->pod.type == SPA_TYPE_Choice));
builder->state.flags = 0;
if ((frame = spa_pod_builder_top(builder)) != NULL)
spa_pod_builder_update_frame(builder, frame);
spa_pod_builder_pad(builder, builder->state.offset);
return pod;
}
#define SPA_TYPE_Collect 0x100
struct spa_pod_collect {
struct spa_pod pod;
struct spa_pod child;
const void *value;
};
static inline uint32_t
spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod *p)
{
const void *head, *body;
uint32_t head_size, body_size, ref;
bool collect = p->type == SPA_TYPE_Collect;
const void *data;
uint32_t size, ref;
if (collect) {
struct spa_pod_collect *col = (struct spa_pod_collect *)p;
head = &col->child;
head_size = sizeof(struct spa_pod);
body = col->value;
if (builder->state.flags == SPA_POD_BUILDER_FLAG_BODY) {
data = SPA_POD_BODY_CONST(p);
size = SPA_POD_BODY_SIZE(p);
} else {
head = p;
head_size = SPA_POD_SIZE(p);
body = SPA_POD_BODY_CONST(p);
data = p;
size = SPA_POD_SIZE(p);
SPA_FLAG_UNSET(builder->state.flags, SPA_POD_BUILDER_FLAG_FIRST);
}
body_size = SPA_POD_BODY_SIZE(head);
ref = spa_pod_builder_raw(builder, data, size);
if (builder->state.flags != SPA_POD_BUILDER_FLAG_BODY)
spa_pod_builder_pad(builder, size);
if (builder->state.in_array && !builder->state.first) {
head = body;
head_size = body_size;
collect = false;
} else {
builder->state.first = false;
}
ref = spa_pod_builder_raw(builder, head, head_size);
if (ref != SPA_ID_INVALID && collect) {
ref = spa_pod_builder_raw(builder, body, body_size);
head_size += body_size;
}
if (!builder->state.in_array)
spa_pod_builder_pad(builder, head_size);
return ref;
}
#define SPA_POD_INIT(size,type) (struct spa_pod) { size, type }
#define SPA_POD_None() SPA_POD_INIT(0, SPA_TYPE_None)
#define SPA_POD_INIT_None() SPA_POD_INIT(0, SPA_TYPE_None)
static inline uint32_t spa_pod_builder_none(struct spa_pod_builder *builder)
{
const struct spa_pod p = SPA_POD_None();
const struct spa_pod p = SPA_POD_INIT_None();
return spa_pod_builder_primitive(builder, &p);
}
#define SPA_POD_Bool(val) (struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, val ? 1 : 0, 0 }
#define SPA_POD_INIT_Bool(val) (struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, val ? 1 : 0, 0 }
static inline uint32_t spa_pod_builder_bool(struct spa_pod_builder *builder, bool val)
{
const struct spa_pod_bool p = SPA_POD_Bool(val);
const struct spa_pod_bool p = SPA_POD_INIT_Bool(val);
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Id(val) (struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, (uint32_t)val, 0 }
#define SPA_POD_INIT_Id(val) (struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, (uint32_t)val, 0 }
static inline uint32_t spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
{
const struct spa_pod_id p = SPA_POD_Id(val);
const struct spa_pod_id p = SPA_POD_INIT_Id(val);
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Int(val) (struct spa_pod_int){ { sizeof(int32_t), SPA_TYPE_Int }, (int32_t)val, 0 }
#define SPA_POD_INIT_Int(val) (struct spa_pod_int){ { sizeof(int32_t), SPA_TYPE_Int }, (int32_t)val, 0 }
static inline uint32_t spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
{
const struct spa_pod_int p = SPA_POD_Int(val);
const struct spa_pod_int p = SPA_POD_INIT_Int(val);
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Long(val) (struct spa_pod_long){ { sizeof(int64_t), SPA_TYPE_Long }, (int64_t)val }
#define SPA_POD_INIT_Long(val) (struct spa_pod_long){ { sizeof(int64_t), SPA_TYPE_Long }, (int64_t)val }
static inline uint32_t spa_pod_builder_long(struct spa_pod_builder *builder, int64_t val)
{
const struct spa_pod_long p = SPA_POD_Long(val);
const struct spa_pod_long p = SPA_POD_INIT_Long(val);
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Float(val) (struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, val }
#define SPA_POD_INIT_Float(val) (struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, val }
static inline uint32_t spa_pod_builder_float(struct spa_pod_builder *builder, float val)
{
const struct spa_pod_float p = SPA_POD_Float(val);
const struct spa_pod_float p = SPA_POD_INIT_Float(val);
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Double(val) (struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, val }
#define SPA_POD_INIT_Double(val) (struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, val }
static inline uint32_t spa_pod_builder_double(struct spa_pod_builder *builder, double val)
{
const struct spa_pod_double p = SPA_POD_Double(val);
const struct spa_pod_double p = SPA_POD_INIT_Double(val);
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Stringv(str) \
(struct spa_pod_collect) \
{ { 0, SPA_TYPE_Collect }, { strlen(str)+1, SPA_TYPE_String }, str }
#define SPA_POD_String(str, len) \
(struct spa_pod_collect) \
{ { 0, SPA_TYPE_Collect }, { len, SPA_TYPE_String }, str }
#define SPA_POD_Stringc(str) \
(struct { struct spa_pod_string pod; char val[sizeof(str)]; }) \
{ { { sizeof(str), SPA_TYPE_String } }, { str } }
#define SPA_POD_INIT_String(len) (struct spa_pod_string){ { len, SPA_TYPE_String } }
static inline uint32_t
spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len)
@ -299,7 +293,7 @@ spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, u
static inline uint32_t
spa_pod_builder_string_len(struct spa_pod_builder *builder, const char *str, uint32_t len)
{
const struct spa_pod_string p = { { len + 1, SPA_TYPE_String } };
const struct spa_pod_string p = SPA_POD_INIT_String(len+1);
uint32_t ref = spa_pod_builder_raw(builder, &p, sizeof(p));
if (spa_pod_builder_write_string(builder, str, len) == SPA_ID_INVALID)
ref = SPA_ID_INVALID;
@ -312,58 +306,53 @@ static inline uint32_t spa_pod_builder_string(struct spa_pod_builder *builder, c
return spa_pod_builder_string_len(builder, str ? str : "", len);
}
#define SPA_POD_Bytes(len) (struct spa_pod_bytes){ { len, SPA_TYPE_Bytes } }
#define SPA_POD_INIT_Bytes(len) (struct spa_pod_bytes){ { len, SPA_TYPE_Bytes } }
static inline uint32_t
spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
{
const struct spa_pod_bytes p = SPA_POD_Bytes(len);
const struct spa_pod_bytes p = SPA_POD_INIT_Bytes(len);
uint32_t ref = spa_pod_builder_raw(builder, &p, sizeof(p));
if (spa_pod_builder_raw_padded(builder, bytes, len) == SPA_ID_INVALID)
ref = SPA_ID_INVALID;
return ref;
}
#define SPA_POD_Pointer(type,value) (struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { type, value } }
#define SPA_POD_INIT_Pointer(type,value) (struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { type, value } }
static inline uint32_t
spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, void *val)
{
const struct spa_pod_pointer p = SPA_POD_Pointer(type, val);
const struct spa_pod_pointer p = SPA_POD_INIT_Pointer(type, val);
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Fd(fd) (struct spa_pod_fd){ { sizeof(int), SPA_TYPE_Fd }, fd }
#define SPA_POD_INIT_Fd(fd) (struct spa_pod_fd){ { sizeof(int), SPA_TYPE_Fd }, fd }
static inline uint32_t spa_pod_builder_fd(struct spa_pod_builder *builder, int fd)
{
const struct spa_pod_fd p = SPA_POD_Fd(fd);
const struct spa_pod_fd p = SPA_POD_INIT_Fd(fd);
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Rectangle(val) (struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, val }
#define SPA_POD_INIT_Rectangle(val) (struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, val }
static inline uint32_t
spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height)
{
const struct spa_pod_rectangle p = SPA_POD_Rectangle(SPA_RECTANGLE(width, height));
const struct spa_pod_rectangle p = SPA_POD_INIT_Rectangle(SPA_RECTANGLE(width, height));
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Fraction(val) (struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, val }
#define SPA_POD_INIT_Fraction(val) (struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, val }
static inline uint32_t
spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
{
const struct spa_pod_fraction p = SPA_POD_Fraction(SPA_FRACTION(num, denom));
const struct spa_pod_fraction p = SPA_POD_INIT_Fraction(SPA_FRACTION(num, denom));
return spa_pod_builder_primitive(builder, &p.pod);
}
#define SPA_POD_Array(ctype, child_type, n_vals, ...) \
(struct { struct spa_pod_array array; ctype vals[n_vals];}) \
{ { { n_vals * sizeof(ctype) + sizeof(struct spa_pod_array_body), SPA_TYPE_Array }, \
{ { sizeof(ctype), child_type } } }, { __VA_ARGS__ } }
static inline uint32_t
spa_pod_builder_push_array(struct spa_pod_builder *builder)
{
@ -389,10 +378,10 @@ spa_pod_builder_array(struct spa_pod_builder *builder,
return ref;
}
#define SPA_POD_CHOICE_BODY_INIT(type, flags, child_size, child_type) \
#define SPA_POD_INIT_CHOICE_BODY(type, flags, child_size, child_type) \
(struct spa_pod_choice_body) { type, flags, { child_size, child_type }}
#define SPA_POD_Choice(type, ctype, child_type, n_vals, ...) \
#define SPA_POD_INIT_Choice(type, ctype, child_type, n_vals, ...) \
(struct { struct spa_pod_choice choice; ctype vals[n_vals];}) \
{ { { n_vals * sizeof(ctype) + sizeof(struct spa_pod_choice_body), SPA_TYPE_Choice }, \
{ type, 0, { sizeof(ctype), child_type } } }, { __VA_ARGS__ } }
@ -408,28 +397,28 @@ spa_pod_builder_push_choice(struct spa_pod_builder *builder, uint32_t type, uint
sizeof(p) - sizeof(struct spa_pod)));
}
#define SPA_POD_Struct(size) (struct spa_pod_struct){ { size, SPA_TYPE_Struct } }
#define SPA_POD_INIT_Struct(size) (struct spa_pod_struct){ { size, SPA_TYPE_Struct } }
static inline uint32_t
spa_pod_builder_push_struct(struct spa_pod_builder *builder)
{
const struct spa_pod_struct p = SPA_POD_Struct(0);
const struct spa_pod_struct p = SPA_POD_INIT_Struct(0);
return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p, sizeof(p)));
}
#define SPA_POD_Object(size,type,id,...) (struct spa_pod_object){ { size, SPA_TYPE_Object }, { type, id }, ##__VA_ARGS__ }
#define SPA_POD_INIT_Object(size,type,id,...) (struct spa_pod_object){ { size, SPA_TYPE_Object }, { type, id }, ##__VA_ARGS__ }
static inline uint32_t
spa_pod_builder_push_object(struct spa_pod_builder *builder, uint32_t type, uint32_t id)
{
const struct spa_pod_object p =
SPA_POD_Object(sizeof(struct spa_pod_object_body), type, id);
SPA_POD_INIT_Object(sizeof(struct spa_pod_object_body), type, id);
return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p, sizeof(p)));
}
#define SPA_POD_Prop(key,flags,size,type) \
#define SPA_POD_INIT_Prop(key,flags,size,type) \
(struct spa_pod_prop){ key, flags, { size, type } }
static inline uint32_t
@ -439,14 +428,14 @@ spa_pod_builder_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t fla
return spa_pod_builder_raw(builder, &p, sizeof(p));
}
#define SPA_POD_Sequence(size,unit,...) \
(struct spa_pod_sequence){ { size, SPA_TYPE_Sequence}, {unit, 0 }, ##__VA_ARGS__ }
#define SPA_POD_INIT_Sequence(size,unit) \
(struct spa_pod_sequence){ { size, SPA_TYPE_Sequence}, {unit, 0 } }
static inline uint32_t
spa_pod_builder_push_sequence(struct spa_pod_builder *builder, uint32_t unit)
{
const struct spa_pod_sequence p =
SPA_POD_Sequence(sizeof(struct spa_pod_sequence_body), unit);
SPA_POD_INIT_Sequence(sizeof(struct spa_pod_sequence_body), unit);
return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p, sizeof(p)));
}
@ -556,6 +545,9 @@ do { \
spa_pod_builder_fd(builder, va_arg(args, int)); \
break; \
case 'P': \
case 'O': \
case 'T': \
case 'V': \
{ \
struct spa_pod *pod = va_arg(args, struct spa_pod *); \
if (pod == NULL) \
@ -568,12 +560,30 @@ do { \
} while(false)
static inline void *
spa_pod_builder_addv(struct spa_pod_builder *builder,
const char *format, va_list args)
spa_pod_builder_addv(struct spa_pod_builder *builder, va_list args)
{
while (format) {
const char *format = "";
void *top = NULL;
do {
int n_values = 1;
bool do_pop = false;
if (SPA_FLAG_CHECK(builder->state.flags, SPA_POD_BUILDER_FLAG_OBJECT)) {
uint32_t key = va_arg(args, uint32_t);
if (key == 0)
break;
if (key != SPA_ID_INVALID)
spa_pod_builder_prop(builder, key, 0);
}
else if (SPA_FLAG_CHECK(builder->state.flags, SPA_POD_BUILDER_FLAG_SEQUENCE)) {
uint32_t offset = va_arg(args, uint32_t);
uint32_t type = va_arg(args, uint32_t);
if (type == 0)
break;
if (type != SPA_ID_INVALID)
spa_pod_builder_control_header(builder, offset, type);
}
again:
switch (*format) {
case '{':
{
@ -594,13 +604,6 @@ spa_pod_builder_addv(struct spa_pod_builder *builder,
spa_pod_builder_push_sequence(builder, unit);
break;
}
case '.':
{
uint32_t offset = va_arg(args, uint32_t);
uint32_t type = va_arg(args, uint32_t);
spa_pod_builder_control_header(builder, offset, type);
break;
}
case '?':
{
uint32_t choice, flags = 0;
@ -616,165 +619,119 @@ spa_pod_builder_addv(struct spa_pod_builder *builder,
do_pop = true;
goto do_collect;
}
case ':':
{
uint32_t key;
key = va_arg(args, uint32_t);
spa_pod_builder_prop(builder, key, 0);
break;
}
case ']': case ')': case '>': case '}':
spa_pod_builder_pop(builder);
top = spa_pod_builder_pop(builder);
break;
case ' ': case '\n': case '\t': case '\r':
break;
case '\0':
format = va_arg(args, const char *);
if ((format = va_arg(args, const char *)) != NULL)
goto again;
continue;
default:
do_collect:
while (n_values-- > 0)
SPA_POD_BUILDER_COLLECT(builder, *format, args);
if (do_pop)
spa_pod_builder_pop(builder);
break;;
top = spa_pod_builder_pop(builder);
break;
}
if (*format != '\0')
format++;
}
return spa_pod_builder_deref_checked(builder, builder->frame[builder->state.depth].ref,true);
} while (format != NULL);
return top;
}
static inline void *spa_pod_builder_add(struct spa_pod_builder *builder, const char *format, ...)
static inline void *spa_pod_builder_add(struct spa_pod_builder *builder, ...)
{
void *res;
va_list args;
va_start(args, format);
res = spa_pod_builder_addv(builder, format, args);
va_start(args, builder);
res = spa_pod_builder_addv(builder, args);
va_end(args);
return res;
}
static inline void spa_pod_builder_prop_val(struct spa_pod_builder *builder,
uint32_t key, void *pod)
{
spa_pod_builder_prop(builder, key, 0);
spa_pod_builder_primitive(builder, (const struct spa_pod *) pod);
}
#define SPA_POD_Object(type,id,...) \
"{", type, id, ##__VA_ARGS__, SPA_ID_INVALID, "}"
static inline void spa_pod_builder_propsv(struct spa_pod_builder *builder,
uint32_t key, va_list args)
{
while (key) {
spa_pod_builder_prop_val(builder, key, va_arg(args, struct spa_pod *));
key = va_arg(args, uint32_t);
}
}
#define SPA_POD_Prop(key,...) \
key, ##__VA_ARGS__
static inline void spa_pod_builder_props(struct spa_pod_builder *builder, uint32_t key, ...)
{
va_list args;
va_start(args, key);
spa_pod_builder_propsv(builder, key, args);
va_end(args);
}
static inline void *spa_pod_builder_object(struct spa_pod_builder *builder,
uint32_t type, uint32_t id, uint32_t key, ...)
{
va_list args;
spa_pod_builder_push_object(builder, type, id);
va_start(args, key);
spa_pod_builder_propsv(builder, key, args);
va_end(args);
return spa_pod_builder_pop(builder);
}
#define SPA_POD_OBJECT(type,id,...) \
"{", type, id, ##__VA_ARGS__, "}"
#define SPA_POD_STRUCT(...) \
#define SPA_POD_Struct(...) \
"[", ##__VA_ARGS__, "]"
#define SPA_POD_PROP(key,spec,value,...) \
":", key, spec, value, ##__VA_ARGS__
#define SPA_POD_Sequence(unit,...) \
"<", unit, ##__VA_ARGS__, 0, SPA_ID_INVALID, ">"
#define SPA_POD_SEQUENCE(unit,...) \
"<", unit, ##__VA_ARGS__, ">"
#define SPA_POD_CONTROL(offset,type,...) \
".", offset, type, ##__VA_ARGS__
#define SPA_POD_Control(offset,type,...) \
offset, type, ##__VA_ARGS__
#define spa_pod_builder_add_object(b,type,id,...) \
spa_pod_builder_add(b, SPA_POD_OBJECT(type,id,##__VA_ARGS__), NULL)
spa_pod_builder_add(b, SPA_POD_Object(type,id,##__VA_ARGS__), NULL)
#define spa_pod_builder_add_struct(b,...) \
spa_pod_builder_add(b, SPA_POD_STRUCT(__VA_ARGS__), NULL)
spa_pod_builder_add(b, SPA_POD_Struct(__VA_ARGS__), NULL)
#define spa_pod_builder_add_sequence(b,unit,...) \
spa_pod_builder_add(b, SPA_POD_SEQUENCE(unit,__VA_ARGS__), NULL)
spa_pod_builder_add(b, SPA_POD_Sequence(unit,__VA_ARGS__), NULL)
#define SPA_CHOICE_RANGE(def,min,max) 3,(def),(min),(max)
#define SPA_CHOICE_STEP(def,min,max,step) 4,(def),(min),(max),(step)
#define SPA_CHOICE_ENUM(n_vals,...) (n_vals),__VA_ARGS__
#define SPA_CHOICE_ENUM(n_vals,...) (n_vals),##__VA_ARGS__
#define SPA_CHOICE_BOOL(def) 3,(def),(def),!(def)
#define SPA_POD_CHOICE_Bool(def) \
SPA_POD_Choice(SPA_CHOICE_Enum, int32_t, SPA_TYPE_Bool, 3, (def), (def), !(def))
#define SPA_POD_Bool(val) "b", val
#define SPA_POD_CHOICE_Bool(def) "?eb", SPA_CHOICE_BOOL(def)
#define SPA_POD_CHOICE_Int(type, n_vals, ...) \
SPA_POD_Choice(type, uint32_t, SPA_TYPE_Int, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Int(n_vals, ...) \
SPA_POD_CHOICE_Int(SPA_CHOICE_Enum, SPA_CHOICE_ENUM(n_vals, __VA_ARGS__))
#define SPA_POD_CHOICE_RANGE_Int(def, min, max) \
SPA_POD_CHOICE_Int(SPA_CHOICE_Range, SPA_CHOICE_RANGE(def, min, max))
#define SPA_POD_CHOICE_STEP_Int(def, min, max, step) \
SPA_POD_CHOICE_Int(SPA_CHOICE_Step, SPA_CHOICE_STEP(def, min, max, step))
#define SPA_POD_Id(val) "I", val
#define SPA_POD_CHOICE_ENUM_Id(n_vals,...) "?eI", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_Id(type, n_vals, ...) \
SPA_POD_Choice(type, uint32_t, SPA_TYPE_Id, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Id(n_vals, ...) \
SPA_POD_CHOICE_Id(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_Int(val) "i", val
#define SPA_POD_CHOICE_ENUM_Int(n_vals,...) "?ei", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Int(def,min,max) "?ri", SPA_CHOICE_RANGE(def, min, max)
#define SPA_POD_CHOICE_STEP_Int(def,min,max,step) "?si", SPA_CHOICE_STEP(def, min, max, step)
#define SPA_POD_CHOICE_Float(type, n_vals, ...) \
SPA_POD_Choice(type, float, SPA_TYPE_Float, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Float(n_vals, ...) \
SPA_POD_CHOICE_Float(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Float(def, min, max) \
SPA_POD_CHOICE_Float(SPA_CHOICE_Range, 3, (def), (min), (max))
#define SPA_POD_CHOICE_STEP_Float(def, min, max, step) \
SPA_POD_CHOICE_Float(SPA_CHOICE_Step, 4, (def), (min), (max), (step))
#define SPA_POD_Long(val) "l", val
#define SPA_POD_CHOICE_ENUM_Long(n_vals,...) "?el", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Long(def,min,max) "?rl", SPA_CHOICE_RANGE(def, min, max)
#define SPA_POD_CHOICE_STEP_Long(def,min,max,step) "?sl", SPA_CHOICE_STEP(def, min, max, step)
#define SPA_POD_CHOICE_Double(type, n_vals, ...) \
SPA_POD_Choice(type, double, SPA_TYPE_Double, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Double(n_vals, ...) \
SPA_POD_CHOICE_Double(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Double(def, min, max) \
SPA_POD_CHOICE_Double(SPA_CHOICE_Range, 3, (def), (min), (max))
#define SPA_POD_CHOICE_STEP_Double(def, min, max, step) \
SPA_POD_CHOICE_Double(SPA_CHOICE_Step, 4, (def), (min), (max), (step))
#define SPA_POD_Float(val) "f", val
#define SPA_POD_CHOICE_ENUM_Float(n_vals,...) "?ef", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Float(def,min,max) "?rf", SPA_CHOICE_RANGE(def, min, max)
#define SPA_POD_CHOICE_STEP_Float(def,min,max,step) "?sf", SPA_CHOICE_STEP(def, min, max, step)
#define SPA_POD_CHOICE_Rectangle(type, n_vals, ...) \
SPA_POD_Choice(type, struct spa_rectangle, SPA_TYPE_Rectangle, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Rectangle(n_vals, ...) \
SPA_POD_CHOICE_Rectangle(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Rectangle(def, min, max) \
SPA_POD_CHOICE_Rectangle(SPA_CHOICE_Range, 3, (def), (min), (max))
#define SPA_POD_CHOICE_STEP_Rectangle(def, min, max, step) \
SPA_POD_CHOICE_Rectangle(SPA_CHOICE_Step, 4, (def), (min), (max), (step))
#define SPA_POD_Double(val) "d", val
#define SPA_POD_CHOICE_ENUM_Double(n_vals,...) "?ed", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Double(def,min,max) "?rd", SPA_CHOICE_RANGE(def, min, max)
#define SPA_POD_CHOICE_STEP_Double(def,min,max,step) "?sd", SPA_CHOICE_STEP(def, min, max, step)
#define SPA_POD_CHOICE_Fraction(type, n_vals, ...) \
SPA_POD_Choice(type, struct spa_fraction, SPA_TYPE_Fraction, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Fraction(n_vals, ...) \
SPA_POD_CHOICE_Fraction(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Fraction(def, min, max) \
SPA_POD_CHOICE_Fraction(SPA_CHOICE_Range, 3, (def), (min), (max))
#define SPA_POD_CHOICE_STEP_Fraction(def, min, max, step) \
SPA_POD_CHOICE_Fraction(SPA_CHOICE_Step, 4, (def), (min), (max), (step))
#define SPA_POD_String(val) "s",val
#define SPA_POD_Stringn(val,len) "S",val,len
#define SPA_POD_Bytes(val,len) "z",val,len
#define SPA_POD_Rectangle(val) "R", val
#define SPA_POD_CHOICE_ENUM_Rectangle(n_vals,...) "?eR", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Rectangle(def,min,max) "?rR", SPA_CHOICE_RANGE((def),(min),(max))
#define SPA_POD_CHOICE_STEP_Rectangle(def,min,max,step) "?sR", SPA_CHOICE_STEP((def),(min),(max),(step))
#define SPA_POD_Fraction(val) "F", val
#define SPA_POD_CHOICE_ENUM_Fraction(n_vals,...) "?eF", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Fraction(def,min,max) "?rF", SPA_CHOICE_RANGE((def),(min),(max))
#define SPA_POD_CHOICE_STEP_Fraction(def,min,max,step) "?sF", SPA_CHOICE_STEP(def, min, max, step)
#define SPA_POD_Array(csize,ctype,n_vals,vals) "a", csize,ctype,n_vals,vals
#define SPA_POD_Pointer(type,val) "p", type,val
#define SPA_POD_Fd(val) "h", val
#define SPA_POD_Pod(val) "P", val
#define SPA_POD_PodObject(val) "O", val
#define SPA_POD_PodStruct(val) "T", val
#define SPA_POD_PodChoice(val) "V", val
#ifdef __cplusplus
} /* extern "C" */

125
spa/include/spa/pod/parser.h
View file

@ -36,6 +36,9 @@ extern "C" {
struct spa_pod_parser {
int depth;
#define SPA_POD_PARSER_FLAG_OBJECT (1<<0)
#define SPA_POD_PARSER_FLAG_STRUCT (1<<1)
uint32_t flags;
struct spa_pod_iter iter[SPA_POD_MAX_DEPTH];
};
@ -43,6 +46,7 @@ static inline void spa_pod_parser_init(struct spa_pod_parser *parser,
const void *data, uint32_t size, uint32_t offset)
{
parser->depth = 0;
parser->flags = 0;
spa_pod_iter_init(&parser->iter[0], data, size, offset);
}
@ -100,9 +104,9 @@ static inline bool spa_pod_parser_can_collect(struct spa_pod *pod, char type)
}
}
#define SPA_POD_PARSER_COLLECT(pod,type,args) \
#define SPA_POD_PARSER_COLLECT(pod,_type,args) \
do { \
switch (type) { \
switch (_type) { \
case 'b': \
*va_arg(args, int*) = SPA_POD_VALUE(struct spa_pod_bool, pod); \
break; \
@ -152,6 +156,7 @@ do { \
{ \
struct spa_pod_pointer_body *b = \
(struct spa_pod_pointer_body *) SPA_POD_BODY(pod); \
*(va_arg(args, uint32_t *)) = b->type; \
*(va_arg(args, const void **)) = b->value; \
break; \
} \
@ -171,13 +176,14 @@ do { \
} \
} while(false)
#define SPA_POD_PARSER_SKIP(type,args) \
#define SPA_POD_PARSER_SKIP(_type,args) \
do { \
switch (type) { \
switch (_type) { \
case 'S': \
va_arg(args, void*); \
va_arg(args, char*); \
va_arg(args, uint32_t); \
break; \
case 'p': \
case 'z': \
va_arg(args, void**); \
/* fallthrough */ \
@ -191,7 +197,6 @@ do { \
case 'R': \
case 'F': \
case 'B': \
case 'p': \
case 'h': \
case 'V': \
case 'P': \
@ -202,58 +207,66 @@ do { \
} \
} while(false)
static inline int spa_pod_parser_getv(struct spa_pod_parser *parser,
const char *format, va_list args)
static inline int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args)
{
struct spa_pod *pod = NULL, *current;
struct spa_pod_prop *prop = NULL;
bool required = true, suppress = false, skip = false;
bool required = true, skip = false;
struct spa_pod_iter *it = &parser->iter[parser->depth];
const char *format = "";
uint32_t *idp;
current = pod = spa_pod_iter_current(it);
while (format) {
do {
again:
switch (*format) {
case '{':
if (pod == NULL || SPA_POD_TYPE(pod) != SPA_TYPE_Object)
return -EINVAL;
break;
if (va_arg(args, uint32_t) != SPA_POD_OBJECT_TYPE(pod))
return -EINVAL;
if ((idp = va_arg(args, uint32_t*)) != NULL)
*idp = SPA_POD_OBJECT_ID(pod);
parser->flags = SPA_POD_PARSER_FLAG_OBJECT;
goto enter;
case '[':
if (pod == NULL || SPA_POD_TYPE(pod) != SPA_TYPE_Struct)
return -EINVAL;
parser->flags = SPA_POD_PARSER_FLAG_STRUCT;
enter:
if (++parser->depth >= SPA_POD_MAX_DEPTH)
return -EINVAL;
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 '}':
if (current != NULL)
return -EINVAL;
if (--parser->depth < 0)
return -EINVAL;
/* fallthrough */
case '}':
it = &parser->iter[parser->depth];
if (SPA_POD_TYPE(it->data) == SPA_TYPE_Object)
parser->flags = SPA_POD_PARSER_FLAG_OBJECT;
else if (SPA_POD_TYPE(it->data) == SPA_TYPE_Struct)
parser->flags = SPA_POD_PARSER_FLAG_STRUCT;
else
parser->flags = 0;
current = spa_pod_iter_current(it);
spa_pod_iter_advance(it, current);
goto read_pod;
case '\0':
format = va_arg(args, char *);
continue;
case ' ': case '\n': case '\t': case '\r':
break;
case '?':
required = false;
break;
case '*':
suppress = true;
break;
case ':':
{
if (parser->flags & SPA_POD_PARSER_FLAG_OBJECT) {
const struct spa_pod *obj = (const struct spa_pod *) it->data;
uint32_t key = va_arg(args, uint32_t);
const struct spa_pod *obj = (const struct spa_pod *) parser->iter[parser->depth].data;
if (key == 0) {
format = NULL;
continue;
}
if (key != SPA_ID_INVALID) {
prop = spa_pod_find_prop(obj, key);
if (prop != NULL)
pod = &prop->value;
@ -263,8 +276,16 @@ static inline int spa_pod_parser_getv(struct spa_pod_parser *parser,
it->offset = it->size;
current = NULL;
required = true;
break;
}
}
if ((format = va_arg(args, char *)) != NULL)
goto again;
continue;
case ' ': case '\n': case '\t': case '\r':
break;
case '?':
required = false;
break;
case 'V':
pod = (struct spa_pod *) prop;
if (pod == NULL && required)
@ -280,9 +301,7 @@ static inline int spa_pod_parser_getv(struct spa_pod_parser *parser,
if (pod->type == SPA_TYPE_Choice)
pod = SPA_POD_CHOICE_CHILD(pod);
if (suppress)
suppress = false;
else if (skip)
if (skip)
SPA_POD_PARSER_SKIP(*format, args);
else
SPA_POD_PARSER_COLLECT(pod, *format, args);
@ -296,28 +315,56 @@ static inline int spa_pod_parser_getv(struct spa_pod_parser *parser,
break;
}
format++;
}
} while (format != NULL);
return 0;
}
static inline int spa_pod_parser_get(struct spa_pod_parser *parser,
const char *format, ...)
static inline int spa_pod_parser_get(struct spa_pod_parser *parser, ...)
{
int res;
va_list args;
va_start(args, format);
res = spa_pod_parser_getv(parser, format, args);
va_start(args, parser);
res = spa_pod_parser_getv(parser, args);
va_end(args);
return res;
}
#define spa_pod_object_parse(pod,...) \
#define SPA_POD_OPT_Bool(val) "?" SPA_POD_Bool(val)
#define SPA_POD_OPT_Id(val) "?" SPA_POD_Id(val)
#define SPA_POD_OPT_Int(val) "?" SPA_POD_Int(val)
#define SPA_POD_OPT_Long(val) "?" SPA_POD_Long(val)
#define SPA_POD_OPT_Float(val) "?" SPA_POD_Float(val)
#define SPA_POD_OPT_Double(val) "?" SPA_POD_Double(val)
#define SPA_POD_OPT_String(val) "?" SPA_POD_String(val)
#define SPA_POD_OPT_Stringn(val,len) "?" SPA_POD_Stringn(val,len)
#define SPA_POD_OPT_Bytes(val,len) "?" SPA_POD_Bytes(val,len)
#define SPA_POD_OPT_Rectangle(val) "?" SPA_POD_Rectangle(val)
#define SPA_POD_OPT_Fraction(val) "?" SPA_POD_Fraction(val)
#define SPA_POD_OPT_Pointer(type,val) "?" SPA_POD_Pointer(type,val)
#define SPA_POD_OPT_Fd(val) "?" SPA_POD_Fd(val)
#define SPA_POD_OPT_Pod(val) "?" SPA_POD_Pod(val)
#define spa_pod_parser_get_object(p,type,id,...) \
spa_pod_parser_get(p, SPA_POD_Object(type,id,##__VA_ARGS__), NULL)
#define spa_pod_parser_get_struct(p,...) \
spa_pod_parser_get(p, SPA_POD_Struct(__VA_ARGS__), NULL)
#define spa_pod_parse_object(pod,type,id,...) \
({ \
struct spa_pod_parser _p; \
spa_pod_parser_pod(&_p, pod); \
spa_pod_parser_get(&_p, "{", ##__VA_ARGS__, NULL); \
spa_pod_parser_get_object(&_p,type,id,##__VA_ARGS__); \
})
#define spa_pod_parse_struct(pod,...) \
({ \
struct spa_pod_parser _p; \
spa_pod_parser_pod(&_p, pod); \
spa_pod_parser_get_struct(&_p,##__VA_ARGS__); \
})
static inline int spa_pod_is_bool(struct spa_pod *pod)

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

@ -295,10 +295,9 @@ static int impl_enum_params(struct spa_device *device,
SPA_PARAM_Profile };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -307,18 +306,16 @@ static int impl_enum_params(struct spa_device *device,
{
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, id,
SPA_PARAM_PROFILE_id, &SPA_POD_Int(0),
SPA_PARAM_PROFILE_name, &SPA_POD_Stringc("On"),
0);
SPA_PARAM_PROFILE_id, SPA_POD_Int(0),
SPA_PARAM_PROFILE_name, SPA_POD_String("On"));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, id,
SPA_PARAM_PROFILE_id, &SPA_POD_Int(1),
SPA_PARAM_PROFILE_name, &SPA_POD_Stringc("Off"),
0);
SPA_PARAM_PROFILE_id, SPA_POD_Int(1),
SPA_PARAM_PROFILE_name, SPA_POD_String("Off"));
break;
default:
return 0;
@ -329,10 +326,9 @@ static int impl_enum_params(struct spa_device *device,
{
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, id,
SPA_PARAM_PROFILE_id, &SPA_POD_Int(this->profile),
0);
SPA_PARAM_PROFILE_id, SPA_POD_Int(this->profile));
break;
default:
return 0;
@ -367,9 +363,9 @@ static int impl_set_param(struct spa_device *device,
{
uint32_t id;
if ((res = spa_pod_object_parse(param,
":", SPA_PARAM_PROFILE_id, "i", &id,
NULL)) < 0) {
if ((res = spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamProfile, NULL,
SPA_PARAM_PROFILE_id, SPA_POD_Int(&id))) < 0) {
spa_log_warn(this->log, "can't parse profile");
spa_debug_pod(0, NULL, param);
return res;

18
spa/plugins/alsa/alsa-monitor.c
View file

@ -126,14 +126,14 @@ static int fill_item(struct impl *this, struct udev_device *dev,
name = "Unknown";
spa_pod_builder_push_object(builder, SPA_TYPE_OBJECT_MonitorItem, 0);
spa_pod_builder_props(builder,
SPA_MONITOR_ITEM_id, &SPA_POD_Stringv(udev_device_get_syspath(dev)),
SPA_MONITOR_ITEM_flags, &SPA_POD_Id(SPA_MONITOR_ITEM_FLAG_NONE),
SPA_MONITOR_ITEM_state, &SPA_POD_Id(SPA_MONITOR_ITEM_STATE_Available),
SPA_MONITOR_ITEM_name, &SPA_POD_Stringv(name),
SPA_MONITOR_ITEM_class, &SPA_POD_Stringv("Audio/Device"),
SPA_MONITOR_ITEM_factory, &SPA_POD_Pointer(SPA_TYPE_INTERFACE_HandleFactory, &spa_alsa_device_factory),
SPA_MONITOR_ITEM_type, &SPA_POD_Id(SPA_TYPE_INTERFACE_Device),
spa_pod_builder_add(builder,
SPA_MONITOR_ITEM_id, SPA_POD_String(udev_device_get_syspath(dev)),
SPA_MONITOR_ITEM_flags, SPA_POD_Id(SPA_MONITOR_ITEM_FLAG_NONE),
SPA_MONITOR_ITEM_state, SPA_POD_Id(SPA_MONITOR_ITEM_STATE_Available),
SPA_MONITOR_ITEM_name, SPA_POD_String(name),
SPA_MONITOR_ITEM_class, SPA_POD_String("Audio/Device"),
SPA_MONITOR_ITEM_factory, SPA_POD_Pointer(SPA_TYPE_INTERFACE_HandleFactory, &spa_alsa_device_factory),
SPA_MONITOR_ITEM_type, SPA_POD_Id(SPA_TYPE_INTERFACE_Device),
0);
if ((str = path_get_card_id(udev_device_get_property_value(dev, "DEVPATH"))) == NULL)
@ -262,7 +262,7 @@ static int emit_device(struct impl *this, uint32_t id, struct udev_device *dev)
struct spa_pod *item;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, id, 0);
event = spa_pod_builder_add_object(&b, SPA_TYPE_EVENT_Monitor, id);
fill_item(this, dev, &item, &b);
this->callbacks->event(this->callbacks_data, event);

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

@ -74,10 +74,9 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -88,44 +87,39 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_device),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA device"),
SPA_PROP_INFO_type, &SPA_POD_String(p->device, sizeof(p->device)),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_device),
SPA_PROP_INFO_name, SPA_POD_String("The ALSA device"),
SPA_PROP_INFO_type, SPA_POD_Stringn(p->device, sizeof(p->device)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_deviceName),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA device name"),
SPA_PROP_INFO_type, &SPA_POD_String(p->device_name, sizeof(p->device_name)),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_deviceName),
SPA_PROP_INFO_name, SPA_POD_String("The ALSA device name"),
SPA_PROP_INFO_type, SPA_POD_Stringn(p->device_name, sizeof(p->device_name)));
break;
case 2:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_cardName),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA card name"),
SPA_PROP_INFO_type, &SPA_POD_String(p->card_name, sizeof(p->card_name)),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_cardName),
SPA_PROP_INFO_name, SPA_POD_String("The ALSA card name"),
SPA_PROP_INFO_type, SPA_POD_Stringn(p->card_name, sizeof(p->card_name)));
break;
case 3:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_minLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The minimum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->min_latency, 1, INT32_MAX),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_minLatency),
SPA_PROP_INFO_name, SPA_POD_String("The minimum latency"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(p->min_latency, 1, INT32_MAX));
break;
case 4:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_maxLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The maximum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->max_latency, 1, INT32_MAX),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_maxLatency),
SPA_PROP_INFO_name, SPA_POD_String("The maximum latency"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(p->max_latency, 1, INT32_MAX));
break;
default:
return 0;
@ -138,14 +132,13 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_device, &SPA_POD_String(p->device, sizeof(p->device)),
SPA_PROP_deviceName, &SPA_POD_String(p->device_name, sizeof(p->device_name)),
SPA_PROP_cardName, &SPA_POD_String(p->card_name, sizeof(p->card_name)),
SPA_PROP_minLatency, &SPA_POD_Int(p->min_latency),
SPA_PROP_maxLatency, &SPA_POD_Int(p->max_latency),
0);
SPA_PROP_device, SPA_POD_Stringn(p->device, sizeof(p->device)),
SPA_PROP_deviceName, SPA_POD_Stringn(p->device_name, sizeof(p->device_name)),
SPA_PROP_cardName, SPA_POD_Stringn(p->card_name, sizeof(p->card_name)),
SPA_PROP_minLatency, SPA_POD_Int(p->min_latency),
SPA_PROP_maxLatency, SPA_POD_Int(p->max_latency));
break;
default:
return 0;
@ -201,10 +194,11 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
reset_props(p);
return 0;
}
spa_pod_object_parse(param,
":", SPA_PROP_device, "?S", p->device, sizeof(p->device),
":", SPA_PROP_minLatency, "?i", &p->min_latency,
":", SPA_PROP_maxLatency, "?i", &p->max_latency, NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_device, SPA_POD_Stringn(p->device, sizeof(p->device)),
SPA_PROP_minLatency, SPA_POD_Int(&p->min_latency),
SPA_PROP_maxLatency, SPA_POD_Int(&p->max_latency));
}
else
return -ENOENT;
@ -369,10 +363,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO, };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -395,17 +388,16 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(3, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(3, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
this->props.max_latency * this->frame_size,
this->props.min_latency * this->frame_size,
INT32_MAX),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(this->frame_size),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(this->frame_size),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
@ -414,11 +406,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -428,25 +419,22 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Clock),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_clock)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Clock),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_clock)));
break;
case 2:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Notify),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence) + 1024),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Notify),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence) + 1024));
break;
default:
return 0;

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

@ -78,10 +78,9 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props, };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -89,44 +88,39 @@ static int impl_node_enum_params(struct spa_node *node,
case SPA_PARAM_PropInfo:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_device),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA device"),
SPA_PROP_INFO_type, &SPA_POD_String(p->device, sizeof(p->device)),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_device),
SPA_PROP_INFO_name, SPA_POD_String("The ALSA device"),
SPA_PROP_INFO_type, SPA_POD_Stringn(p->device, sizeof(p->device)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_deviceName),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA device name"),
SPA_PROP_INFO_type, &SPA_POD_String(p->device_name, sizeof(p->device_name)),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_deviceName),
SPA_PROP_INFO_name, SPA_POD_String("The ALSA device name"),
SPA_PROP_INFO_type, SPA_POD_Stringn(p->device_name, sizeof(p->device_name)));
break;
case 2:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_cardName),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The ALSA card name"),
SPA_PROP_INFO_type, &SPA_POD_String(p->card_name, sizeof(p->card_name)),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_cardName),
SPA_PROP_INFO_name, SPA_POD_String("The ALSA card name"),
SPA_PROP_INFO_type, SPA_POD_Stringn(p->card_name, sizeof(p->card_name)));
break;
case 3:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_minLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The minimum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->min_latency, 1, INT32_MAX),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_minLatency),
SPA_PROP_INFO_name, SPA_POD_String("The minimum latency"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(p->min_latency, 1, INT32_MAX));
break;
case 4:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_maxLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The maximum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->max_latency, 1, INT32_MAX),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_maxLatency),
SPA_PROP_INFO_name, SPA_POD_String("The maximum latency"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(p->max_latency, 1, INT32_MAX));
break;
default:
return 0;
@ -136,14 +130,13 @@ static int impl_node_enum_params(struct spa_node *node,
case SPA_PARAM_Props:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_device, &SPA_POD_String(p->device, sizeof(p->device)),
SPA_PROP_deviceName, &SPA_POD_String(p->device_name, sizeof(p->device_name)),
SPA_PROP_cardName, &SPA_POD_String(p->card_name, sizeof(p->card_name)),
SPA_PROP_minLatency, &SPA_POD_Int(p->min_latency),
SPA_PROP_maxLatency, &SPA_POD_Int(p->max_latency),
0);
SPA_PROP_device, SPA_POD_Stringn(p->device, sizeof(p->device)),
SPA_PROP_deviceName, SPA_POD_Stringn(p->device_name, sizeof(p->device_name)),
SPA_PROP_cardName, SPA_POD_Stringn(p->card_name, sizeof(p->card_name)),
SPA_PROP_minLatency, SPA_POD_Int(p->min_latency),
SPA_PROP_maxLatency, SPA_POD_Int(p->max_latency));
break;
default:
return 0;
@ -201,10 +194,11 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
reset_props(p);
return 0;
}
spa_pod_object_parse(param,
":", SPA_PROP_device, "?S", p->device, sizeof(p->device),
":", SPA_PROP_minLatency, "?i", &p->min_latency,
":", SPA_PROP_maxLatency, "?i", &p->max_latency, NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_device, SPA_POD_OPT_Stringn(p->device, sizeof(p->device)),
SPA_PROP_minLatency, SPA_POD_OPT_Int(&p->min_latency),
SPA_PROP_maxLatency, SPA_POD_OPT_Int(&p->max_latency));
break;
}
default:
@ -379,10 +373,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_Meta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -405,17 +398,16 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(2, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
this->props.max_latency * this->frame_size,
this->props.min_latency * this->frame_size,
INT32_MAX),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(this->frame_size),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(this->frame_size),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
@ -424,11 +416,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -438,18 +429,16 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Clock),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_clock)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Clock),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_clock)));
break;
default:
return 0;

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

@ -249,9 +249,9 @@ spa_alsa_enum_format(struct state *state, uint32_t *index,
CHECK(snd_pcm_hw_params_any(hndl, params), "Broken configuration: no configurations available");
spa_pod_builder_push_object(&b, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat);
spa_pod_builder_props(&b,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
spa_pod_builder_add(&b,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
0);
snd_pcm_format_mask_alloca(&fmask);

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

@ -306,12 +306,12 @@ static int negotiate_link_buffers(struct impl *this, struct link *link)
in_alloc = false;
}
if (spa_pod_object_parse(param,
":", SPA_PARAM_BUFFERS_buffers, "i", &buffers,
":", SPA_PARAM_BUFFERS_blocks, "i", &blocks,
":", SPA_PARAM_BUFFERS_size, "i", &size,
":", SPA_PARAM_BUFFERS_align, "i", &align,
NULL) < 0)
if (spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamBuffers, NULL,
SPA_PARAM_BUFFERS_buffers, SPA_POD_Int(&buffers),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(&blocks),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(&size),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(&align)) < 0)
return -EINVAL;
spa_log_debug(this->log, "%p: buffers %d, blocks %d, size %d, align %d",
@ -418,16 +418,14 @@ static int impl_node_enum_params(struct spa_node *node,
case SPA_PARAM_EnumProfile:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, id,
SPA_PARAM_PROFILE_direction, &SPA_POD_Id(SPA_DIRECTION_INPUT),
0);
SPA_PARAM_PROFILE_direction, SPA_POD_Id(SPA_DIRECTION_INPUT));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, id,
SPA_PARAM_PROFILE_direction, &SPA_POD_Id(SPA_DIRECTION_OUTPUT),
0);
SPA_PARAM_PROFILE_direction, SPA_POD_Id(SPA_DIRECTION_OUTPUT));
break;
default:
return 0;
@ -477,10 +475,10 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
if (spa_pod_object_parse(param,
":", SPA_PARAM_PROFILE_direction, "I", &direction,
":", SPA_PARAM_PROFILE_format, "P", &format,
NULL) < 0)
if (spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamProfile, NULL,
SPA_PARAM_PROFILE_direction, SPA_POD_Id(&direction),
SPA_PARAM_PROFILE_format, SPA_POD_Pod(&format)) < 0)
return -EINVAL;
if (!SPA_POD_IS_OBJECT_TYPE(format, SPA_TYPE_OBJECT_Format))
@ -506,11 +504,10 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
spa_pod_builder_init(&b, buffer, sizeof(buffer));
param = spa_format_audio_raw_build(&b, SPA_PARAM_Format, &info.info.raw);
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, id,
SPA_PARAM_PROFILE_direction, &SPA_POD_Id(direction),
SPA_PARAM_PROFILE_format, param,
0);
SPA_PARAM_PROFILE_direction, SPA_POD_Id(direction),
SPA_PARAM_PROFILE_format, SPA_POD_Pod(param));
res = spa_node_set_param(this->fmt[direction], id, flags, param);
break;
default:
@ -676,11 +673,10 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_PropInfo:
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_volume),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Float(1.0, 0.0, 10.0),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_volume),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Float(1.0, 0.0, 10.0));
break;
default:
return 0;
@ -690,25 +686,22 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_range)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_range)));
break;
case 2:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence)));
break;
default:
return 0;

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

@ -457,10 +457,9 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -471,20 +470,18 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_volume),
SPA_PROP_INFO_name, &SPA_POD_Stringc("Volume"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Float(p->volume, 0.0, 10.0),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_volume),
SPA_PROP_INFO_name, SPA_POD_String("Volume"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Float(p->volume, 0.0, 10.0));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_mute),
SPA_PROP_INFO_name, &SPA_POD_Stringc("Mute"),
SPA_PROP_INFO_type, &SPA_POD_Bool(p->mute),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_mute),
SPA_PROP_INFO_name, SPA_POD_String("Mute"),
SPA_PROP_INFO_type, SPA_POD_Bool(p->mute));
break;
default:
return 0;
@ -497,11 +494,10 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_volume, &SPA_POD_Float(p->volume),
SPA_PROP_mute, &SPA_POD_Bool(p->mute),
0);
SPA_PROP_volume, SPA_POD_Float(p->volume),
SPA_PROP_mute, SPA_POD_Bool(p->mute));
break;
default:
return 0;
@ -688,23 +684,21 @@ static int port_enum_formats(struct spa_node *node,
switch (*index) {
case 0:
if (other->have_format) {
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, &SPA_POD_Int(other->format.info.raw.rate),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(DEFAULT_CHANNELS, 1, INT32_MAX),
0);
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, SPA_POD_Int(other->format.info.raw.rate),
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(DEFAULT_CHANNELS, 1, INT32_MAX));
} else {
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(DEFAULT_RATE, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(DEFAULT_CHANNELS, 1, INT32_MAX),
0);
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(DEFAULT_RATE, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(DEFAULT_CHANNELS, 1, INT32_MAX));
}
break;
default:
@ -752,10 +746,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -791,17 +784,16 @@ impl_node_port_enum_params(struct spa_node *node,
size = port->format.info.raw.rate * 1024 / DEFAULT_RATE;
}
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(buffers, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(buffers, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
size * port->stride,
16 * port->stride,
INT32_MAX / port->stride),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
}
case SPA_PARAM_Meta:
@ -810,11 +802,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -824,18 +815,16 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence)));
break;
default:
return 0;

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

@ -351,16 +351,16 @@ static int port_enum_formats(struct spa_node *node,
spa_pod_builder_push_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat);
spa_pod_builder_props(builder,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_CHOICE_ENUM_Id(4,
spa_pod_builder_add(builder,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_CHOICE_ENUM_Id(4,
info.info.raw.format,
info.info.raw.format,
SPA_AUDIO_FORMAT_F32,
SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, &SPA_POD_Int(info.info.raw.rate),
SPA_FORMAT_AUDIO_channels, &SPA_POD_Int(info.info.raw.channels),
SPA_FORMAT_AUDIO_rate, SPA_POD_Int(info.info.raw.rate),
SPA_FORMAT_AUDIO_channels, SPA_POD_Int(info.info.raw.channels),
0);
if (!SPA_FLAG_CHECK(info.info.raw.flags, SPA_AUDIO_FLAG_UNPOSITIONED)) {
spa_pod_builder_prop(builder, SPA_FORMAT_AUDIO_position, 0);
@ -369,11 +369,11 @@ static int port_enum_formats(struct spa_node *node,
}
*param = spa_pod_builder_pop(builder);
} else {
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_CHOICE_ENUM_Id(18,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_CHOICE_ENUM_Id(18,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_U8P,
SPA_AUDIO_FORMAT_U8,
@ -392,11 +392,10 @@ static int port_enum_formats(struct spa_node *node,
SPA_AUDIO_FORMAT_S24_32P,
SPA_AUDIO_FORMAT_S24_32,
SPA_AUDIO_FORMAT_S24_32_OE),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(
DEFAULT_RATE, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(
DEFAULT_CHANNELS, 1, INT32_MAX),
0);
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(
DEFAULT_CHANNELS, 1, INT32_MAX));
}
break;
default:
@ -446,8 +445,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b, SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]), 0);
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -478,22 +478,23 @@ impl_node_port_enum_params(struct spa_node *node,
if (other->n_buffers > 0) {
buffers = other->n_buffers;
pod = &SPA_POD_Int(other->size / other->stride * port->stride);
pod = &SPA_POD_INIT_Int(other->size / other->stride * port->stride);
} else {
buffers = 1;
pod = &SPA_POD_CHOICE_RANGE_Int(1024 * port->stride,
pod = &SPA_POD_INIT_Choice(SPA_CHOICE_Range,
int32_t, SPA_TYPE_Int, 3,
1024 * port->stride,
16 * port->stride,
INT32_MAX / port->stride);
}
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(buffers, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, pod,
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(buffers, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, SPA_POD_Pod(pod),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
}
case SPA_PARAM_Meta:
@ -502,11 +503,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -516,11 +516,10 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
default:
return 0;

57
spa/plugins/audioconvert/merger.c
View file

@ -166,10 +166,9 @@ static int impl_node_enum_params(struct spa_node *node,
uint32_t list[] = { SPA_PARAM_Profile };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -208,9 +207,9 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
struct spa_pod *format;
uint32_t i;
if (spa_pod_object_parse(param,
":", SPA_PARAM_PROFILE_format, "P", &format,
NULL) < 0)
if (spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamProfile, NULL,
SPA_PARAM_PROFILE_format, SPA_POD_Pod(&format)) < 0)
return -EINVAL;
if (!SPA_POD_IS_OBJECT_TYPE(format, SPA_TYPE_OBJECT_Format))
@ -401,11 +400,11 @@ static int port_enum_formats(struct spa_node *node,
SPA_PARAM_EnumFormat, &port->format.info.raw);
}
else {
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_CHOICE_ENUM_Id(13,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_CHOICE_ENUM_Id(13,
SPA_AUDIO_FORMAT_F32,
SPA_AUDIO_FORMAT_F32,
SPA_AUDIO_FORMAT_F32P,
@ -419,11 +418,10 @@ static int port_enum_formats(struct spa_node *node,
SPA_AUDIO_FORMAT_S16P,
SPA_AUDIO_FORMAT_U8,
SPA_AUDIO_FORMAT_U8P),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(
DEFAULT_RATE, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(
DEFAULT_CHANNELS, 1, MAX_PORTS),
0);
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(
DEFAULT_CHANNELS, 1, MAX_PORTS));
}
break;
default:
@ -472,9 +470,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO, };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]), 0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -497,17 +495,16 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
1024 * port->stride,
16 * port->stride,
MAX_SAMPLES * port->stride),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
if (!port->have_format)
@ -515,11 +512,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -528,11 +524,10 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
default:
return 0;

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

@ -335,27 +335,26 @@ static int port_enum_formats(struct spa_node *node,
if (other->have_format) {
spa_pod_builder_push_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat);
spa_pod_builder_props(builder,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(
spa_pod_builder_add(builder,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(
other->format.info.raw.rate, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_Int(other->format.info.raw.channels),
SPA_FORMAT_AUDIO_channels, SPA_POD_Int(other->format.info.raw.channels),
0);
spa_pod_builder_prop(builder, SPA_FORMAT_AUDIO_position, 0);
spa_pod_builder_array(builder, sizeof(uint32_t), SPA_TYPE_Id,
other->format.info.raw.channels, other->format.info.raw.position);
*param = spa_pod_builder_pop(builder);
} else {
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(DEFAULT_RATE, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(DEFAULT_CHANNELS, 1, INT32_MAX),
0);
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(DEFAULT_RATE, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(DEFAULT_CHANNELS, 1, INT32_MAX));
}
break;
default:
@ -403,10 +402,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -441,17 +439,16 @@ impl_node_port_enum_params(struct spa_node *node,
size = 1024;
}
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(buffers, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(buffers, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
size * port->stride,
16 * port->stride,
INT32_MAX / port->stride),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
}
case SPA_PARAM_Meta:
@ -460,11 +457,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -473,18 +469,16 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_range)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_range)));
break;
default:
return 0;

59
spa/plugins/audioconvert/splitter.c
View file

@ -36,6 +36,7 @@
#include <spa/pod/filter.h>
#include <spa/debug/types.h>
#include <spa/debug/mem.h>
#include <spa/debug/pod.h>
#define NAME "splitter"
@ -160,10 +161,9 @@ static int impl_node_enum_params(struct spa_node *node,
uint32_t list[] = { SPA_PARAM_Profile };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -202,9 +202,9 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
struct spa_pod *format;
uint32_t i;
if (spa_pod_object_parse(param,
":", SPA_PARAM_PROFILE_format, "P", &format,
NULL) < 0)
if (spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamProfile, NULL,
SPA_PARAM_PROFILE_format, SPA_POD_Pod(&format)) < 0)
return -EINVAL;
if (!SPA_POD_IS_OBJECT_TYPE(format, SPA_TYPE_OBJECT_Format))
@ -386,11 +386,11 @@ static int port_enum_formats(struct spa_node *node,
SPA_PARAM_EnumFormat, &port->format.info.raw);
}
else {
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_CHOICE_ENUM_Id(18,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_CHOICE_ENUM_Id(18,
SPA_AUDIO_FORMAT_F32,
SPA_AUDIO_FORMAT_F32P,
SPA_AUDIO_FORMAT_F32,
@ -409,11 +409,10 @@ static int port_enum_formats(struct spa_node *node,
SPA_AUDIO_FORMAT_S16_OE,
SPA_AUDIO_FORMAT_U8P,
SPA_AUDIO_FORMAT_U8),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(
DEFAULT_RATE, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(
DEFAULT_CHANNELS, 1, MAX_PORTS),
0);
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(
DEFAULT_CHANNELS, 1, MAX_PORTS));
}
break;
default:
@ -462,10 +461,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -488,17 +486,16 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(port->blocks),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
1024 * port->stride,
16 * port->stride,
MAX_SAMPLES * port->stride),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(port->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
@ -507,11 +504,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -520,11 +516,10 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
default:
return 0;

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

@ -337,26 +337,24 @@ static int port_enum_formats(struct spa_node *node,
switch (*index) {
case 0:
if (this->have_format) {
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_Id(this->format.info.raw.format),
SPA_FORMAT_AUDIO_rate, &SPA_POD_Int(this->format.info.raw.rate),
SPA_FORMAT_AUDIO_channels, &SPA_POD_Int(this->format.info.raw.channels),
0);
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_Id(this->format.info.raw.format),
SPA_FORMAT_AUDIO_rate, SPA_POD_Int(this->format.info.raw.rate),
SPA_FORMAT_AUDIO_channels, SPA_POD_Int(this->format.info.raw.channels));
} else {
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_CHOICE_ENUM_Int(3,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_CHOICE_ENUM_Int(3,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_F32),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(2, 1, INT32_MAX),
0);
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(2, 1, INT32_MAX));
}
break;
default:
@ -403,10 +401,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO, };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -429,17 +426,16 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
1024 * this->bpf,
16 * this->bpf,
INT32_MAX / this->bpf),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
if (!port->have_format)
@ -447,11 +443,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -460,25 +455,22 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_range)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_range)));
break;
case 2:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence)));
break;
default:
return 0;

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

@ -152,10 +152,9 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -166,19 +165,18 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_live),
SPA_PROP_INFO_name, &SPA_POD_Stringc("Configure live mode of the source"),
SPA_PROP_INFO_type, &SPA_POD_Bool(p->live),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_live),
SPA_PROP_INFO_name, SPA_POD_String("Configure live mode of the source"),
SPA_PROP_INFO_type, SPA_POD_Bool(p->live));
break;
case 1:
spa_pod_builder_push_object(&b, SPA_TYPE_OBJECT_PropInfo, id);
spa_pod_builder_props(&b,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_waveType),
SPA_PROP_INFO_name, &SPA_POD_Stringc("Select the waveform"),
SPA_PROP_INFO_type, &SPA_POD_Int(p->wave),
spa_pod_builder_add(&b,
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_waveType),
SPA_PROP_INFO_name, SPA_POD_String("Select the waveform"),
SPA_PROP_INFO_type, SPA_POD_Int(p->wave),
0);
spa_pod_builder_prop(&b, SPA_PROP_INFO_labels, 0);
spa_pod_builder_push_struct(&b);
@ -190,20 +188,18 @@ static int impl_node_enum_params(struct spa_node *node,
param = spa_pod_builder_pop(&b);
break;
case 2:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_frequency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("Select the frequency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Float(p->freq, 0.0, 50000000.0),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_frequency),
SPA_PROP_INFO_name, SPA_POD_String("Select the frequency"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Float(p->freq, 0.0, 50000000.0));
break;
case 3:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_volume),
SPA_PROP_INFO_name, &SPA_POD_Stringc("Select the volume"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Float(p->volume, 0.0, 10.0),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_volume),
SPA_PROP_INFO_name, SPA_POD_String("Select the volume"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Float(p->volume, 0.0, 10.0));
break;
default:
return 0;
@ -216,13 +212,12 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_live, &SPA_POD_Bool(p->live),
SPA_PROP_waveType, &SPA_POD_Int(p->wave),
SPA_PROP_frequency, &SPA_POD_Float(p->freq),
SPA_PROP_volume, &SPA_POD_Float(p->volume),
0);
SPA_PROP_live, SPA_POD_Bool(p->live),
SPA_PROP_waveType, SPA_POD_Int(p->wave),
SPA_PROP_frequency, SPA_POD_Float(p->freq),
SPA_PROP_volume, SPA_POD_Float(p->volume));
break;
default:
return 0;
@ -257,12 +252,12 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
reset_props(p);
return 0;
}
spa_pod_object_parse(param,
":",SPA_PROP_live, "?b", &p->live,
":",SPA_PROP_waveType, "?i", &p->wave,
":",SPA_PROP_frequency, "?d", &p->freq,
":",SPA_PROP_volume, "?d", &p->volume,
NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_live, "?b", &p->live,
SPA_PROP_waveType, "?i", &p->wave,
SPA_PROP_frequency, "?d", &p->freq,
SPA_PROP_volume, "?d", &p->volume);
if (p->live)
this->info.flags |= SPA_PORT_INFO_FLAG_LIVE;
@ -550,19 +545,18 @@ port_enum_formats(struct impl *this,
{
switch (*index) {
case 0:
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_CHOICE_ENUM_Id(5,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_CHOICE_ENUM_Id(5,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32,
SPA_AUDIO_FORMAT_F32,
SPA_AUDIO_FORMAT_F64),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(2, 1, INT32_MAX),
0);
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(2, 1, INT32_MAX));
break;
default:
return 0;
@ -605,10 +599,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO, };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -633,17 +626,16 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
1024 * this->bpf,
16 * this->bpf,
INT32_MAX / this->bpf),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
if (!this->have_format)
@ -651,11 +643,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -664,25 +655,22 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_range)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_range)));
break;
case 2:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence)));
break;
default:
return 0;
@ -935,10 +923,10 @@ static int process_control(struct impl *this, struct spa_pod_sequence *sequence)
case SPA_CONTROL_Properties:
{
struct props *p = &this->props;
spa_pod_object_parse(&c->value,
":", SPA_PROP_frequency, "?f", &p->freq,
":", SPA_PROP_volume, "?f", &p->volume,
NULL);
spa_pod_parse_object(&c->value,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_frequency, "?f", &p->freq,
SPA_PROP_volume, "?f", &p->volume);
break;
}
default:

69
spa/plugins/bluez5/a2dp-sink.c
View file

@ -172,10 +172,9 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -186,20 +185,18 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_minLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The minimum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->min_latency, 1, INT32_MAX),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_minLatency),
SPA_PROP_INFO_name, SPA_POD_String("The minimum latency"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(p->min_latency, 1, INT32_MAX));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_maxLatency),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The maximum latency"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Int(p->max_latency, 1, INT32_MAX),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_maxLatency),
SPA_PROP_INFO_name, SPA_POD_String("The maximum latency"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Int(p->max_latency, 1, INT32_MAX));
break;
default:
return 0;
@ -212,11 +209,10 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_minLatency, &SPA_POD_Int(p->min_latency),
SPA_PROP_maxLatency, &SPA_POD_Int(p->max_latency),
0);
SPA_PROP_minLatency, SPA_POD_Int(p->min_latency),
SPA_PROP_maxLatency, SPA_POD_Int(p->max_latency));
break;
default:
return 0;
@ -258,9 +254,10 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
reset_props(p);
return 0;
}
spa_pod_object_parse(param,
":", SPA_PROP_minLatency, "?i", &p->min_latency,
":", SPA_PROP_maxLatency, "?i", &p->max_latency, NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_minLatency, SPA_POD_OPT_Int(&p->min_latency),
SPA_PROP_maxLatency, SPA_POD_OPT_Int(&p->max_latency));
break;
}
default:
@ -970,10 +967,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_Meta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -1011,11 +1007,10 @@ impl_node_port_enum_params(struct spa_node *node,
}
case A2DP_CODEC_MPEG24:
{
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Format, id,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_aac),
0);
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_aac));
break;
}
default:
@ -1038,17 +1033,16 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(2, 2, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 2, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
this->props.min_latency * this->frame_size,
this->props.min_latency * this->frame_size,
INT32_MAX),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
@ -1057,11 +1051,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;

20
spa/plugins/bluez5/bluez5-monitor.c
View file

@ -91,15 +91,15 @@ static void fill_item(struct spa_bt_monitor *this, struct spa_bt_device *device,
char dev[16];
spa_pod_builder_push_object(builder, SPA_TYPE_OBJECT_MonitorItem, 0);
spa_pod_builder_props(builder,
SPA_MONITOR_ITEM_id, &SPA_POD_Stringv(device->path),
SPA_MONITOR_ITEM_flags, &SPA_POD_Id(SPA_MONITOR_ITEM_FLAG_NONE),
SPA_MONITOR_ITEM_state, &SPA_POD_Id(SPA_MONITOR_ITEM_STATE_Available),
SPA_MONITOR_ITEM_name, &SPA_POD_Stringv(device->name),
SPA_MONITOR_ITEM_class, &SPA_POD_Stringc("Adapter/Bluetooth"),
SPA_MONITOR_ITEM_factory, &SPA_POD_Pointer(SPA_TYPE_INTERFACE_HandleFactory,
spa_pod_builder_add(builder,
SPA_MONITOR_ITEM_id, SPA_POD_String(device->path),
SPA_MONITOR_ITEM_flags, SPA_POD_Id(SPA_MONITOR_ITEM_FLAG_NONE),
SPA_MONITOR_ITEM_state, SPA_POD_Id(SPA_MONITOR_ITEM_STATE_Available),
SPA_MONITOR_ITEM_name, SPA_POD_String(device->name),
SPA_MONITOR_ITEM_class, SPA_POD_String("Adapter/Bluetooth"),
SPA_MONITOR_ITEM_factory, SPA_POD_Pointer(SPA_TYPE_INTERFACE_HandleFactory,
&spa_bluez5_device_factory),
SPA_MONITOR_ITEM_type, &SPA_POD_Id(SPA_TYPE_INTERFACE_Device),
SPA_MONITOR_ITEM_type, SPA_POD_Id(SPA_TYPE_INTERFACE_Device),
0);
spa_pod_builder_prop(builder, SPA_MONITOR_ITEM_info, 0);
@ -529,7 +529,7 @@ static int device_add(struct spa_bt_monitor *monitor, struct spa_bt_device *devi
return 0;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, SPA_MONITOR_EVENT_Added, 0);
event = spa_pod_builder_add_object(&b, SPA_TYPE_EVENT_Monitor, SPA_MONITOR_EVENT_Added);
fill_item(monitor, device, &item, &b);
device->added = true;
@ -549,7 +549,7 @@ static int device_remove(struct spa_bt_monitor *monitor, struct spa_bt_device *d
return 0;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, SPA_MONITOR_EVENT_Removed, 0);
event = spa_pod_builder_add_object(&b, SPA_TYPE_EVENT_Monitor, SPA_MONITOR_EVENT_Removed);
fill_item(monitor, device, &item, &b);
device->added = false;

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

@ -285,10 +285,9 @@ spa_ffmpeg_dec_node_port_enum_params(struct spa_node *node,
SPA_PARAM_Format };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;

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

@ -274,10 +274,9 @@ spa_ffmpeg_enc_node_port_enum_params(struct spa_node *node,
SPA_PARAM_Format };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;

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

@ -121,19 +121,17 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(SPA_PARAM_Props),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(SPA_PARAM_Props));
break;
case SPA_PARAM_Props:
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_live, &SPA_POD_Bool(this->props.live),
0);
SPA_PROP_live, SPA_POD_Bool(this->props.live));
break;
default:
return -ENOENT;
@ -167,8 +165,9 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
reset_props(this, &this->props);
return 0;
}
spa_pod_object_parse(param,
":", SPA_PROP_live, "?b", &this->props.live, NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_live, "?b", &this->props.live);
if (this->props.live)
this->info.flags |= SPA_PORT_INFO_FLAG_LIVE;
@ -473,10 +472,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_Meta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -493,23 +491,21 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(2, 1, 32),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_Int(128),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, 32),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(128),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;

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

@ -126,10 +126,9 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(SPA_PARAM_Props),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(SPA_PARAM_Props));
break;
case SPA_PARAM_Props:
@ -139,11 +138,10 @@ static int impl_node_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_live, &SPA_POD_Bool(p->live),
SPA_PROP_patternType, &SPA_POD_CHOICE_ENUM_Id(2, p->pattern, p->pattern),
0);
SPA_PROP_live, SPA_POD_Bool(p->live),
SPA_PROP_patternType, SPA_POD_CHOICE_ENUM_Id(2, p->pattern, p->pattern));
break;
}
default:
@ -181,9 +179,10 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
reset_props(this, p);
return 0;
}
spa_pod_object_parse(param,
":", SPA_PROP_live, "?b", &p->live,
":", SPA_PROP_patternType, "?I", &p->pattern, NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_live, SPA_POD_OPT_Bool(&p->live),
SPA_PROP_patternType, SPA_POD_OPT_Id(&p->pattern));
if (p->live)
this->info.flags |= SPA_PORT_INFO_FLAG_LIVE;
@ -488,10 +487,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_Meta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -508,23 +506,21 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(32, 2, 32),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_Int(128),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(32, 2, 32),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(128),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;

18
spa/plugins/v4l2/v4l2-monitor.c
View file

@ -99,14 +99,14 @@ static void fill_item(struct impl *this, struct udev_device *dev,
name = "Unknown";
spa_pod_builder_push_object(builder, SPA_TYPE_OBJECT_MonitorItem, 0);
spa_pod_builder_props(builder,
SPA_MONITOR_ITEM_id, &SPA_POD_Stringv(udev_device_get_syspath(dev)),
SPA_MONITOR_ITEM_flags, &SPA_POD_Id(SPA_MONITOR_ITEM_FLAG_NONE),
SPA_MONITOR_ITEM_state, &SPA_POD_Id(SPA_MONITOR_ITEM_STATE_Available),
SPA_MONITOR_ITEM_name, &SPA_POD_Stringv(name),
SPA_MONITOR_ITEM_class, &SPA_POD_Stringc("Video/Device"),
SPA_MONITOR_ITEM_factory, &SPA_POD_Pointer(SPA_TYPE_INTERFACE_HandleFactory, &spa_v4l2_device_factory),
SPA_MONITOR_ITEM_type, &SPA_POD_Id(SPA_TYPE_INTERFACE_Device),
spa_pod_builder_add(builder,
SPA_MONITOR_ITEM_id, SPA_POD_String(udev_device_get_syspath(dev)),
SPA_MONITOR_ITEM_flags, SPA_POD_Id(SPA_MONITOR_ITEM_FLAG_NONE),
SPA_MONITOR_ITEM_state, SPA_POD_Id(SPA_MONITOR_ITEM_STATE_Available),
SPA_MONITOR_ITEM_name, SPA_POD_String(name),
SPA_MONITOR_ITEM_class, SPA_POD_String("Video/Device"),
SPA_MONITOR_ITEM_factory, SPA_POD_Pointer(SPA_TYPE_INTERFACE_HandleFactory, &spa_v4l2_device_factory),
SPA_MONITOR_ITEM_type, SPA_POD_Id(SPA_TYPE_INTERFACE_Device),
0);
spa_pod_builder_prop(builder, SPA_MONITOR_ITEM_info, 0);
@ -171,7 +171,7 @@ static int emit_device(struct impl *this, uint32_t id, struct udev_device *dev)
struct spa_pod *item;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
event = spa_pod_builder_object(&b, SPA_TYPE_EVENT_Monitor, id, 0);
event = spa_pod_builder_add_object(&b, SPA_TYPE_EVENT_Monitor, id);
fill_item(this, dev, &item, &b);
this->callbacks->event(this->callbacks_data, event);

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

@ -173,10 +173,9 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -187,28 +186,25 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_device),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The V4L2 device"),
SPA_PROP_INFO_type, &SPA_POD_Stringv(p->device),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_device),
SPA_PROP_INFO_name, SPA_POD_String("The V4L2 device"),
SPA_PROP_INFO_type, SPA_POD_String(p->device));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_deviceName),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The V4L2 device name"),
SPA_PROP_INFO_type, &SPA_POD_Stringv(p->device_name),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_deviceName),
SPA_PROP_INFO_name, SPA_POD_String("The V4L2 device name"),
SPA_PROP_INFO_type, SPA_POD_String(p->device_name));
break;
case 2:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_deviceFd),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The V4L2 fd"),
SPA_PROP_INFO_type, &SPA_POD_Int(p->device_fd),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_deviceFd),
SPA_PROP_INFO_name, SPA_POD_String("The V4L2 fd"),
SPA_PROP_INFO_type, SPA_POD_Int(p->device_fd));
break;
default:
return 0;
@ -221,12 +217,11 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_device, &SPA_POD_Stringv(p->device),
SPA_PROP_deviceName, &SPA_POD_Stringv(p->device_name),
SPA_PROP_deviceFd, &SPA_POD_Int(p->device_fd),
0);
SPA_PROP_device, SPA_POD_String(p->device),
SPA_PROP_deviceName, SPA_POD_String(p->device_name),
SPA_PROP_deviceFd, SPA_POD_Int(p->device_fd));
break;
default:
return 0;
@ -264,8 +259,9 @@ static int impl_node_set_param(struct spa_node *node,
reset_props(p);
return 0;
}
spa_pod_object_parse(param,
":", SPA_PROP_device, "?S", p->device, sizeof(p->device), NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_device, SPA_POD_OPT_Stringn(p->device, sizeof(p->device)));
break;
}
default:
@ -441,30 +437,30 @@ static int port_get_format(struct spa_node *node,
return 0;
spa_pod_builder_push_object(builder, SPA_TYPE_OBJECT_Format, SPA_PARAM_Format);
spa_pod_builder_props(builder,
SPA_FORMAT_mediaType, &SPA_POD_Id(port->current_format.media_type),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(port->current_format.media_subtype),
spa_pod_builder_add(builder,
SPA_FORMAT_mediaType, SPA_POD_Id(port->current_format.media_type),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(port->current_format.media_subtype),
0);
switch (port->current_format.media_subtype) {
case SPA_MEDIA_SUBTYPE_raw:
spa_pod_builder_props(builder,
SPA_FORMAT_VIDEO_format, &SPA_POD_Id(port->current_format.info.raw.format),
SPA_FORMAT_VIDEO_size, &SPA_POD_Rectangle(port->current_format.info.raw.size),
SPA_FORMAT_VIDEO_framerate, &SPA_POD_Fraction(port->current_format.info.raw.framerate),
spa_pod_builder_add(builder,
SPA_FORMAT_VIDEO_format, SPA_POD_Id(port->current_format.info.raw.format),
SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(port->current_format.info.raw.size),
SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(port->current_format.info.raw.framerate),
0);
break;
case SPA_MEDIA_SUBTYPE_mjpg:
case SPA_MEDIA_SUBTYPE_jpeg:
spa_pod_builder_props(builder,
SPA_FORMAT_VIDEO_size, &SPA_POD_Rectangle(port->current_format.info.mjpg.size),
SPA_FORMAT_VIDEO_framerate, &SPA_POD_Fraction(port->current_format.info.mjpg.framerate),
spa_pod_builder_add(builder,
SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(port->current_format.info.mjpg.size),
SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(port->current_format.info.mjpg.framerate),
0);
break;
case SPA_MEDIA_SUBTYPE_h264:
spa_pod_builder_props(builder,
SPA_FORMAT_VIDEO_size, &SPA_POD_Rectangle(port->current_format.info.h264.size),
SPA_FORMAT_VIDEO_framerate, &SPA_POD_Fraction(port->current_format.info.h264.framerate),
spa_pod_builder_add(builder,
SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(port->current_format.info.h264.size),
SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(port->current_format.info.h264.framerate),
0);
break;
default:
@ -516,10 +512,9 @@ static int impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -540,24 +535,22 @@ static int impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(MAX_BUFFERS, 2, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_Int(port->fmt.fmt.pix.sizeimage),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(port->fmt.fmt.pix.bytesperline),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(MAX_BUFFERS, 2, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(port->fmt.fmt.pix.sizeimage),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(port->fmt.fmt.pix.bytesperline),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -566,25 +559,22 @@ static int impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Clock),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_clock)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Clock),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_clock)));
break;
case 2:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence)));
break;
default:
return 0;

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

@ -681,9 +681,9 @@ spa_v4l2_enum_format(struct impl *this,
}
spa_pod_builder_push_object(builder, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat);
spa_pod_builder_props(builder,
SPA_FORMAT_mediaType, &SPA_POD_Id(info->media_type),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(info->media_subtype),
spa_pod_builder_add(builder,
SPA_FORMAT_mediaType, SPA_POD_Id(info->media_type),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(info->media_subtype),
0);
if (info->media_subtype == SPA_MEDIA_SUBTYPE_raw) {
@ -1070,34 +1070,32 @@ spa_v4l2_enum_controls(struct impl *this,
switch (queryctrl.type) {
case V4L2_CTRL_TYPE_INTEGER:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo,
SPA_PROP_INFO_id, &SPA_POD_Id(prop_id),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_STEP_Int(
SPA_PROP_INFO_id, SPA_POD_Id(prop_id),
SPA_PROP_INFO_type, SPA_POD_CHOICE_STEP_Int(
queryctrl.default_value,
queryctrl.minimum,
queryctrl.maximum,
queryctrl.step),
SPA_PROP_INFO_name, &SPA_POD_Stringv(queryctrl.name),
0);
SPA_PROP_INFO_name, SPA_POD_String(queryctrl.name));
break;
case V4L2_CTRL_TYPE_BOOLEAN:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo,
SPA_PROP_INFO_id, &SPA_POD_Id(prop_id),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_Bool(queryctrl.default_value),
SPA_PROP_INFO_name, &SPA_POD_Stringv(queryctrl.name),
0);
SPA_PROP_INFO_id, SPA_POD_Id(prop_id),
SPA_PROP_INFO_type, SPA_POD_CHOICE_Bool(queryctrl.default_value),
SPA_PROP_INFO_name, SPA_POD_String(queryctrl.name));
break;
case V4L2_CTRL_TYPE_MENU:
{
struct v4l2_querymenu querymenu;
spa_pod_builder_push_object(&b, SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo);
spa_pod_builder_props(&b,
SPA_PROP_INFO_id, &SPA_POD_Id(prop_id),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_ENUM_Int(1, queryctrl.default_value),
SPA_PROP_INFO_name, &SPA_POD_Stringv(queryctrl.name),
spa_pod_builder_add(&b,
SPA_PROP_INFO_id, SPA_POD_Id(prop_id),
SPA_PROP_INFO_type, SPA_POD_CHOICE_ENUM_Int(1, queryctrl.default_value),
SPA_PROP_INFO_name, SPA_POD_String(queryctrl.name),
0);
spa_zero(querymenu);

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

@ -136,9 +136,9 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b, SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -149,19 +149,18 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_live),
SPA_PROP_INFO_name, &SPA_POD_Stringc("Configure live mode of the source"),
SPA_PROP_INFO_type, &SPA_POD_Bool(p->live),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_live),
SPA_PROP_INFO_name, SPA_POD_String("Configure live mode of the source"),
SPA_PROP_INFO_type, SPA_POD_Bool(p->live));
break;
case 1:
spa_pod_builder_push_object(&b, SPA_TYPE_OBJECT_PropInfo, id);
spa_pod_builder_props(&b,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_patternType),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The pattern"),
SPA_PROP_INFO_type, &SPA_POD_Int(p->pattern),
spa_pod_builder_add(&b,
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_patternType),
SPA_PROP_INFO_name, SPA_POD_String("The pattern"),
SPA_PROP_INFO_type, SPA_POD_Int(p->pattern),
0);
spa_pod_builder_prop(&b, SPA_PROP_INFO_labels, 0),
spa_pod_builder_push_struct(&b);
@ -183,11 +182,10 @@ static int impl_node_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_live, &SPA_POD_Bool(p->live),
SPA_PROP_patternType, &SPA_POD_Int(p->pattern),
0);
SPA_PROP_live, SPA_POD_Bool(p->live),
SPA_PROP_patternType, SPA_POD_Int(p->pattern));
break;
default:
return 0;
@ -229,10 +227,10 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
reset_props(p);
return 0;
}
spa_pod_object_parse(param,
":", SPA_PROP_live, "?b", &p->live,
":", SPA_PROP_patternType, "?i", &p->pattern,
NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_live, SPA_POD_OPT_Bool(&p->live),
SPA_PROP_patternType, SPA_POD_OPT_Int(&p->pattern));
if (p->live)
this->info.flags |= SPA_PORT_INFO_FLAG_LIVE;
@ -490,23 +488,22 @@ static int port_enum_formats(struct spa_node *node,
{
switch (*index) {
case 0:
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, &SPA_POD_CHOICE_ENUM_Id(3,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, SPA_POD_CHOICE_ENUM_Id(3,
SPA_VIDEO_FORMAT_RGB,
SPA_VIDEO_FORMAT_RGB,
SPA_VIDEO_FORMAT_UYVY),
SPA_FORMAT_VIDEO_size, &SPA_POD_CHOICE_RANGE_Rectangle(
SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(
SPA_RECTANGLE(320, 240),
SPA_RECTANGLE(1, 1),
SPA_RECTANGLE(INT32_MAX, INT32_MAX)),
SPA_FORMAT_VIDEO_framerate, &SPA_POD_CHOICE_RANGE_Fraction(
SPA_FORMAT_VIDEO_framerate, SPA_POD_CHOICE_RANGE_Fraction(
SPA_FRACTION(25,1),
SPA_FRACTION(0, 1),
SPA_FRACTION(INT32_MAX, 1)),
0);
SPA_FRACTION(INT32_MAX, 1)));
break;
default:
return 0;
@ -548,10 +545,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_Meta };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -579,14 +575,13 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(2, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_Int(this->stride * raw_info->size.height),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(this->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(this->stride * raw_info->size.height),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(this->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
}
case SPA_PARAM_Meta:
@ -595,11 +590,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:

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

@ -131,10 +131,9 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Props };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -142,20 +141,18 @@ static int impl_node_enum_params(struct spa_node *node,
case SPA_PARAM_PropInfo:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_volume),
SPA_PROP_INFO_name, &SPA_POD_Stringc("The volume"),
SPA_PROP_INFO_type, &SPA_POD_CHOICE_RANGE_Float(p->volume, 0.0, 10.0),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_volume),
SPA_PROP_INFO_name, SPA_POD_String("The volume"),
SPA_PROP_INFO_type, SPA_POD_CHOICE_RANGE_Float(p->volume, 0.0, 10.0));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_PropInfo, id,
SPA_PROP_INFO_id, &SPA_POD_Id(SPA_PROP_mute),
SPA_PROP_INFO_name, &SPA_POD_Stringc("Mute"),
SPA_PROP_INFO_type, &SPA_POD_Bool(p->mute),
0);
SPA_PROP_INFO_id, SPA_POD_Id(SPA_PROP_mute),
SPA_PROP_INFO_name, SPA_POD_String("Mute"),
SPA_PROP_INFO_type, SPA_POD_Bool(p->mute));
break;
default:
return 0;
@ -164,11 +161,10 @@ static int impl_node_enum_params(struct spa_node *node,
case SPA_PARAM_Props:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, id,
SPA_PROP_volume, &SPA_POD_Float(p->volume),
SPA_PROP_mute, &SPA_POD_Bool(p->mute),
0);
SPA_PROP_volume, SPA_POD_Float(p->volume),
SPA_PROP_mute, SPA_POD_Bool(p->mute));
break;
default:
return 0;
@ -209,9 +205,10 @@ static int impl_node_set_param(struct spa_node *node, uint32_t id, uint32_t flag
reset_props(p);
return 0;
}
spa_pod_object_parse(param,
":", SPA_PROP_volume, "?d", &p->volume,
":", SPA_PROP_mute, "?b", &p->mute, NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_Props, NULL,
SPA_PROP_volume, "?d", &p->volume,
SPA_PROP_mute, "?b", &p->mute);
break;
}
default:
@ -341,17 +338,16 @@ static int port_enum_formats(struct spa_node *node,
{
switch (*index) {
case 0:
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_CHOICE_ENUM_Id(3,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_CHOICE_ENUM_Id(3,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S32),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(2, 1, INT32_MAX),
0);
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(2, 1, INT32_MAX));
break;
default:
return 0;
@ -397,10 +393,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -425,26 +420,24 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(2, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
1024 * this->bpf,
16 * this->bpf,
INT32_MAX / this->bpf),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -453,18 +446,16 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_range)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_range)));
break;
default:
return 0;

23
spa/tests/test-control.c
View file

@ -216,11 +216,10 @@ static void update_props(struct data *data)
#else
spa_pod_builder_push_sequence(&b, 0);
spa_pod_builder_control_header(&b, 0, SPA_CONTROL_Properties);
spa_pod_builder_object(&b,
spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, 0,
SPA_PROP_frequency, &SPA_POD_Float(((sin(data->freq_accum) + 1.0) * 200.0) + 440.0),
SPA_PROP_volume, &SPA_POD_Float((sin(data->volume_accum) / 2.0) + 0.5),
0);
SPA_PROP_frequency, SPA_POD_Float(((sin(data->freq_accum) + 1.0) * 200.0) + 440.0),
SPA_PROP_volume, SPA_POD_Float((sin(data->volume_accum) / 2.0) + 0.5));
pod = spa_pod_builder_pop(&b);
#endif
@ -304,11 +303,10 @@ static int make_nodes(struct data *data, const char *device)
spa_node_set_callbacks(data->sink, &sink_callbacks, data);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, 0,
SPA_PROP_device, &SPA_POD_Stringv(device ? device : "hw:0"),
SPA_PROP_minLatency, &SPA_POD_Int(MIN_LATENCY),
0);
SPA_PROP_device, SPA_POD_String(device ? device : "hw:0"),
SPA_PROP_minLatency, SPA_POD_Int(MIN_LATENCY));
spa_debug_pod(0, NULL, props);
@ -323,12 +321,11 @@ static int make_nodes(struct data *data, const char *device)
}
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, 0,
SPA_PROP_frequency, &SPA_POD_Float(600.0),
SPA_PROP_volume, &SPA_POD_Float(0.5),
SPA_PROP_live, &SPA_POD_Bool(false),
0);
SPA_PROP_frequency, SPA_POD_Float(600.0),
SPA_PROP_volume, SPA_POD_Float(0.5),
SPA_PROP_live, SPA_POD_Bool(false));
if ((res = spa_node_set_param(data->source, SPA_PARAM_Props, 0, props)) < 0)
printf("got set_props error %d\n", res);

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

@ -344,12 +344,12 @@ static int negotiate_link_buffers(struct data *data, struct link *link)
in_alloc = false;
}
if (spa_pod_object_parse(param,
":", SPA_PARAM_BUFFERS_buffers, "i", &buffers,
":", SPA_PARAM_BUFFERS_blocks, "i", &blocks,
":", SPA_PARAM_BUFFERS_size, "i", &size,
":", SPA_PARAM_BUFFERS_align, "i", &align,
NULL) < 0)
if (spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamBuffers, NULL,
SPA_PARAM_BUFFERS_buffers, SPA_POD_Int(&buffers),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(&blocks),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(&size),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(&align)) < 0)
return -EINVAL;
datas = alloca(sizeof(struct spa_data) * blocks);

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

@ -258,11 +258,10 @@ static int make_nodes(struct data *data, const char *device)
spa_node_set_callbacks(data->sink, &sink_callbacks, data);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, 0,
SPA_PROP_device, &SPA_POD_Stringv(device ? device : "hw:0"),
SPA_PROP_minLatency, &SPA_POD_Int(MIN_LATENCY),
0);
SPA_PROP_device, SPA_POD_String(device ? device : "hw:0"),
SPA_PROP_minLatency, SPA_POD_Int(MIN_LATENCY));
spa_debug_pod(0, NULL, props);
@ -283,12 +282,11 @@ static int make_nodes(struct data *data, const char *device)
}
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, 0,
SPA_PROP_frequency, &SPA_POD_Float(600.0),
SPA_PROP_volume, &SPA_POD_Float(0.5),
SPA_PROP_live, &SPA_POD_Bool(false),
0);
SPA_PROP_frequency, SPA_POD_Float(600.0),
SPA_PROP_volume, SPA_POD_Float(0.5),
SPA_PROP_live, SPA_POD_Bool(false));
if ((res = spa_node_set_param(data->source, SPA_PARAM_Props, 0, props)) < 0)
printf("got set_props error %d\n", res);

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

@ -320,11 +320,10 @@ static int make_nodes(struct data *data, const char *device)
spa_node_set_callbacks(data->sink, &sink_callbacks, data);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, 0,
SPA_PROP_device, &SPA_POD_Stringv(device ? device : "hw:0"),
SPA_PROP_minLatency, &SPA_POD_Int(MIN_LATENCY),
0);
SPA_PROP_device, SPA_POD_String(device ? device : "hw:0"),
SPA_PROP_minLatency, SPA_POD_Int(MIN_LATENCY));
if ((res = spa_node_set_param(data->sink, SPA_PARAM_Props, 0, props)) < 0)
error(0, -res, "set_param props");
@ -344,12 +343,11 @@ static int make_nodes(struct data *data, const char *device)
}
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
SPA_PROP_frequency, &SPA_POD_Float(600.0),
SPA_PROP_volume, &SPA_POD_Float(1.0),
SPA_PROP_live, &SPA_POD_Bool(false),
0);
SPA_PROP_frequency, SPA_POD_Float(600.0),
SPA_PROP_volume, SPA_POD_Float(1.0),
SPA_PROP_live, SPA_POD_Bool(false));
if ((res = spa_node_set_param(data->source1, SPA_PARAM_Props, 0, props)) < 0)
printf("got set_props error %d\n", res);
@ -362,12 +360,11 @@ static int make_nodes(struct data *data, const char *device)
}
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
SPA_PROP_frequency, &SPA_POD_Float(440.0),
SPA_PROP_volume, &SPA_POD_Float(1.0),
SPA_PROP_live, &SPA_POD_Bool(false),
0);
SPA_PROP_frequency, SPA_POD_Float(440.0),
SPA_PROP_volume, SPA_POD_Float(1.0),
SPA_PROP_live, SPA_POD_Bool(false));
if ((res = spa_node_set_param(data->source2, SPA_PARAM_Props, 0, props)) < 0)
printf("got set_props error %d\n", res);
@ -409,8 +406,8 @@ static int make_nodes(struct data *data, const char *device)
SPA_IO_Buffers,
&data->mix_sink_io[0], sizeof(data->mix_sink_io[0]));
data->ctrl_volume[0] = SPA_POD_Double(0.5);
data->ctrl_volume[1] = SPA_POD_Double(0.5);
data->ctrl_volume[0] = SPA_POD_INIT_Double(0.5);
data->ctrl_volume[1] = SPA_POD_INIT_Double(0.5);
#if 0
if ((res = spa_node_port_set_io(data->mix,

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

@ -360,11 +360,10 @@ static int negotiate_formats(struct data *data)
uint8_t buffer[256];
spa_pod_builder_init(&b, buffer, sizeof(buffer));
format = spa_pod_builder_object(&b,
format = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Format, 0,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_binary),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
0);
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_binary),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw));
if ((res = spa_node_port_set_param(data->sink,
SPA_DIRECTION_INPUT, 0,

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

@ -165,9 +165,9 @@ key: "<name>"
{ "Type" : "Format", "Id" : 0,
"mediaType": "video",
"mediaSubtype": "raw",
"videoFormat": [ "enum", "I420", "YUY2" ],
"videoSize": [ "range", [320,242], [1,1], [MAX,MAX] ],
"videoFramerate": [ "range", [25,1], [0,1], [MAX,1] ]
"Video:Format": [ "enum", "I420", "YUY2" ],
"Video:Size": [ "range", [320,242], [1,1], [MAX,MAX] ],
"Video:Framerate": [ "range", [25,1], [0,1], [MAX,1] ]
}
spa_build(SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
@ -216,45 +216,45 @@ static void do_static_struct(void)
struct spa_pod_prop prop_framerate SPA_ALIGNED(8);
struct {
struct spa_pod_choice_body array;
struct spa_pod_choice_body choice;
struct spa_fraction def_framerate;
struct spa_fraction min_framerate;
struct spa_fraction max_framerate;
} framerate_vals;
} props;
} test_format = {
SPA_POD_Object(sizeof(test_format.props) + sizeof(struct spa_pod_object_body),
SPA_POD_INIT_Object(sizeof(test_format.props) + sizeof(struct spa_pod_object_body),
SPA_TYPE_OBJECT_Format, 0),
{
SPA_POD_Prop(SPA_FORMAT_mediaType, 0,
SPA_POD_INIT_Prop(SPA_FORMAT_mediaType, 0,
sizeof(test_format.props.media_type), SPA_TYPE_Id),
SPA_MEDIA_TYPE_video,
SPA_POD_Prop(SPA_FORMAT_mediaSubtype, 0,
SPA_POD_INIT_Prop(SPA_FORMAT_mediaSubtype, 0,
sizeof(test_format.props.media_subtype), SPA_TYPE_Id),
SPA_MEDIA_SUBTYPE_raw,
SPA_POD_Prop(SPA_FORMAT_VIDEO_format, 0,
SPA_POD_INIT_Prop(SPA_FORMAT_VIDEO_format, 0,
sizeof(test_format.props.format_vals), SPA_TYPE_Choice),
{
SPA_POD_CHOICE_BODY_INIT(SPA_CHOICE_Enum, 0,
SPA_POD_INIT_CHOICE_BODY(SPA_CHOICE_Enum, 0,
sizeof(uint32_t), SPA_TYPE_Id),
SPA_VIDEO_FORMAT_I420,
{ SPA_VIDEO_FORMAT_I420, SPA_VIDEO_FORMAT_YUY2 }
},
SPA_POD_Prop(SPA_FORMAT_VIDEO_size, 0,
SPA_POD_INIT_Prop(SPA_FORMAT_VIDEO_size, 0,
sizeof(test_format.props.size_vals), SPA_TYPE_Choice),
{
SPA_POD_CHOICE_BODY_INIT(SPA_CHOICE_Range, 0,
SPA_POD_INIT_CHOICE_BODY(SPA_CHOICE_Range, 0,
sizeof(struct spa_rectangle), SPA_TYPE_Rectangle),
SPA_RECTANGLE(320,243),
SPA_RECTANGLE(1,1), SPA_RECTANGLE(INT32_MAX, INT32_MAX)
},
SPA_POD_Prop(SPA_FORMAT_VIDEO_framerate, 0,
SPA_POD_INIT_Prop(SPA_FORMAT_VIDEO_framerate, 0,
sizeof(test_format.props.framerate_vals), SPA_TYPE_Choice),
{
SPA_POD_CHOICE_BODY_INIT(SPA_CHOICE_Range, 0,
SPA_POD_INIT_CHOICE_BODY(SPA_CHOICE_Range, 0,
sizeof(struct spa_fraction), SPA_TYPE_Fraction),
SPA_FRACTION(25,1),
SPA_FRACTION(0,1), SPA_FRACTION(INT32_MAX,1)
@ -262,6 +262,8 @@ static void do_static_struct(void)
}
};
fprintf(stderr, "static:\n");
spa_debug_pod(0, NULL, &test_format.fmt.pod);
spa_debug_format(0, NULL, &test_format.fmt.pod);
@ -270,17 +272,19 @@ static void do_static_struct(void)
int res;
struct spa_fraction frac = { -1, -1 };
res = spa_pod_object_parse(&test_format.fmt.pod,
":", SPA_FORMAT_VIDEO_format, "I", &format,
":", SPA_FORMAT_VIDEO_framerate, "F", &frac, NULL);
res = spa_pod_parse_object(&test_format.fmt.pod,
SPA_TYPE_OBJECT_Format, NULL,
SPA_FORMAT_VIDEO_format, SPA_POD_Id(&format),
SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&frac));
printf("%d format %d num %d denom %d\n", res, format, frac.num, frac.denom);
spa_pod_fixate(&test_format.fmt.pod);
res = spa_pod_object_parse(&test_format.fmt.pod,
":", SPA_FORMAT_VIDEO_format, "I", &format,
":", SPA_FORMAT_VIDEO_framerate, "F", &frac, NULL);
res = spa_pod_parse_object(&test_format.fmt.pod,
SPA_TYPE_OBJECT_Format, NULL,
SPA_FORMAT_VIDEO_format, SPA_POD_Id(&format),
SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&frac));
printf("%d format %d num %d denom %d\n", res, format, frac.num, frac.denom);
}
@ -343,15 +347,15 @@ int main(int argc, char *argv[])
fmt = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Format, 0,
":", SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video,
":", SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_raw,
":", SPA_FORMAT_VIDEO_format, "?eI", 3, SPA_VIDEO_FORMAT_I420,
SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video,
SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_raw,
SPA_FORMAT_VIDEO_format, "?eI", 3, SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_YUY2,
":", SPA_FORMAT_VIDEO_size, "?rR", 3, &SPA_RECTANGLE(320,241),
SPA_FORMAT_VIDEO_size, "?rR", 3, &SPA_RECTANGLE(320,241),
&SPA_RECTANGLE(1,1),
&SPA_RECTANGLE(INT32_MAX,INT32_MAX),
":", SPA_FORMAT_VIDEO_framerate, "?rF", 3, &SPA_FRACTION(25,1),
SPA_FORMAT_VIDEO_framerate, "?rF", 3, &SPA_FRACTION(25,1),
&SPA_FRACTION(0,1),
&SPA_FRACTION(INT32_MAX,1));
}
@ -368,20 +372,21 @@ int main(int argc, char *argv[])
fmt = spa_pod_builder_add(&b,
"{", SPA_TYPE_OBJECT_Format, 0,
":", SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video,
":", SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_raw,
":", SPA_FORMAT_VIDEO_format, "P", &SPA_POD_CHOICE_ENUM_Id(3,
SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video,
SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_raw,
SPA_FORMAT_VIDEO_format, SPA_POD_CHOICE_ENUM_Id(3,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_YUY2),
":", SPA_FORMAT_VIDEO_size, "P", &SPA_POD_CHOICE_RANGE_Rectangle(
SPA_RECTANGLE(320,242),
SPA_RECTANGLE(1,1),
SPA_RECTANGLE(INT32_MAX,INT32_MAX)),
":", SPA_FORMAT_VIDEO_framerate, "P", &SPA_POD_CHOICE_RANGE_Fraction(
SPA_FRACTION(25,1),
SPA_FRACTION(0,1),
SPA_FRACTION(INT32_MAX,1)),
SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(
&SPA_RECTANGLE(320,242),
&SPA_RECTANGLE(1,1),
&SPA_RECTANGLE(INT32_MAX,INT32_MAX)),
SPA_FORMAT_VIDEO_framerate, SPA_POD_CHOICE_RANGE_Fraction(
&SPA_FRACTION(25,1),
&SPA_FRACTION(0,1),
&SPA_FRACTION(INT32_MAX,1)),
0,
"}", NULL);
}
clock_gettime(CLOCK_MONOTONIC, &ts2);
@ -402,15 +407,18 @@ int main(int argc, char *argv[])
spa_pod_builder_prop(&b, SPA_FORMAT_mediaSubtype, 0);
spa_pod_builder_id(&b, SPA_MEDIA_SUBTYPE_raw);
spa_pod_builder_prop(&b, SPA_FORMAT_VIDEO_format, 0);
spa_pod_builder_primitive(&b, (struct spa_pod*)&SPA_POD_CHOICE_ENUM_Id(3,
spa_pod_builder_primitive(&b, (struct spa_pod*)&SPA_POD_INIT_Choice(
SPA_CHOICE_Enum, uint32_t, SPA_TYPE_Id, 3,
SPA_VIDEO_FORMAT_I420, SPA_VIDEO_FORMAT_I420, SPA_VIDEO_FORMAT_YUY2));
spa_pod_builder_prop(&b, SPA_FORMAT_VIDEO_size, 0);
spa_pod_builder_primitive(&b, (struct spa_pod*)&SPA_POD_CHOICE_RANGE_Rectangle(
spa_pod_builder_primitive(&b, (struct spa_pod*)&SPA_POD_INIT_Choice(
SPA_CHOICE_Range, struct spa_rectangle, SPA_TYPE_Rectangle, 3,
SPA_RECTANGLE(320,242),
SPA_RECTANGLE(1,1),
SPA_RECTANGLE(INT32_MAX,INT32_MAX)));
spa_pod_builder_prop(&b, SPA_FORMAT_VIDEO_framerate, 0);
spa_pod_builder_primitive(&b, (struct spa_pod *)&SPA_POD_CHOICE_RANGE_Fraction(
spa_pod_builder_primitive(&b, (struct spa_pod*)&SPA_POD_INIT_Choice(
SPA_CHOICE_Range, struct spa_fraction, SPA_TYPE_Fraction, 3,
SPA_FRACTION(25,1),
SPA_FRACTION(0,1),
SPA_FRACTION(INT32_MAX,1)));
@ -426,50 +434,22 @@ int main(int argc, char *argv[])
clock_gettime(CLOCK_MONOTONIC, &ts1);
for (i = 0 ; i < ITER; i++) {
spa_pod_builder_init(&b, buffer, sizeof(buffer));
fmt = spa_pod_builder_object(&b,
fmt = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Format, 0,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, &SPA_POD_CHOICE_ENUM_Id(3,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, SPA_POD_CHOICE_ENUM_Id(3,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_YUY2),
SPA_FORMAT_VIDEO_size, &SPA_POD_CHOICE_RANGE_Rectangle(
SPA_RECTANGLE(320,242),
SPA_RECTANGLE(1,1),
SPA_RECTANGLE(INT32_MAX,INT32_MAX)),
SPA_FORMAT_VIDEO_framerate,&SPA_POD_CHOICE_RANGE_Fraction(
SPA_FRACTION(25,1),
SPA_FRACTION(0,1),
SPA_FRACTION(INT32_MAX,1)),
0);
}
clock_gettime(CLOCK_MONOTONIC, &ts2);
fprintf(stderr, "elapsed %lld\n", SPA_TIMESPEC_TO_NSEC(&ts2) - SPA_TIMESPEC_TO_NSEC(&ts1));
spa_debug_pod(0, NULL, &fmt->pod);
spa_debug_format(0, NULL, &fmt->pod);
fprintf(stderr, "build 6: ");
clock_gettime(CLOCK_MONOTONIC, &ts1);
for (i = 0 ; i < ITER; i++) {
spa_pod_builder_init(&b, buffer, sizeof(buffer));
spa_pod_builder_push_object(&b, SPA_TYPE_OBJECT_Format, 0);
spa_pod_builder_prop_val(&b, SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_video));
spa_pod_builder_prop_val(&b, SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw));
spa_pod_builder_prop_val(&b, SPA_FORMAT_VIDEO_format, &SPA_POD_CHOICE_ENUM_Id(3,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_YUY2));
spa_pod_builder_prop_val(&b, SPA_FORMAT_VIDEO_size, &SPA_POD_CHOICE_RANGE_Rectangle(
SPA_RECTANGLE(320,242),
SPA_RECTANGLE(1,1),
SPA_RECTANGLE(INT32_MAX,INT32_MAX)));
spa_pod_builder_prop_val(&b, SPA_FORMAT_VIDEO_framerate, &SPA_POD_CHOICE_RANGE_Fraction(
SPA_FRACTION(25,1),
SPA_FRACTION(0,1),
SPA_FRACTION(INT32_MAX,1)));
fmt = spa_pod_builder_pop(&b);
SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(
&SPA_RECTANGLE(320,242),
&SPA_RECTANGLE(1,1),
&SPA_RECTANGLE(INT32_MAX,INT32_MAX)),
SPA_FORMAT_VIDEO_framerate,SPA_POD_CHOICE_RANGE_Fraction(
&SPA_FRACTION(25,1),
&SPA_FRACTION(0,1),
&SPA_FRACTION(INT32_MAX,1)));
}
clock_gettime(CLOCK_MONOTONIC, &ts2);
fprintf(stderr, "elapsed %lld\n", SPA_TIMESPEC_TO_NSEC(&ts2) - SPA_TIMESPEC_TO_NSEC(&ts1));

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

@ -239,11 +239,10 @@ static int make_nodes(struct data *data, const char *device)
spa_node_set_callbacks(data->sink, &sink_callbacks, data);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, 0,
SPA_PROP_device, &SPA_POD_Stringv(device ? device : "hw:0"),
SPA_PROP_minLatency, &SPA_POD_Int(64),
0);
SPA_PROP_device, SPA_POD_String(device ? device : "hw:0"),
SPA_PROP_minLatency, SPA_POD_Int(64));
if ((res = spa_node_set_param(data->sink, SPA_PARAM_Props, 0, props)) < 0)
printf("got set_props error %d\n", res);
@ -256,10 +255,9 @@ static int make_nodes(struct data *data, const char *device)
}
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, 0,
SPA_PROP_live, &SPA_POD_Bool(false),
0);
SPA_PROP_live, SPA_POD_Bool(false));
if ((res = spa_node_set_param(data->source, SPA_PARAM_Props, 0, props)) < 0)
printf("got set_props error %d\n", res);

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

@ -295,10 +295,9 @@ static int make_nodes(struct data *data, const char *device)
spa_node_set_callbacks(data->source, &source_callbacks, data);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
props = spa_pod_builder_object(&b,
props = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, 0,
SPA_PROP_device, &SPA_POD_Stringv(device ? device : "/dev/video0"),
0);
SPA_PROP_device, SPA_POD_String(device ? device : "/dev/video0"));
if ((res = spa_node_set_param(data->source, SPA_PARAM_Props, 0, props)) < 0)
printf("got set_props error %d\n", res);

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

@ -70,9 +70,9 @@ inspect_node_params(struct data *data, struct spa_node *node)
break;
}
spa_pod_object_parse(param,
":", SPA_PARAM_LIST_id, "I", &id,
NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamList, NULL,
SPA_PARAM_LIST_id, SPA_POD_Id(&id));
printf("enumerating: %s:\n", spa_debug_type_find_name(NULL, id));
for (idx2 = 0;;) {
@ -111,9 +111,9 @@ inspect_port_params(struct data *data, struct spa_node *node,
error(0, -res, "port_enum_params");
break;
}
spa_pod_object_parse(param,
":", SPA_PARAM_LIST_id, "I", &id,
NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamList, NULL,
SPA_PARAM_LIST_id, SPA_POD_Id(&id));
printf("enumerating: %s:\n", spa_debug_type_find_name(NULL, id));
for (idx2 = 0;;) {

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

@ -245,10 +245,9 @@ static int impl_port_enum_params(struct spa_node *node,
SPA_PARAM_IO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -266,31 +265,28 @@ static int impl_port_enum_params(struct spa_node *node,
if (*index != 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(2, 2, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_Int(d->stride * d->format.size.height),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(d->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 2, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(d->stride * d->format.size.height),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(d->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
case 1:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_VideoDamage),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_region)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_VideoDamage),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_region)));
break;
default:
return 0;
@ -300,18 +296,16 @@ static int impl_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Notify),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence) + 1024),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Notify),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence) + 1024));
break;
default:
return 0;

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

@ -181,19 +181,18 @@ static int port_enum_formats(struct spa_node *node,
if (*index != 0)
return 0;
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_CHOICE_ENUM_Id(5,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_CHOICE_ENUM_Id(5,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_S16P,
SPA_AUDIO_FORMAT_S16,
SPA_AUDIO_FORMAT_F32P,
SPA_AUDIO_FORMAT_F32),
SPA_FORMAT_AUDIO_channels, &SPA_POD_CHOICE_RANGE_Int(2, 1, INT32_MAX),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
0);
SPA_FORMAT_AUDIO_channels, SPA_POD_CHOICE_RANGE_Int(2, 1, INT32_MAX),
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX));
(*index)++;
@ -220,10 +219,9 @@ static int impl_port_enum_params(struct spa_node *node,
SPA_PARAM_IO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -243,24 +241,22 @@ static int impl_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(1, 1, 32),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(BUFFER_SAMPLES * sizeof(float), 32, 4096),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(1, 1, 32),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(BUFFER_SAMPLES * sizeof(float), 32, 4096),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(0),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -269,18 +265,16 @@ static int impl_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(builder,
param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Notify),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence) + 1024),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Notify),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence) + 1024));
break;
default:
return 0;

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

@ -180,25 +180,23 @@ static int impl_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
*result = spa_pod_builder_object(builder,
*result = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(2, 1, 32),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_Int(d->stride * d->format.size.height),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(d->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, 32),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(d->stride * d->format.size.height),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(d->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
if (*index > 0)
return 0;
*result = spa_pod_builder_object(builder,
*result = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:

23
src/examples/media-session.c
View file

@ -934,11 +934,10 @@ static void stream_set_volume(struct impl *impl, struct node *node, float volume
pw_node_proxy_set_param((struct pw_node_proxy*)node->obj.proxy,
SPA_PARAM_Props, 0,
spa_pod_builder_object(&b,
spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
SPA_PROP_volume, &SPA_POD_Float(volume),
SPA_PROP_mute, &SPA_POD_Bool(mute),
0));
SPA_PROP_volume, SPA_POD_Float(volume),
SPA_PROP_mute, SPA_POD_Bool(mute)));
}
static int rescan_node(struct impl *impl, struct node *node)
@ -1148,12 +1147,11 @@ do_link_profile:
node->profile_format = audio_info;
spa_pod_builder_init(&b, buf, sizeof(buf));
param = spa_pod_builder_object(&b,
param = spa_format_audio_raw_build(&b, SPA_PARAM_Format, &audio_info);
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, SPA_PARAM_Profile,
SPA_PARAM_PROFILE_direction, &SPA_POD_Id(pw_direction_reverse(direction)),
SPA_PARAM_PROFILE_format, spa_format_audio_raw_build(&b,
SPA_PARAM_Format, &audio_info),
0);
SPA_PARAM_PROFILE_direction, SPA_POD_Id(pw_direction_reverse(direction)),
SPA_PARAM_PROFILE_format, SPA_POD_Pod(param));
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(2, NULL, param);
@ -1241,11 +1239,10 @@ static void rescan_session(struct impl *impl, struct session *sess)
spa_pod_builder_init(&b, buf, sizeof(buf));
param = spa_format_audio_raw_build(&b, SPA_PARAM_Format, &info);
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, SPA_PARAM_Profile,
SPA_PARAM_PROFILE_direction, &SPA_POD_Id(pw_direction_reverse(sess->direction)),
SPA_PARAM_PROFILE_format, param,
0);
SPA_PARAM_PROFILE_direction, SPA_POD_Id(pw_direction_reverse(sess->direction)),
SPA_PARAM_PROFILE_format, SPA_POD_Pod(param));
pw_node_proxy_set_param((struct pw_node_proxy*)sess->dsp_proxy,
SPA_PARAM_Profile, 0, param);

18
src/examples/sdl.h
View file

@ -124,16 +124,16 @@ static struct spa_pod *sdl_build_formats(SDL_RendererInfo *info, struct spa_pod_
spa_pod_builder_id(b, id);
}
spa_pod_builder_pop(b);
spa_pod_builder_props(b,
SPA_FORMAT_VIDEO_size, &SPA_POD_CHOICE_RANGE_Rectangle(
SPA_RECTANGLE(WIDTH, HEIGHT),
SPA_RECTANGLE(1,1),
SPA_RECTANGLE(info->max_texture_width,
spa_pod_builder_add(b,
SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(
&SPA_RECTANGLE(WIDTH, HEIGHT),
&SPA_RECTANGLE(1,1),
&SPA_RECTANGLE(info->max_texture_width,
info->max_texture_height)),
SPA_FORMAT_VIDEO_framerate, &SPA_POD_CHOICE_RANGE_Fraction(
SPA_FRACTION(25,1),
SPA_FRACTION(0,1),
SPA_FRACTION(30,1)),
SPA_FORMAT_VIDEO_framerate, SPA_POD_CHOICE_RANGE_Fraction(
&SPA_FRACTION(25,1),
&SPA_FRACTION(0,1),
&SPA_FRACTION(30,1)),
0);
return spa_pod_builder_pop(b);
}

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

@ -238,35 +238,31 @@ on_stream_format_changed(void *_data, const struct spa_pod *format)
data->rect.w = data->format.size.width;
data->rect.h = data->format.size.height;
params[0] = spa_pod_builder_object(&b,
params[0] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(8, 2, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_Int(data->stride * data->format.size.height),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(data->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(8, 2, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(data->stride * data->format.size.height),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(data->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
params[1] = spa_pod_builder_object(&b,
params[1] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
params[2] = spa_pod_builder_object(&b,
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
params[2] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_VideoCrop),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_region)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_VideoCrop),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_region)));
#define CURSOR_META_SIZE(w,h) (sizeof(struct spa_meta_cursor) + \
sizeof(struct spa_meta_bitmap) + w * h * 4)
params[3] = spa_pod_builder_object(&b,
params[3] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Cursor),
SPA_PARAM_META_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Cursor),
SPA_PARAM_META_size, SPA_POD_CHOICE_RANGE_Int(
CURSOR_META_SIZE(64,64),
CURSOR_META_SIZE(1,1),
CURSOR_META_SIZE(256,256)),
0);
CURSOR_META_SIZE(256,256)));
pw_stream_finish_format(stream, 0, params, 4);
}

71
src/examples/video-src.c
View file

@ -224,42 +224,37 @@ on_stream_format_changed(void *_data, const struct spa_pod *format)
data->stride = SPA_ROUND_UP_N(data->format.size.width * BPP, 4);
params[0] = spa_pod_builder_object(&b,
params[0] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(2, 1, 32),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_Int(data->stride * data->format.size.height),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(data->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(2, 1, 32),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(data->stride * data->format.size.height),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(data->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
params[1] = spa_pod_builder_object(&b,
params[1] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
params[2] = spa_pod_builder_object(&b,
params[2] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_VideoDamage),
SPA_PARAM_META_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_VideoDamage),
SPA_PARAM_META_size, SPA_POD_CHOICE_RANGE_Int(
sizeof(struct spa_meta_region) * 16,
sizeof(struct spa_meta_region) * 1,
sizeof(struct spa_meta_region) * 16),
0);
params[3] = spa_pod_builder_object(&b,
sizeof(struct spa_meta_region) * 16));
params[3] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_VideoCrop),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_region)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_VideoCrop),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_region)));
#define CURSOR_META_SIZE(w,h) (sizeof(struct spa_meta_cursor) + \
sizeof(struct spa_meta_bitmap) + w * h * CURSOR_BPP)
params[4] = spa_pod_builder_object(&b,
params[4] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Cursor),
SPA_PARAM_META_size, &SPA_POD_Int(
CURSOR_META_SIZE(CURSOR_WIDTH,CURSOR_HEIGHT)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Cursor),
SPA_PARAM_META_size, SPA_POD_Int(
CURSOR_META_SIZE(CURSOR_WIDTH,CURSOR_HEIGHT)));
pw_stream_finish_format(stream, 0, params, 5);
}
@ -295,30 +290,16 @@ static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remo
"media.class", "Video/Source",
NULL));
#if 0
params[0] = spa_pod_builder_object(&b,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, &SPA_POD_Id(SPA_VIDEO_FORMAT_RGB),
SPA_FORMAT_VIDEO_size, &SPA_POD_CHOICE_RANGE_Rectangle(
SPA_RECTANGLE(320, 240),
SPA_RECTANGLE(1, 1),
SPA_RECTANGLE(4096, 4096)),
SPA_FORMAT_VIDEO_framerate, &SPA_POD_Fraction(SPA_FRACTION(25, 1)),
0);
#else
params[0] = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
":", SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video,
":", SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_raw,
":", SPA_FORMAT_VIDEO_format, "I", SPA_VIDEO_FORMAT_RGB,
":", SPA_FORMAT_VIDEO_size, "?rR", 3,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, SPA_POD_Id(SPA_VIDEO_FORMAT_RGB),
SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(
&SPA_RECTANGLE(320, 240),
&SPA_RECTANGLE(1, 1),
&SPA_RECTANGLE(4096, 4096),
":", SPA_FORMAT_VIDEO_framerate, "F", &SPA_FRACTION(25, 1));
#endif
&SPA_RECTANGLE(4096, 4096)),
SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&SPA_FRACTION(25, 1)));
pw_stream_add_listener(data->stream,
&data->stream_listener,

25
src/gst/gstpipewiresink.c
View file

@ -237,25 +237,26 @@ pool_activated (GstPipeWirePool *pool, GstPipeWireSink *sink)
spa_pod_builder_init (&b, buffer, sizeof (buffer));
spa_pod_builder_push_object (&b, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers);
if (size == 0)
spa_pod_builder_props (&b,
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX), 0);
spa_pod_builder_add (&b,
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX),
0);
else
spa_pod_builder_props (&b,
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(size, size, INT32_MAX), 0);
spa_pod_builder_add (&b,
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(size, size, INT32_MAX),
0);
spa_pod_builder_props (&b,
SPA_PARAM_BUFFERS_stride, &SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX),
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(min_buffers, min_buffers,
spa_pod_builder_add (&b,
SPA_PARAM_BUFFERS_stride, SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX),
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(min_buffers, min_buffers,
max_buffers ? max_buffers : INT32_MAX),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16),
0);
port_params[0] = spa_pod_builder_pop (&b);
port_params[1] = spa_pod_builder_object (&b,
port_params[1] = spa_pod_builder_add_object (&b,
SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
SPA_PARAM_META_type, &SPA_POD_Int(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof (struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Int(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof (struct spa_meta_header)));
pw_thread_loop_lock (sink->main_loop);

20
src/gst/gstpipewiresrc.c
View file

@ -706,20 +706,18 @@ on_format_changed (void *data,
uint8_t buffer[512];
spa_pod_builder_init (&b, buffer, sizeof (buffer));
params[0] = spa_pod_builder_object (&b,
params[0] = spa_pod_builder_add_object (&b,
SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(16, 1, INT32_MAX),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_CHOICE_RANGE_Int(0, 1, INT32_MAX),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX),
SPA_PARAM_BUFFERS_stride, &SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(16, 1, INT32_MAX),
SPA_PARAM_BUFFERS_blocks, SPA_POD_CHOICE_RANGE_Int(0, 1, INT32_MAX),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX),
SPA_PARAM_BUFFERS_stride, SPA_POD_CHOICE_RANGE_Int(0, 0, INT32_MAX),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
params[1] = spa_pod_builder_object (&b,
params[1] = spa_pod_builder_add_object (&b,
SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof (struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof (struct spa_meta_header)));
GST_DEBUG_OBJECT (pwsrc, "doing finish format");
pw_stream_finish_format (pwsrc->stream, 0, params, 2);

59
src/modules/module-audio-dsp/floatmix.c
View file

@ -336,14 +336,13 @@ static int port_enum_formats(struct spa_node *node,
*param = spa_format_audio_raw_build(builder, SPA_PARAM_EnumFormat,
&this->format.info.raw);
} else {
*param = spa_pod_builder_object(builder,
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, &SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, &SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, &SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, &SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, &SPA_POD_Int(1),
0);
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, SPA_POD_Int(1));
}
break;
default:
@ -390,10 +389,9 @@ impl_node_port_enum_params(struct spa_node *node,
SPA_PARAM_IO };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -418,17 +416,16 @@ impl_node_port_enum_params(struct spa_node *node,
if (*index > 0)
return 0;
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, &SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, &SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, &SPA_POD_CHOICE_RANGE_Int(
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
1024 * this->stride,
16 * this->stride,
INT32_MAX / this->stride),
SPA_PARAM_BUFFERS_stride, &SPA_POD_Int(this->stride),
SPA_PARAM_BUFFERS_align, &SPA_POD_Int(16),
0);
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(this->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
@ -437,11 +434,10 @@ impl_node_port_enum_params(struct spa_node *node,
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, &SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, &SPA_POD_Int(sizeof(struct spa_meta_header)),
0);
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
@ -451,25 +447,22 @@ impl_node_port_enum_params(struct spa_node *node,
case SPA_PARAM_IO:
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
case 1:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_range)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Range),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_range)));
break;
case 2:
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence)),
0);
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence)));
break;
default:
return 0;

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

@ -138,10 +138,9 @@ static int impl_node_enum_params(struct spa_node *node,
SPA_PARAM_Format };
if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b,
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(list[*index]),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(list[*index]));
else
return 0;
break;
@ -602,12 +601,12 @@ static int negotiate_buffers(struct impl *impl)
in_alloc = false;
}
if (spa_pod_object_parse(param,
":", SPA_PARAM_BUFFERS_buffers, "i", &buffers,
":", SPA_PARAM_BUFFERS_blocks, "i", &blocks,
":", SPA_PARAM_BUFFERS_size, "i", &size,
":", SPA_PARAM_BUFFERS_align, "i", &align,
NULL) < 0)
if (spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamBuffers, NULL,
SPA_PARAM_BUFFERS_buffers, SPA_POD_Int(&buffers),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(&blocks),
SPA_PARAM_BUFFERS_size, SPA_POD_Int(&size),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(&align)) < 0)
return -EINVAL;
spa_log_debug(this->log, "%p: buffers %d, blocks %d, size %d, align %d",

380
src/modules/module-client-node/protocol-native.c
View file

@ -40,8 +40,8 @@ client_node_marshal_done(void *object, int seq, int res)
b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_NODE_PROXY_METHOD_DONE);
spa_pod_builder_add_struct(b,
"i", seq,
"i", res);
SPA_POD_Int(seq),
SPA_POD_Int(res));
pw_protocol_native_end_proxy(proxy, b);
}
@ -64,20 +64,21 @@ client_node_marshal_update(void *object,
spa_pod_builder_add(b,
"[",
"i", change_mask,
"i", max_input_ports,
"i", max_output_ports,
"i", n_params, NULL);
SPA_POD_Int(change_mask),
SPA_POD_Int(max_input_ports),
SPA_POD_Int(max_output_ports),
SPA_POD_Int(n_params), NULL);
for (i = 0; i < n_params; i++)
spa_pod_builder_add(b, "P", params[i], NULL);
spa_pod_builder_add(b, SPA_POD_Pod(params[i]), NULL);
n_items = props ? props->n_items : 0;
spa_pod_builder_add(b, "i", n_items, NULL);
spa_pod_builder_add(b,
SPA_POD_Int(n_items), NULL);
for (i = 0; i < n_items; i++) {
spa_pod_builder_add(b,
"s", props->items[i].key,
"s", props->items[i].value, NULL);
SPA_POD_String(props->items[i].key),
SPA_POD_String(props->items[i].value), NULL);
}
spa_pod_builder_add(b, "]", NULL);
@ -101,30 +102,33 @@ client_node_marshal_port_update(void *object,
spa_pod_builder_add(b,
"[",
"i", direction,
"i", port_id,
"i", change_mask,
"i", n_params, NULL);
SPA_POD_Int(direction),
SPA_POD_Int(port_id),
SPA_POD_Int(change_mask),
SPA_POD_Int(n_params), NULL);
for (i = 0; i < n_params; i++)
spa_pod_builder_add(b, "P", params[i], NULL);
spa_pod_builder_add(b,
SPA_POD_Pod(params[i]), NULL);
if (info) {
n_items = info->props ? info->props->n_items : 0;
spa_pod_builder_add(b,
"[",
"i", info->flags,
"i", info->rate,
"i", n_items, NULL);
SPA_POD_Int(info->flags),
SPA_POD_Int(info->rate),
SPA_POD_Int(n_items), NULL);
for (i = 0; i < n_items; i++) {
spa_pod_builder_add(b,
"s", info->props->items[i].key,
"s", info->props->items[i].value, NULL);
SPA_POD_String(info->props->items[i].key),
SPA_POD_String(info->props->items[i].value), NULL);
}
spa_pod_builder_add(b, "]", NULL);
spa_pod_builder_add(b,
"]", NULL);
} else {
spa_pod_builder_add(b, "P", NULL, NULL);
spa_pod_builder_add(b,
SPA_POD_Pod(NULL), NULL);
}
spa_pod_builder_add(b, "]", NULL);
@ -138,7 +142,8 @@ static void client_node_marshal_set_active(void *object, bool active)
b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_NODE_PROXY_METHOD_SET_ACTIVE);
spa_pod_builder_add_struct(b, "b", active);
spa_pod_builder_add_struct(b,
SPA_POD_Bool(active));
pw_protocol_native_end_proxy(proxy, b);
}
@ -150,7 +155,8 @@ static void client_node_marshal_event_method(void *object, struct spa_event *eve
b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_NODE_PROXY_METHOD_EVENT);
spa_pod_builder_add_struct(b, "P", event);
spa_pod_builder_add_struct(b,
SPA_POD_Pod(event));
pw_protocol_native_end_proxy(proxy, b);
}
@ -163,12 +169,11 @@ static int client_node_demarshal_add_mem(void *object, void *data, size_t size)
int memfd;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &mem_id,
"I", &type,
"i", &memfd_idx,
"i", &flags, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&mem_id),
SPA_POD_Id(&type),
SPA_POD_Int(&memfd_idx),
SPA_POD_Int(&flags)) < 0)
return -EINVAL;
memfd = pw_protocol_native_get_proxy_fd(proxy, memfd_idx);
@ -188,11 +193,10 @@ static int client_node_demarshal_transport(void *object, void *data, size_t size
int readfd, writefd;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &node_id,
"i", &ridx,
"i", &widx, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&node_id),
SPA_POD_Int(&ridx),
SPA_POD_Int(&widx)) < 0)
return -EINVAL;
readfd = pw_protocol_native_get_proxy_fd(proxy, ridx);
@ -214,12 +218,11 @@ static int client_node_demarshal_set_param(void *object, void *data, size_t size
const struct spa_pod *param = NULL;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &seq,
"I", &id,
"i", &flags,
"O", &param, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&seq),
SPA_POD_Id(&id),
SPA_POD_Int(&flags),
SPA_POD_PodObject(&param)) < 0)
return -EINVAL;
pw_proxy_notify(proxy, struct pw_client_node_proxy_events, set_param, 0, seq, id, flags, param);
@ -233,7 +236,8 @@ static int client_node_demarshal_event_event(void *object, void *data, size_t si
const struct spa_event *event;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs, "[ O", &event, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_PodObject(&event)) < 0)
return -EINVAL;
pw_proxy_notify(proxy, struct pw_client_node_proxy_events, event, 0, event);
@ -248,10 +252,9 @@ static int client_node_demarshal_command(void *object, void *data, size_t size)
uint32_t seq;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &seq,
"O", &command, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&seq),
SPA_POD_PodObject(&command)) < 0)
return -EINVAL;
pw_proxy_notify(proxy, struct pw_client_node_proxy_events, command, 0, seq, command);
@ -265,11 +268,10 @@ static int client_node_demarshal_add_port(void *object, void *data, size_t size)
int32_t seq, direction, port_id;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &seq,
"i", &direction,
"i", &port_id, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&seq),
SPA_POD_Int(&direction),
SPA_POD_Int(&port_id)) < 0)
return -EINVAL;
pw_proxy_notify(proxy, struct pw_client_node_proxy_events, add_port, 0, seq, direction, port_id);
@ -283,11 +285,10 @@ static int client_node_demarshal_remove_port(void *object, void *data, size_t si
int32_t seq, direction, port_id;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &seq,
"i", &direction,
"i", &port_id, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&seq),
SPA_POD_Int(&direction),
SPA_POD_Int(&port_id)) < 0)
return -EINVAL;
pw_proxy_notify(proxy, struct pw_client_node_proxy_events, remove_port, 0, seq, direction, port_id);
@ -302,14 +303,13 @@ static int client_node_demarshal_port_set_param(void *object, void *data, size_t
const struct spa_pod *param = NULL;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &seq,
"i", &direction,
"i", &port_id,
"I", &id,
"i", &flags,
"O", &param, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&seq),
SPA_POD_Int(&direction),
SPA_POD_Int(&port_id),
SPA_POD_Id(&id),
SPA_POD_Int(&flags),
SPA_POD_PodObject(&param)) < 0)
return -EINVAL;
pw_proxy_notify(proxy, struct pw_client_node_proxy_events, port_set_param, 0,
@ -328,11 +328,11 @@ static int client_node_demarshal_port_use_buffers(void *object, void *data, size
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &seq,
"i", &direction,
"i", &port_id,
"i", &mix_id,
"i", &n_buffers, NULL) < 0)
SPA_POD_Int(&seq),
SPA_POD_Int(&direction),
SPA_POD_Int(&port_id),
SPA_POD_Int(&mix_id),
SPA_POD_Int(&n_buffers), NULL) < 0)
return -EINVAL;
buffers = alloca(sizeof(struct pw_client_node_buffer) * n_buffers);
@ -340,10 +340,10 @@ static int client_node_demarshal_port_use_buffers(void *object, void *data, size
struct spa_buffer *buf = buffers[i].buffer = alloca(sizeof(struct spa_buffer));
if (spa_pod_parser_get(&prs,
"i", &buffers[i].mem_id,
"i", &buffers[i].offset,
"i", &buffers[i].size,
"i", &buf->n_metas, NULL) < 0)
SPA_POD_Int(&buffers[i].mem_id),
SPA_POD_Int(&buffers[i].offset),
SPA_POD_Int(&buffers[i].size),
SPA_POD_Int(&buf->n_metas), NULL) < 0)
return -EINVAL;
buf->metas = alloca(sizeof(struct spa_meta) * buf->n_metas);
@ -351,11 +351,12 @@ static int client_node_demarshal_port_use_buffers(void *object, void *data, size
struct spa_meta *m = &buf->metas[j];
if (spa_pod_parser_get(&prs,
"I", &m->type,
"i", &m->size, NULL) < 0)
SPA_POD_Id(&m->type),
SPA_POD_Int(&m->size), NULL) < 0)
return -EINVAL;
}
if (spa_pod_parser_get(&prs, "i", &buf->n_datas, NULL) < 0)
if (spa_pod_parser_get(&prs,
SPA_POD_Int(&buf->n_datas), NULL) < 0)
return -EINVAL;
buf->datas = alloca(sizeof(struct spa_data) * buf->n_datas);
@ -363,11 +364,11 @@ static int client_node_demarshal_port_use_buffers(void *object, void *data, size
struct spa_data *d = &buf->datas[j];
if (spa_pod_parser_get(&prs,
"I", &d->type,
"i", &data_id,
"i", &d->flags,
"i", &d->mapoffset,
"i", &d->maxsize, NULL) < 0)
SPA_POD_Id(&d->type),
SPA_POD_Int(&data_id),
SPA_POD_Int(&d->flags),
SPA_POD_Int(&d->mapoffset),
SPA_POD_Int(&d->maxsize), NULL) < 0)
return -EINVAL;
d->data = SPA_UINT32_TO_PTR(data_id);
@ -389,11 +390,10 @@ static int client_node_demarshal_port_command(void *object, void *data, size_t s
uint32_t direction, port_id;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &direction,
"i", &port_id,
"O", &command, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&direction),
SPA_POD_Int(&port_id),
SPA_POD_PodObject(&command)) < 0)
return -EINVAL;
pw_proxy_notify(proxy, struct pw_client_node_proxy_events, port_command, 0, direction,
@ -409,16 +409,15 @@ static int client_node_demarshal_port_set_io(void *object, void *data, size_t si
uint32_t seq, direction, port_id, mix_id, id, memid, off, sz;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &seq,
"i", &direction,
"i", &port_id,
"i", &mix_id,
"I", &id,
"i", &memid,
"i", &off,
"i", &sz, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&seq),
SPA_POD_Int(&direction),
SPA_POD_Int(&port_id),
SPA_POD_Int(&mix_id),
SPA_POD_Id(&id),
SPA_POD_Int(&memid),
SPA_POD_Int(&off),
SPA_POD_Int(&sz)) < 0)
return -EINVAL;
pw_proxy_notify(proxy, struct pw_client_node_proxy_events, port_set_io, 0,
@ -436,12 +435,11 @@ static int client_node_demarshal_set_io(void *object, void *data, size_t size)
uint32_t id, memid, off, sz;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"I", &id,
"i", &memid,
"i", &off,
"i", &sz, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Id(&id),
SPA_POD_Int(&memid),
SPA_POD_Int(&off),
SPA_POD_Int(&sz)) < 0)
return -EINVAL;
pw_proxy_notify(proxy, struct pw_client_node_proxy_events, set_io, 0,
@ -461,10 +459,10 @@ client_node_marshal_add_mem(void *object,
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_ADD_MEM);
spa_pod_builder_add_struct(b,
"i", mem_id,
"I", type,
"i", pw_protocol_native_add_resource_fd(resource, memfd),
"i", flags);
SPA_POD_Int(mem_id),
SPA_POD_Id(type),
SPA_POD_Int(pw_protocol_native_add_resource_fd(resource, memfd)),
SPA_POD_Int(flags));
pw_protocol_native_end_resource(resource, b);
}
@ -477,9 +475,9 @@ static void client_node_marshal_transport(void *object, uint32_t node_id, int re
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_TRANSPORT);
spa_pod_builder_add_struct(b,
"i", node_id,
"i", pw_protocol_native_add_resource_fd(resource, readfd),
"i", pw_protocol_native_add_resource_fd(resource, writefd));
SPA_POD_Int(node_id),
SPA_POD_Int(pw_protocol_native_add_resource_fd(resource, readfd)),
SPA_POD_Int(pw_protocol_native_add_resource_fd(resource, writefd)));
pw_protocol_native_end_resource(resource, b);
}
@ -494,10 +492,10 @@ client_node_marshal_set_param(void *object, uint32_t seq, uint32_t id, uint32_t
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_SET_PARAM);
spa_pod_builder_add_struct(b,
"i", seq,
"I", id,
"i", flags,
"P", param);
SPA_POD_Int(seq),
SPA_POD_Id(id),
SPA_POD_Int(flags),
SPA_POD_Pod(param));
pw_protocol_native_end_resource(resource, b);
}
@ -509,7 +507,8 @@ static void client_node_marshal_event_event(void *object, const struct spa_event
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_EVENT);
spa_pod_builder_add_struct(b, "P", event);
spa_pod_builder_add_struct(b,
SPA_POD_Pod(event));
pw_protocol_native_end_resource(resource, b);
}
@ -522,7 +521,9 @@ client_node_marshal_command(void *object, uint32_t seq, const struct spa_command
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_COMMAND);
spa_pod_builder_add_struct(b, "i", seq, "P", command);
spa_pod_builder_add_struct(b,
SPA_POD_Int(seq),
SPA_POD_Pod(command));
pw_protocol_native_end_resource(resource, b);
}
@ -537,9 +538,9 @@ client_node_marshal_add_port(void *object,
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_ADD_PORT);
spa_pod_builder_add_struct(b,
"i", seq,
"i", direction,
"i", port_id);
SPA_POD_Int(seq),
SPA_POD_Int(direction),
SPA_POD_Int(port_id));
pw_protocol_native_end_resource(resource, b);
}
@ -554,9 +555,9 @@ client_node_marshal_remove_port(void *object,
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_REMOVE_PORT);
spa_pod_builder_add_struct(b,
"i", seq,
"i", direction,
"i", port_id);
SPA_POD_Int(seq),
SPA_POD_Int(direction),
SPA_POD_Int(port_id));
pw_protocol_native_end_resource(resource, b);
}
@ -576,12 +577,12 @@ client_node_marshal_port_set_param(void *object,
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_PORT_SET_PARAM);
spa_pod_builder_add_struct(b,
"i", seq,
"i", direction,
"i", port_id,
"I", id,
"i", flags,
"P", param);
SPA_POD_Int(seq),
SPA_POD_Int(direction),
SPA_POD_Int(port_id),
SPA_POD_Id(id),
SPA_POD_Int(flags),
SPA_POD_Pod(param));
pw_protocol_native_end_resource(resource, b);
}
@ -602,36 +603,37 @@ client_node_marshal_port_use_buffers(void *object,
spa_pod_builder_add(b,
"[",
"i", seq,
"i", direction,
"i", port_id,
"i", mix_id,
"i", n_buffers, NULL);
SPA_POD_Int(seq),
SPA_POD_Int(direction),
SPA_POD_Int(port_id),
SPA_POD_Int(mix_id),
SPA_POD_Int(n_buffers), NULL);
for (i = 0; i < n_buffers; i++) {
struct spa_buffer *buf = buffers[i].buffer;
spa_pod_builder_add(b,
"i", buffers[i].mem_id,
"i", buffers[i].offset,
"i", buffers[i].size,
"i", buf->n_metas, NULL);
SPA_POD_Int(buffers[i].mem_id),
SPA_POD_Int(buffers[i].offset),
SPA_POD_Int(buffers[i].size),
SPA_POD_Int(buf->n_metas), NULL);
for (j = 0; j < buf->n_metas; j++) {
struct spa_meta *m = &buf->metas[j];
spa_pod_builder_add(b,
"I", m->type,
"i", m->size, NULL);
SPA_POD_Id(m->type),
SPA_POD_Int(m->size), NULL);
}
spa_pod_builder_add(b, "i", buf->n_datas, NULL);
spa_pod_builder_add(b,
SPA_POD_Int(buf->n_datas), NULL);
for (j = 0; j < buf->n_datas; j++) {
struct spa_data *d = &buf->datas[j];
spa_pod_builder_add(b,
"I", d->type,
"i", SPA_PTR_TO_UINT32(d->data),
"i", d->flags,
"i", d->mapoffset,
"i", d->maxsize, NULL);
SPA_POD_Id(d->type),
SPA_POD_Int(SPA_PTR_TO_UINT32(d->data)),
SPA_POD_Int(d->flags),
SPA_POD_Int(d->mapoffset),
SPA_POD_Int(d->maxsize), NULL);
}
}
spa_pod_builder_add(b, "]", NULL);
@ -651,9 +653,9 @@ client_node_marshal_port_command(void *object,
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_PORT_COMMAND);
spa_pod_builder_add_struct(b,
"i", direction,
"i", port_id,
"P", command);
SPA_POD_Int(direction),
SPA_POD_Int(port_id),
SPA_POD_Pod(command));
pw_protocol_native_end_resource(resource, b);
}
@ -675,14 +677,14 @@ client_node_marshal_port_set_io(void *object,
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_PORT_SET_IO);
spa_pod_builder_add_struct(b,
"i", seq,
"i", direction,
"i", port_id,
"i", mix_id,
"I", id,
"i", memid,
"i", offset,
"i", size);
SPA_POD_Int(seq),
SPA_POD_Int(direction),
SPA_POD_Int(port_id),
SPA_POD_Int(mix_id),
SPA_POD_Id(id),
SPA_POD_Int(memid),
SPA_POD_Int(offset),
SPA_POD_Int(size));
pw_protocol_native_end_resource(resource, b);
}
@ -699,10 +701,10 @@ client_node_marshal_set_io(void *object,
b = pw_protocol_native_begin_resource(resource, PW_CLIENT_NODE_PROXY_EVENT_SET_IO);
spa_pod_builder_add_struct(b,
"I", id,
"i", memid,
"i", offset,
"i", size);
SPA_POD_Id(id),
SPA_POD_Int(memid),
SPA_POD_Int(offset),
SPA_POD_Int(size));
pw_protocol_native_end_resource(resource, b);
}
@ -713,10 +715,9 @@ static int client_node_demarshal_done(void *object, void *data, size_t size)
uint32_t seq, res;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &seq,
"i", &res, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Int(&seq),
SPA_POD_Int(&res)) < 0)
return -EINVAL;
pw_resource_do(resource, struct pw_client_node_proxy_methods, done, 0, seq, res);
@ -735,27 +736,27 @@ static int client_node_demarshal_update(void *object, void *data, size_t size)
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &change_mask,
"i", &max_input_ports,
"i", &max_output_ports,
"i", &n_params, NULL) < 0)
SPA_POD_Int(&change_mask),
SPA_POD_Int(&max_input_ports),
SPA_POD_Int(&max_output_ports),
SPA_POD_Int(&n_params), NULL) < 0)
return -EINVAL;
params = alloca(n_params * sizeof(struct spa_pod *));
for (i = 0; i < n_params; i++)
if (spa_pod_parser_get(&prs, "O", &params[i], NULL) < 0)
if (spa_pod_parser_get(&prs,
SPA_POD_PodObject(&params[i]), NULL) < 0)
return -EINVAL;
if (spa_pod_parser_get(&prs,
"i", &props.n_items, NULL) < 0)
SPA_POD_Int(&props.n_items), NULL) < 0)
return -EINVAL;
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
for (i = 0; i < props.n_items; i++) {
if (spa_pod_parser_get(&prs,
"s", &props.items[i].key,
"s", &props.items[i].value,
NULL) < 0)
SPA_POD_String(&props.items[i].key),
SPA_POD_String(&props.items[i].value), NULL) < 0)
return -EINVAL;
}
@ -782,18 +783,20 @@ static int client_node_demarshal_port_update(void *object, void *data, size_t si
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"i", &direction,
"i", &port_id,
"i", &change_mask,
"i", &n_params, NULL) < 0)
SPA_POD_Int(&direction),
SPA_POD_Int(&port_id),
SPA_POD_Int(&change_mask),
SPA_POD_Int(&n_params), NULL) < 0)
return -EINVAL;
params = alloca(n_params * sizeof(struct spa_pod *));
for (i = 0; i < n_params; i++)
if (spa_pod_parser_get(&prs, "O", &params[i], NULL) < 0)
if (spa_pod_parser_get(&prs,
SPA_POD_PodObject(&params[i]), NULL) < 0)
return -EINVAL;
if (spa_pod_parser_get(&prs, "T", &ipod, NULL) < 0)
if (spa_pod_parser_get(&prs,
SPA_POD_PodStruct(&ipod), NULL) < 0)
return -EINVAL;
if (ipod) {
@ -803,9 +806,9 @@ static int client_node_demarshal_port_update(void *object, void *data, size_t si
spa_pod_parser_pod(&p2, ipod);
if (spa_pod_parser_get(&p2,
"["
"i", &info.flags,
"i", &info.rate,
"i", &props.n_items, NULL) < 0)
SPA_POD_Int(&info.flags),
SPA_POD_Int(&info.rate),
SPA_POD_Int(&props.n_items), NULL) < 0)
return -EINVAL;
if (props.n_items > 0) {
@ -814,9 +817,8 @@ static int client_node_demarshal_port_update(void *object, void *data, size_t si
props.items = alloca(props.n_items * sizeof(struct spa_dict_item));
for (i = 0; i < props.n_items; i++) {
if (spa_pod_parser_get(&p2,
"s", &props.items[i].key,
"s", &props.items[i].value,
NULL) < 0)
SPA_POD_String(&props.items[i].key),
SPA_POD_String(&props.items[i].value), NULL) < 0)
return -EINVAL;
}
}
@ -837,9 +839,8 @@ static int client_node_demarshal_set_active(void *object, void *data, size_t siz
int active;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"b", &active, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_Bool(&active)) < 0)
return -EINVAL;
pw_resource_do(resource, struct pw_client_node_proxy_methods, set_active, 0, active);
@ -853,9 +854,8 @@ static int client_node_demarshal_event_method(void *object, void *data, size_t s
struct spa_event *event;
spa_pod_parser_init(&prs, data, size, 0);
if (spa_pod_parser_get(&prs,
"["
"O", &event, NULL) < 0)
if (spa_pod_parser_get_struct(&prs,
SPA_POD_PodObject(&event)) < 0)
return -EINVAL;
pw_resource_do(resource, struct pw_client_node_proxy_methods, event, 0, event);

637
src/modules/module-protocol-native/protocol-native.c
View file

File diff suppressed because it is too large Load diff

35
src/modules/spa/spa-monitor.c
View file

@ -80,16 +80,17 @@ static struct monitor_item *add_item(struct pw_spa_monitor *this,
enum spa_monitor_item_state state;
struct spa_pod *info = NULL;
const struct spa_support *support;
uint32_t n_support, type;
uint32_t n_support, type, ftype;
if (spa_pod_object_parse(item,
":", SPA_MONITOR_ITEM_id, "s", &id,
":", SPA_MONITOR_ITEM_state, "I", &state,
":", SPA_MONITOR_ITEM_name, "s", &name,
":", SPA_MONITOR_ITEM_class, "s", &klass,
":", SPA_MONITOR_ITEM_factory, "p", &factory,
":", SPA_MONITOR_ITEM_type, "I", &type,
":", SPA_MONITOR_ITEM_info, "T", &info, NULL) < 0) {
if (spa_pod_parse_object(item,
SPA_TYPE_OBJECT_MonitorItem, NULL,
SPA_MONITOR_ITEM_id, SPA_POD_String(&id),
SPA_MONITOR_ITEM_state, SPA_POD_Id(&state),
SPA_MONITOR_ITEM_name, SPA_POD_String(&name),
SPA_MONITOR_ITEM_class, SPA_POD_String(&klass),
SPA_MONITOR_ITEM_factory, SPA_POD_Pointer(&ftype, &factory),
SPA_MONITOR_ITEM_type, SPA_POD_Id(&type),
SPA_MONITOR_ITEM_info, SPA_POD_Pod(&info)) < 0) {
pw_log_warn("monitor %p: could not parse item", this);
spa_debug_pod(0, NULL, item);
return NULL;
@ -195,9 +196,10 @@ static void remove_item(struct pw_spa_monitor *this, struct spa_pod *item, uint6
struct monitor_item *mitem;
const char *name, *id;
if (spa_pod_object_parse(item,
":", SPA_MONITOR_ITEM_name, "s", &name,
":", SPA_MONITOR_ITEM_id, "s", &id, NULL) < 0)
if (spa_pod_parse_object(item,
SPA_TYPE_OBJECT_MonitorItem, NULL,
SPA_MONITOR_ITEM_name, SPA_POD_String(&name),
SPA_MONITOR_ITEM_id, SPA_POD_String(&id)) < 0)
return;
pw_log_debug("monitor %p: remove: \"%s\" (%s)", this, name, id);
@ -212,10 +214,11 @@ static void change_item(struct pw_spa_monitor *this, struct spa_pod *item, uint6
const char *name, *id;
enum spa_monitor_item_state state;
if (spa_pod_object_parse(item,
":", SPA_MONITOR_ITEM_name, "s", &name,
":", SPA_MONITOR_ITEM_state, "I", &state,
":", SPA_MONITOR_ITEM_id, "s", &id, NULL) < 0)
if (spa_pod_parse_object(item,
SPA_TYPE_OBJECT_MonitorItem, NULL,
SPA_MONITOR_ITEM_name, SPA_POD_String(&name),
SPA_MONITOR_ITEM_state, SPA_POD_Id(&state),
SPA_MONITOR_ITEM_id, SPA_POD_String(&id)) < 0)
return;
pw_log_debug("monitor %p: change: \"%s\" (%s)", this, name, id);

16
src/pipewire/link.c
View file

@ -442,9 +442,10 @@ static int alloc_buffers(struct pw_link *this,
if (spa_pod_is_object_type (params[i], SPA_TYPE_OBJECT_ParamMeta)) {
uint32_t type, size;
if (spa_pod_object_parse(params[i],
":", SPA_PARAM_META_type, "I", &type,
":", SPA_PARAM_META_size, "i", &size, NULL) < 0)
if (spa_pod_parse_object(params[i],
SPA_TYPE_OBJECT_ParamMeta, NULL,
SPA_PARAM_META_type, SPA_POD_Id(&type),
SPA_PARAM_META_size, SPA_POD_Int(&size)) < 0)
continue;
pw_log_debug("link %p: enable meta %d %d", this, type, size);
@ -724,10 +725,11 @@ static int do_allocation(struct pw_link *this, uint32_t in_state, uint32_t out_s
uint32_t qmax_buffers = max_buffers,
qminsize = minsize, qstride = stride;
spa_pod_object_parse(param,
":", SPA_PARAM_BUFFERS_size, "i", &qminsize,
":", SPA_PARAM_BUFFERS_stride, "i", &qstride,
":", SPA_PARAM_BUFFERS_buffers, "i", &qmax_buffers, NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamBuffers, NULL,
SPA_PARAM_BUFFERS_size, SPA_POD_Int(&qminsize),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(&qstride),
SPA_PARAM_BUFFERS_buffers, SPA_POD_Int(&qmax_buffers));
max_buffers =
qmax_buffers == 0 ? max_buffers : SPA_MIN(qmax_buffers,

7
src/pipewire/port.c
View file

@ -389,9 +389,10 @@ static int check_param_io(void *data, uint32_t id, uint32_t index, uint32_t next
struct pw_node *node = port->node;
uint32_t pid, psize;
if (spa_pod_object_parse(param,
":", SPA_PARAM_IO_id, "I", &pid,
":", SPA_PARAM_IO_size, "i", &psize) < 0)
if (spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamIO, NULL,
SPA_PARAM_IO_id, SPA_POD_Id(&pid),
SPA_PARAM_IO_size, SPA_POD_Int(&psize)) < 0)
return 0;
switch (pid) {

5
src/pipewire/remote.c
View file

@ -757,8 +757,9 @@ static void add_port_update(struct pw_proxy *proxy, struct pw_port *port, uint32
NULL, &param, &b) <= 0)
break;
spa_pod_object_parse(param,
":", SPA_PARAM_LIST_id, "I", &id, NULL);
spa_pod_parse_object(param,
SPA_TYPE_OBJECT_ParamList, NULL,
SPA_PARAM_LIST_id, SPA_POD_Id(&id));
params = realloc(params, sizeof(struct spa_pod *) * (n_params + 1));
params[n_params++] = pw_spa_pod_copy(param);

26
src/pipewire/stream.c
View file

@ -426,10 +426,9 @@ static int impl_port_enum_params(struct spa_node *node,
uint32_t new_id = ((struct spa_pod_object *) param)->body.id;
if (last_id == SPA_ID_INVALID){
*result = spa_pod_builder_object(builder,
*result = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_ParamList, id,
SPA_PARAM_LIST_id, &SPA_POD_Id(new_id),
0);
SPA_PARAM_LIST_id, SPA_POD_Id(new_id));
last_id = new_id;
}
else if (last_id != new_id) {
@ -1065,23 +1064,20 @@ static void add_controls(struct pw_stream *stream)
spa_pod_builder_init(&b, buffer, 4096);
add_param(stream, PARAM_TYPE_INIT,
spa_pod_builder_object(&b,
spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, SPA_PARAM_IO,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_buffers)),
0));
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers))));
add_param(stream, PARAM_TYPE_INIT,
spa_pod_builder_object(&b,
spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, SPA_PARAM_IO,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Notify),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence) + 1024),
0));
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Notify),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence) + 1024)));
add_param(stream, PARAM_TYPE_INIT,
spa_pod_builder_object(&b,
spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, SPA_PARAM_IO,
SPA_PARAM_IO_id, &SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, &SPA_POD_Int(sizeof(struct spa_io_sequence)),
0));
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Control),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_sequence))));
}
int