diff --git a/pipewire-alsa b/pipewire-alsa index 5a8c6d457..ea1f9e18f 160000 --- a/pipewire-alsa +++ b/pipewire-alsa @@ -1 +1 @@ -Subproject commit 5a8c6d457e846639e4e949461ecf3f494cabba39 +Subproject commit ea1f9e18f7a61d7632c2d65248f99b6abf33f140 diff --git a/pipewire-jack b/pipewire-jack index 168745363..c1da362a2 160000 --- a/pipewire-jack +++ b/pipewire-jack @@ -1 +1 @@ -Subproject commit 16874536363649535cfdda5227e9108ec158127a +Subproject commit c1da362a24351c8827d5b964d24ef5176e87ca95 diff --git a/pipewire-pulseaudio b/pipewire-pulseaudio index f509e8552..386e5c966 160000 --- a/pipewire-pulseaudio +++ b/pipewire-pulseaudio @@ -1 +1 @@ -Subproject commit f509e8552d1836268c6f85a3d8e78aadcdfec197 +Subproject commit 386e5c966c7c44086cb81e3649e7d58193cde43d diff --git a/spa/include/spa/param/audio/format-utils.h b/spa/include/spa/param/audio/format-utils.h index 2c7adcfad..a2e6aeb4f 100644 --- a/spa/include/spa/param/audio/format-utils.h +++ b/spa/include/spa/param/audio/format-utils.h @@ -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); } diff --git a/spa/include/spa/param/format-utils.h b/spa/include/spa/param/format-utils.h index 98a371f47..8e11bab50 100644 --- a/spa/include/spa/param/format-utils.h +++ b/spa/include/spa/param/format-utils.h @@ -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 diff --git a/spa/include/spa/param/video/format-utils.h b/spa/include/spa/param/video/format-utils.h index 105853767..f77d19d51 100644 --- a/spa/include/spa/param/video/format-utils.h +++ b/spa/include/spa/param/video/format-utils.h @@ -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 diff --git a/spa/include/spa/pod/builder.h b/spa/include/spa/pod/builder.h index c09e7a94e..e1a763367 100644 --- a/spa/include/spa/pod/builder.h +++ b/spa/include/spa/pod/builder.h @@ -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,13 +378,13 @@ 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__ } } + { type, 0, { sizeof(ctype), child_type } } }, { __VA_ARGS__ } } static inline uint32_t spa_pod_builder_push_choice(struct spa_pod_builder *builder, uint32_t type, uint32_t flags) @@ -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_BOOL(def) 3,(def),(def),!(def) +#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_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" */ diff --git a/spa/include/spa/pod/parser.h b/spa/include/spa/pod/parser.h index 2e7a5e7cc..85bcebbbf 100644 --- a/spa/include/spa/pod/parser.h +++ b/spa/include/spa/pod/parser.h @@ -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,7 +156,8 @@ do { \ { \ struct spa_pod_pointer_body *b = \ (struct spa_pod_pointer_body *) SPA_POD_BODY(pod); \ - *(va_arg(args, const void **)) = b->value; \ + *(va_arg(args, uint32_t *)) = b->type; \ + *(va_arg(args, const void **)) = b->value; \ break; \ } \ case 'h': \ @@ -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,69 +207,85 @@ 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 *); + 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); + if (key == 0) { + format = NULL; + continue; + } + if (key != SPA_ID_INVALID) { + prop = spa_pod_find_prop(obj, key); + if (prop != NULL) + pod = &prop->value; + else + pod = NULL; + + it->offset = it->size; + current = NULL; + required = true; + } + } + if ((format = va_arg(args, char *)) != NULL) + goto again; continue; case ' ': case '\n': case '\t': case '\r': break; case '?': required = false; break; - case '*': - suppress = true; - break; - case ':': - { - uint32_t key = va_arg(args, uint32_t); - const struct spa_pod *obj = (const struct spa_pod *) parser->iter[parser->depth].data; - - prop = spa_pod_find_prop(obj, key); - if (prop != NULL) - pod = &prop->value; - else - pod = NULL; - - it->offset = it->size; - current = NULL; - required = true; - 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) diff --git a/spa/plugins/alsa/alsa-device.c b/spa/plugins/alsa/alsa-device.c index 9071a87f5..4855a7ca8 100644 --- a/spa/plugins/alsa/alsa-device.c +++ b/spa/plugins/alsa/alsa-device.c @@ -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; diff --git a/spa/plugins/alsa/alsa-monitor.c b/spa/plugins/alsa/alsa-monitor.c index ddbc59a67..539c7c86b 100644 --- a/spa/plugins/alsa/alsa-monitor.c +++ b/spa/plugins/alsa/alsa-monitor.c @@ -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); diff --git a/spa/plugins/alsa/alsa-sink.c b/spa/plugins/alsa/alsa-sink.c index b137ce0a2..390fc3024 100644 --- a/spa/plugins/alsa/alsa-sink.c +++ b/spa/plugins/alsa/alsa-sink.c @@ -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; diff --git a/spa/plugins/alsa/alsa-source.c b/spa/plugins/alsa/alsa-source.c index 0698e8e19..bab233790 100644 --- a/spa/plugins/alsa/alsa-source.c +++ b/spa/plugins/alsa/alsa-source.c @@ -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; diff --git a/spa/plugins/alsa/alsa-utils.c b/spa/plugins/alsa/alsa-utils.c index 80c690f69..0886d068e 100644 --- a/spa/plugins/alsa/alsa-utils.c +++ b/spa/plugins/alsa/alsa-utils.c @@ -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); diff --git a/spa/plugins/audioconvert/audioconvert.c b/spa/plugins/audioconvert/audioconvert.c index 92130c55f..9084875d6 100644 --- a/spa/plugins/audioconvert/audioconvert.c +++ b/spa/plugins/audioconvert/audioconvert.c @@ -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; diff --git a/spa/plugins/audioconvert/channelmix.c b/spa/plugins/audioconvert/channelmix.c index ac7e518d2..6b885c27f 100644 --- a/spa/plugins/audioconvert/channelmix.c +++ b/spa/plugins/audioconvert/channelmix.c @@ -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; diff --git a/spa/plugins/audioconvert/fmtconvert.c b/spa/plugins/audioconvert/fmtconvert.c index 8060f561d..15c0dde67 100644 --- a/spa/plugins/audioconvert/fmtconvert.c +++ b/spa/plugins/audioconvert/fmtconvert.c @@ -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; diff --git a/spa/plugins/audioconvert/merger.c b/spa/plugins/audioconvert/merger.c index cb735cb11..4dd17a663 100644 --- a/spa/plugins/audioconvert/merger.c +++ b/spa/plugins/audioconvert/merger.c @@ -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( - 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_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)); 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; diff --git a/spa/plugins/audioconvert/resample.c b/spa/plugins/audioconvert/resample.c index da9af14c9..e2b1e6ba2 100644 --- a/spa/plugins/audioconvert/resample.c +++ b/spa/plugins/audioconvert/resample.c @@ -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; diff --git a/spa/plugins/audioconvert/splitter.c b/spa/plugins/audioconvert/splitter.c index 69defdd16..06e82da16 100644 --- a/spa/plugins/audioconvert/splitter.c +++ b/spa/plugins/audioconvert/splitter.c @@ -36,6 +36,7 @@ #include #include #include +#include #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; diff --git a/spa/plugins/audiomixer/audiomixer.c b/spa/plugins/audiomixer/audiomixer.c index 5a5eb2d4d..59d68ea8a 100644 --- a/spa/plugins/audiomixer/audiomixer.c +++ b/spa/plugins/audiomixer/audiomixer.c @@ -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; diff --git a/spa/plugins/audiotestsrc/audiotestsrc.c b/spa/plugins/audiotestsrc/audiotestsrc.c index 1d08e37e8..5330de9ce 100644 --- a/spa/plugins/audiotestsrc/audiotestsrc.c +++ b/spa/plugins/audiotestsrc/audiotestsrc.c @@ -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: diff --git a/spa/plugins/bluez5/a2dp-sink.c b/spa/plugins/bluez5/a2dp-sink.c index eaadab868..54773c28d 100644 --- a/spa/plugins/bluez5/a2dp-sink.c +++ b/spa/plugins/bluez5/a2dp-sink.c @@ -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( - 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_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)); 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; diff --git a/spa/plugins/bluez5/bluez5-monitor.c b/spa/plugins/bluez5/bluez5-monitor.c index b7924d7cf..7916c9118 100644 --- a/spa/plugins/bluez5/bluez5-monitor.c +++ b/spa/plugins/bluez5/bluez5-monitor.c @@ -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; diff --git a/spa/plugins/ffmpeg/ffmpeg-dec.c b/spa/plugins/ffmpeg/ffmpeg-dec.c index d0c5d022a..18119dee0 100644 --- a/spa/plugins/ffmpeg/ffmpeg-dec.c +++ b/spa/plugins/ffmpeg/ffmpeg-dec.c @@ -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; diff --git a/spa/plugins/ffmpeg/ffmpeg-enc.c b/spa/plugins/ffmpeg/ffmpeg-enc.c index 7e94f2697..0385ff63c 100644 --- a/spa/plugins/ffmpeg/ffmpeg-enc.c +++ b/spa/plugins/ffmpeg/ffmpeg-enc.c @@ -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; diff --git a/spa/plugins/test/fakesink.c b/spa/plugins/test/fakesink.c index 03e870012..47bdffb08 100644 --- a/spa/plugins/test/fakesink.c +++ b/spa/plugins/test/fakesink.c @@ -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; diff --git a/spa/plugins/test/fakesrc.c b/spa/plugins/test/fakesrc.c index 12dbdd2de..3ad0b7dc3 100644 --- a/spa/plugins/test/fakesrc.c +++ b/spa/plugins/test/fakesrc.c @@ -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; diff --git a/spa/plugins/v4l2/v4l2-monitor.c b/spa/plugins/v4l2/v4l2-monitor.c index 3833263ba..cd23528c2 100644 --- a/spa/plugins/v4l2/v4l2-monitor.c +++ b/spa/plugins/v4l2/v4l2-monitor.c @@ -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); diff --git a/spa/plugins/v4l2/v4l2-source.c b/spa/plugins/v4l2/v4l2-source.c index 521f5c0e2..e0d64bf4d 100644 --- a/spa/plugins/v4l2/v4l2-source.c +++ b/spa/plugins/v4l2/v4l2-source.c @@ -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; diff --git a/spa/plugins/v4l2/v4l2-utils.c b/spa/plugins/v4l2/v4l2-utils.c index 1d8add439..eb5c84aa2 100644 --- a/spa/plugins/v4l2/v4l2-utils.c +++ b/spa/plugins/v4l2/v4l2-utils.c @@ -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( - queryctrl.default_value, - queryctrl.minimum, - queryctrl.maximum, - queryctrl.step), - 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_STEP_Int( + queryctrl.default_value, + queryctrl.minimum, + queryctrl.maximum, + queryctrl.step), + 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); diff --git a/spa/plugins/videotestsrc/videotestsrc.c b/spa/plugins/videotestsrc/videotestsrc.c index d4cd5948b..94f495fec 100644 --- a/spa/plugins/videotestsrc/videotestsrc.c +++ b/spa/plugins/videotestsrc/videotestsrc.c @@ -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: diff --git a/spa/plugins/volume/volume.c b/spa/plugins/volume/volume.c index cdb76f138..0f04e4431 100644 --- a/spa/plugins/volume/volume.c +++ b/spa/plugins/volume/volume.c @@ -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; diff --git a/spa/tests/test-control.c b/spa/tests/test-control.c index 0c8cc8e80..09505c839 100644 --- a/spa/tests/test-control.c +++ b/spa/tests/test-control.c @@ -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); diff --git a/spa/tests/test-convert2.c b/spa/tests/test-convert2.c index 4438d9af7..c05cc98ec 100644 --- a/spa/tests/test-convert2.c +++ b/spa/tests/test-convert2.c @@ -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); diff --git a/spa/tests/test-graph.c b/spa/tests/test-graph.c index d6154f4c5..aee8b2119 100644 --- a/spa/tests/test-graph.c +++ b/spa/tests/test-graph.c @@ -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); diff --git a/spa/tests/test-mixer.c b/spa/tests/test-mixer.c index 96897c84c..79ff39b1f 100644 --- a/spa/tests/test-mixer.c +++ b/spa/tests/test-mixer.c @@ -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, diff --git a/spa/tests/test-perf.c b/spa/tests/test-perf.c index 0fcbe58bf..3f84e87e6 100644 --- a/spa/tests/test-perf.c +++ b/spa/tests/test-perf.c @@ -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, diff --git a/spa/tests/test-props.c b/spa/tests/test-props.c index 33374472f..5e03126b0 100644 --- a/spa/tests/test-props.c +++ b/spa/tests/test-props.c @@ -163,11 +163,11 @@ key: "" ) { "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] ] + "mediaType": "video", + "mediaSubtype": "raw", + "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)); diff --git a/spa/tests/test-ringbuffer.c b/spa/tests/test-ringbuffer.c index 2ed419efe..1380bcb59 100644 --- a/spa/tests/test-ringbuffer.c +++ b/spa/tests/test-ringbuffer.c @@ -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); diff --git a/spa/tests/test-v4l2.c b/spa/tests/test-v4l2.c index 900309976..d4553b701 100644 --- a/spa/tests/test-v4l2.c +++ b/spa/tests/test-v4l2.c @@ -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); diff --git a/spa/tools/spa-inspect.c b/spa/tools/spa-inspect.c index e00e31484..37a685e35 100644 --- a/spa/tools/spa-inspect.c +++ b/spa/tools/spa-inspect.c @@ -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;;) { diff --git a/src/examples/export-sink.c b/src/examples/export-sink.c index 2b0bbd412..f29a1a182 100644 --- a/src/examples/export-sink.c +++ b/src/examples/export-sink.c @@ -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; diff --git a/src/examples/export-source.c b/src/examples/export-source.c index d6f7453c8..f151ae685 100644 --- a/src/examples/export-source.c +++ b/src/examples/export-source.c @@ -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; diff --git a/src/examples/local-v4l2.c b/src/examples/local-v4l2.c index a963fd013..26e06709b 100644 --- a/src/examples/local-v4l2.c +++ b/src/examples/local-v4l2.c @@ -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: diff --git a/src/examples/media-session.c b/src/examples/media-session.c index 40b0871dd..c6089e90f 100644 --- a/src/examples/media-session.c +++ b/src/examples/media-session.c @@ -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); diff --git a/src/examples/sdl.h b/src/examples/sdl.h index 2d1734d6c..a2a25e127 100644 --- a/src/examples/sdl.h +++ b/src/examples/sdl.h @@ -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); } diff --git a/src/examples/video-play.c b/src/examples/video-play.c index 7ae5e4ac4..2352dc51f 100644 --- a/src/examples/video-play.c +++ b/src/examples/video-play.c @@ -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); } diff --git a/src/examples/video-src.c b/src/examples/video-src.c index c5154a223..9e0dd7343 100644 --- a/src/examples/video-src.c +++ b/src/examples/video-src.c @@ -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_RECTANGLE(320, 240), - &SPA_RECTANGLE(1, 1), - &SPA_RECTANGLE(4096, 4096), - ":", SPA_FORMAT_VIDEO_framerate, "F", &SPA_FRACTION(25, 1)); -#endif + 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))); pw_stream_add_listener(data->stream, &data->stream_listener, diff --git a/src/gst/gstpipewiresink.c b/src/gst/gstpipewiresink.c index 62d803ea3..d7dbb1827 100644 --- a/src/gst/gstpipewiresink.c +++ b/src/gst/gstpipewiresink.c @@ -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); diff --git a/src/gst/gstpipewiresrc.c b/src/gst/gstpipewiresrc.c index 0d40cce77..0200fc507 100644 --- a/src/gst/gstpipewiresrc.c +++ b/src/gst/gstpipewiresrc.c @@ -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); diff --git a/src/modules/module-audio-dsp/floatmix.c b/src/modules/module-audio-dsp/floatmix.c index 924c2ae33..d87091f8f 100644 --- a/src/modules/module-audio-dsp/floatmix.c +++ b/src/modules/module-audio-dsp/floatmix.c @@ -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( - 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_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)); 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; diff --git a/src/modules/module-client-node/client-stream.c b/src/modules/module-client-node/client-stream.c index 293ee9056..8d56c73f7 100644 --- a/src/modules/module-client-node/client-stream.c +++ b/src/modules/module-client-node/client-stream.c @@ -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", diff --git a/src/modules/module-client-node/protocol-native.c b/src/modules/module-client-node/protocol-native.c index 4b7be2de0..12ddb3f8d 100644 --- a/src/modules/module-client-node/protocol-native.c +++ b/src/modules/module-client-node/protocol-native.c @@ -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", ¶m, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&seq), + SPA_POD_Id(&id), + SPA_POD_Int(&flags), + SPA_POD_PodObject(¶m)) < 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", ¶m, 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(¶m)) < 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", ¶ms[i], NULL) < 0) + if (spa_pod_parser_get(&prs, + SPA_POD_PodObject(¶ms[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", ¶ms[i], NULL) < 0) + if (spa_pod_parser_get(&prs, + SPA_POD_PodObject(¶ms[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); diff --git a/src/modules/module-protocol-native/protocol-native.c b/src/modules/module-protocol-native/protocol-native.c index 38bc4a758..142a1c267 100644 --- a/src/modules/module-protocol-native/protocol-native.c +++ b/src/modules/module-protocol-native/protocol-native.c @@ -39,7 +39,8 @@ static void core_marshal_hello(void *object, uint32_t version) b = pw_protocol_native_begin_proxy(proxy, PW_CORE_PROXY_METHOD_HELLO); - spa_pod_builder_add_struct(b, "i", version); + spa_pod_builder_add_struct(b, + SPA_POD_Int(version)); pw_protocol_native_end_proxy(proxy, b); } @@ -51,7 +52,8 @@ static void core_marshal_sync(void *object, uint32_t seq) b = pw_protocol_native_begin_proxy(proxy, PW_CORE_PROXY_METHOD_SYNC); - spa_pod_builder_add_struct(b, "i", seq); + spa_pod_builder_add_struct(b, + SPA_POD_Int(seq)); pw_protocol_native_end_proxy(proxy, b); } @@ -64,8 +66,8 @@ static void core_marshal_get_registry(void *object, uint32_t version, uint32_t n b = pw_protocol_native_begin_proxy(proxy, PW_CORE_PROXY_METHOD_GET_REGISTRY); spa_pod_builder_add_struct(b, - "i", version, - "i", new_id); + SPA_POD_Int(version), + SPA_POD_Int(new_id)); pw_protocol_native_end_proxy(proxy, b); } @@ -84,21 +86,23 @@ core_marshal_create_object(void *object, n_items = props ? props->n_items : 0; - spa_pod_builder_add(b, - "[" - "s", factory_name, - "I", type, - "i", version, - "i", n_items, NULL); + spa_pod_builder_add(b, "[" + SPA_POD_String(factory_name), + SPA_POD_Id(type), + SPA_POD_Int(version), + 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, - "i", new_id, - "]", NULL); + SPA_POD_Int(new_id), + "]", + NULL); pw_protocol_native_end_proxy(proxy, b); } @@ -111,7 +115,8 @@ core_marshal_destroy(void *object, uint32_t id) b = pw_protocol_native_begin_proxy(proxy, PW_CORE_PROXY_METHOD_DESTROY); - spa_pod_builder_add_struct(b, "i", id); + spa_pod_builder_add_struct(b, + SPA_POD_Int(id)); pw_protocol_native_end_proxy(proxy, b); } @@ -127,22 +132,22 @@ static int core_demarshal_info(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "i", &info.id, - "l", &info.change_mask, - "s", &info.user_name, - "s", &info.host_name, - "s", &info.version, - "s", &info.name, - "i", &info.cookie, - "i", &props.n_items, NULL) < 0) + SPA_POD_Int(&info.id), + SPA_POD_Long(&info.change_mask), + SPA_POD_String(&info.user_name), + SPA_POD_String(&info.host_name), + SPA_POD_String(&info.version), + SPA_POD_String(&info.name), + SPA_POD_Int(&info.cookie), + SPA_POD_Int(&props.n_items), NULL) < 0) return -EINVAL; info.props = &props; 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, + SPA_POD_String(&props.items[i].key), + SPA_POD_String(&props.items[i].value), NULL) < 0) return -EINVAL; } @@ -157,7 +162,8 @@ static int core_demarshal_done(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, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&seq)) < 0) return -EINVAL; pw_proxy_notify(proxy, struct pw_core_proxy_events, done, 0, seq); @@ -172,10 +178,10 @@ static int core_demarshal_error(void *object, void *data, size_t size) const char *error; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ i", &id, - "i", &res, - "s", &error, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&id), + SPA_POD_Int(&res), + SPA_POD_String(&error)) < 0) return -EINVAL; pw_proxy_notify(proxy, struct pw_core_proxy_events, error, 0, id, res, error); @@ -189,7 +195,7 @@ static int core_demarshal_remove_id(void *object, void *data, size_t size) uint32_t id; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, "[ i", &id, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, SPA_POD_Int(&id)) < 0) return -EINVAL; pw_proxy_notify(proxy, struct pw_core_proxy_events, remove_id, 0, id); @@ -208,19 +214,21 @@ static void core_marshal_info(void *object, const struct pw_core_info *info) spa_pod_builder_add(b, "[", - "i", info->id, - "l", info->change_mask, - "s", info->user_name, - "s", info->host_name, - "s", info->version, - "s", info->name, - "i", info->cookie, - "i", n_items, NULL); + SPA_POD_Int(info->id), + SPA_POD_Long(info->change_mask), + SPA_POD_String(info->user_name), + SPA_POD_String(info->host_name), + SPA_POD_String(info->version), + SPA_POD_String(info->name), + SPA_POD_Int(info->cookie), + 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); @@ -234,7 +242,8 @@ static void core_marshal_done(void *object, uint32_t seq) b = pw_protocol_native_begin_resource(resource, PW_CORE_PROXY_EVENT_DONE); - spa_pod_builder_add_struct(b, "i", seq); + spa_pod_builder_add_struct(b, + SPA_POD_Int(seq)); pw_protocol_native_end_resource(resource, b); } @@ -253,9 +262,9 @@ static void core_marshal_error(void *object, uint32_t id, int res, const char *e va_end(ap); spa_pod_builder_add_struct(b, - "i", id, - "i", res, - "s", buffer); + SPA_POD_Int(id), + SPA_POD_Int(res), + SPA_POD_String(buffer)); pw_protocol_native_end_resource(resource, b); } @@ -267,7 +276,8 @@ static void core_marshal_remove_id(void *object, uint32_t id) b = pw_protocol_native_begin_resource(resource, PW_CORE_PROXY_EVENT_REMOVE_ID); - spa_pod_builder_add_struct(b, "i", id); + spa_pod_builder_add_struct(b, + SPA_POD_Int(id)); pw_protocol_native_end_resource(resource, b); } @@ -279,8 +289,8 @@ static int core_demarshal_hello(void *object, void *data, size_t size) uint32_t version; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, "[ i", &version, - NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&version)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_core_proxy_methods, hello, 0, version); @@ -294,7 +304,8 @@ static int core_demarshal_sync(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, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&seq)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_core_proxy_methods, sync, 0, seq); @@ -308,7 +319,9 @@ static int core_demarshal_get_registry(void *object, void *data, size_t size) int32_t version, new_id; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, "[ii]", &version, &new_id, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&version), + SPA_POD_Int(&new_id)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_core_proxy_methods, get_registry, 0, version, new_id); @@ -326,19 +339,21 @@ static int core_demarshal_create_object(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "s", &factory_name, - "I", &type, - "i", &version, - "i", &props.n_items, NULL) < 0) + SPA_POD_String(&factory_name), + SPA_POD_Id(&type), + SPA_POD_Int(&version), + 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, "ss", - &props.items[i].key, &props.items[i].value, NULL) < 0) + if (spa_pod_parser_get(&prs, + SPA_POD_String(&props.items[i].key), + SPA_POD_String(&props.items[i].value), NULL) < 0) return -EINVAL; } - if (spa_pod_parser_get(&prs, "i", &new_id, NULL) < 0) + if (spa_pod_parser_get(&prs, + SPA_POD_Int(&new_id), NULL) < 0) return -EINVAL; pw_resource_do(resource, struct pw_core_proxy_methods, create_object, 0, factory_name, @@ -354,7 +369,8 @@ static int core_demarshal_destroy(void *object, void *data, size_t size) uint32_t id; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, "[i]", &id, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&id)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_core_proxy_methods, destroy, 0, id); @@ -374,17 +390,17 @@ static void registry_marshal_global(void *object, uint32_t id, uint32_t parent_i spa_pod_builder_add(b, "[", - "i", id, - "i", parent_id, - "i", permissions, - "I", type, - "i", version, - "i", n_items, NULL); + SPA_POD_Int(id), + SPA_POD_Int(parent_id), + SPA_POD_Int(permissions), + SPA_POD_Id(type), + SPA_POD_Int(version), + 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); @@ -398,7 +414,7 @@ static void registry_marshal_global_remove(void *object, uint32_t id) b = pw_protocol_native_begin_resource(resource, PW_REGISTRY_PROXY_EVENT_GLOBAL_REMOVE); - spa_pod_builder_add_struct(b, "i", id); + spa_pod_builder_add_struct(b, SPA_POD_Int(id)); pw_protocol_native_end_resource(resource, b); } @@ -410,12 +426,11 @@ static int registry_demarshal_bind(void *object, void *data, size_t size) uint32_t id, version, type, new_id; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[" - "i", &id, - "I", &type, - "i", &version, - "i", &new_id, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&id), + SPA_POD_Id(&type), + SPA_POD_Int(&version), + SPA_POD_Int(&new_id)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_registry_proxy_methods, bind, 0, id, type, version, new_id); @@ -429,9 +444,8 @@ static int registry_demarshal_destroy(void *object, void *data, size_t size) uint32_t id; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[" - "i", &id, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&id)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_registry_proxy_methods, destroy, 0, id); @@ -450,17 +464,17 @@ static void module_marshal_info(void *object, const struct pw_module_info *info) spa_pod_builder_add(b, "[", - "i", info->id, - "l", info->change_mask, - "s", info->name, - "s", info->filename, - "s", info->args, - "i", n_items, NULL); + SPA_POD_Int(info->id), + SPA_POD_Long(info->change_mask), + SPA_POD_String(info->name), + SPA_POD_String(info->filename), + SPA_POD_String(info->args), + 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); @@ -478,19 +492,20 @@ static int module_demarshal_info(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "i", &info.id, - "l", &info.change_mask, - "s", &info.name, - "s", &info.filename, - "s", &info.args, - "i", &props.n_items, NULL) < 0) + SPA_POD_Int(&info.id), + SPA_POD_Long(&info.change_mask), + SPA_POD_String(&info.name), + SPA_POD_String(&info.filename), + SPA_POD_String(&info.args), + SPA_POD_Int(&props.n_items), NULL) < 0) return -EINVAL; info.props = &props; 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, "ss", - &props.items[i].key, &props.items[i].value, NULL) < 0) + if (spa_pod_parser_get(&prs, + SPA_POD_String(&props.items[i].key), + SPA_POD_String(&props.items[i].value), NULL) < 0) return -EINVAL; } pw_proxy_notify(proxy, struct pw_module_proxy_events, info, 0, &info); @@ -509,15 +524,15 @@ static void device_marshal_info(void *object, const struct pw_device_info *info) spa_pod_builder_add(b, "[", - "i", info->id, - "s", info->name, - "l", info->change_mask, - "i", n_items, NULL); + SPA_POD_Int(info->id), + SPA_POD_String(info->name), + SPA_POD_Long(info->change_mask), + 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); @@ -535,17 +550,18 @@ static int device_demarshal_info(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "i", &info.id, - "s", &info.name, - "l", &info.change_mask, - "i", &props.n_items, NULL) < 0) + SPA_POD_Int(&info.id), + SPA_POD_String(&info.name), + SPA_POD_Long(&info.change_mask), + SPA_POD_Int(&props.n_items), NULL) < 0) return -EINVAL; info.props = &props; 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, "ss", - &props.items[i].key, &props.items[i].value, NULL) < 0) + if (spa_pod_parser_get(&prs, + SPA_POD_String(&props.items[i].key), + SPA_POD_String(&props.items[i].value), NULL) < 0) return -EINVAL; } pw_proxy_notify(proxy, struct pw_device_proxy_events, info, 0, &info); @@ -560,7 +576,11 @@ static void device_marshal_param(void *object, uint32_t id, uint32_t index, uint b = pw_protocol_native_begin_resource(resource, PW_DEVICE_PROXY_EVENT_PARAM); - spa_pod_builder_add_struct(b, "I", id, "i", index, "i", next, "P", param); + spa_pod_builder_add_struct(b, + SPA_POD_Id(id), + SPA_POD_Int(index), + SPA_POD_Int(next), + SPA_POD_Pod(param)); pw_protocol_native_end_resource(resource, b); } @@ -573,11 +593,11 @@ static int device_demarshal_param(void *object, void *data, size_t size) struct spa_pod *param; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ I", &id, - "i", &index, - "i", &next, - "P", ¶m, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Id(&id), + SPA_POD_Int(&index), + SPA_POD_Int(&next), + SPA_POD_Pod(¶m)) < 0) return -EINVAL; pw_proxy_notify(proxy, struct pw_device_proxy_events, param, 0, id, index, next, param); @@ -593,10 +613,10 @@ static void device_marshal_enum_params(void *object, uint32_t id, uint32_t index b = pw_protocol_native_begin_proxy(proxy, PW_DEVICE_PROXY_METHOD_ENUM_PARAMS); spa_pod_builder_add_struct(b, - "I", id, - "i", index, - "i", num, - "P", filter); + SPA_POD_Id(id), + SPA_POD_Int(index), + SPA_POD_Int(num), + SPA_POD_Pod(filter)); pw_protocol_native_end_proxy(proxy, b); } @@ -609,11 +629,11 @@ static int device_demarshal_enum_params(void *object, void *data, size_t size) struct spa_pod *filter; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ I", &id, - "i", &index, - "i", &num, - "P", &filter, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Id(&id), + SPA_POD_Int(&index), + SPA_POD_Int(&num), + SPA_POD_Pod(&filter)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_device_proxy_methods, enum_params, 0, id, index, num, filter); @@ -629,9 +649,9 @@ static void device_marshal_set_param(void *object, uint32_t id, uint32_t flags, b = pw_protocol_native_begin_proxy(proxy, PW_DEVICE_PROXY_METHOD_SET_PARAM); spa_pod_builder_add_struct(b, - "I", id, - "i", flags, - "P", param); + SPA_POD_Id(id), + SPA_POD_Int(flags), + SPA_POD_Pod(param)); pw_protocol_native_end_proxy(proxy, b); } @@ -643,10 +663,10 @@ static int device_demarshal_set_param(void *object, void *data, size_t size) struct spa_pod *param; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ I", &id, - "i", &flags, - "P", ¶m, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Id(&id), + SPA_POD_Int(&flags), + SPA_POD_Pod(¶m)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_device_proxy_methods, set_param, 0, id, flags, param); @@ -665,17 +685,17 @@ static void factory_marshal_info(void *object, const struct pw_factory_info *inf spa_pod_builder_add(b, "[", - "i", info->id, - "l", info->change_mask, - "s", info->name, - "I", info->type, - "i", info->version, - "i", n_items, NULL); + SPA_POD_Int(info->id), + SPA_POD_Long(info->change_mask), + SPA_POD_String(info->name), + SPA_POD_Id(info->type), + SPA_POD_Int(info->version), + 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); @@ -693,20 +713,20 @@ static int factory_demarshal_info(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "i", &info.id, - "l", &info.change_mask, - "s", &info.name, - "I", &info.type, - "i", &info.version, - "i", &props.n_items, NULL) < 0) + SPA_POD_Int(&info.id), + SPA_POD_Long(&info.change_mask), + SPA_POD_String(&info.name), + SPA_POD_Id(&info.type), + SPA_POD_Int(&info.version), + SPA_POD_Int(&props.n_items), NULL) < 0) return -EINVAL; info.props = &props; 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; } pw_proxy_notify(proxy, struct pw_factory_proxy_events, info, 0, &info); @@ -725,21 +745,21 @@ static void node_marshal_info(void *object, const struct pw_node_info *info) spa_pod_builder_add(b, "[", - "i", info->id, - "l", info->change_mask, - "s", info->name, - "i", info->max_input_ports, - "i", info->n_input_ports, - "i", info->max_output_ports, - "i", info->n_output_ports, - "I", info->state, - "s", info->error, - "i", n_items, NULL); + SPA_POD_Int(info->id), + SPA_POD_Long(info->change_mask), + SPA_POD_String(info->name), + SPA_POD_Int(info->max_input_ports), + SPA_POD_Int(info->n_input_ports), + SPA_POD_Int(info->max_output_ports), + SPA_POD_Int(info->n_output_ports), + SPA_POD_Id(info->state), + SPA_POD_String(info->error), + 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); @@ -757,24 +777,24 @@ static int node_demarshal_info(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "i", &info.id, - "l", &info.change_mask, - "s", &info.name, - "i", &info.max_input_ports, - "i", &info.n_input_ports, - "i", &info.max_output_ports, - "i", &info.n_output_ports, - "I", &info.state, - "s", &info.error, - "i", &props.n_items, NULL) < 0) + SPA_POD_Int(&info.id), + SPA_POD_Long(&info.change_mask), + SPA_POD_String(&info.name), + SPA_POD_Int(&info.max_input_ports), + SPA_POD_Int(&info.n_input_ports), + SPA_POD_Int(&info.max_output_ports), + SPA_POD_Int(&info.n_output_ports), + SPA_POD_Id(&info.state), + SPA_POD_String(&info.error), + SPA_POD_Int(&props.n_items), NULL) < 0) return -EINVAL; info.props = &props; 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; } pw_proxy_notify(proxy, struct pw_node_proxy_events, info, 0, &info); @@ -789,7 +809,11 @@ static void node_marshal_param(void *object, uint32_t id, uint32_t index, uint32 b = pw_protocol_native_begin_resource(resource, PW_NODE_PROXY_EVENT_PARAM); - spa_pod_builder_add_struct(b, "I", id, "i", index, "i", next, "P", param); + spa_pod_builder_add_struct(b, + SPA_POD_Id(id), + SPA_POD_Int(index), + SPA_POD_Int(next), + SPA_POD_Pod(param)); pw_protocol_native_end_resource(resource, b); } @@ -802,11 +826,11 @@ static int node_demarshal_param(void *object, void *data, size_t size) struct spa_pod *param; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ I", &id, - "i", &index, - "i", &next, - "P", ¶m, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Id(&id), + SPA_POD_Int(&index), + SPA_POD_Int(&next), + SPA_POD_Pod(¶m)) < 0) return -EINVAL; pw_proxy_notify(proxy, struct pw_node_proxy_events, param, 0, id, index, next, param); @@ -822,10 +846,10 @@ static void node_marshal_enum_params(void *object, uint32_t id, uint32_t index, b = pw_protocol_native_begin_proxy(proxy, PW_NODE_PROXY_METHOD_ENUM_PARAMS); spa_pod_builder_add_struct(b, - "I", id, - "i", index, - "i", num, - "P", filter); + SPA_POD_Id(id), + SPA_POD_Int(index), + SPA_POD_Int(num), + SPA_POD_Pod(filter)); pw_protocol_native_end_proxy(proxy, b); } @@ -838,11 +862,11 @@ static int node_demarshal_enum_params(void *object, void *data, size_t size) struct spa_pod *filter; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ I", &id, - "i", &index, - "i", &num, - "P", &filter, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Id(&id), + SPA_POD_Int(&index), + SPA_POD_Int(&num), + SPA_POD_Pod(&filter)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_node_proxy_methods, enum_params, 0, id, index, num, filter); @@ -858,9 +882,9 @@ static void node_marshal_set_param(void *object, uint32_t id, uint32_t flags, b = pw_protocol_native_begin_proxy(proxy, PW_NODE_PROXY_METHOD_SET_PARAM); spa_pod_builder_add_struct(b, - "I", id, - "i", flags, - "P", param); + SPA_POD_Id(id), + SPA_POD_Int(flags), + SPA_POD_Pod(param)); pw_protocol_native_end_proxy(proxy, b); } @@ -872,10 +896,10 @@ static int node_demarshal_set_param(void *object, void *data, size_t size) struct spa_pod *param; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ I", &id, - "i", &flags, - "P", ¶m, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Id(&id), + SPA_POD_Int(&flags), + SPA_POD_Pod(¶m)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_node_proxy_methods, set_param, 0, id, flags, param); @@ -888,7 +912,8 @@ static void node_marshal_send_command(void *object, const struct spa_command *co struct spa_pod_builder *b; b = pw_protocol_native_begin_proxy(proxy, PW_NODE_PROXY_METHOD_SEND_COMMAND); - spa_pod_builder_add_struct(b, "P", command); + spa_pod_builder_add_struct(b, + SPA_POD_Pod(command)); pw_protocol_native_end_proxy(proxy, b); } @@ -899,8 +924,8 @@ static int node_demarshal_send_command(void *object, void *data, size_t size) struct spa_command *command; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ P", &command, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Pod(&command)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_node_proxy_methods, send_command, 0, command); @@ -919,15 +944,15 @@ static void port_marshal_info(void *object, const struct pw_port_info *info) spa_pod_builder_add(b, "[", - "i", info->id, - "i", info->direction, - "l", info->change_mask, - "i", n_items, NULL); + SPA_POD_Int(info->id), + SPA_POD_Int(info->direction), + SPA_POD_Long(info->change_mask), + 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); @@ -945,18 +970,18 @@ static int port_demarshal_info(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "i", &info.id, - "i", &info.direction, - "l", &info.change_mask, - "i", &props.n_items, NULL) < 0) + SPA_POD_Int(&info.id), + SPA_POD_Int(&info.direction), + SPA_POD_Long(&info.change_mask), + SPA_POD_Int(&props.n_items), NULL) < 0) return -EINVAL; info.props = &props; 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; } pw_proxy_notify(proxy, struct pw_port_proxy_events, info, 0, &info); @@ -971,7 +996,11 @@ static void port_marshal_param(void *object, uint32_t id, uint32_t index, uint32 b = pw_protocol_native_begin_resource(resource, PW_PORT_PROXY_EVENT_PARAM); - spa_pod_builder_add_struct(b, "I", id, "i", index, "i", next, "P", param); + spa_pod_builder_add_struct(b, + SPA_POD_Id(id), + SPA_POD_Int(index), + SPA_POD_Int(next), + SPA_POD_Pod(param)); pw_protocol_native_end_resource(resource, b); } @@ -984,11 +1013,11 @@ static int port_demarshal_param(void *object, void *data, size_t size) struct spa_pod *param; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ I", &id, - "i", &index, - "i", &next, - "P", ¶m, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Id(&id), + SPA_POD_Int(&index), + SPA_POD_Int(&next), + SPA_POD_Pod(¶m)) < 0) return -EINVAL; pw_proxy_notify(proxy, struct pw_port_proxy_events, param, 0, id, index, next, param); @@ -1004,10 +1033,10 @@ static void port_marshal_enum_params(void *object, uint32_t id, uint32_t index, b = pw_protocol_native_begin_proxy(proxy, PW_PORT_PROXY_METHOD_ENUM_PARAMS); spa_pod_builder_add_struct(b, - "I", id, - "i", index, - "i", num, - "P", filter); + SPA_POD_Id(id), + SPA_POD_Int(index), + SPA_POD_Int(num), + SPA_POD_Pod(filter)); pw_protocol_native_end_proxy(proxy, b); } @@ -1020,11 +1049,11 @@ static int port_demarshal_enum_params(void *object, void *data, size_t size) struct spa_pod *filter; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ I", &id, - "i", &index, - "i", &num, - "P", &filter, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Id(&id), + SPA_POD_Int(&index), + SPA_POD_Int(&num), + SPA_POD_Pod(&filter)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_port_proxy_methods, enum_params, 0, id, index, num, filter); @@ -1043,14 +1072,14 @@ static void client_marshal_info(void *object, const struct pw_client_info *info) spa_pod_builder_add(b, "[", - "i", info->id, - "l", info->change_mask, - "i", n_items, NULL); + SPA_POD_Int(info->id), + SPA_POD_Long(info->change_mask), + 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); @@ -1068,17 +1097,17 @@ static int client_demarshal_info(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "i", &info.id, - "l", &info.change_mask, - "i", &props.n_items, NULL) < 0) + SPA_POD_Int(&info.id), + SPA_POD_Long(&info.change_mask), + SPA_POD_Int(&props.n_items), NULL) < 0) return -EINVAL; info.props = &props; 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; } pw_proxy_notify(proxy, struct pw_client_proxy_events, info, 0, &info); @@ -1100,15 +1129,16 @@ static void client_marshal_permissions(void *object, uint32_t index, uint32_t n_ } spa_pod_builder_add(b, - "[ i", index, - "i", n, NULL); + "[", + SPA_POD_Int(index), + SPA_POD_Int(n), NULL); for (i = 0; i < n_permissions; i++) { if (permissions[i].permissions == SPA_ID_INVALID) continue; spa_pod_builder_add(b, - "i", permissions[i].id, - "i", permissions[i].permissions, NULL); + SPA_POD_Int(permissions[i].id), + SPA_POD_Int(permissions[i].permissions), NULL); } spa_pod_builder_add(b, "]", NULL); @@ -1123,16 +1153,16 @@ static int client_demarshal_permissions(void *object, void *data, size_t size) uint32_t i, index, n_permissions; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, "[ i", &index, - "i", &n_permissions, NULL) < 0) + if (spa_pod_parser_get(&prs, "[", + SPA_POD_Int(&index), + SPA_POD_Int(&n_permissions), NULL) < 0) return -EINVAL; permissions = alloca(n_permissions * sizeof(struct pw_permission)); for (i = 0; i < n_permissions; i++) { if (spa_pod_parser_get(&prs, - "i", &permissions[i].id, - "i", &permissions[i].permissions, - NULL) < 0) + SPA_POD_Int(&permissions[i].id), + SPA_POD_Int(&permissions[i].permissions), NULL) < 0) return -EINVAL; } pw_proxy_notify(proxy, struct pw_client_proxy_events, permissions, 0, index, n_permissions, permissions); @@ -1146,9 +1176,9 @@ static void client_marshal_error(void *object, uint32_t id, int res, const char b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_PROXY_METHOD_ERROR); spa_pod_builder_add_struct(b, - "i", id, - "i", res, - "s", error); + SPA_POD_Int(id), + SPA_POD_Int(res), + SPA_POD_String(error)); pw_protocol_native_end_proxy(proxy, b); } @@ -1160,10 +1190,10 @@ static int client_demarshal_error(void *object, void *data, size_t size) const char *error; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[ i", &id, - "i", &res, - "s", &error, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&id), + SPA_POD_Int(&res), + SPA_POD_String(&error)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_client_proxy_methods, error, 0, id, res, error); @@ -1178,8 +1208,8 @@ static void client_marshal_get_permissions(void *object, uint32_t index, uint32_ b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_PROXY_METHOD_GET_PERMISSIONS); spa_pod_builder_add_struct(b, - "i", index, - "i", num); + SPA_POD_Int(index), + SPA_POD_Int(num)); pw_protocol_native_end_proxy(proxy, b); } @@ -1194,12 +1224,13 @@ static void client_marshal_update_properties(void *object, const struct spa_dict 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); @@ -1214,15 +1245,16 @@ static int client_demarshal_update_properties(void *object, void *data, size_t s uint32_t i; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, "[ i", &props.n_items, NULL) < 0) + if (spa_pod_parser_get(&prs, + "[", + 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; } pw_resource_do(resource, struct pw_client_proxy_methods, update_properties, 0, @@ -1237,9 +1269,9 @@ static int client_demarshal_get_permissions(void *object, void *data, size_t siz uint32_t index, num; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, - "[i", &index, - "i", &num, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&index), + SPA_POD_Int(&num)) < 0) return -EINVAL; pw_resource_do(resource, struct pw_client_proxy_methods, get_permissions, 0, index, num); @@ -1255,12 +1287,13 @@ static void client_marshal_update_permissions(void *object, uint32_t n_permissio b = pw_protocol_native_begin_proxy(proxy, PW_CLIENT_PROXY_METHOD_UPDATE_PERMISSIONS); - spa_pod_builder_add(b, "[ i", n_permissions, NULL); + spa_pod_builder_add(b, "[", + SPA_POD_Int(n_permissions), NULL); for (i = 0; i < n_permissions; i++) { spa_pod_builder_add(b, - "i", permissions[i].id, - "i", permissions[i].permissions, NULL); + SPA_POD_Int(permissions[i].id), + SPA_POD_Int(permissions[i].permissions), NULL); } spa_pod_builder_add(b, "]", NULL); @@ -1275,15 +1308,16 @@ static int client_demarshal_update_permissions(void *object, void *data, size_t uint32_t i, n_permissions; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, "[ i", &n_permissions, NULL) < 0) + if (spa_pod_parser_get(&prs, + "[", + SPA_POD_Int(&n_permissions), NULL) < 0) return -EINVAL; permissions = alloca(n_permissions * sizeof(struct pw_permission)); for (i = 0; i < n_permissions; i++) { if (spa_pod_parser_get(&prs, - "i", &permissions[i].id, - "i", &permissions[i].permissions, - NULL) < 0) + SPA_POD_Int(&permissions[i].id), + SPA_POD_Int(&permissions[i].permissions), NULL) < 0) return -EINVAL; } pw_resource_do(resource, struct pw_client_proxy_methods, update_permissions, 0, @@ -1303,21 +1337,21 @@ static void link_marshal_info(void *object, const struct pw_link_info *info) spa_pod_builder_add(b, "[", - "i", info->id, - "l", info->change_mask, - "i", info->output_node_id, - "i", info->output_port_id, - "i", info->input_node_id, - "i", info->input_port_id, - "i", info->state, - "s", info->error, - "P", info->format, - "i", n_items, NULL); + SPA_POD_Int(info->id), + SPA_POD_Long(info->change_mask), + SPA_POD_Int(info->output_node_id), + SPA_POD_Int(info->output_port_id), + SPA_POD_Int(info->input_node_id), + SPA_POD_Int(info->input_port_id), + SPA_POD_Int(info->state), + SPA_POD_String(info->error), + SPA_POD_Pod(info->format), + 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); @@ -1335,24 +1369,24 @@ static int link_demarshal_info(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "i", &info.id, - "l", &info.change_mask, - "i", &info.output_node_id, - "i", &info.output_port_id, - "i", &info.input_node_id, - "i", &info.input_port_id, - "i", &info.state, - "s", &info.error, - "P", &info.format, - "i", &props.n_items, NULL) < 0) + SPA_POD_Int(&info.id), + SPA_POD_Long(&info.change_mask), + SPA_POD_Int(&info.output_node_id), + SPA_POD_Int(&info.output_port_id), + SPA_POD_Int(&info.input_node_id), + SPA_POD_Int(&info.input_port_id), + SPA_POD_Int(&info.state), + SPA_POD_String(&info.error), + SPA_POD_Pod(&info.format), + SPA_POD_Int(&props.n_items), NULL) < 0) return -EINVAL; info.props = &props; 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; } pw_proxy_notify(proxy, struct pw_link_proxy_events, info, 0, &info); @@ -1369,19 +1403,19 @@ static int registry_demarshal_global(void *object, void *data, size_t size) spa_pod_parser_init(&prs, data, size, 0); if (spa_pod_parser_get(&prs, "[" - "i", &id, - "i", &parent_id, - "i", &permissions, - "I", &type, - "i", &version, - "i", &props.n_items, NULL) < 0) + SPA_POD_Int(&id), + SPA_POD_Int(&parent_id), + SPA_POD_Int(&permissions), + SPA_POD_Id(&type), + SPA_POD_Int(&version), + 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; } @@ -1398,7 +1432,8 @@ static int registry_demarshal_global_remove(void *object, void *data, size_t siz uint32_t id; spa_pod_parser_init(&prs, data, size, 0); - if (spa_pod_parser_get(&prs, "[ i", &id, NULL) < 0) + if (spa_pod_parser_get_struct(&prs, + SPA_POD_Int(&id)) < 0) return -EINVAL; pw_proxy_notify(proxy, struct pw_registry_proxy_events, global_remove, 0, id); @@ -1414,10 +1449,10 @@ static void registry_marshal_bind(void *object, uint32_t id, b = pw_protocol_native_begin_proxy(proxy, PW_REGISTRY_PROXY_METHOD_BIND); spa_pod_builder_add_struct(b, - "i", id, - "I", type, - "i", version, - "i", new_id); + SPA_POD_Int(id), + SPA_POD_Id(type), + SPA_POD_Int(version), + SPA_POD_Int(new_id)); pw_protocol_native_end_proxy(proxy, b); } @@ -1429,7 +1464,7 @@ static void registry_marshal_destroy(void *object, uint32_t id) b = pw_protocol_native_begin_proxy(proxy, PW_REGISTRY_PROXY_METHOD_DESTROY); spa_pod_builder_add_struct(b, - "i", id); + SPA_POD_Int(id)); pw_protocol_native_end_proxy(proxy, b); } diff --git a/src/modules/spa/spa-monitor.c b/src/modules/spa/spa-monitor.c index 378d01c28..136824ad6 100644 --- a/src/modules/spa/spa-monitor.c +++ b/src/modules/spa/spa-monitor.c @@ -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); diff --git a/src/pipewire/link.c b/src/pipewire/link.c index 2fe840dea..b52f7b9f6 100644 --- a/src/pipewire/link.c +++ b/src/pipewire/link.c @@ -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, diff --git a/src/pipewire/port.c b/src/pipewire/port.c index cd3aaa6dd..590a2effa 100644 --- a/src/pipewire/port.c +++ b/src/pipewire/port.c @@ -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) { diff --git a/src/pipewire/remote.c b/src/pipewire/remote.c index 377794f08..b04c9a5c0 100644 --- a/src/pipewire/remote.c +++ b/src/pipewire/remote.c @@ -757,8 +757,9 @@ static void add_port_update(struct pw_proxy *proxy, struct pw_port *port, uint32 NULL, ¶m, &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); diff --git a/src/pipewire/stream.c b/src/pipewire/stream.c index c68549de6..00a2284c7 100644 --- a/src/pipewire/stream.c +++ b/src/pipewire/stream.c @@ -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