diff --git a/spa/include/spa/format-builder.h b/spa/include/spa/format-builder.h
index 252e7ddf4..bee044f02 100644
--- a/spa/include/spa/format-builder.h
+++ b/spa/include/spa/format-builder.h
@@ -47,7 +47,7 @@ static inline uint32_t
 spa_pod_builder_format (SpaPODBuilder *builder,
                         uint32_t       media_type,
                         uint32_t       media_subtype,
-                        uint32_t       propid, ...)
+                        uint32_t       type, ...)
 {
   SpaPODFrame f;
   va_list args;
@@ -55,8 +55,8 @@ spa_pod_builder_format (SpaPODBuilder *builder,
 
   off = spa_pod_builder_push_format (builder, &f, media_type, media_subtype);
 
-  va_start (args, propid);
-  spa_pod_builder_propv (builder, propid, args);
+  va_start (args, type);
+  spa_pod_builder_addv (builder, type, args);
   va_end (args);
 
   spa_pod_builder_pop (builder, &f);
diff --git a/spa/include/spa/pod-builder.h b/spa/include/spa/pod-builder.h
index 142d7a65f..4a617a056 100644
--- a/spa/include/spa/pod-builder.h
+++ b/spa/include/spa/pod-builder.h
@@ -126,9 +126,9 @@ spa_pod_builder_string_body (SpaPODBuilder *builder,
                              const char    *str,
                              uint32_t       len)
 {
-  uint32_t out = spa_pod_builder_raw (builder, str, len + 1 , true);
+  uint32_t out = spa_pod_builder_raw (builder, str, len, true);
   if (out != -1)
-    *SPA_MEMBER (builder->data, out + len, char) = '\0';
+    *SPA_MEMBER (builder->data, out + len-1, char) = '\0';
   return out;
 }
 
@@ -194,7 +194,7 @@ spa_pod_builder_double (SpaPODBuilder *builder, double val)
 static inline uint32_t
 spa_pod_builder_string_len (SpaPODBuilder *builder, const char *str, uint32_t len)
 {
-  const SpaPODString p = { { len + 1, SPA_POD_TYPE_STRING } };
+  const SpaPODString p = { { len, SPA_POD_TYPE_STRING } };
   uint32_t out = spa_pod_builder_raw (builder, &p, sizeof (p) , false);
   if (spa_pod_builder_string_body (builder, str, len) == -1)
     out = -1;
@@ -205,7 +205,7 @@ static inline uint32_t
 spa_pod_builder_string (SpaPODBuilder *builder, const char *str)
 {
   uint32_t len = str ? strlen (str) : 0;
-  return spa_pod_builder_string_len (builder, str ? str : "", len);
+  return spa_pod_builder_string_len (builder, str ? str : "", len + 1);
 }
 
 static inline uint32_t
@@ -290,107 +290,6 @@ spa_pod_builder_push_prop (SpaPODBuilder *builder,
                                spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD), false));
 }
 
