Adding upstream version 0.3.65.upstream/0.3.65upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1706 insertions, 0 deletions

diff --git a/test/test-spa-pod.c b/test/test-spa-pod.c
new file mode 100644
index 0000000..24c3303
--- /dev/null
+++ b/test/test-spa-pod.c
@@ -0,0 +1,1706 @@
+/* Simple Plugin API
+ * Copyright © 2019 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <spa/pod/pod.h>
+#include <spa/pod/builder.h>
+#include <spa/pod/command.h>
+#include <spa/pod/event.h>
+#include <spa/pod/iter.h>
+#include <spa/pod/parser.h>
+#include <spa/pod/vararg.h>
+#include <spa/debug/pod.h>
+#include <spa/param/format.h>
+#include <spa/param/video/raw.h>
+#include <spa/utils/string.h>
+
+#include "pwtest.h"
+
+PWTEST(pod_abi_sizes)
+{
+#if defined(__x86_64__) && defined(__LP64__)
+	spa_assert_se(sizeof(struct spa_pod) == 8);
+	spa_assert_se(sizeof(struct spa_pod_bool) == 16);
+	spa_assert_se(sizeof(struct spa_pod_id) == 16);
+	spa_assert_se(sizeof(struct spa_pod_int) == 16);
+	spa_assert_se(sizeof(struct spa_pod_long) == 16);
+	spa_assert_se(sizeof(struct spa_pod_float) == 16);
+	spa_assert_se(sizeof(struct spa_pod_double) == 16);
+	spa_assert_se(sizeof(struct spa_pod_string) == 8);
+	spa_assert_se(sizeof(struct spa_pod_bytes) == 8);
+	spa_assert_se(sizeof(struct spa_pod_rectangle) == 16);
+	spa_assert_se(sizeof(struct spa_pod_fraction) == 16);
+	spa_assert_se(sizeof(struct spa_pod_bitmap) == 8);
+	spa_assert_se(sizeof(struct spa_pod_array_body) == 8);
+	spa_assert_se(sizeof(struct spa_pod_array) == 16);
+
+	spa_assert_se(sizeof(struct spa_pod_choice_body) == 16);
+	spa_assert_se(sizeof(struct spa_pod_choice) == 24);
+	spa_assert_se(sizeof(struct spa_pod_struct) == 8);
+	spa_assert_se(sizeof(struct spa_pod_object_body) == 8);
+	spa_assert_se(sizeof(struct spa_pod_object) == 16);
+	spa_assert_se(sizeof(struct spa_pod_pointer_body) == 16);
+	spa_assert_se(sizeof(struct spa_pod_pointer) == 24);
+	spa_assert_se(sizeof(struct spa_pod_fd) == 16);
+	spa_assert_se(sizeof(struct spa_pod_prop) == 16);
+	spa_assert_se(sizeof(struct spa_pod_control) == 16);
+	spa_assert_se(sizeof(struct spa_pod_sequence_body) == 8);
+	spa_assert_se(sizeof(struct spa_pod_sequence) == 16);
+
+	/* builder */
+	spa_assert_se(sizeof(struct spa_pod_frame) == 24);
+	spa_assert_se(sizeof(struct spa_pod_builder_state) == 16);
+	spa_assert_se(sizeof(struct spa_pod_builder) == 48);
+
+	/* command */
+	spa_assert_se(sizeof(struct spa_command_body) == 8);
+	spa_assert_se(sizeof(struct spa_command) == 16);
+
+	/* event */
+	spa_assert_se(sizeof(struct spa_event_body) == 8);
+	spa_assert_se(sizeof(struct spa_event) == 16);
+
+	/* parser */
+	spa_assert_se(sizeof(struct spa_pod_parser_state) == 16);
+	spa_assert_se(sizeof(struct spa_pod_parser) == 32);
+
+	return PWTEST_PASS;
+#endif
+	return PWTEST_SKIP;
+}
+
+PWTEST(pod_abi)
+{
+	spa_assert_se(SPA_CHOICE_None == 0);
+	spa_assert_se(SPA_CHOICE_Range == 1);
+	spa_assert_se(SPA_CHOICE_Step == 2);
+	spa_assert_se(SPA_CHOICE_Enum == 3);
+	spa_assert_se(SPA_CHOICE_Flags == 4);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_init)
+{
+	{
+		struct spa_pod pod = SPA_POD_INIT(sizeof(int64_t), SPA_TYPE_Long);
+		int32_t val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == sizeof(int64_t) + 8);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Long);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == sizeof(int64_t));
+		spa_assert_se(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == sizeof(int64_t));
+		spa_assert_se(spa_pod_is_long(&pod));
+
+		pod = SPA_POD_INIT(sizeof(int32_t), SPA_TYPE_Int);
+		spa_assert_se(SPA_POD_SIZE(&pod) == sizeof(int32_t) + 8);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Int);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == sizeof(int32_t));
+		spa_assert_se(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == sizeof(int32_t));
+		spa_assert_se(spa_pod_is_int(&pod));
+
+		/** too small */
+		pod = SPA_POD_INIT(0, SPA_TYPE_Int);
+		spa_assert_se(!spa_pod_is_int(&pod));
+		spa_assert_se(spa_pod_get_int(&pod, &val) < 0);
+	}
+	{
+		struct spa_pod pod = SPA_POD_INIT_None();
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_None);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 0);
+		spa_assert_se(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == 0);
+		spa_assert_se(spa_pod_is_none(&pod));
+	}
+	{
+		struct spa_pod_bool pod = SPA_POD_INIT_Bool(true);
+		bool val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Bool);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_bool, &pod) == true);
+		spa_assert_se(spa_pod_is_bool(&pod.pod));
+		spa_assert_se(spa_pod_get_bool(&pod.pod, &val) == 0);
+		spa_assert_se(val == true);
+
+		pod = SPA_POD_INIT_Bool(false);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Bool);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_bool, &pod) == false);
+		spa_assert_se(spa_pod_is_bool(&pod.pod));
+		spa_assert_se(spa_pod_get_bool(&pod.pod, &val) == 0);
+		spa_assert_se(val == false);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Bool);
+		spa_assert_se(!spa_pod_is_bool(&pod.pod));
+		spa_assert_se(spa_pod_get_bool(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_id pod = SPA_POD_INIT_Id(SPA_TYPE_Int);
+		uint32_t val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Id);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_id, &pod) == SPA_TYPE_Int);
+		spa_assert_se(spa_pod_is_id(&pod.pod));
+		spa_assert_se(spa_pod_get_id(&pod.pod, &val) == 0);
+		spa_assert_se(val == SPA_TYPE_Int);
+
+		pod = SPA_POD_INIT_Id(SPA_TYPE_Long);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Id);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_id, &pod) == SPA_TYPE_Long);
+		spa_assert_se(spa_pod_is_id(&pod.pod));
+		spa_assert_se(spa_pod_get_id(&pod.pod, &val) == 0);
+		spa_assert_se(val == SPA_TYPE_Long);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Id);
+		spa_assert_se(!spa_pod_is_id(&pod.pod));
+		spa_assert_se(spa_pod_get_id(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_int pod = SPA_POD_INIT_Int(23);
+		int32_t val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Int);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_int, &pod) == 23);
+		spa_assert_se(spa_pod_is_int(&pod.pod));
+		spa_assert_se(spa_pod_get_int(&pod.pod, &val) == 0);
+		spa_assert_se(val == 23);
+
+		pod = SPA_POD_INIT_Int(-123);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Int);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_int, &pod) == -123);
+		spa_assert_se(spa_pod_is_int(&pod.pod));
+		spa_assert_se(spa_pod_get_int(&pod.pod, &val) == 0);
+		spa_assert_se(val == -123);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Int);
+		spa_assert_se(!spa_pod_is_int(&pod.pod));
+		spa_assert_se(spa_pod_get_int(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_long pod = SPA_POD_INIT_Long(-23);
+		int64_t val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Long);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_long, &pod) == -23);
+		spa_assert_se(spa_pod_is_long(&pod.pod));
+		spa_assert_se(spa_pod_get_long(&pod.pod, &val) == 0);
+		spa_assert_se(val == -23);
+
+		pod = SPA_POD_INIT_Long(123);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Long);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_long, &pod) == 123);
+		spa_assert_se(spa_pod_is_long(&pod.pod));
+		spa_assert_se(spa_pod_get_long(&pod.pod, &val) == 0);
+		spa_assert_se(val == 123);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Long);
+		spa_assert_se(!spa_pod_is_long(&pod.pod));
+		spa_assert_se(spa_pod_get_long(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_float pod = SPA_POD_INIT_Float(0.67f);
+		float val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Float);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_float, &pod) == 0.67f);
+		spa_assert_se(spa_pod_is_float(&pod.pod));
+		spa_assert_se(spa_pod_get_float(&pod.pod, &val) == 0);
+		spa_assert_se(val == 0.67f);
+
+		pod = SPA_POD_INIT_Float(-134.8f);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Float);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_float, &pod) == -134.8f);
+		spa_assert_se(spa_pod_is_float(&pod.pod));
+		spa_assert_se(spa_pod_get_float(&pod.pod, &val) == 0);
+		spa_assert_se(val == -134.8f);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Float);
+		spa_assert_se(!spa_pod_is_float(&pod.pod));
+		spa_assert_se(spa_pod_get_float(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_double pod = SPA_POD_INIT_Double(0.67);
+		double val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Double);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_double, &pod) == 0.67);
+		spa_assert_se(spa_pod_is_double(&pod.pod));
+		spa_assert_se(spa_pod_get_double(&pod.pod, &val) == 0);
+		spa_assert_se(val == 0.67);
+
+		pod = SPA_POD_INIT_Double(-134.8);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Double);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_double, &pod) == -134.8);
+		spa_assert_se(spa_pod_is_double(&pod.pod));
+		spa_assert_se(spa_pod_get_double(&pod.pod, &val) == 0);
+		spa_assert_se(val == -134.8);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Double);
+		spa_assert_se(!spa_pod_is_double(&pod.pod));
+		spa_assert_se(spa_pod_get_double(&pod.pod, &val) < 0);
+	}
+	{
+		struct {
+			struct spa_pod_string pod;
+			char str[9];
+		} pod;
+		char val[12];
+
+		pod.pod	= SPA_POD_INIT_String(9);
+		strncpy(pod.str, "test", 9);
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 17);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_String);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 9);
+		spa_assert_se(spa_pod_is_string(&pod.pod.pod));
+		spa_assert_se(spa_pod_copy_string(&pod.pod.pod, sizeof(val), val) == 0);
+		spa_assert_se(spa_streq(pod.str, val));
+
+		pod.pod	= SPA_POD_INIT_String(6);
+		memcpy(pod.str, "test123456789", 9);
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 14);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_String);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 6);
+		spa_assert_se(!spa_pod_is_string(&pod.pod.pod));
+		spa_assert_se(spa_pod_copy_string(&pod.pod.pod, sizeof(val), val) < 0);
+	}
+	{
+		struct spa_pod_rectangle pod = SPA_POD_INIT_Rectangle(SPA_RECTANGLE(320,240));
+		struct spa_rectangle val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Rectangle);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(memcmp(&SPA_POD_VALUE(struct spa_pod_rectangle, &pod),
+					&SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0);
+		spa_assert_se(spa_pod_is_rectangle(&pod.pod));
+		spa_assert_se(spa_pod_get_rectangle(&pod.pod, &val) == 0);
+		spa_assert_se(memcmp(&val, &SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Rectangle);
+		spa_assert_se(!spa_pod_is_rectangle(&pod.pod));
+		spa_assert_se(spa_pod_get_rectangle(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_fraction pod = SPA_POD_INIT_Fraction(SPA_FRACTION(25,1));
+		struct spa_fraction val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Fraction);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(memcmp(&SPA_POD_VALUE(struct spa_pod_fraction, &pod),
+					&SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+		spa_assert_se(spa_pod_is_fraction(&pod.pod));
+		spa_assert_se(spa_pod_get_fraction(&pod.pod, &val) == 0);
+		spa_assert_se(memcmp(&val, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Fraction);
+		spa_assert_se(!spa_pod_is_fraction(&pod.pod));
+		spa_assert_se(spa_pod_get_fraction(&pod.pod, &val) < 0);
+	}
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_build)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod *array, *choice, *head, *pod, *it;
+	const struct spa_pod_prop *prop;
+	struct spa_pod_control *control;
+	int64_t longs[] = { 5, 7, 11, 13, 17 }, *al;
+	uint32_t i, len, yl, *ai;
+	union {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		const void *y;
+		const void *p;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+	} val;
+	struct spa_pod_frame f;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(b.data == buffer);
+	spa_assert_se(b.size == sizeof(buffer));
+	spa_assert_se(b.state.offset == 0);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(spa_pod_builder_none(&b) == 0);
+	spa_assert_se(b.state.offset == 8);
+	spa_assert_se(spa_pod_builder_bool(&b, true) == 0);
+	spa_assert_se(b.state.offset == 24);
+	spa_assert_se(spa_pod_builder_id(&b, SPA_TYPE_Object) == 0);
+	spa_assert_se(b.state.offset == 40);
+	spa_assert_se(spa_pod_builder_int(&b, 21) == 0);
+	spa_assert_se(b.state.offset == 56);
+	spa_assert_se(spa_pod_builder_float(&b, 0.8f) == 0);
+	spa_assert_se(b.state.offset == 72);
+	spa_assert_se(spa_pod_builder_double(&b, -1.56) == 0);
+	spa_assert_se(b.state.offset == 88);
+	spa_assert_se(spa_pod_builder_string(&b, "test") == 0);
+	spa_assert_se(b.state.offset == 104);
+	spa_assert_se(spa_pod_builder_bytes(&b, "PipeWire", 8) == 0);
+	spa_assert_se(b.state.offset == 120);
+	spa_assert_se(spa_pod_builder_pointer(&b, SPA_TYPE_Object, &b) == 0);
+	spa_assert_se(b.state.offset == 144);
+	spa_assert_se(spa_pod_builder_fd(&b, 4) == 0);
+	spa_assert_se(b.state.offset == 160);
+	spa_assert_se(spa_pod_builder_rectangle(&b, 320, 240) == 0);
+	spa_assert_se(b.state.offset == 176);
+	spa_assert_se(spa_pod_builder_fraction(&b, 25, 1) == 0);
+
+	spa_assert_se(b.state.offset == 192);
+	spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0);
+	spa_assert_se(f.offset == 192);
+	spa_assert_se(b.state.flags == (SPA_POD_BUILDER_FLAG_BODY | SPA_POD_BUILDER_FLAG_FIRST));
+	spa_assert_se(b.state.offset == 200);
+	spa_assert_se(spa_pod_builder_int(&b, 1) == 0);
+	spa_assert_se(b.state.flags == SPA_POD_BUILDER_FLAG_BODY);
+	spa_assert_se(b.state.offset == 212);
+	spa_assert_se(spa_pod_builder_int(&b, 2) == 0);
+	spa_assert_se(b.state.offset == 216);
+	spa_assert_se(spa_pod_builder_int(&b, 3) == 0);
+	array = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(f.pod.size == 20);
+	spa_assert_se(array != NULL);
+	spa_assert_se(SPA_POD_BODY_SIZE(array) == 8 + 12);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 224);
+	spa_assert_se(spa_pod_builder_array(&b,
+				sizeof(int64_t), SPA_TYPE_Long,
+				SPA_N_ELEMENTS(longs), longs) == 0);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 280);
+	spa_assert_se(spa_pod_builder_push_choice(&b, &f, SPA_CHOICE_Enum, 0) == 0);
+	spa_assert_se(b.state.flags == (SPA_POD_BUILDER_FLAG_BODY | SPA_POD_BUILDER_FLAG_FIRST));
+	spa_assert_se(b.state.offset == 296);
+	spa_assert_se(spa_pod_builder_long(&b, 1) == 0);
+	spa_assert_se(b.state.flags == SPA_POD_BUILDER_FLAG_BODY);
+	spa_assert_se(b.state.offset == 312);
+	spa_assert_se(spa_pod_builder_long(&b, 2) == 0);
+	spa_assert_se(b.state.offset == 320);
+	spa_assert_se(spa_pod_builder_long(&b, 3) == 0);
+	choice = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(choice != NULL);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 328);
+	spa_assert_se(spa_pod_builder_push_struct(&b, &f) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 336);
+	spa_assert_se(spa_pod_builder_int(&b, 21) == 0);
+	spa_assert_se(b.state.offset == 352);
+	spa_assert_se(spa_pod_builder_float(&b, 0.8f) == 0);
+	spa_assert_se(b.state.offset == 368);
+	spa_assert_se(spa_pod_builder_double(&b, -1.56) == 0);
+	spa_assert_se(spa_pod_builder_pop(&b, &f) != NULL);
+
+	spa_assert_se(b.state.offset == 384);
+	spa_assert_se(spa_pod_builder_push_object(&b, &f, SPA_TYPE_OBJECT_Props, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 400);
+	spa_assert_se(spa_pod_builder_prop(&b, 1, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 408);
+	spa_assert_se(spa_pod_builder_int(&b, 21) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 424);
+	spa_assert_se(spa_pod_builder_prop(&b, 2, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 432);
+	spa_assert_se(spa_pod_builder_long(&b, 42) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 448);
+	spa_assert_se(spa_pod_builder_prop(&b, 3, 0) == 0);
+	spa_assert_se(b.state.offset == 456);
+	spa_assert_se(spa_pod_builder_string(&b, "test123") == 0);
+	spa_assert_se(spa_pod_builder_pop(&b, &f) != NULL);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 472);
+	spa_assert_se(spa_pod_builder_push_sequence(&b, &f, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 488);
+	spa_assert_se(spa_pod_builder_control(&b, 0, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 496);
+	spa_assert_se(spa_pod_builder_float(&b, 0.667f) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 512);
+	spa_assert_se(spa_pod_builder_control(&b, 12, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 520);
+	spa_assert_se(spa_pod_builder_double(&b, 1.22) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(spa_pod_builder_pop(&b, &f) != NULL);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 536);
+
+	len = b.state.offset;
+	pod = head = (struct spa_pod *)buffer;
+
+	spa_assert_se(spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_none(pod));
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_bool(pod));
+	spa_assert_se(spa_pod_get_bool(pod, &val.b) == 0);
+	spa_assert_se(val.b == true);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_id(pod));
+	spa_assert_se(spa_pod_get_id(pod, &val.I) == 0);
+	spa_assert_se(val.I == SPA_TYPE_Object);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_int(pod));
+	spa_assert_se(spa_pod_get_int(pod, &val.i) == 0);
+	spa_assert_se(val.i == 21);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_float(pod));
+	spa_assert_se(spa_pod_get_float(pod, &val.f) == 0);
+	spa_assert_se(val.f == 0.8f);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_double(pod));
+	spa_assert_se(spa_pod_get_double(pod, &val.d) == 0);
+	spa_assert_se(val.d == -1.56);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_string(pod));
+	spa_assert_se(spa_pod_get_string(pod, &val.s) == 0);
+	spa_assert_se(spa_streq(val.s, "test"));
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_bytes(pod));
+	spa_assert_se(spa_pod_get_bytes(pod, &val.y, &yl) == 0);
+	spa_assert_se(yl == 8);
+	spa_assert_se(memcmp(val.y, "PipeWire", yl) == 0);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_pointer(pod));
+	spa_assert_se(spa_pod_get_pointer(pod, &yl, &val.p) == 0);
+	spa_assert_se(yl == SPA_TYPE_Object);
+	spa_assert_se(val.p == &b);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_fd(pod));
+	spa_assert_se(spa_pod_get_fd(pod, &val.l) == 0);
+	spa_assert_se(val.l == 4);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_rectangle(pod));
+	spa_assert_se(spa_pod_get_rectangle(pod, &val.R) == 0);
+	spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_fraction(pod));
+	spa_assert_se(spa_pod_get_fraction(pod, &val.F) == 0);
+	spa_assert_se(memcmp(&val.F, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_array(pod));
+	spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(pod) == SPA_TYPE_Int);
+	spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(pod) == sizeof(int32_t));
+	spa_assert_se(SPA_POD_ARRAY_N_VALUES(pod) == 3);
+	ai = SPA_POD_ARRAY_VALUES(pod);
+	spa_assert_se(ai != NULL);
+	spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->type == SPA_TYPE_Int);
+	spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->size == sizeof(int32_t));
+	spa_assert_se(ai[0] == 1);
+	spa_assert_se(ai[1] == 2);
+	spa_assert_se(ai[2] == 3);
+	i = 1;
+	SPA_POD_ARRAY_FOREACH((struct spa_pod_array*)pod, ai) {
+		spa_assert_se(*ai == i);
+		i++;
+	}
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_array(pod));
+	spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(pod) == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(pod) == sizeof(int64_t));
+	spa_assert_se(SPA_POD_ARRAY_N_VALUES(pod) == SPA_N_ELEMENTS(longs));
+	al = SPA_POD_ARRAY_VALUES(pod);
+	spa_assert_se(al != NULL);
+	spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->type == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->size == sizeof(int64_t));
+	for (i = 0; i < SPA_N_ELEMENTS(longs); i++)
+		spa_assert_se(al[i] == longs[i]);
+	i = 0;
+	SPA_POD_ARRAY_FOREACH((struct spa_pod_array*)pod, al) {
+		spa_assert_se(*al == longs[i++]);
+	}
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_choice(pod));
+	spa_assert_se(SPA_POD_CHOICE_TYPE(pod) == SPA_CHOICE_Enum);
+	spa_assert_se(SPA_POD_CHOICE_FLAGS(pod) == 0);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(pod) == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(pod) == sizeof(int64_t));
+	spa_assert_se(SPA_POD_CHOICE_N_VALUES(pod) == 3);
+	al = SPA_POD_CHOICE_VALUES(pod);
+	spa_assert_se(al != NULL);
+	spa_assert_se(SPA_POD_CHOICE_CHILD(pod)->type == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_CHOICE_CHILD(pod)->size == sizeof(int64_t));
+	spa_assert_se(al[0] == 1);
+	spa_assert_se(al[1] == 2);
+	spa_assert_se(al[2] == 3);
+	i = 1;
+	SPA_POD_CHOICE_FOREACH((struct spa_pod_choice*)pod, al) {
+		spa_assert_se(*al == i);
+		i++;
+	}
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_struct(pod));
+	i = 0;
+	SPA_POD_STRUCT_FOREACH(pod, it) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(spa_pod_is_int(it));
+			spa_assert_se(spa_pod_get_int(it, &val.i) == 0 && val.i == 21);
+			break;
+		case 1:
+			spa_assert_se(spa_pod_is_float(it));
+			spa_assert_se(spa_pod_get_float(it, &val.f) == 0 && val.f == 0.8f);
+			break;
+		case 2:
+			spa_assert_se(spa_pod_is_double(it));
+			spa_assert_se(spa_pod_get_double(it, &val.d) == 0 && val.d == -1.56);
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_object(pod));
+	spa_assert_se(spa_pod_is_object_type(pod, SPA_TYPE_OBJECT_Props));
+	spa_assert_se(spa_pod_is_object_id(pod, 0));
+	i = 0;
+	SPA_POD_OBJECT_FOREACH((const struct spa_pod_object*)pod, prop) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(prop->key == 1);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 21);
+			break;
+		case 1:
+			spa_assert_se(prop->key == 2);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 42);
+			break;
+		case 2:
+			spa_assert_se(prop->key == 3);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0 &&
+					spa_streq(val.s, "test123"));
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+	prop = spa_pod_find_prop(pod, NULL, 3);
+	spa_assert_se(prop != NULL);
+	spa_assert_se(prop->key == 3);
+	spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0 &&
+				spa_streq(val.s, "test123"));
+	prop = spa_pod_find_prop(pod, prop, 1);
+	spa_assert_se(prop != NULL);
+	spa_assert_se(prop->key == 1);
+	spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 21);
+	prop = spa_pod_find_prop(pod, prop, 2);
+	spa_assert_se(prop != NULL);
+	spa_assert_se(prop->key == 2);
+	spa_assert_se(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 42);
+	prop = spa_pod_find_prop(pod, prop, 5);
+	spa_assert_se(prop == NULL);
+
+	prop = spa_pod_find_prop(pod, NULL, 3);
+	spa_assert_se(prop != NULL);
+	spa_assert_se(prop->key == 3);
+	spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0 &&
+				spa_streq(val.s, "test123"));
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_sequence(pod));
+
+	i = 0;
+	SPA_POD_SEQUENCE_FOREACH((const struct spa_pod_sequence*)pod, control) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(control->offset == 0);
+			spa_assert_se(SPA_POD_CONTROL_SIZE(control) == 20);
+			spa_assert_se(spa_pod_get_float(&control->value, &val.f) == 0 && val.f == 0.667f);
+			break;
+		case 1:
+			spa_assert_se(control->offset == 12);
+			spa_assert_se(SPA_POD_CONTROL_SIZE(control) == 24);
+			spa_assert_se(spa_pod_get_double(&control->value, &val.d) == 0 && val.d == 1.22);
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_empty)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod *array, *a2, *choice, *ch2;
+	struct spa_pod_frame f;
+	uint32_t n_vals, ch;
+
+	memset(buffer, 0xab, sizeof(buffer));
+
+	/* create empty arrays */
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0);
+	spa_assert_se(spa_pod_builder_child(&b, sizeof(uint32_t), SPA_TYPE_Id) == 0);
+	array = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(array != NULL);
+	spa_debug_mem(0, array, 16);
+	spa_assert_se(spa_pod_is_array(array));
+	a2 = spa_pod_get_array(array, &n_vals);
+	spa_assert_se(a2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0);
+	array = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(array != NULL);
+	spa_assert_se(spa_pod_is_array(array));
+	a2 = spa_pod_get_array(array, &n_vals);
+	spa_assert_se(a2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0);
+	spa_assert_se(spa_pod_builder_none(&b) == 0);
+	array = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(array != NULL);
+	spa_assert_se(spa_pod_is_array(array));
+	a2 = spa_pod_get_array(array, &n_vals);
+	spa_assert_se(a2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_array(&b, 4, SPA_TYPE_Id, 0, NULL) == 0);
+	array = (struct spa_pod*)buffer;
+	spa_assert_se(spa_pod_is_array(array));
+	a2 = spa_pod_get_array(array, &n_vals);
+	spa_assert_se(a2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	/* create empty choice */
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0);
+	spa_assert_se(spa_pod_builder_child(&b, sizeof(uint32_t), SPA_TYPE_Id) == 0);
+	choice = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(choice != NULL);
+	spa_debug_mem(0, choice, 32);
+	spa_assert_se(spa_pod_is_choice(choice));
+	ch2 = spa_pod_get_values(choice, &n_vals, &ch);
+	spa_assert_se(ch2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0);
+	choice = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(choice != NULL);
+	spa_assert_se(spa_pod_is_choice(choice));
+	ch2 = spa_pod_get_values(choice, &n_vals, &ch);
+	spa_assert_se(ch2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0);
+	spa_assert_se(spa_pod_builder_none(&b) == 0);
+	choice = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(choice != NULL);
+	spa_assert_se(spa_pod_is_choice(choice));
+	ch2 = spa_pod_get_values(choice, &n_vals, &ch);
+	spa_assert_se(ch2 != NULL);
+	spa_assert_se(n_vals == 0);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_varargs)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod *pod;
+	struct spa_pod_prop *prop;
+	uint32_t i, *aI;
+	union {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		const void *y;
+		const void *p;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+	} val;
+	uint32_t media_type, media_subtype, format;
+	int32_t views;
+	struct spa_rectangle *aR, size;
+	struct spa_fraction *aF, framerate;
+	struct spa_pod *Vformat, *Vsize, *Vframerate;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	pod = 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_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)));
+
+	i = 0;
+	SPA_POD_OBJECT_FOREACH((const struct spa_pod_object*)pod, prop) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(prop->key == SPA_FORMAT_mediaType);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_MEDIA_TYPE_video);
+			break;
+		case 1:
+			spa_assert_se(prop->key == SPA_FORMAT_mediaSubtype);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_MEDIA_SUBTYPE_raw);
+			break;
+		case 2:
+			spa_assert_se(prop->key == SPA_FORMAT_VIDEO_format);
+			spa_assert_se(spa_pod_is_choice(&prop->value));
+			spa_assert_se(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Enum);
+			spa_assert_se(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Id);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(uint32_t));
+			aI = SPA_POD_CHOICE_VALUES(&prop->value);
+			spa_assert_se(aI != NULL);
+			spa_assert_se(aI[0] == SPA_VIDEO_FORMAT_I420);
+			spa_assert_se(aI[1] == SPA_VIDEO_FORMAT_I420);
+			spa_assert_se(aI[2] == SPA_VIDEO_FORMAT_YUY2);
+			break;
+		case 3:
+			spa_assert_se(prop->key == SPA_FORMAT_VIDEO_size);
+			spa_assert_se(spa_pod_is_choice(&prop->value));
+			spa_assert_se(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Range);
+			spa_assert_se(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Rectangle);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(struct spa_rectangle));
+			aR = SPA_POD_CHOICE_VALUES(&prop->value);
+			spa_assert_se(aR != NULL);
+			spa_assert_se(memcmp(&aR[0], &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0);
+			spa_assert_se(memcmp(&aR[1], &SPA_RECTANGLE(1,1), sizeof(struct spa_rectangle)) == 0);
+			spa_assert_se(memcmp(&aR[2], &SPA_RECTANGLE(INT32_MAX,INT32_MAX), sizeof(struct spa_rectangle)) == 0);
+			break;
+		case 4:
+			spa_assert_se(prop->key == SPA_FORMAT_VIDEO_framerate);
+			spa_assert_se(spa_pod_is_choice(&prop->value));
+			spa_assert_se(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Range);
+			spa_assert_se(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Fraction);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(struct spa_fraction));
+			aF = SPA_POD_CHOICE_VALUES(&prop->value);
+			spa_assert_se(aF != NULL);
+			spa_assert_se(memcmp(&aF[0], &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+			spa_assert_se(memcmp(&aF[1], &SPA_FRACTION(0,1), sizeof(struct spa_fraction)) == 0);
+			spa_assert_se(memcmp(&aF[2], &SPA_FRACTION(INT32_MAX,1), sizeof(struct spa_fraction)) == 0);
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,		SPA_POD_Id(&media_type),
+		SPA_FORMAT_mediaSubtype,	SPA_POD_Id(&media_subtype),
+		SPA_FORMAT_VIDEO_format,	SPA_POD_PodChoice(&Vformat),
+		SPA_FORMAT_VIDEO_size,		SPA_POD_PodChoice(&Vsize),
+		SPA_FORMAT_VIDEO_framerate,	SPA_POD_PodChoice(&Vframerate)) == 5);
+
+	spa_assert_se(media_type == SPA_MEDIA_TYPE_video);
+	spa_assert_se(media_subtype == SPA_MEDIA_SUBTYPE_raw);
+
+	spa_assert_se(spa_pod_is_choice(Vformat));
+	spa_assert_se(SPA_POD_CHOICE_TYPE(Vformat) == SPA_CHOICE_Enum);
+	spa_assert_se(SPA_POD_CHOICE_N_VALUES(Vformat) == 3);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(Vformat) == SPA_TYPE_Id);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(Vformat) == sizeof(uint32_t));
+	aI = SPA_POD_CHOICE_VALUES(Vformat);
+	spa_assert_se(aI != NULL);
+	spa_assert_se(aI[0] == SPA_VIDEO_FORMAT_I420);
+	spa_assert_se(aI[1] == SPA_VIDEO_FORMAT_I420);
+	spa_assert_se(aI[2] == SPA_VIDEO_FORMAT_YUY2);
+
+	spa_assert_se(spa_pod_is_choice(Vsize));
+	spa_assert_se(SPA_POD_CHOICE_TYPE(Vsize) == SPA_CHOICE_Range);
+	spa_assert_se(SPA_POD_CHOICE_N_VALUES(Vsize) == 3);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(Vsize) == SPA_TYPE_Rectangle);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(Vsize) == sizeof(struct spa_rectangle));
+	aR = SPA_POD_CHOICE_VALUES(Vsize);
+	spa_assert_se(aR != NULL);
+	spa_assert_se(memcmp(&aR[0], &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&aR[1], &SPA_RECTANGLE(1,1), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&aR[2], &SPA_RECTANGLE(INT32_MAX,INT32_MAX), sizeof(struct spa_rectangle)) == 0);
+
+	spa_assert_se(spa_pod_is_choice(Vframerate));
+
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,		SPA_POD_Id(&media_type),
+		SPA_FORMAT_mediaSubtype,	SPA_POD_Id(&media_subtype),
+		SPA_FORMAT_VIDEO_views,		SPA_POD_Int(&views),
+		SPA_FORMAT_VIDEO_format,	SPA_POD_Id(&format),
+		SPA_FORMAT_VIDEO_size,		SPA_POD_Rectangle(&size),
+		SPA_FORMAT_VIDEO_framerate,	SPA_POD_Fraction(&framerate)) == -ESRCH);
+
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,		SPA_POD_Id(&media_type),
+		SPA_FORMAT_mediaSubtype,	SPA_POD_Id(&media_subtype),
+		SPA_FORMAT_VIDEO_format,	SPA_POD_Id(&format),
+		SPA_FORMAT_VIDEO_size,		SPA_POD_Rectangle(&size),
+		SPA_FORMAT_VIDEO_framerate,	SPA_POD_Fraction(&framerate)) == -EPROTO);
+
+	spa_debug_pod(0, NULL, pod);
+	spa_pod_fixate(pod);
+
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,		SPA_POD_Id(&media_type),
+		SPA_FORMAT_mediaSubtype,	SPA_POD_Id(&media_subtype),
+		SPA_FORMAT_VIDEO_format,	SPA_POD_Id(&format),
+		SPA_FORMAT_VIDEO_views,		SPA_POD_OPT_Int(&views),
+		SPA_FORMAT_VIDEO_size,		SPA_POD_Rectangle(&size),
+		SPA_FORMAT_VIDEO_framerate,	SPA_POD_Fraction(&framerate)) == 5);
+
+	spa_assert_se(media_type == SPA_MEDIA_TYPE_video);
+	spa_assert_se(media_subtype == SPA_MEDIA_SUBTYPE_raw);
+	spa_assert_se(format == SPA_VIDEO_FORMAT_I420);
+	spa_assert_se(memcmp(&size, &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&framerate, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+
+	spa_debug_pod(0, NULL, pod);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_varargs2)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod *pod;
+	struct spa_pod_prop *prop;
+	uint32_t i, j;
+	struct {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		uint32_t yl;
+		const void *y;
+		uint32_t ptype;
+		const void *p;
+		uint32_t asize, atype, anvals;
+		const void *a;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+		struct spa_pod *P;
+	} val;
+	uint8_t bytes[] = { 0x56, 0x00, 0x12, 0xf3, 0xba };
+	int64_t longs[] = { 1002, 5383, 28944, 1237748 }, *al;
+	struct spa_pod_int pi = SPA_POD_INIT_Int(77);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	pod = spa_pod_builder_add_object(&b,
+		SPA_TYPE_OBJECT_Props, 0,
+		1,	SPA_POD_Bool(true),
+		2,	SPA_POD_Id(SPA_TYPE_Id),
+		3,	SPA_POD_Int(3),
+		4,	SPA_POD_Long(4LL),
+		5,	SPA_POD_Float(0.453f),
+		6,	SPA_POD_Double(0.871),
+		7,	SPA_POD_String("test"),
+		8,	SPA_POD_Bytes(bytes, sizeof(bytes)),
+		9,	SPA_POD_Rectangle(&SPA_RECTANGLE(3,4)),
+		10,	SPA_POD_Fraction(&SPA_FRACTION(24,1)),
+		11,	SPA_POD_Array(sizeof(int64_t), SPA_TYPE_Long, SPA_N_ELEMENTS(longs), longs),
+		12,	SPA_POD_Pointer(SPA_TYPE_Object, &b),
+		13,	SPA_POD_Fd(3),
+		14,	SPA_POD_Pod(&pi));
+
+	spa_debug_pod(0, NULL, pod);
+
+	i = 0;
+	SPA_POD_OBJECT_FOREACH((const struct spa_pod_object*)pod, prop) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(prop->key == 1);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_bool(&prop->value, &val.b) == 0 && val.b == true);
+			break;
+		case 1:
+			spa_assert_se(prop->key == 2);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_TYPE_Id);
+			break;
+		case 2:
+			spa_assert_se(prop->key == 3);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 3);
+			break;
+		case 3:
+			spa_assert_se(prop->key == 4);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 4);
+			break;
+		case 4:
+			spa_assert_se(prop->key == 5);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_float(&prop->value, &val.f) == 0 && val.f == 0.453f);
+			break;
+		case 5:
+			spa_assert_se(prop->key == 6);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_double(&prop->value, &val.d) == 0 && val.d == 0.871);
+			break;
+		case 6:
+			spa_assert_se(prop->key == 7);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 21);
+			spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0);
+			spa_assert_se(spa_streq(val.s, "test"));
+			break;
+		case 7:
+			spa_assert_se(prop->key == 8);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 21);
+			spa_assert_se(spa_pod_get_bytes(&prop->value, &val.y, &val.yl) == 0);
+			spa_assert_se(val.yl == sizeof(bytes));
+			spa_assert_se(memcmp(val.y, bytes, val.yl) == 0);
+			break;
+		case 8:
+			spa_assert_se(prop->key == 9);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_rectangle(&prop->value, &val.R) == 0);
+			spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3,4), sizeof(struct spa_rectangle)) == 0);
+			break;
+		case 9:
+			spa_assert_se(prop->key == 10);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_fraction(&prop->value, &val.F) == 0);
+			spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24,1), sizeof(struct spa_fraction)) == 0);
+			break;
+		case 10:
+			spa_assert_se(prop->key == 11);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 56);
+			spa_assert_se(spa_pod_is_array(&prop->value));
+			spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(&prop->value) == SPA_TYPE_Long);
+			spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(&prop->value) == sizeof(int64_t));
+			spa_assert_se(SPA_POD_ARRAY_N_VALUES(&prop->value) == SPA_N_ELEMENTS(longs));
+			al = SPA_POD_ARRAY_VALUES(&prop->value);
+			spa_assert_se(al != NULL);
+			spa_assert_se(SPA_POD_ARRAY_CHILD(&prop->value)->type == SPA_TYPE_Long);
+			spa_assert_se(SPA_POD_ARRAY_CHILD(&prop->value)->size == sizeof(int64_t));
+			for (j = 0; j < SPA_N_ELEMENTS(longs); j++)
+				spa_assert_se(al[j] == longs[j]);
+			break;
+		case 11:
+			spa_assert_se(prop->key == 12);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == (sizeof(struct spa_pod_prop) +
+					sizeof(struct spa_pod_pointer_body)));
+			spa_assert_se(spa_pod_get_pointer(&prop->value, &val.ptype, &val.p) == 0);
+			spa_assert_se(val.ptype == SPA_TYPE_Object);
+			spa_assert_se(val.p == &b);
+			break;
+		case 12:
+			spa_assert_se(prop->key == 13);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_fd(&prop->value, &val.h) == 0);
+			spa_assert_se(val.h == 3);
+			break;
+		case 13:
+			spa_assert_se(prop->key == 14);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0);
+			spa_assert_se(val.i == 77);
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+	spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Format, NULL) == -EPROTO);
+	spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Props, NULL) == 0);
+
+	spa_zero(val);
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Props, NULL,
+		1,	SPA_POD_Bool(&val.b),
+		2,	SPA_POD_Id(&val.I),
+		3,	SPA_POD_Int(&val.i),
+		4,	SPA_POD_Long(&val.l),
+		5,	SPA_POD_Float(&val.f),
+		6,	SPA_POD_Double(&val.d),
+		7,	SPA_POD_String(&val.s),
+		8,	SPA_POD_Bytes(&val.y, &val.yl),
+		9,	SPA_POD_Rectangle(&val.R),
+		10,	SPA_POD_Fraction(&val.F),
+		11,	SPA_POD_Array(&val.asize, &val.atype, &val.anvals, &val.a),
+		12,	SPA_POD_Pointer(&val.ptype, &val.p),
+		13,	SPA_POD_Fd(&val.h),
+		14,	SPA_POD_Pod(&val.P)) == 14);
+
+	spa_assert_se(val.b == true);
+	spa_assert_se(val.I == SPA_TYPE_Id);
+	spa_assert_se(val.i == 3);
+	spa_assert_se(val.l == 4);
+	spa_assert_se(val.f == 0.453f);
+	spa_assert_se(val.d == 0.871);
+	spa_assert_se(spa_streq(val.s, "test"));
+	spa_assert_se(val.yl == sizeof(bytes));
+	spa_assert_se(memcmp(val.y, bytes, sizeof(bytes)) == 0);
+	spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3, 4), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24, 1), sizeof(struct spa_fraction)) == 0);
+	spa_assert_se(val.asize == sizeof(int64_t));
+	spa_assert_se(val.atype == SPA_TYPE_Long);
+	spa_assert_se(val.anvals == SPA_N_ELEMENTS(longs));
+	spa_assert_se(memcmp(val.a, longs, val.anvals * val.asize) == 0);
+	spa_assert_se(val.ptype == SPA_TYPE_Object);
+	spa_assert_se(val.p == &b);
+	spa_assert_se(val.h == 3);
+	spa_assert_se(memcmp(val.P, &pi, sizeof(pi)) == 0);
+
+	spa_zero(val);
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Props, NULL,
+		0,	SPA_POD_OPT_Bool(&val.b),
+		0,	SPA_POD_OPT_Id(&val.I),
+		0,	SPA_POD_OPT_Int(&val.i),
+		0,	SPA_POD_OPT_Long(&val.l),
+		0,	SPA_POD_OPT_Float(&val.f),
+		0,	SPA_POD_OPT_Double(&val.d),
+		0,	SPA_POD_OPT_String(&val.s),
+		0,	SPA_POD_OPT_Bytes(&val.y, &val.yl),
+		0,	SPA_POD_OPT_Rectangle(&val.R),
+		0,	SPA_POD_OPT_Fraction(&val.F),
+		0,	SPA_POD_OPT_Array(&val.asize, &val.atype, &val.anvals, &val.a),
+		0,	SPA_POD_OPT_Pointer(&val.ptype, &val.p),
+		0,	SPA_POD_OPT_Fd(&val.h),
+		0,	SPA_POD_OPT_Pod(&val.P)) == 0);
+
+	for (i = 1; i < 15; i++) {
+		spa_zero(val);
+		spa_assert_se(spa_pod_parse_object(pod,
+			SPA_TYPE_OBJECT_Props, NULL,
+			i,	SPA_POD_OPT_Bool(&val.b),
+			i,	SPA_POD_OPT_Id(&val.I),
+			i,	SPA_POD_OPT_Int(&val.i),
+			i,	SPA_POD_OPT_Long(&val.l),
+			i,	SPA_POD_OPT_Float(&val.f),
+			i,	SPA_POD_OPT_Double(&val.d),
+			i,	SPA_POD_OPT_String(&val.s),
+			i,	SPA_POD_OPT_Bytes(&val.y, &val.yl),
+			i,	SPA_POD_OPT_Rectangle(&val.R),
+			i,	SPA_POD_OPT_Fraction(&val.F),
+			i,	SPA_POD_OPT_Array(&val.asize, &val.atype, &val.anvals, &val.a),
+			i,	SPA_POD_OPT_Pointer(&val.ptype, &val.p),
+			i,	SPA_POD_OPT_Fd(&val.h),
+			i,	SPA_POD_OPT_Pod(&val.P)) == 2);
+	}
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_parser)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod_parser p;
+	struct spa_pod_frame f;
+	struct spa_pod *pod;
+	struct {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		uint32_t yl;
+		const void *y;
+		uint32_t ptype;
+		const void *p;
+		uint32_t asize, atype, anvals;
+		const void *a;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+		struct spa_pod *P;
+	} val;
+	uint8_t bytes[] = { 0x56, 0x00, 0x12, 0xf3, 0xba };
+	int64_t longs[] = { 1002, 5383, 28944, 1237748 };
+	struct spa_pod_int pi = SPA_POD_INIT_Int(77);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	pod = spa_pod_builder_add_object(&b,
+		SPA_TYPE_OBJECT_Props, 0,
+		1,	SPA_POD_Bool(true),
+		2,	SPA_POD_Id(SPA_TYPE_Id),
+		3,	SPA_POD_Int(3),
+		4,	SPA_POD_Long(4LL),
+		5,	SPA_POD_Float(0.453f),
+		6,	SPA_POD_Double(0.871),
+		7,	SPA_POD_String("test"),
+		8,	SPA_POD_Bytes(bytes, sizeof(bytes)),
+		9,	SPA_POD_Rectangle(&SPA_RECTANGLE(3,4)),
+		10,	SPA_POD_Fraction(&SPA_FRACTION(24,1)),
+		11,	SPA_POD_Array(sizeof(int64_t), SPA_TYPE_Long, SPA_N_ELEMENTS(longs), longs),
+		12,	SPA_POD_Pointer(SPA_TYPE_Object, &b),
+		13,	SPA_POD_Fd(3),
+		14,	SPA_POD_Pod(&pi));
+
+	spa_debug_pod(0, NULL, pod);
+
+	spa_pod_parser_pod(&p, pod);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_bool(&p, &val.b) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_id(&p, &val.I) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_int(&p, &val.i) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_long(&p, &val.l) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_float(&p, &val.f) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_double(&p, &val.d) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_string(&p, &val.s) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_rectangle(&p, &val.R) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_fraction(&p, &val.F) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_fd(&p, &val.h) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_pod(&p, &val.P) == 0);
+	spa_assert_se(p.state.offset == 392);
+	spa_assert_se(spa_pod_is_object(val.P));
+
+	spa_pod_parser_pod(&p, val.P);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_struct(&p, &f) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Format, NULL) == -EPROTO);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Props, NULL) == 0);
+	spa_assert_se(p.state.offset == 392);
+	spa_assert_se(spa_pod_parser_frame(&p, &f) == val.P);
+
+	spa_zero(val);
+	spa_assert_se(spa_pod_parser_get(&p,
+		1,	SPA_POD_OPT_Bool(&val.b),
+		2,	SPA_POD_OPT_Id(&val.I),
+		3,	SPA_POD_OPT_Int(&val.i),
+		4,	SPA_POD_OPT_Long(&val.l),
+		5,	SPA_POD_OPT_Float(&val.f),
+		6,	SPA_POD_OPT_Double(&val.d),
+		7,	SPA_POD_OPT_String(&val.s),
+		8,	SPA_POD_OPT_Bytes(&val.y, &val.yl),
+		9,	SPA_POD_OPT_Rectangle(&val.R),
+		10,	SPA_POD_OPT_Fraction(&val.F),
+		11,	SPA_POD_OPT_Array(&val.asize, &val.atype, &val.anvals, &val.a),
+		12,	SPA_POD_OPT_Pointer(&val.ptype, &val.p),
+		13,	SPA_POD_OPT_Fd(&val.h),
+		14,	SPA_POD_OPT_Pod(&val.P), 0) == 14);
+	spa_pod_parser_pop(&p, &f);
+
+	spa_assert_se(val.b == true);
+	spa_assert_se(val.I == SPA_TYPE_Id);
+	spa_assert_se(val.i == 3);
+	spa_assert_se(val.l == 4);
+	spa_assert_se(val.f == 0.453f);
+	spa_assert_se(val.d == 0.871);
+	spa_assert_se(spa_streq(val.s, "test"));
+	spa_assert_se(val.yl == sizeof(bytes));
+	spa_assert_se(memcmp(val.y, bytes, sizeof(bytes)) == 0);
+	spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3, 4), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24, 1), sizeof(struct spa_fraction)) == 0);
+	spa_assert_se(val.asize == sizeof(int64_t));
+	spa_assert_se(val.atype == SPA_TYPE_Long);
+	spa_assert_se(val.anvals == SPA_N_ELEMENTS(longs));
+	spa_assert_se(memcmp(val.a, longs, val.anvals * val.asize) == 0);
+	spa_assert_se(val.ptype == SPA_TYPE_Object);
+	spa_assert_se(val.p == &b);
+	spa_assert_se(val.h == 3);
+	spa_assert_se(memcmp(val.P, &pi, sizeof(pi)) == 0);
+
+	spa_assert_se(p.state.offset == 392);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_parser2)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod_parser p;
+	struct spa_pod_frame f;
+	struct spa_pod *pod;
+	struct {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		uint32_t yl;
+		const void *y;
+		uint32_t ptype;
+		const void *p;
+		uint32_t asize, atype, anvals;
+		const void *a;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+		struct spa_pod *P;
+	} val;
+	uint8_t bytes[] = { 0x56, 0x00, 0x12, 0xf3, 0xba };
+	int64_t longs[] = { 1002, 5383, 28944, 1237748 };
+	struct spa_pod_int pi = SPA_POD_INIT_Int(77);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	pod = spa_pod_builder_add_struct(&b,
+		SPA_POD_Bool(true),
+		SPA_POD_Id(SPA_TYPE_Id),
+		SPA_POD_Int(3),
+		SPA_POD_Long(4LL),
+		SPA_POD_Float(0.453f),
+		SPA_POD_Double(0.871),
+		SPA_POD_String("test"),
+		SPA_POD_Bytes(bytes, sizeof(bytes)),
+		SPA_POD_Rectangle(&SPA_RECTANGLE(3,4)),
+		SPA_POD_Fraction(&SPA_FRACTION(24,1)),
+		SPA_POD_Array(sizeof(int64_t), SPA_TYPE_Long, SPA_N_ELEMENTS(longs), longs),
+		SPA_POD_Pointer(SPA_TYPE_Object, &b),
+		SPA_POD_Fd(3),
+		SPA_POD_Pod(&pi));
+
+	spa_debug_pod(0, NULL, pod);
+
+	spa_pod_parser_pod(&p, pod);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_bool(&p, &val.b) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_id(&p, &val.I) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_int(&p, &val.i) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_long(&p, &val.l) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_float(&p, &val.f) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_double(&p, &val.d) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_string(&p, &val.s) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_rectangle(&p, &val.R) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_fraction(&p, &val.F) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_fd(&p, &val.h) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_pod(&p, &val.P) == 0);
+	spa_assert_se(p.state.offset == 272);
+	spa_assert_se(spa_pod_is_struct(val.P));
+
+	spa_pod_parser_pod(&p, val.P);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Format, NULL) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_struct(&p, &f) == 0);
+	spa_assert_se(f.pod.type == SPA_TYPE_Struct);
+	spa_assert_se(f.pod.size == 264);
+	spa_assert_se(f.offset == 0);
+	spa_assert_se(p.state.frame == &f);
+	spa_assert_se(spa_pod_parser_frame(&p, &f) == val.P);
+	spa_assert_se(p.state.offset == 8);
+	spa_assert_se(spa_pod_parser_get_bool(&p, &val.b) == 0 && val.b == true);
+	spa_assert_se(p.state.offset == 24);
+	spa_assert_se(spa_pod_parser_get_id(&p, &val.I) == 0 && val.I == SPA_TYPE_Id);
+	spa_assert_se(p.state.offset == 40);
+	spa_assert_se(spa_pod_parser_get_int(&p, &val.i) == 0 && val.i == 3);
+	spa_assert_se(p.state.offset == 56);
+	spa_assert_se(spa_pod_parser_get_long(&p, &val.l) == 0 && val.l == 4);
+	spa_assert_se(p.state.offset == 72);
+	spa_assert_se(spa_pod_parser_get_float(&p, &val.f) == 0 && val.f == 0.453f);
+	spa_assert_se(p.state.offset == 88);
+	spa_assert_se(spa_pod_parser_get_double(&p, &val.d) == 0 && val.d == 0.871);
+	spa_assert_se(p.state.offset == 104);
+	spa_assert_se(spa_pod_parser_get_string(&p, &val.s) == 0 && spa_streq(val.s, "test"));
+	spa_assert_se(p.state.offset == 120);
+	spa_assert_se(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == 0);
+	spa_assert_se(val.yl == sizeof(bytes));
+	spa_assert_se(memcmp(bytes, val.y, sizeof(bytes)) == 0);
+	spa_assert_se(p.state.offset == 136);
+	spa_assert_se(spa_pod_parser_get_rectangle(&p, &val.R) == 0);
+	spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3,4), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(p.state.offset == 152);
+	spa_assert_se(spa_pod_parser_get_fraction(&p, &val.F) == 0);
+	spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24,1), sizeof(struct spa_fraction)) == 0);
+	spa_assert_se(p.state.offset == 168);
+	val.P = spa_pod_parser_next(&p);
+	spa_assert_se(val.P != NULL);
+	spa_assert_se(spa_pod_is_array(val.P));
+	spa_assert_se(p.state.offset == 216);
+	spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(val.P) == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(val.P) == sizeof(int64_t));
+	spa_assert_se(SPA_POD_ARRAY_N_VALUES(val.P) == SPA_N_ELEMENTS(longs));
+	spa_assert_se(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == 0);
+	spa_assert_se(val.ptype == SPA_TYPE_Object);
+	spa_assert_se(val.p == &b);
+	spa_assert_se(p.state.offset == 240);
+	spa_assert_se(spa_pod_parser_get_fd(&p, &val.h) == 0);
+	spa_assert_se(val.h == 3);
+	spa_assert_se(p.state.offset == 256);
+	spa_assert_se(spa_pod_parser_get_pod(&p, &val.P) == 0);
+	spa_assert_se(p.state.offset == 272);
+	spa_assert_se(spa_pod_is_int(val.P));
+	spa_pod_parser_pop(&p, &f);
+	spa_assert_se(p.state.offset == 272);
+	spa_assert_se(p.state.frame == NULL);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_static)
+{
+	struct _test_format {
+		struct spa_pod_object fmt;
+
+		struct {
+			struct spa_pod_prop prop_media_type	SPA_ALIGNED(8);
+			uint32_t media_type;
+
+			struct spa_pod_prop prop_media_subtype	SPA_ALIGNED(8);
+			uint32_t media_subtype;
+
+			struct spa_pod_prop prop_format		SPA_ALIGNED(8);
+			struct {
+				struct spa_pod_choice_body choice;
+				uint32_t def_format;
+				uint32_t enum_format[2];
+			} format_vals;
+
+			struct spa_pod_prop prop_size		SPA_ALIGNED(8);
+			struct {
+				struct spa_pod_choice_body choice;
+				struct spa_rectangle def_size;
+				struct spa_rectangle min_size;
+				struct spa_rectangle max_size;
+			} size_vals;
+
+			struct spa_pod_prop prop_framerate	SPA_ALIGNED(8);
+			struct {
+				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_INIT_Object(sizeof(test_format.props) + sizeof(struct spa_pod_object_body),
+				SPA_TYPE_OBJECT_Format, 0),
+		{
+			SPA_POD_INIT_Prop(SPA_FORMAT_mediaType, 0,
+					  sizeof(test_format.props.media_type), SPA_TYPE_Id),
+			SPA_MEDIA_TYPE_video,
+
+			SPA_POD_INIT_Prop(SPA_FORMAT_mediaSubtype, 0,
+					  sizeof(test_format.props.media_subtype), SPA_TYPE_Id),
+			SPA_MEDIA_SUBTYPE_raw,
+
+			SPA_POD_INIT_Prop(SPA_FORMAT_VIDEO_format, 0,
+					  sizeof(test_format.props.format_vals), SPA_TYPE_Choice),
+			{
+				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_INIT_Prop(SPA_FORMAT_VIDEO_size, 0,
+					  sizeof(test_format.props.size_vals), SPA_TYPE_Choice),
+
+			{
+				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_INIT_Prop(SPA_FORMAT_VIDEO_framerate, 0,
+					  sizeof(test_format.props.framerate_vals), SPA_TYPE_Choice),
+			{
+				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)
+			}
+		}
+	};
+	struct {
+		uint32_t media_type;
+		uint32_t media_subtype;
+		uint32_t format;
+		struct spa_rectangle size;
+		struct spa_fraction framerate;
+	} vals;
+	int res;
+
+	spa_debug_pod(0, NULL, &test_format.fmt.pod);
+
+	spa_zero(vals);
+	res = spa_pod_parse_object(&test_format.fmt.pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,       SPA_POD_Id(&vals.media_type),
+		SPA_FORMAT_mediaSubtype,    SPA_POD_Id(&vals.media_subtype),
+		SPA_FORMAT_VIDEO_format,    SPA_POD_Id(&vals.format),
+		SPA_FORMAT_VIDEO_size,      SPA_POD_Rectangle(&vals.size),
+		SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&vals.framerate));
+
+	spa_assert_se(res == -EPROTO);
+	spa_assert_se(vals.media_type == SPA_MEDIA_TYPE_video);
+	spa_assert_se(vals.media_subtype == SPA_MEDIA_SUBTYPE_raw);
+	spa_assert_se(vals.format == 0);
+	spa_assert_se(vals.size.width == 0 && vals.size.height == 0);
+	spa_assert_se(vals.framerate.num == 0 && vals.framerate.denom == 0);
+
+	spa_pod_fixate(&test_format.fmt.pod);
+
+	spa_zero(vals);
+	res = spa_pod_parse_object(&test_format.fmt.pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,       SPA_POD_Id(&vals.media_type),
+		SPA_FORMAT_mediaSubtype,    SPA_POD_Id(&vals.media_subtype),
+		SPA_FORMAT_VIDEO_format,    SPA_POD_Id(&vals.format),
+		SPA_FORMAT_VIDEO_size,      SPA_POD_Rectangle(&vals.size),
+		SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&vals.framerate));
+
+	spa_assert_se(res == 5);
+	spa_assert_se(vals.media_type == SPA_MEDIA_TYPE_video);
+	spa_assert_se(vals.media_subtype == SPA_MEDIA_SUBTYPE_raw);
+	spa_assert_se(vals.format == SPA_VIDEO_FORMAT_I420);
+	spa_assert_se(vals.size.width == 320 && vals.size.height == 243);
+	spa_assert_se(vals.framerate.num == 25 && vals.framerate.denom == 1);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_overflow)
+{
+	static const char * const labels[] = {
+		"640x480p59", "720x480i29", "720x480p59", "720x576i25", "720x576p50",
+		"1280x720p24", "1280x720p25", "1280x720p30", "1280x720p50", "1280x720p60",
+		"1920x1080p24", "1920x1080p25", "1920x1080p30", "1920x1080i25", "1920x1080p50",
+		"1920x1080i30", "1920x1080p60", "640x350p85", "640x400p85", "720x400p85",
+		"640x480p72", "640x480p75", "640x480p85", "800x600p56", "800x600p60",
+		"800x600p72", "800x600p75", "800x600p85", "800x600p119", "848x480p60",
+		"1024x768i43", "1024x768p60", "1024x768p70", "1024x768p75", "1024x768p84",
+		"1024x768p119", "1152x864p75", "1280x768p59", "1280x768p59", "1280x768p74",
+		"1280x768p84", "1280x768p119", "1280x800p59", "1280x800p59", "1280x800p74",
+		"1280x800p84", "1280x800p119", "1280x960p60", "1280x960p85", "1280x960p119",
+		"1280x1024p60", "1280x1024p75", "1280x1024p85", "1280x1024p119", "1360x768p60",
+		"1360x768p119", "1366x768p59", "1366x768p60", "1400x1050p59", "1400x1050p59",
+		"1400x1050p74", "1400x1050p84", "1400x1050p119", "1440x900p59", "1440x900p59",
+		"1440x900p74", "1440x900p84", "1440x900p119", "1600x900p60", "1600x1200p60",
+		"1600x1200p65", "1600x1200p70", "1600x1200p75", "1600x1200p85", "1600x1200p119",
+		"1680x1050p59", "1680x1050p59", "1680x1050p74", "1680x1050p84", "1680x1050p119",
+		"1792x1344p59", "1792x1344p74", "1792x1344p119", "1856x1392p59", "1856x1392p75",
+		"1856x1392p119", "1920x1200p59", "1920x1200p59", "1920x1200p74", "1920x1200p84",
+		"1920x1200p119", "1920x1440p60", "1920x1440p75", "1920x1440p119", "2048x1152p60",
+		"2560x1600p59", "2560x1600p59", "2560x1600p74", "2560x1600p84", "2560x1600p119",
+		"3840x2160p24", "3840x2160p25", "3840x2160p30", "3840x2160p50", "3840x2160p60",
+		"4096x2160p24", "4096x2160p25", "4096x2160p30", "4096x2160p50", "4096x2160p59",
+		"4096x2160p60", NULL };
+
+	uint8_t buffer[1024];
+	struct spa_pod_builder b = { 0 };
+	struct spa_pod_builder_state state;
+	struct spa_pod_frame f[2];
+	uint32_t idx;
+	struct spa_pod *pod;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+
+	spa_pod_builder_push_object(&b, &f[0], SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo);
+	spa_pod_builder_add(&b,
+			SPA_PROP_INFO_id,    SPA_POD_Id(32567359),
+			SPA_PROP_INFO_type,  SPA_POD_CHOICE_ENUM_Int(1, 0),
+			SPA_PROP_INFO_description,  SPA_POD_String("DV Timings"),
+			0);
+
+	spa_pod_builder_get_state(&b, &state),
+
+	spa_pod_builder_prop(&b, SPA_PROP_INFO_labels, 0);
+	spa_pod_builder_push_struct(&b, &f[1]);
+
+	for (idx = 0; labels[idx]; idx++) {
+		spa_pod_builder_int(&b, idx);
+		spa_pod_builder_string(&b, labels[idx]);
+	}
+	spa_assert_se(b.state.offset > sizeof(buffer));
+	pod = spa_pod_builder_pop(&b, &f[1]);
+	spa_assert_se(pod == NULL);
+	spa_pod_builder_reset(&b, &state);
+
+	spa_pod_builder_prop(&b, SPA_PROP_INFO_labels, 0);
+	spa_pod_builder_push_struct(&b, &f[1]);
+	pod = spa_pod_builder_pop(&b, &f[1]);
+
+	spa_assert_se(b.state.offset < sizeof(buffer));
+	pod = spa_pod_builder_pop(&b, &f[0]);
+	spa_assert_se(pod != NULL);
+
+	spa_debug_pod(0, NULL, pod);
+	return PWTEST_PASS;
+}
+
+static int handle_overflow(void *data, uint32_t size)
+{
+	uint32_t *d = data;
+	(*d)++;
+	return -ENOSPC;
+}
+
+static struct spa_pod_builder_callbacks overflow_cb = {
+	SPA_VERSION_POD_BUILDER_CALLBACKS,
+	.overflow = handle_overflow
+};
+
+PWTEST(pod_overflow2)
+{
+	uint8_t buffer[1024];
+	struct spa_pod_builder b = { 0 };
+	struct spa_pod_builder_state state;
+	struct spa_pod_frame f[2];
+	uint32_t idx, overflow_count = 0;
+	struct spa_pod *pod;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_pod_builder_set_callbacks(&b, &overflow_cb, &overflow_count);
+
+	spa_pod_builder_push_object(&b, &f[0], SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo);
+	spa_pod_builder_add(&b,
+			SPA_PROP_INFO_id,    SPA_POD_Id(32567359),
+			SPA_PROP_INFO_type,  SPA_POD_CHOICE_ENUM_Int(1, 0),
+			SPA_PROP_INFO_description,  SPA_POD_String("DV Timings"),
+			0);
+
+	spa_pod_builder_get_state(&b, &state),
+
+	spa_pod_builder_prop(&b, SPA_PROP_INFO_labels, 0);
+	spa_pod_builder_push_struct(&b, &f[1]);
+
+	for (idx = 0; idx < 512; idx++) {
+		spa_pod_builder_int(&b, idx);
+		spa_pod_builder_string(&b, "foo");
+	}
+	spa_assert_se(b.state.offset > sizeof(buffer));
+	pod = spa_pod_builder_pop(&b, &f[1]);
+	spa_assert_se(pod == NULL);
+	spa_assert_se(overflow_count == 1);
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(spa_pod)
+{
+	pwtest_add(pod_abi_sizes, PWTEST_NOARG);
+	pwtest_add(pod_abi, PWTEST_NOARG);
+	pwtest_add(pod_init, PWTEST_NOARG);
+	pwtest_add(pod_empty, PWTEST_NOARG);
+	pwtest_add(pod_build, PWTEST_NOARG);
+	pwtest_add(pod_varargs, PWTEST_NOARG);
+	pwtest_add(pod_varargs2, PWTEST_NOARG);
+	pwtest_add(pod_parser, PWTEST_NOARG);
+	pwtest_add(pod_parser2, PWTEST_NOARG);
+	pwtest_add(pod_static, PWTEST_NOARG);
+	pwtest_add(pod_overflow, PWTEST_NOARG);
+	pwtest_add(pod_overflow2, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}