pipewire/spa/include/spa/pod/parser.h

/* Spa */
/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
/* SPDX-License-Identifier: MIT */

#ifndef SPA_POD_PARSER_H
#define SPA_POD_PARSER_H

#include <errno.h>
#include <stdarg.h>

#include <spa/pod/body.h>
#include <spa/pod/vararg.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifndef SPA_API_POD_PARSER
 #ifdef SPA_API_IMPL
  #define SPA_API_POD_PARSER SPA_API_IMPL
 #else
  #define SPA_API_POD_PARSER static inline
 #endif
#endif

/**
 * \addtogroup spa_pod
 * \{
 */

struct spa_pod_parser_state {
	uint32_t offset;
	uint32_t flags;
	struct spa_pod_frame *frame;
};

struct spa_pod_parser {
	const void *data;
	uint32_t size;
	uint32_t _padding;
	struct spa_pod_parser_state state;
};

#define SPA_POD_PARSER_INIT(buffer,size)  ((struct spa_pod_parser){ (buffer), (size), 0, {0,0,NULL}})

SPA_API_POD_PARSER void spa_pod_parser_init(struct spa_pod_parser *parser,
				       const void *data, uint32_t size)
{
	*parser = SPA_POD_PARSER_INIT(data, size);
}

SPA_API_POD_PARSER void spa_pod_parser_pod(struct spa_pod_parser *parser,
				      const struct spa_pod *pod)
{
	spa_pod_parser_init(parser, pod, SPA_POD_SIZE(pod));
}

SPA_API_POD_PARSER void spa_pod_parser_init_pod_body(struct spa_pod_parser *parser,
	      const struct spa_pod *pod, const void *body)
{
	spa_pod_parser_init(parser,
			SPA_PTROFF(body, -sizeof(struct spa_pod), const struct spa_pod),
			pod->size + sizeof(struct spa_pod));
}
SPA_API_POD_PARSER void spa_pod_parser_init_from_data(struct spa_pod_parser *parser,
		const void *data, uint32_t maxsize, uint32_t offset, uint32_t size)
{
	size_t offs, sz;
	offs = SPA_MIN(offset, maxsize);
	sz = SPA_MIN(maxsize - offs, size);
	spa_pod_parser_init(parser, SPA_PTROFF(data, offs, void), sz);
}