-static inline void
-spa_pod_builder_propv (SpaPODBuilder *builder,
-                       uint32_t       propid,
-                       va_list        args)
-{
-  while (propid != 0) {
-    uint32_t type, n_alternatives = -1;
-    SpaPODProp *prop = NULL;
-    SpaPODFrame f;
-    uint32_t off;
-
-    if ((off = spa_pod_builder_push_prop (builder, &f, propid, SPA_POD_PROP_FLAG_READWRITE)) != -1)
-      prop = SPA_MEMBER (builder->data, off, SpaPODProp);
-
-    type = va_arg (args, uint32_t);
-
-    while (n_alternatives != 0) {
-      switch (type) {
-        case SPA_POD_TYPE_INVALID:
-          break;
-        case SPA_POD_TYPE_BOOL:
-          spa_pod_builder_bool (builder, va_arg (args, int));
-          break;
-        case SPA_POD_TYPE_URI:
-          spa_pod_builder_uri (builder, va_arg (args, int32_t));
-          break;
-        case SPA_POD_TYPE_INT:
-          spa_pod_builder_int (builder, va_arg (args, int32_t));
-          break;
-        case SPA_POD_TYPE_LONG:
-          spa_pod_builder_long (builder, va_arg (args, int64_t));
-          break;
-        case SPA_POD_TYPE_FLOAT:
-          spa_pod_builder_float (builder, va_arg (args, double));
-          break;
-        case SPA_POD_TYPE_DOUBLE:
-          spa_pod_builder_double (builder, va_arg (args, double));
-          break;
-        case SPA_POD_TYPE_STRING:
-          spa_pod_builder_string (builder, va_arg (args, char *));
-          break;
-        case SPA_POD_TYPE_RECTANGLE:
-        {
-          uint32_t width = va_arg (args, uint32_t), height = va_arg (args, uint32_t);
-          spa_pod_builder_rectangle (builder, width, height);
-          break;
-        }
-        case SPA_POD_TYPE_FRACTION:
-        {
-          uint32_t num = va_arg (args, uint32_t), denom = va_arg (args, uint32_t);
-          spa_pod_builder_fraction (builder, num, denom);
-          break;
-        }
-        case SPA_POD_TYPE_BITMASK:
-          break;
-        case SPA_POD_TYPE_ARRAY:
-        case SPA_POD_TYPE_STRUCT:
-        case SPA_POD_TYPE_OBJECT:
-        case SPA_POD_TYPE_PROP:
-          break;
-      }
-      if (n_alternatives == -1) {
-        uint32_t flags = va_arg (args, uint32_t);
-        if (prop)
-          prop->body.flags = flags;
-
-        switch (flags & SPA_POD_PROP_RANGE_MASK) {
-          case SPA_POD_PROP_RANGE_NONE:
-            n_alternatives = 0;
-            break;
-          case SPA_POD_PROP_RANGE_MIN_MAX:
-            n_alternatives = 2;
-            break;
-          case SPA_POD_PROP_RANGE_STEP:
-            n_alternatives = 3;
-            break;
-          case SPA_POD_PROP_RANGE_ENUM:
-          case SPA_POD_PROP_RANGE_MASK:
-            n_alternatives = va_arg (args, int);
-            break;
-        }
-      } else
-        n_alternatives--;
-    }
-    spa_pod_builder_pop (builder, &f);
-
-    propid = va_arg (args, uint32_t);
-  }
-}
-
-static inline void
-spa_pod_builder_prop (SpaPODBuilder *builder,
-                      uint32_t       propid, ...)
-{
-  va_list args;
-
-  va_start (args, propid);
-  spa_pod_builder_propv (builder, propid, args);
-  va_end (args);
-}
-
 static inline void
 spa_pod_builder_addv (SpaPODBuilder *builder,
                       uint32_t       type,
@@ -422,6 +321,13 @@ spa_pod_builder_addv (SpaPODBuilder *builder,
       case SPA_POD_TYPE_STRING:
         spa_pod_builder_string (builder, va_arg (args, char *));
         break;
+      case -SPA_POD_TYPE_STRING:
+      {
+        char *str = va_arg (args, char *);
+        uint32_t len = va_arg (args, uint32_t);
+        spa_pod_builder_string_len (builder, str, len);
+        break;
+      }
       case SPA_POD_TYPE_RECTANGLE:
       {
         uint32_t width = va_arg (args, uint32_t), height = va_arg (args, uint32_t);
@@ -439,6 +345,8 @@ spa_pod_builder_addv (SpaPODBuilder *builder,
       case SPA_POD_TYPE_ARRAY:
       {
         SpaPODFrame *f = va_arg (args, SpaPODFrame *);
+        type = va_arg (args, uint32_t);
+        n_values = va_arg (args, uint32_t);
         spa_pod_builder_push_array (builder, f);
         break;
       }
diff --git a/spa/include/spa/pod.h b/spa/include/spa/pod.h
index b5b4abf43..c59ab566a 100644
--- a/spa/include/spa/pod.h
+++ b/spa/include/spa/pod.h
@@ -191,7 +191,7 @@ typedef struct {
 
 #define SPA_POD_PROP_ALTERNATIVE_FOREACH(body, _size, iter) \
   for ((iter) = SPA_MEMBER ((body), (body)->value.size + sizeof (SpaPODPropBody), __typeof__(*iter)); \
-       (iter) < SPA_MEMBER ((body), (_size), __typeof__(*iter)); \
+       (iter) <= SPA_MEMBER ((body), (_size)-(body)->value.size, __typeof__(*iter)); \
        (iter) = SPA_MEMBER ((iter), (body)->value.size, __typeof__(*iter)))
 
 static inline SpaPODProp *
diff --git a/spa/include/spa/props.h b/spa/include/spa/props.h
index daf114ef0..dd64e8fcc 100644
--- a/spa/include/spa/props.h
+++ b/spa/include/spa/props.h
@@ -42,7 +42,7 @@ spa_pod_builder_push_props (SpaPODBuilder *builder,
 
 static inline uint32_t
 spa_pod_builder_props (SpaPODBuilder *builder,
-                       uint32_t       propid, ...)
+                       uint32_t       type, ...)
 {
   SpaPODFrame f;
   va_list args;
@@ -50,8 +50,8 @@ spa_pod_builder_props (SpaPODBuilder *builder,
 
   off = spa_pod_builder_push_props (builder, &f);
 
-  va_start (args, propid);
-  spa_pod_builder_propv (builder, propid, args);
+  va_start (args, type);
+  spa_pod_builder_addv (builder, type, args);
   va_end (args);
 
   spa_pod_builder_pop (builder, &f);
diff --git a/spa/lib/debug.c b/spa/lib/debug.c
index 95bfc0ad8..59456f647 100644
--- a/spa/lib/debug.c
+++ b/spa/lib/debug.c
@@ -412,7 +412,7 @@ print_pod_value (uint32_t size, uint32_t type, void *body, int prefix)
       if (b->flags & SPA_POD_PROP_FLAG_UNSET)
         printf ("%-*sUnset (Default):\n", prefix + 4, "");
       else
-        printf ("%-*sValue:\n", prefix + 4, "");
+        printf ("%-*sValue: size %u\n", prefix + 4, "", b->value.size);
       print_pod_value (b->value.size, b->value.type, SPA_POD_BODY (&b->value), prefix + 6);
 
       i = 0;
diff --git a/spa/plugins/alsa/alsa-sink.c b/spa/plugins/alsa/alsa-sink.c
index 1212747b8..494cb48a8 100644
--- a/spa/plugins/alsa/alsa-sink.c
+++ b/spa/plugins/alsa/alsa-sink.c
@@ -68,6 +68,7 @@ spa_alsa_sink_node_get_props (SpaNode       *node,
 {
   SpaALSASink *this;
   SpaPODBuilder b = { NULL,  };
+  SpaPODFrame f;
 
   if (node == NULL || props == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -77,33 +78,44 @@ spa_alsa_sink_node_get_props (SpaNode       *node,
   spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
 
   *props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
-           PROP_ID_DEVICE,       SPA_POD_TYPE_STRING,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE,       SPA_POD_PROP_FLAG_READWRITE |
+                                 SPA_POD_PROP_RANGE_NONE,
+                                 -SPA_POD_TYPE_STRING, 1,
                                      this->props.device, sizeof (this->props.device),
-                                 SPA_POD_PROP_FLAG_READWRITE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE_NAME,  SPA_POD_PROP_FLAG_READABLE |
                                  SPA_POD_PROP_RANGE_NONE,
-           PROP_ID_DEVICE_NAME,  SPA_POD_TYPE_STRING,
+                                 -SPA_POD_TYPE_STRING, 1,
                                      this->props.device_name, sizeof (this->props.device_name),
-                                 SPA_POD_PROP_FLAG_READABLE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_CARD_NAME,    SPA_POD_PROP_FLAG_READABLE |
                                  SPA_POD_PROP_RANGE_NONE,
-           PROP_ID_CARD_NAME,    SPA_POD_TYPE_STRING,
+                                 -SPA_POD_TYPE_STRING, 1,
                                      this->props.card_name, sizeof (this->props.card_name),
-                                 SPA_POD_PROP_FLAG_READABLE |
-                                 SPA_POD_PROP_RANGE_NONE,
-           PROP_ID_PERIOD_SIZE,  SPA_POD_TYPE_INT,
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_PERIOD_SIZE,  SPA_POD_PROP_FLAG_READWRITE |
+                                 SPA_POD_PROP_RANGE_MIN_MAX,
+                                 SPA_POD_TYPE_INT, 3,
                                      this->props.period_size,
-                                 SPA_POD_PROP_FLAG_READWRITE |
-                                 SPA_POD_PROP_RANGE_MIN_MAX,
                                      1, INT32_MAX,
-           PROP_ID_PERIODS,      SPA_POD_TYPE_INT,
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_PERIODS,      SPA_POD_PROP_FLAG_READWRITE |
+                                 SPA_POD_PROP_RANGE_MIN_MAX,
+                                 SPA_POD_TYPE_INT, 3,
                                      this->props.periods,
-                                 SPA_POD_PROP_FLAG_READWRITE |
-                                 SPA_POD_PROP_RANGE_MIN_MAX,
                                      1, INT32_MAX,
-           PROP_ID_PERIOD_EVENT, SPA_POD_TYPE_BOOL,
-                                    this->props.period_event,
-                                 SPA_POD_PROP_FLAG_READWRITE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_PERIOD_EVENT, SPA_POD_PROP_FLAG_READWRITE |
                                  SPA_POD_PROP_RANGE_NONE,
-           0), SpaProps);
+                                 SPA_POD_TYPE_BOOL, 1,
+                                    this->props.period_event,
+       -SPA_POD_TYPE_PROP, &f, 0), SpaProps);
 
 
   return SPA_RESULT_OK;
@@ -329,6 +341,7 @@ spa_alsa_sink_node_port_enum_formats (SpaNode         *node,
   SpaFormat *fmt;
   uint8_t buffer[1024];
   SpaPODBuilder b = { NULL, };
+  SpaPODFrame f[2];
 
   if (node == NULL || format == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -344,24 +357,29 @@ next:
   switch (index++) {
     case 0:
       fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
-         SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
-           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_TYPE_INT,
+        SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
+        SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_ENUM,
+                                        SPA_POD_TYPE_INT, 3,
                                                 SPA_AUDIO_FORMAT_S16,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_ENUM, 2,
                                                 SPA_AUDIO_FORMAT_S16,
                                                 SPA_AUDIO_FORMAT_S32,
-           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_TYPE_INT,
+       -SPA_POD_TYPE_PROP, &f[0],
+        SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_INT, 3,
                                                 44100,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_MIN_MAX,
                                                 1, INT32_MAX,
-           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_TYPE_INT,
+       -SPA_POD_TYPE_PROP, &f[0],
+        SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_INT, 3,
                                                 2,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_MIN_MAX,
                                                 1, INT32_MAX,
-           0), SpaFormat);
+       -SPA_POD_TYPE_PROP, &f[0], 0), SpaFormat);
       break;
     case 1:
       fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
diff --git a/spa/plugins/alsa/alsa-source.c b/spa/plugins/alsa/alsa-source.c
index 983e1789c..d55bb44dc 100644
--- a/spa/plugins/alsa/alsa-source.c
+++ b/spa/plugins/alsa/alsa-source.c
@@ -68,6 +68,7 @@ spa_alsa_source_node_get_props (SpaNode       *node,
 {
   SpaALSASource *this;
   SpaPODBuilder b = { NULL,  };
+  SpaPODFrame f;
 
   if (node == NULL || props == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -77,33 +78,44 @@ spa_alsa_source_node_get_props (SpaNode       *node,
   spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
 
   *props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
-           PROP_ID_DEVICE,       SPA_POD_TYPE_STRING,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE,       SPA_POD_PROP_FLAG_READWRITE |
+                                 SPA_POD_PROP_RANGE_NONE,
+                                 -SPA_POD_TYPE_STRING, 1,
                                      this->props.device, sizeof (this->props.device),
-                                 SPA_POD_PROP_FLAG_READWRITE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE_NAME,  SPA_POD_PROP_FLAG_READABLE |
                                  SPA_POD_PROP_RANGE_NONE,
-           PROP_ID_DEVICE_NAME,  SPA_POD_TYPE_STRING,
+                                 -SPA_POD_TYPE_STRING, 1,
                                      this->props.device_name, sizeof (this->props.device_name),
-                                 SPA_POD_PROP_FLAG_READABLE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_CARD_NAME,    SPA_POD_PROP_FLAG_READABLE |
                                  SPA_POD_PROP_RANGE_NONE,
-           PROP_ID_CARD_NAME,    SPA_POD_TYPE_STRING,
+                                 -SPA_POD_TYPE_STRING, 1,
                                      this->props.card_name, sizeof (this->props.card_name),
-                                 SPA_POD_PROP_FLAG_READABLE |
-                                 SPA_POD_PROP_RANGE_NONE,
-           PROP_ID_PERIOD_SIZE,  SPA_POD_TYPE_INT,
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_PERIOD_SIZE,  SPA_POD_PROP_FLAG_READWRITE |
+                                 SPA_POD_PROP_RANGE_MIN_MAX,
+                                 SPA_POD_TYPE_INT, 3,
                                      this->props.period_size,
-                                 SPA_POD_PROP_FLAG_READWRITE |
-                                 SPA_POD_PROP_RANGE_MIN_MAX,
                                      1, INT32_MAX,
-           PROP_ID_PERIODS,      SPA_POD_TYPE_INT,
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_PERIODS,      SPA_POD_PROP_FLAG_READWRITE |
+                                 SPA_POD_PROP_RANGE_MIN_MAX,
+                                 SPA_POD_TYPE_INT, 3,
                                      this->props.periods,
-                                 SPA_POD_PROP_FLAG_READWRITE |
-                                 SPA_POD_PROP_RANGE_MIN_MAX,
                                      1, INT32_MAX,
-           PROP_ID_PERIOD_EVENT, SPA_POD_TYPE_BOOL,
-                                    this->props.period_event,
-                                 SPA_POD_PROP_FLAG_READWRITE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_PERIOD_EVENT, SPA_POD_PROP_FLAG_READWRITE |
                                  SPA_POD_PROP_RANGE_NONE,
-           0), SpaProps);
+                                 SPA_POD_TYPE_BOOL, 1,
+                                    this->props.period_event,
+       -SPA_POD_TYPE_PROP, &f, 0), SpaProps);
 
   return SPA_RESULT_OK;
 }
@@ -364,6 +376,7 @@ spa_alsa_source_node_port_enum_formats (SpaNode         *node,
   SpaFormat *fmt;
   uint8_t buffer[1024];
   SpaPODBuilder b = { NULL, };
+  SpaPODFrame f[2];
 
   if (node == NULL || format == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -380,23 +393,28 @@ next:
     case 0:
       fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
          SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
-           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_TYPE_INT,
+         SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_ENUM,
+                                        SPA_POD_TYPE_INT, 3,
                                                 SPA_AUDIO_FORMAT_S16,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_ENUM, 2,
                                                 SPA_AUDIO_FORMAT_S16,
                                                 SPA_AUDIO_FORMAT_S32,
-           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_TYPE_INT,
+        -SPA_POD_TYPE_PROP, &f[0],
+         SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_INT, 3,
                                                 44100,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_MIN_MAX,
                                                 1, INT32_MAX,
-           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_TYPE_INT,
+        -SPA_POD_TYPE_PROP, &f[0],
+         SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_INT, 3,
                                                 2,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_MIN_MAX,
                                                 1, INT32_MAX,
-           0), SpaFormat);
+        -SPA_POD_TYPE_PROP, &f[0], 0), SpaFormat);
       break;
     case 1:
       fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
diff --git a/spa/plugins/audiotestsrc/audiotestsrc.c b/spa/plugins/audiotestsrc/audiotestsrc.c
index 222d86264..0854bd89a 100644
--- a/spa/plugins/audiotestsrc/audiotestsrc.c
+++ b/spa/plugins/audiotestsrc/audiotestsrc.c
@@ -137,6 +137,7 @@ spa_audiotestsrc_node_get_props (SpaNode       *node,
 {
   SpaAudioTestSrc *this;
   SpaPODBuilder b = { NULL,  };
+  SpaPODFrame f;
 
   if (node == NULL || props == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -146,29 +147,36 @@ spa_audiotestsrc_node_get_props (SpaNode       *node,
   spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
 
   *props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
-           PROP_ID_LIVE,      SPA_POD_TYPE_BOOL,
-                                  this->props.live,
-                              SPA_POD_PROP_FLAG_READWRITE |
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_LIVE,      SPA_POD_PROP_FLAG_READWRITE |
                               SPA_POD_PROP_RANGE_NONE,
-           PROP_ID_WAVE,      SPA_POD_TYPE_INT,
+                              SPA_POD_TYPE_BOOL, 1,
+                                  this->props.live,
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_WAVE,      SPA_POD_PROP_FLAG_READWRITE |
+                              SPA_POD_PROP_RANGE_ENUM,
+                              SPA_POD_TYPE_INT, 3,
                                   this->props.wave,
-                              SPA_POD_PROP_FLAG_READWRITE |
-                              SPA_POD_PROP_RANGE_ENUM, 2,
                                   wave_val_sine,
                                   wave_val_square,
-           PROP_ID_FREQ,      SPA_POD_TYPE_DOUBLE,
-                                  this->props.freq,
-                              SPA_POD_PROP_FLAG_READWRITE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_FREQ,      SPA_POD_PROP_FLAG_READWRITE |
                               SPA_POD_PROP_RANGE_MIN_MAX,
+                              SPA_POD_TYPE_DOUBLE, 3,
+                                  this->props.freq,
                                   0.0,
                                   50000000.0,
-           PROP_ID_VOLUME,    SPA_POD_TYPE_DOUBLE,
-                                  this->props.volume,
-                              SPA_POD_PROP_FLAG_READWRITE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_VOLUME,    SPA_POD_PROP_FLAG_READWRITE |
                               SPA_POD_PROP_RANGE_MIN_MAX,
+                              SPA_POD_TYPE_DOUBLE, 3,
+                                  this->props.volume,
                                   0.0,
                                   10.0,
-           0), SpaProps);
+       -SPA_POD_TYPE_PROP, &f, 0), SpaProps);
 
   return SPA_RESULT_OK;
 }
@@ -462,6 +470,7 @@ spa_audiotestsrc_node_port_enum_formats (SpaNode          *node,
   SpaFormat *fmt;
   uint8_t buffer[256];
   SpaPODBuilder b = { NULL, };
+  SpaPODFrame f[2];
 
   if (node == NULL || format == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -478,23 +487,28 @@ next:
     case 0:
       fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
          SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
-           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_TYPE_INT,
+         SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_ENUM,
+                                        SPA_POD_TYPE_INT, 3,
                                                 SPA_AUDIO_FORMAT_S16,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_ENUM, 2,
                                                 SPA_AUDIO_FORMAT_S16,
                                                 SPA_AUDIO_FORMAT_S32,
-           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_TYPE_INT,
+        -SPA_POD_TYPE_PROP, &f[0],
+         SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_INT, 3,
                                                 44100,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_MIN_MAX,
                                                 1, INT32_MAX,
-           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_TYPE_INT,
+        -SPA_POD_TYPE_PROP, &f[0],
+         SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_INT, 3,
                                                 2,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_MIN_MAX,
                                                 1, INT32_MAX,
-           0), SpaFormat);
+        -SPA_POD_TYPE_PROP, &f[0], 0), SpaFormat);
       break;
     default:
       return SPA_RESULT_ENUM_END;
@@ -587,6 +601,7 @@ spa_audiotestsrc_node_port_get_format (SpaNode          *node,
 {
   SpaAudioTestSrc *this;
   SpaPODBuilder b = { NULL, };
+  SpaPODFrame f;
 
   if (node == NULL || format == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -603,16 +618,21 @@ spa_audiotestsrc_node_port_get_format (SpaNode          *node,
 
   *format = SPA_MEMBER (b.data, spa_pod_builder_format (&b,
          SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
-           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_TYPE_INT,
+         SPA_POD_TYPE_PROP, &f,
+           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_INT, 1,
                                                 this->current_format.info.raw.format,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_TYPE_INT,
+        -SPA_POD_TYPE_PROP, &f,
+         SPA_POD_TYPE_PROP, &f,
+           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_INT, 1,
                                                 this->current_format.info.raw.rate,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_TYPE_INT,
+        -SPA_POD_TYPE_PROP, &f,
+         SPA_POD_TYPE_PROP, &f,
+           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_INT, 1,
                                                 this->current_format.info.raw.channels,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           0), SpaFormat);
+        -SPA_POD_TYPE_PROP, &f, 0), SpaFormat);
 
   return SPA_RESULT_OK;
 }
diff --git a/spa/plugins/v4l2/v4l2-source.c b/spa/plugins/v4l2/v4l2-source.c
index d25f04a30..4bc1c678d 100644
--- a/spa/plugins/v4l2/v4l2-source.c
+++ b/spa/plugins/v4l2/v4l2-source.c
@@ -151,32 +151,36 @@ spa_v4l2_source_node_get_props (SpaNode       *node,
 {
   SpaV4l2Source *this;
   SpaPODBuilder b = { NULL,  };
+  SpaPODFrame f;
 
   if (node == NULL || props == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
 
   this = SPA_CONTAINER_OF (node, SpaV4l2Source, node);
 
-  b.data = this->props_buffer;
-  b.size = sizeof (this->props_buffer);
+  spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
 
   *props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
-
-           PROP_ID_DEVICE,      SPA_POD_TYPE_STRING,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE,      SPA_POD_PROP_FLAG_READWRITE |
+                                SPA_POD_PROP_RANGE_NONE,
+                                -SPA_POD_TYPE_STRING, 1,
                                     this->props.device, sizeof (this->props.device),
-                                SPA_POD_PROP_FLAG_READWRITE |
-                                SPA_POD_PROP_RANGE_NONE,
 
-           PROP_ID_DEVICE_NAME, SPA_POD_TYPE_STRING,
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE_NAME, SPA_POD_PROP_FLAG_READABLE |
+                                SPA_POD_PROP_RANGE_NONE,
+                                -SPA_POD_TYPE_STRING, 1,
                                     this->props.device_name, sizeof (this->props.device_name),
-                                SPA_POD_PROP_FLAG_READABLE |
-                                SPA_POD_PROP_RANGE_NONE,
 
-           PROP_ID_DEVICE_FD,   SPA_POD_TYPE_INT,
-                                    this->props.device_fd,
-                                SPA_POD_PROP_FLAG_READABLE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE_FD,   SPA_POD_PROP_FLAG_READABLE |
                                 SPA_POD_PROP_RANGE_NONE,
-           0), SpaProps);
+                                SPA_POD_TYPE_INT, 1,
+                                    this->props.device_fd,
+       -SPA_POD_TYPE_PROP, &f, 0), SpaProps);
 
   return SPA_RESULT_OK;
 }