SPA_API_POD_PARSER void
spa_pod_parser_get_state(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
{
	*state = parser->state;
}

SPA_API_POD_PARSER void
spa_pod_parser_reset(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
{
	parser->state = *state;
}

SPA_API_POD_PARSER int
spa_pod_parser_read_header(struct spa_pod_parser *parser, uint32_t offset, uint32_t size,
		void *header, uint32_t header_size, uint32_t pod_offset, const void **body)
{
	/* Cast to uint64_t to avoid wraparound. */
	const uint64_t long_offset = (uint64_t)offset + header_size;
	if (long_offset <= size && (offset & 7) == 0) {
		/* a barrier around the memcpy to make sure it is not moved around or
		 * duplicated after the size check below. We need to to work on shared
		 * memory while there could be updates happening while we read. */
		SPA_BARRIER;
		memcpy(header, SPA_PTROFF(parser->data, offset, void), header_size);
		SPA_BARRIER;
		struct spa_pod *pod = SPA_PTROFF(header, pod_offset, struct spa_pod);
		/* Check that the size (rounded to the next multiple of 8) is in bounds. */
		if (long_offset + SPA_ROUND_UP_N((uint64_t)pod->size, SPA_POD_ALIGN) <= size) {
			*body = SPA_PTROFF(parser->data, long_offset, void);
			return 0;
		}
	}
	return -EPIPE;
}

SPA_API_POD_PARSER struct spa_pod *
spa_pod_parser_deref(struct spa_pod_parser *parser, uint32_t offset, uint32_t size)
{
	struct spa_pod pod;
	const void *body;
	if (spa_pod_parser_read_header(parser, offset, size, &pod, sizeof(pod), 0, &body) < 0)
		return NULL;
	return SPA_PTROFF(body, -sizeof(pod), struct spa_pod);
}

SPA_API_POD_PARSER struct spa_pod *spa_pod_parser_frame(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
{
	return SPA_PTROFF(parser->data, frame->offset, struct spa_pod);
}

SPA_API_POD_PARSER void spa_pod_parser_push(struct spa_pod_parser *parser,
		      struct spa_pod_frame *frame, const struct spa_pod *pod, uint32_t offset)
{
	frame->pod = *pod;
	frame->offset = offset;
	frame->parent = parser->state.frame;
	frame->flags = parser->state.flags;
	parser->state.frame = frame;
}

SPA_API_POD_PARSER int spa_pod_parser_get_header(struct spa_pod_parser *parser,
		void *header, uint32_t header_size, uint32_t pod_offset, const void **body)
{
	struct spa_pod_frame *f = parser->state.frame;
	uint32_t size = f ? f->offset + SPA_POD_SIZE(&f->pod) : parser->size;
	return spa_pod_parser_read_header(parser, parser->state.offset, size,
			header, header_size, pod_offset, body);
}

SPA_API_POD_PARSER int spa_pod_parser_current_body(struct spa_pod_parser *parser,
		struct spa_pod *pod, const void **body)
{
	return spa_pod_parser_get_header(parser, pod, sizeof(struct spa_pod), 0, body);
}

SPA_API_POD_PARSER struct spa_pod *spa_pod_parser_current(struct spa_pod_parser *parser)
{
	struct spa_pod pod;
	const void *body;
	if (spa_pod_parser_current_body(parser, &pod, &body) < 0)
		return NULL;
	return SPA_PTROFF(body, -sizeof(struct spa_pod), struct spa_pod);
}

SPA_API_POD_PARSER void spa_pod_parser_advance(struct spa_pod_parser *parser, const struct spa_pod *pod)
{
	parser->state.offset += SPA_ROUND_UP_N(SPA_POD_SIZE(pod), SPA_POD_ALIGN);
}

SPA_API_POD_PARSER int spa_pod_parser_next_body(struct spa_pod_parser *parser,
		struct spa_pod *pod, const void **body)
{
	if (spa_pod_parser_current_body(parser, pod, body) < 0)
		return -EINVAL;
	spa_pod_parser_advance(parser, pod);
	return 0;
}

SPA_API_POD_PARSER struct spa_pod *spa_pod_parser_next(struct spa_pod_parser *parser)
{
	struct spa_pod pod;
	const void *body;
	if (spa_pod_parser_current_body(parser, &pod, &body) < 0)
		return NULL;
	spa_pod_parser_advance(parser, &pod);
	return SPA_PTROFF(body, -sizeof(struct spa_pod), struct spa_pod);
}

SPA_API_POD_PARSER void spa_pod_parser_restart(struct spa_pod_parser *parser,
		      struct spa_pod_frame *frame)
{
	parser->state.offset = frame->offset;
}

SPA_API_POD_PARSER void spa_pod_parser_unpush(struct spa_pod_parser *parser,
		      struct spa_pod_frame *frame)
{
	spa_pod_parser_restart(parser, frame);
	parser->state.frame = frame->parent;
}

SPA_API_POD_PARSER void spa_pod_parser_pop(struct spa_pod_parser *parser,
		      struct spa_pod_frame *frame)
{
	spa_pod_parser_unpush(parser, frame);
	spa_pod_parser_advance(parser, &frame->pod);
}

SPA_API_POD_PARSER int spa_pod_parser_get_bool(struct spa_pod_parser *parser, bool *value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_bool(&pod))
		return -EINVAL;
	spa_pod_body_get_bool(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_id(struct spa_pod_parser *parser, uint32_t *value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_id(&pod))
		return -EINVAL;
	spa_pod_body_get_id(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_int(struct spa_pod_parser *parser, int32_t *value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_int(&pod))
		return -EINVAL;
	spa_pod_body_get_int(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_long(struct spa_pod_parser *parser, int64_t *value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_long(&pod))
		return -EINVAL;
	spa_pod_body_get_long(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_float(struct spa_pod_parser *parser, float *value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_float(&pod))
		return -EINVAL;
	spa_pod_body_get_float(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_double(struct spa_pod_parser *parser, double *value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_double(&pod))
		return -EINVAL;
	spa_pod_body_get_double(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_string(struct spa_pod_parser *parser, const char **value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_string(&pod))
		return -EINVAL;
	spa_pod_body_get_string(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_bytes(struct spa_pod_parser *parser, const void **value, uint32_t *len)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_bytes(&pod))
		return -EINVAL;
	spa_pod_body_get_bytes(&pod, body, value, len);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_pointer(struct spa_pod_parser *parser, uint32_t *type, const void **value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_pointer(&pod))
		return -EINVAL;
	spa_pod_body_get_pointer(&pod, body, type, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_fd(struct spa_pod_parser *parser, int64_t *value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_fd(&pod))
		return -EINVAL;
	spa_pod_body_get_fd(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_rectangle(struct spa_pod_parser *parser, struct spa_rectangle *value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_rectangle(&pod))
		return -EINVAL;
	spa_pod_body_get_rectangle(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_fraction(struct spa_pod_parser *parser, struct spa_fraction *value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_fraction(&pod))
		return -EINVAL;
	spa_pod_body_get_fraction(&pod, body, value);
	spa_pod_parser_advance(parser, &pod);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_get_pod_body(struct spa_pod_parser *parser,
		struct spa_pod *value, const void **body)
{
	int res;
	if ((res = spa_pod_parser_current_body(parser, value, body)) < 0)
		return res;
	spa_pod_parser_advance(parser, value);
	return 0;
}

SPA_API_POD_PARSER int spa_pod_parser_get_pod(struct spa_pod_parser *parser, struct spa_pod **value)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_get_pod_body(parser, &pod, &body)) < 0)
		return res;
	*value = SPA_PTROFF(body, -sizeof(struct spa_pod), struct spa_pod);
	return 0;
}

SPA_API_POD_PARSER int spa_pod_parser_init_struct_body(struct spa_pod_parser *parser,
		struct spa_pod_frame *frame, const struct spa_pod *pod, const void *body)
{
	if (!spa_pod_is_struct(pod))
		return -EINVAL;
	spa_pod_parser_init_pod_body(parser, pod, body);
	spa_pod_parser_push(parser, frame, pod, parser->state.offset);
	parser->state.offset += sizeof(struct spa_pod_struct);
	return 0;
}

SPA_API_POD_PARSER int spa_pod_parser_push_struct_body(struct spa_pod_parser *parser,
		struct spa_pod_frame *frame, struct spa_pod *str, const void **str_body)
{
	int res;
	if ((res = spa_pod_parser_current_body(parser, str, str_body)) < 0)
		return res;
	if (!spa_pod_is_struct(str))
		return -EINVAL;
	spa_pod_parser_push(parser, frame, str, parser->state.offset);
	parser->state.offset += sizeof(struct spa_pod_struct);
	return 0;
}
SPA_API_POD_PARSER int spa_pod_parser_push_struct(struct spa_pod_parser *parser,
		struct spa_pod_frame *frame)
{
	struct spa_pod pod;
	const void *body;
	return spa_pod_parser_push_struct_body(parser, frame, &pod, &body);
}

SPA_API_POD_PARSER int spa_pod_parser_init_object_body(struct spa_pod_parser *parser,
		struct spa_pod_frame *frame, const struct spa_pod *pod, const void *body,
		struct spa_pod_object *object, const void **object_body)
{
	if (!spa_pod_is_object(pod))
		return -EINVAL;
	spa_pod_parser_init_pod_body(parser, pod, body);
	spa_pod_body_get_object(pod, body, object, object_body);
	spa_pod_parser_push(parser, frame, pod, parser->state.offset);
	parser->state.offset += sizeof(struct spa_pod_object);
	return 0;
}

SPA_API_POD_PARSER int spa_pod_parser_push_object_body(struct spa_pod_parser *parser,
		struct spa_pod_frame *frame, struct spa_pod_object *object, const void **object_body)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_object(&pod))
		return -EINVAL;
	spa_pod_body_get_object(&pod, body, object, object_body);
	spa_pod_parser_push(parser, frame, &pod, parser->state.offset);
	parser->state.offset += sizeof(struct spa_pod_object);
	return 0;
}
SPA_API_POD_PARSER int spa_pod_parser_push_object(struct spa_pod_parser *parser,
		struct spa_pod_frame *frame, uint32_t type, uint32_t *id)
{
	int res;
	struct spa_pod_object obj;
	const void *obj_body;
	if ((res = spa_pod_parser_push_object_body(parser, frame, &obj, &obj_body)) < 0)
		return res;
	if (type != obj.body.type) {
		spa_pod_parser_unpush(parser, frame);
		return -EPROTO;
	}
	if (id != NULL)
		*id = obj.body.id;
	return 0;
}
SPA_API_POD_PARSER int spa_pod_parser_get_prop_body(struct spa_pod_parser *parser,
		struct spa_pod_prop *prop, const void **body)
{
	int res;
	if ((res = spa_pod_parser_get_header(parser, prop,
			sizeof(struct spa_pod_prop),
			offsetof(struct spa_pod_prop, value), body)) >= 0)
		parser->state.offset += SPA_ROUND_UP_N(SPA_POD_PROP_SIZE(prop), SPA_POD_ALIGN);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_push_sequence_body(struct spa_pod_parser *parser,
		struct spa_pod_frame *frame, struct spa_pod_sequence *seq, const void **seq_body)
{
	int res;
	struct spa_pod pod;
	const void *body;
	if ((res = spa_pod_parser_current_body(parser, &pod, &body)) < 0)
		return res;
	if (!spa_pod_is_sequence(&pod))
		return -EINVAL;
	spa_pod_body_get_sequence(&pod, body, seq, seq_body);
	spa_pod_parser_push(parser, frame, &pod, parser->state.offset);
	parser->state.offset += sizeof(struct spa_pod_sequence);
	return 0;
}

SPA_API_POD_PARSER int spa_pod_parser_get_control_body(struct spa_pod_parser *parser,
		struct spa_pod_control *control, const void **body)
{
	int res;
	if ((res = spa_pod_parser_get_header(parser, control,
			sizeof(struct spa_pod_control),
			offsetof(struct spa_pod_control, value), body)) >= 0)
		parser->state.offset += SPA_ROUND_UP_N(SPA_POD_CONTROL_SIZE(control), SPA_POD_ALIGN);
	return res;
}

SPA_API_POD_PARSER int spa_pod_parser_object_find_prop(struct spa_pod_parser *parser,
		uint32_t key, struct spa_pod_prop *prop, const void **body)
{
	uint32_t start_offset;
	struct spa_pod_frame *f = parser->state.frame;

	if (f == NULL || f->pod.type != SPA_TYPE_Object)
		return -EINVAL;

	start_offset = f->offset;
	while (spa_pod_parser_get_prop_body(parser, prop, body) >= 0) {
		if (prop->key == key)
			return 0;
	}
	spa_pod_parser_restart(parser, f);
	parser->state.offset += sizeof(struct spa_pod_object);
	while (parser->state.offset != start_offset &&
	       spa_pod_parser_get_prop_body(parser, prop, body) >= 0) {
		if (prop->key == key)
			return 0;
	}
	return -ENOENT;
}

SPA_API_POD_PARSER bool spa_pod_parser_body_can_collect(const struct spa_pod *pod, const void *body, char type)
{
	struct spa_pod_choice choice;

	if (pod == NULL)
		return false;

	if (pod->type == SPA_TYPE_Choice) {
		if (!spa_pod_is_choice(pod))
			return false;
		if (type == 'V')
			return true;
		spa_pod_body_get_choice(pod, body, &choice, &body);
		if (choice.body.type != SPA_CHOICE_None)
			return false;
		pod = &choice.body.child;
	}

	switch (type) {
	case 'P':
	case 'Q':
		return true;
	case 'b':
		return spa_pod_is_bool(pod);
	case 'I':
		return spa_pod_is_id(pod);
	case 'i':
		return spa_pod_is_int(pod);
	case 'l':
		return spa_pod_is_long(pod);
	case 'f':
		return spa_pod_is_float(pod);
	case 'd':
		return spa_pod_is_double(pod);
	case 's':
		return spa_pod_is_string(pod) || spa_pod_is_none(pod);
	case 'S':
		return spa_pod_is_string(pod);
	case 'y':
		return spa_pod_is_bytes(pod);
	case 'R':
		return spa_pod_is_rectangle(pod);
	case 'F':
		return spa_pod_is_fraction(pod);
	case 'B':
		return spa_pod_is_bitmap(pod);
	case 'a':
		return spa_pod_is_array(pod);
	case 'p':
		return spa_pod_is_pointer(pod);
	case 'h':
		return spa_pod_is_fd(pod);
	case 'T':
	case 'U':
		return spa_pod_is_struct(pod) || spa_pod_is_none(pod);
	case 'N':
	case 'O':
		return spa_pod_is_object(pod) || spa_pod_is_none(pod);
	case 'V':
	case 'W':
	default:
		return false;
	}
}
SPA_API_POD_PARSER bool spa_pod_parser_can_collect(const struct spa_pod *pod, char type)
{
	return spa_pod_parser_body_can_collect(pod, SPA_POD_BODY_CONST(pod), type);
}

#define SPA_POD_PARSER_COLLECT_BODY(pod,body,_type,args)				\
do {											\
	switch (_type) {								\
	case 'b':									\
		spa_pod_body_get_bool(pod, body, va_arg(args, bool*));			\
		break;									\
	case 'I':									\
		spa_pod_body_get_id(pod, body, va_arg(args, uint32_t*));		\
		break;									\
	case 'i':									\
		spa_pod_body_get_int(pod, body, va_arg(args, int32_t*));		\
		break;									\
	case 'l':									\
		spa_pod_body_get_long(pod, body, va_arg(args, int64_t*));		\
		break;									\
	case 'f':									\
		spa_pod_body_get_float(pod, body, va_arg(args, float*));		\
		break;									\
	case 'd':									\
		spa_pod_body_get_double(pod, body, va_arg(args, double*));		\
		break;									\
	case 's':									\
	{										\
		const char **dest = va_arg(args, const char**);				\
		if ((pod)->type == SPA_TYPE_None)					\
			*dest = NULL;							\
		else									\
			spa_pod_body_get_string(pod, body, dest);			\
		break;									\
	}										\
	case 'S':									\
	{										\
		char *dest = va_arg(args, char*);					\
		uint32_t maxlen = va_arg(args, uint32_t);				\
		spa_pod_body_copy_string(pod, body, dest, maxlen);			\
		break;									\
	}										\
	case 'y':									\
	{										\
		const void **value = va_arg(args, const void**);			\
		uint32_t *len = va_arg(args, uint32_t*);				\
		spa_pod_body_get_bytes(pod, body, value, len);				\
		break;									\
	}										\
	case 'R':									\
		spa_pod_body_get_rectangle(pod, body,					\
				va_arg(args, struct spa_rectangle*));			\
		break;									\
	case 'F':									\
		spa_pod_body_get_fraction(pod, body,					\
				va_arg(args, struct spa_fraction*));			\
		break;									\
	case 'B':									\
		spa_pod_body_get_bitmap(pod, body, va_arg(args, const uint8_t**));	\
		break;									\
	case 'a':									\
	{										\
		struct spa_pod_array arr; 						\
		uint32_t *val_size = va_arg(args, uint32_t*);				\
		uint32_t *val_type = va_arg(args, uint32_t*);				\
		uint32_t *n_values = va_arg(args, uint32_t*);				\
		const void **arr_body = va_arg(args, const void**);			\
		spa_pod_body_get_array(pod, body, &arr, arr_body);			\
		spa_pod_array_body_get_values(&arr, *arr_body,				\
				n_values, val_size, val_type);				\
		break;									\
	}										\
	case 'p':									\
	{										\
		uint32_t *type = va_arg(args, uint32_t*);				\
		const void **value = va_arg(args, const void**);			\
		spa_pod_body_get_pointer(pod, body, type, value);			\
		break;									\
	}										\
	case 'h':									\
		spa_pod_body_get_fd(pod, body, va_arg(args, int64_t*));			\
		break;									\
	case 'P':									\
	case 'T':									\
	case 'O':									\
	case 'V':									\
	{										\
		const struct spa_pod **d = va_arg(args, const struct spa_pod**);	\
		if (d)									\
			*d = ((pod)->type == SPA_TYPE_None) ?				\
			NULL : SPA_PTROFF((body), -sizeof(struct spa_pod), const struct spa_pod);	\
		break;									\
	}										\
	case 'Q':									\
	case 'U':									\
	case 'N':									\
	case 'W':									\
	{										\
		struct spa_pod *p = va_arg(args, struct spa_pod*);			\
		const void **v = va_arg(args, const void **);				\
		*p = *pod;								\
		*v = body;								\
		break;									\
	}										\
	default:									\
		break;									\
	}										\
} while(false)

#define SPA_POD_PARSER_COLLECT(pod,_type,args)						\
	SPA_POD_PARSER_COLLECT_BODY(pod, SPA_POD_BODY_CONST(pod),_type,args)

#define SPA_POD_PARSER_SKIP(_type,args)							\
do {											\
	switch (_type) {								\
	case 'S':									\
		va_arg(args, char*);							\
		va_arg(args, uint32_t);							\
		break;									\
	case 'a':									\
		va_arg(args, void*);							\
		va_arg(args, void*);							\
		SPA_FALLTHROUGH 							\
	case 'p':									\
	case 'y':									\
		va_arg(args, void*);							\
		SPA_FALLTHROUGH 							\
	case 'b':									\
	case 'I':									\
	case 'i':									\
	case 'l':									\
	case 'f':									\
	case 'd':									\
	case 's':									\
	case 'R':									\
	case 'F':									\
	case 'B':									\
	case 'h':									\
	case 'V':									\
	case 'P':									\
	case 'T':									\
	case 'O':									\
		va_arg(args, void*);							\
		break;									\
	}										\
} while(false)

SPA_API_POD_PARSER int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args)
{
	struct spa_pod_frame *f = parser->state.frame;
	int count = 0;

	if (f == NULL)
		return -EINVAL;

	do {
		bool optional, have_pod = false;
		struct spa_pod pod;
		const void *body = NULL;
		const char *format;
		struct spa_pod_prop prop;

		if (f->pod.type == SPA_TYPE_Object) {
			uint32_t key = va_arg(args, uint32_t);

			if (key == 0)
				break;

			if (spa_pod_parser_object_find_prop(parser, key, &prop, &body) >= 0) {
				pod = prop.value;
				have_pod = true;
			}
		}

		if ((format = va_arg(args, char *)) == NULL)
			break;

		if (f->pod.type == SPA_TYPE_Struct)
			if (spa_pod_parser_next_body(parser, &pod, &body) >= 0)
				have_pod = true;

		if ((optional = (*format == '?')))
			format++;

		if (!have_pod || !spa_pod_parser_body_can_collect(&pod, body, *format)) {
			if (!optional) {
				if (!have_pod)
					return -ESRCH;
				else
					return -EPROTO;
			}
			SPA_POD_PARSER_SKIP(*format, args);
		} else {
			struct spa_pod_choice choice;

			if (pod.type == SPA_TYPE_Choice && *format != 'V') {
				spa_pod_body_get_choice(&pod, body, &choice, &body);
				pod = choice.body.child;
			}

			SPA_POD_PARSER_COLLECT_BODY(&pod, body, *format, args);
			count++;
		}
	} while (true);

	return count;
}

SPA_API_POD_PARSER int spa_pod_parser_get(struct spa_pod_parser *parser, ...)
{
	int res;
	va_list args;

	va_start(args, parser);
	res = spa_pod_parser_getv(parser, args);
	va_end(args);

	return res;
}

#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_Array(csize,ctype,n_vals,vals)	"?" SPA_POD_Array(csize,ctype,n_vals,vals)
#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_OPT_PodObject(val)			"?" SPA_POD_PodObject(val)
#define SPA_POD_OPT_PodStruct(val)			"?" SPA_POD_PodStruct(val)
#define SPA_POD_OPT_PodChoice(val)			"?" SPA_POD_PodChoice(val)
#define SPA_POD_OPT_PodBody(val,body)			"?" SPA_POD_PodBody(val,body)
#define SPA_POD_OPT_PodBodyObject(val,body)		"?" SPA_POD_PodBodyObject(val,body)
#define SPA_POD_OPT_PodBodyStruct(val,body)		"?" SPA_POD_PodBodyStruct(val,body)
#define SPA_POD_OPT_PodBodyChoice(val,body)		"?" SPA_POD_PodBodyChoice(val,body)

#define spa_pod_parser_get_object(p,type,id,...)				\
({										\
	struct spa_pod_frame _f;						\
	int _res;								\
	if ((_res = spa_pod_parser_push_object(p, &_f, type, id)) == 0) {	\
		_res = spa_pod_parser_get(p,##__VA_ARGS__, 0);			\
		spa_pod_parser_pop(p, &_f);					\
	}									\
	_res;									\
})

#define spa_pod_parser_get_struct(p,...)				\
({									\
	struct spa_pod_frame _f;					\
	int _res;							\
	if ((_res = spa_pod_parser_push_struct(p, &_f)) == 0) {		\
		_res = spa_pod_parser_get(p,##__VA_ARGS__, NULL);	\
		spa_pod_parser_pop(p, &_f);				\
	}								\
	_res;							\
})

#define spa_pod_parse_object(pod,type,id,...)			\
({								\
	struct spa_pod_parser _p;				\
	spa_pod_parser_pod(&_p, pod);				\
	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__);		\
})

/**
 * \}
 */

#ifdef __cplusplus
}  /* extern "C" */
#endif

#endif /* SPA_POD_PARSER_H */