@@ -561,7 +565,7 @@ spa_v4l2_source_node_port_get_format (SpaNode          *node,
   SpaV4l2Source *this;
   SpaV4l2State *state;
   SpaPODBuilder b = { NULL, };
-  SpaPODFrame f;
+  SpaPODFrame f[2];
 
   if (node == NULL || format == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -579,51 +583,61 @@ spa_v4l2_source_node_port_get_format (SpaNode          *node,
   b.data = state->format_buffer;
   b.size = sizeof (state->format_buffer);
 
-  *format = SPA_POD_BUILDER_DEREF (&b, spa_pod_builder_push_format (&b, &f,
-                                           state->current_format.media_type,
-                                           state->current_format.media_subtype),
-                                   SpaFormat);
+  spa_pod_builder_push_format (&b, &f[0],
+                               state->current_format.media_type,
+                               state->current_format.media_subtype);
 
   switch (state->current_format.media_subtype) {
     case SPA_MEDIA_SUBTYPE_RAW:
-      spa_pod_builder_prop (&b,
-           SPA_PROP_ID_VIDEO_FORMAT,    SPA_POD_TYPE_INT,
+      spa_pod_builder_add (&b,
+          SPA_POD_TYPE_PROP, &f[1],
+           SPA_PROP_ID_VIDEO_FORMAT,    SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_INT, 1,
                                                 state->current_format.info.raw.format,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_TYPE_RECTANGLE,
+         -SPA_POD_TYPE_PROP, &f[1],
+          SPA_POD_TYPE_PROP, &f[1],
+           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_RECTANGLE, 1,
                                                 state->current_format.info.raw.size.width,
                                                 state->current_format.info.raw.size.height,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_TYPE_FRACTION,
+         -SPA_POD_TYPE_PROP, &f[1],
+          SPA_POD_TYPE_PROP, &f[1],
+           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_FRACTION, 1,
                                                 state->current_format.info.raw.framerate.num,
                                                 state->current_format.info.raw.framerate.denom,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           0);
+         -SPA_POD_TYPE_PROP, &f[1], 0);
       break;
     case SPA_MEDIA_SUBTYPE_MJPG:
     case SPA_MEDIA_SUBTYPE_JPEG:
-      spa_pod_builder_prop (&b,
-           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_TYPE_RECTANGLE,
+      spa_pod_builder_add (&b,
+          SPA_POD_TYPE_PROP, &f[1],
+           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_RECTANGLE, 1,
                                                 state->current_format.info.mjpg.size.width,
                                                 state->current_format.info.mjpg.size.height,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_TYPE_FRACTION,
+         -SPA_POD_TYPE_PROP, &f[1],
+          SPA_POD_TYPE_PROP, &f[1],
+           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_FRACTION, 1,
                                                 state->current_format.info.mjpg.framerate.num,
                                                 state->current_format.info.mjpg.framerate.denom,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           0);
+         -SPA_POD_TYPE_PROP, &f[1], 0);
       break;
     case SPA_MEDIA_SUBTYPE_H264:
-      spa_pod_builder_prop (&b,
-           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_TYPE_RECTANGLE,
+      spa_pod_builder_add (&b,
+          SPA_POD_TYPE_PROP, &f[1],
+           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_RECTANGLE, 1,
                                                 state->current_format.info.h264.size.width,
                                                 state->current_format.info.h264.size.height,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_TYPE_FRACTION,
+         -SPA_POD_TYPE_PROP, &f[1],
+          SPA_POD_TYPE_PROP, &f[1],
+           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_FRACTION, 1,
                                                 state->current_format.info.h264.framerate.num,
                                                 state->current_format.info.h264.framerate.denom,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           0);
+         -SPA_POD_TYPE_PROP, &f[1], 0);
       break;
     case SPA_MEDIA_SUBTYPE_DV:
     case SPA_MEDIA_SUBTYPE_MPEGTS:
@@ -636,7 +650,9 @@ spa_v4l2_source_node_port_get_format (SpaNode          *node,
     default:
       return SPA_RESULT_NO_FORMAT;
   }
-  spa_pod_builder_pop (&b, &f);
+  spa_pod_builder_pop (&b, &f[0]);
+
+  *format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
 
   return SPA_RESULT_OK;
 }
diff --git a/spa/plugins/v4l2/v4l2-utils.c b/spa/plugins/v4l2/v4l2-utils.c
index fbca4ccd5..f25431840 100644
--- a/spa/plugins/v4l2/v4l2-utils.c
+++ b/spa/plugins/v4l2/v4l2-utils.c
@@ -603,34 +603,35 @@ have_size:
     }
   }
 
-  fmt = SPA_MEMBER (b.data,
-                    spa_pod_builder_push_format (&b, &f[0],
-                                                 info->media_type,
-                                                 info->media_subtype),
-                    SpaFormat);
+  spa_pod_builder_push_format (&b, &f[0],
+                               info->media_type,
+                               info->media_subtype),
+
+  fmt = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
 
   if (info->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
-    spa_pod_builder_prop (&b,
-        SPA_PROP_ID_VIDEO_FORMAT,  SPA_POD_TYPE_INT,
+    spa_pod_builder_add (&b,
+        SPA_POD_TYPE_PROP, &f[1],
+          SPA_PROP_ID_VIDEO_FORMAT,  SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_READWRITE,
+                                     SPA_POD_TYPE_INT, 1,
                                         info->format,
-                                   SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_READWRITE,
-        0);
+       -SPA_POD_TYPE_PROP, &f[1], 0);
   }
+  spa_pod_builder_add (&b,
+      SPA_POD_TYPE_PROP, &f[1],
+        SPA_PROP_ID_VIDEO_SIZE,    SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_READWRITE,
+                                   SPA_POD_TYPE_RECTANGLE, 1,
+                                    state->frmsize.discrete.width,
+                                    state->frmsize.discrete.height,
+     -SPA_POD_TYPE_PROP, &f[1], 0);
 
-  spa_pod_builder_prop (&b,
-      SPA_PROP_ID_VIDEO_SIZE,  SPA_POD_TYPE_RECTANGLE,
-                                      state->frmsize.discrete.width,
-                                      state->frmsize.discrete.height,
-                               SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_READWRITE,
-      0);
+  spa_pod_builder_push_prop (&b, &f[1],
+                             SPA_PROP_ID_VIDEO_FRAMERATE,
+                             SPA_POD_PROP_RANGE_NONE |
+                             SPA_POD_PROP_FLAG_UNSET |
+                             SPA_POD_PROP_FLAG_READWRITE);
 
-  prop = SPA_MEMBER (b.data,
-                     spa_pod_builder_push_prop (&b, &f[1],
-                                                SPA_PROP_ID_VIDEO_FRAMERATE,
-                                                SPA_POD_PROP_RANGE_NONE |
-                                                SPA_POD_PROP_FLAG_UNSET |
-                                                SPA_POD_PROP_FLAG_READWRITE),
-                     SpaPODProp);
+  prop = SPA_POD_BUILDER_DEREF (&b, f[1].ref, SpaPODProp);
   n_fractions = 0;
 
   state->frmival.index = 0;
diff --git a/spa/plugins/videotestsrc/videotestsrc.c b/spa/plugins/videotestsrc/videotestsrc.c
index 96ae7d2a4..4f938b146 100644
--- a/spa/plugins/videotestsrc/videotestsrc.c
+++ b/spa/plugins/videotestsrc/videotestsrc.c
@@ -129,6 +129,7 @@ spa_videotestsrc_node_get_props (SpaNode       *node,
 {
   SpaVideoTestSrc *this;
   SpaPODBuilder b = { NULL,  };
+  SpaPODFrame f;
 
   if (node == NULL || props == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -138,17 +139,20 @@ spa_videotestsrc_node_get_props (SpaNode       *node,
   spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
 
   *props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
-           PROP_ID_LIVE,      SPA_POD_TYPE_BOOL,
-                                  this->props.live,
-                              SPA_POD_PROP_FLAG_READWRITE |
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_LIVE,      SPA_POD_PROP_FLAG_READWRITE |
                               SPA_POD_PROP_RANGE_NONE,
-           PROP_ID_PATTERN,   SPA_POD_TYPE_INT,
+                              SPA_POD_TYPE_BOOL, 1,
+                                  this->props.live,
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_PATTERN,   SPA_POD_PROP_FLAG_READWRITE |
+                              SPA_POD_PROP_RANGE_ENUM,
+                              SPA_POD_TYPE_INT, 3,
                                   this->props.pattern,
-                              SPA_POD_PROP_FLAG_READWRITE |
-                              SPA_POD_PROP_RANGE_ENUM, 2,
                                   pattern_val_smpte_snow,
                                   pattern_val_snow,
-           0), SpaProps);
+       -SPA_POD_TYPE_PROP, &f, 0), SpaProps);
 
   return SPA_RESULT_OK;
 }
@@ -431,6 +435,7 @@ spa_videotestsrc_node_port_enum_formats (SpaNode          *node,
   SpaFormat *fmt;
   uint8_t buffer[1024];
   SpaPODBuilder b = { NULL, };
+  SpaPODFrame f[2];
 
   if (node == NULL || format == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -447,24 +452,30 @@ next:
     case 0:
       fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
          SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
-           SPA_PROP_ID_VIDEO_FORMAT,    SPA_POD_TYPE_INT,
+         SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_VIDEO_FORMAT,    SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_ENUM,
+                                        SPA_POD_TYPE_INT, 3,
                                                 SPA_VIDEO_FORMAT_RGB,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_ENUM, 2,
                                                 SPA_VIDEO_FORMAT_RGB,
                                                 SPA_VIDEO_FORMAT_UYVY,
-           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_TYPE_RECTANGLE,
-                                                320, 240,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+        -SPA_POD_TYPE_PROP, &f[0],
+         SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
                                         SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_RECTANGLE, 3,
+                                                320, 240,
                                                 1, 1,
                                                 INT32_MAX, INT32_MAX,
-           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_TYPE_FRACTION, 25, 1,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+        -SPA_POD_TYPE_PROP, &f[0],
+         SPA_POD_TYPE_PROP, &f[0],
+           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
                                         SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_FRACTION, 3,
+                                                25, 1,
                                                 0, 1,
                                                 INT32_MAX, 1,
-           0), SpaFormat);
+        -SPA_POD_TYPE_PROP, &f[0], 0), SpaFormat);
       break;
     default:
       return SPA_RESULT_ENUM_END;
@@ -569,6 +580,7 @@ spa_videotestsrc_node_port_get_format (SpaNode          *node,
 {
   SpaVideoTestSrc *this;
   SpaPODBuilder b = { NULL, };
+  SpaPODFrame f;
 
   if (node == NULL || format == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -585,18 +597,23 @@ spa_videotestsrc_node_port_get_format (SpaNode          *node,
 
   *format = SPA_MEMBER (b.data, spa_pod_builder_format (&b,
          SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
-           SPA_PROP_ID_VIDEO_FORMAT,    SPA_POD_TYPE_INT,
+         SPA_POD_TYPE_PROP, &f,
+           SPA_PROP_ID_VIDEO_FORMAT,    SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_INT, 1,
                                                 this->current_format.info.raw.format,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_TYPE_RECTANGLE,
+        -SPA_POD_TYPE_PROP, &f,
+         SPA_POD_TYPE_PROP, &f,
+           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_RECTANGLE, 1,
                                                 this->current_format.info.raw.size.width,
                                                 this->current_format.info.raw.size.height,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_TYPE_FRACTION,
+        -SPA_POD_TYPE_PROP, &f,
+         SPA_POD_TYPE_PROP, &f,
+           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_READWRITE,
+                                        SPA_POD_TYPE_FRACTION, 1,
                                                 this->current_format.info.raw.framerate.num,
                                                 this->current_format.info.raw.framerate.denom,
-                                        SPA_POD_PROP_FLAG_READWRITE,
-           0), SpaFormat);
+        -SPA_POD_TYPE_PROP, &f, 0), SpaFormat);
 
   return SPA_RESULT_OK;
 }
diff --git a/spa/plugins/volume/volume.c b/spa/plugins/volume/volume.c
index 5b0952530..bd59588ac 100644
--- a/spa/plugins/volume/volume.c
+++ b/spa/plugins/volume/volume.c
@@ -119,6 +119,7 @@ spa_volume_node_get_props (SpaNode        *node,
 {
   SpaVolume *this;
   SpaPODBuilder b = { NULL,  };
+  SpaPODFrame f;
 
   if (node == NULL || props == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -128,17 +129,20 @@ spa_volume_node_get_props (SpaNode        *node,
   spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
 
   *props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
-           PROP_ID_VOLUME,    SPA_POD_TYPE_DOUBLE,
-                                  this->props.volume,
-                              SPA_POD_PROP_FLAG_READWRITE |
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_VOLUME,    SPA_POD_PROP_FLAG_READWRITE |
                               SPA_POD_PROP_RANGE_MIN_MAX,
+                              SPA_POD_TYPE_DOUBLE, 3,
+                                  this->props.volume,
                                   0.0,
                                   10.0,
-           PROP_ID_MUTE,      SPA_POD_TYPE_BOOL,
-                                  this->props.mute,
-                              SPA_POD_PROP_FLAG_READWRITE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_MUTE,      SPA_POD_PROP_FLAG_READWRITE |
                               SPA_POD_PROP_RANGE_NONE,
-           0), SpaProps);
+                              SPA_POD_TYPE_BOOL, 1,
+                                  this->props.mute,
+       -SPA_POD_TYPE_PROP, &f, 0), SpaProps);
 
   return SPA_RESULT_OK;
 }
@@ -293,6 +297,7 @@ spa_volume_node_port_enum_formats (SpaNode          *node,
   SpaFormat *fmt;
   uint8_t buffer[1024];
   SpaPODBuilder b = { NULL, };
+  SpaPODFrame f;
 
   if (node == NULL || format == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -309,23 +314,28 @@ next:
     case 0:
       fmt = SPA_MEMBER (buffer, spa_pod_builder_format (&b,
          SPA_MEDIA_TYPE_AUDIO, SPA_MEDIA_SUBTYPE_RAW,
-           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_TYPE_INT,
+         SPA_POD_TYPE_PROP, &f,
+           SPA_PROP_ID_AUDIO_FORMAT,    SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_ENUM,
+                                        SPA_POD_TYPE_INT, 3,
                                                 SPA_AUDIO_FORMAT_S16,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_ENUM, 2,
                                                 SPA_AUDIO_FORMAT_S16,
                                                 SPA_AUDIO_FORMAT_S32,
-           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_TYPE_INT,
+        -SPA_POD_TYPE_PROP, &f,
+         SPA_POD_TYPE_PROP, &f,
+           SPA_PROP_ID_AUDIO_RATE,      SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_INT, 3,
                                                 44100,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_MIN_MAX,
                                                 1, INT32_MAX,
-           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_TYPE_INT,
+        -SPA_POD_TYPE_PROP, &f,
+         SPA_POD_TYPE_PROP, &f,
+           SPA_PROP_ID_AUDIO_CHANNELS,  SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
+                                        SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_INT, 3,
                                                 2,
-                                        SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE |
-                                        SPA_POD_PROP_RANGE_MIN_MAX,
                                                 1, INT32_MAX,
-           0), SpaFormat);
+        -SPA_POD_TYPE_PROP, &f, 0), SpaFormat);
       break;
     default:
       return SPA_RESULT_ENUM_END;
diff --git a/spa/plugins/xv/xv-sink.c b/spa/plugins/xv/xv-sink.c
index 528b89df7..6220ff9ee 100644
--- a/spa/plugins/xv/xv-sink.c
+++ b/spa/plugins/xv/xv-sink.c
@@ -120,6 +120,7 @@ spa_xv_sink_node_get_props (SpaNode       *node,
 {
   SpaXvSink *this;
   SpaPODBuilder b = { NULL,  };
+  SpaPODFrame f;
 
   if (node == NULL || props == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -129,22 +130,24 @@ spa_xv_sink_node_get_props (SpaNode       *node,
   spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
 
   *props = SPA_MEMBER (b.data, spa_pod_builder_props (&b,
-
-           PROP_ID_DEVICE,      SPA_POD_TYPE_STRING,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE,      SPA_POD_PROP_FLAG_READWRITE |
+                                SPA_POD_PROP_RANGE_NONE,
+                               -SPA_POD_TYPE_STRING, 1,
                                     this->props.device, sizeof (this->props.device),
-                                SPA_POD_PROP_FLAG_READWRITE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE_NAME, SPA_POD_PROP_FLAG_READABLE |
                                 SPA_POD_PROP_RANGE_NONE,
-
-           PROP_ID_DEVICE_NAME, SPA_POD_TYPE_STRING,
+                                -SPA_POD_TYPE_STRING, 1,
                                     this->props.device_name, sizeof (this->props.device_name),
-                                SPA_POD_PROP_FLAG_READABLE |
+       -SPA_POD_TYPE_PROP, &f,
+        SPA_POD_TYPE_PROP, &f,
+           PROP_ID_DEVICE_FD,   SPA_POD_PROP_FLAG_READABLE |
                                 SPA_POD_PROP_RANGE_NONE,
-
-           PROP_ID_DEVICE_FD,   SPA_POD_TYPE_INT,
+                                SPA_POD_TYPE_INT, 1,
                                     this->props.device_fd,
-                                SPA_POD_PROP_FLAG_READABLE |
-                                SPA_POD_PROP_RANGE_NONE,
-           0), SpaProps);
+       -SPA_POD_TYPE_PROP, &f, 0), SpaProps);
 
   return SPA_RESULT_OK;
 }
diff --git a/spa/tests/test-props.c b/spa/tests/test-props.c
index 126aaa7e0..3e7d71698 100644
--- a/spa/tests/test-props.c
+++ b/spa/tests/test-props.c
@@ -160,25 +160,32 @@ main (int argc, char *argv[])
 
   spa_pod_builder_init (&b, buffer, sizeof (buffer));
 
-  o = spa_pod_builder_format (&b, SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
-           SPA_PROP_ID_VIDEO_FORMAT,    SPA_POD_TYPE_INT,
+  o = spa_pod_builder_format (&b,
+       SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
+       SPA_POD_TYPE_PROP, &frame[0],
+           SPA_PROP_ID_VIDEO_FORMAT,    SPA_POD_PROP_FLAG_UNSET |
+                                        SPA_POD_PROP_RANGE_ENUM,
+                                        SPA_POD_TYPE_INT, 3,
                                                 SPA_VIDEO_FORMAT_I420,
-                                        SPA_POD_PROP_FLAG_UNSET |
-                                        SPA_POD_PROP_RANGE_ENUM, 2,
                                                 SPA_VIDEO_FORMAT_I420,
                                                 SPA_VIDEO_FORMAT_YUY2,
-           SPA_PROP_ID_VIDEO_SIZE  ,    SPA_POD_TYPE_RECTANGLE,
-                                                320, 241,
-                                        SPA_POD_PROP_FLAG_UNSET |
+      -SPA_POD_TYPE_PROP, &frame[0],
+       SPA_POD_TYPE_PROP, &frame[0],
+           SPA_PROP_ID_VIDEO_SIZE,      SPA_POD_PROP_FLAG_UNSET |
                                         SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_RECTANGLE, 3,
+                                                320, 241,
                                                 1, 1,
                                                 INT32_MAX, INT32_MAX,
-           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_TYPE_FRACTION, 25, 1,
-                                        SPA_POD_PROP_FLAG_UNSET |
+      -SPA_POD_TYPE_PROP, &frame[0],
+       SPA_POD_TYPE_PROP, &frame[0],
+           SPA_PROP_ID_VIDEO_FRAMERATE, SPA_POD_PROP_FLAG_UNSET |
                                         SPA_POD_PROP_RANGE_MIN_MAX,
+                                        SPA_POD_TYPE_FRACTION, 3,
+                                                25, 1,
                                                 0, 1,
                                                 INT32_MAX, 1,
-           0);
+      -SPA_POD_TYPE_PROP, &frame[0], 0);
 
   fmt = SPA_MEMBER (buffer, o, SpaFormat);
   spa_debug_pod (&fmt->pod);