Add support for async results

Add an async result code and an event to signal the completion.
Use async return values to signal completion of a method and potential
state change.
Add selected format to port update message.
Make it possible to parse into a custom copy of the command memory.
Remove state change events from the elements, we now just update the
state.
Implement async results in the proxy element
Add support for removing buffers in the client.
Fix up pinossink
Deal with async return in the links.

spa/lib/control.c

@@ -418,6 +418,8 @@ iter_parse_port_update (struct stack_iter *si, SpaControlCmdPortUpdate *pu)
     pu->possible_formats[i] = parse_format (p, si->size,
                         SPA_PTR_TO_INT (pu->possible_formats[i]));
   }
+  if (pu->format)
+    pu->format = parse_format (p, si->size, SPA_PTR_TO_INT (pu->format));
 
   if (pu->props)
     pu->props = parse_props (p, SPA_PTR_TO_INT (pu->props));
@@ -484,6 +486,26 @@ iter_parse_node_command (struct stack_iter *si, SpaControlCmdNodeCommand *cmd)
     cmd->command->data = SPA_MEMBER (p, SPA_PTR_TO_INT (cmd->command->data), void);
 }
 
+SpaResult
+spa_control_iter_set_data (SpaControlIter *iter,
+                           void           *data,
+                           size_t          size)
+{
+  struct stack_iter *si = SCSI (iter);
+  SpaResult res = SPA_RESULT_OK;
+
+  if (!is_valid_iter (iter))
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  if (si->size > size)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  si->size = size;
+  si->data = data;
+
+  return SPA_RESULT_OK;
+}
+
 SpaResult
 spa_control_iter_parse_cmd (SpaControlIter *iter,
                             void           *command)
@@ -514,6 +536,12 @@ spa_control_iter_parse_cmd (SpaControlIter *iter,
       fprintf (stderr, "implement iter of %d\n", si->cmd);
       break;
 
+    case SPA_CONTROL_CMD_NODE_STATE_CHANGE:
+      if (si->size < sizeof (SpaControlCmdNodeStateChange))
+        return SPA_RESULT_ERROR;
+      memcpy (command, si->data, sizeof (SpaControlCmdNodeStateChange));
+      break;
+
     /* S -> C */
     case SPA_CONTROL_CMD_ADD_PORT:
       if (si->size < sizeof (SpaControlCmdAddPort))
@@ -572,7 +600,6 @@ spa_control_iter_parse_cmd (SpaControlIter *iter,
   return res;
 }
 
-
 struct stack_builder {
   size_t          magic;
 
@@ -945,8 +972,8 @@ write_format (void *p, const SpaFormat *format)
   tf = p;
   tf->media_type = format->media_type;
   tf->media_subtype = format->media_subtype;
-  tf->mem.mem.pool_id = SPA_ID_INVALID;
-  tf->mem.mem.id = SPA_ID_INVALID;
+  tf->mem.mem.pool_id = 0;
+  tf->mem.mem.id = 0;
   tf->mem.offset = 0;
   tf->mem.size = 0;
 
@@ -1025,6 +1052,7 @@ builder_add_port_update (struct stack_builder *sb, SpaControlCmdPortUpdate *pu)
   len += pu->n_possible_formats * sizeof (SpaFormat *);
   for (i = 0; i < pu->n_possible_formats; i++)
     len += calc_format_len (pu->possible_formats[i]);
+  len += calc_format_len (pu->format);
   len += calc_props_len (pu->props);
   if (pu->info) {
     len += sizeof (SpaPortInfo);
@@ -1051,6 +1079,13 @@ builder_add_port_update (struct stack_builder *sb, SpaControlCmdPortUpdate *pu)
     bfa[i] = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
     p = SPA_MEMBER (p, len, void);
   }
+  if (pu->format) {
+    len = write_format (p, pu->format);
+    d->format = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
+    p = SPA_MEMBER (p, len, void);
+  } else {
+    d->format = 0;
+  }
   if (pu->props) {
     len = write_props (p, pu->props, sizeof (SpaProps));
     d->props = SPA_INT_TO_PTR (SPA_PTRDIFF (p, d));
@@ -1066,6 +1101,7 @@ builder_add_port_update (struct stack_builder *sb, SpaControlCmdPortUpdate *pu)
     d->info = 0;
   }
 }
+
 static void
 builder_add_set_format (struct stack_builder *sb, SpaControlCmdSetFormat *sf)
 {
@@ -1218,6 +1254,11 @@ spa_control_builder_add_cmd (SpaControlBuilder *builder,
       p = builder_add_cmd (sb, cmd, 0);
       break;
 
+    case SPA_CONTROL_CMD_NODE_STATE_CHANGE:
+      p = builder_add_cmd (sb, cmd, sizeof (SpaControlCmdNodeStateChange));
+      memcpy (p, command, sizeof (SpaControlCmdNodeStateChange));
+      break;
+
     /* S -> C */
     case SPA_CONTROL_CMD_ADD_PORT:
       p = builder_add_cmd (sb, cmd, sizeof (SpaControlCmdAddPort));
@@ -1265,7 +1306,6 @@ spa_control_builder_add_cmd (SpaControlBuilder *builder,
       builder_add_node_command (sb, command);
       break;
 
-    default:
     case SPA_CONTROL_CMD_INVALID:
       return SPA_RESULT_INVALID_ARGUMENTS;
   }

spa/lib/format.c

@@ -36,50 +36,10 @@ spa_format_to_string (const SpaFormat *format, char **result)
 SpaResult
 spa_format_fixate (SpaFormat *format)
 {
-#if 0
-  unsigned int i, j;
-  SpaProps *props;
-  uint32_t mask;
-#endif
-
   if (format == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
 
   format->props.unset_mask = 0;
 
-#if 0
-  props = &format->props;
-  mask = props->unset_mask;
-
-  for (i = 0; i < props->n_prop_info; i++) {
-    if (mask & 1) {
-      const SpaPropInfo *pi = &props->prop_info[i];
-
-      switch (pi->range_type) {
-        case SPA_PROP_RANGE_TYPE_NONE:
-          break;
-	case SPA_PROP_RANGE_TYPE_MIN_MAX:
-          break;
-	case SPA_PROP_RANGE_TYPE_STEP:
-          break;
-	case SPA_PROP_RANGE_TYPE_ENUM:
-        {
-          for (j = 0; j < pi->n_range_values; j++) {
-            const SpaPropRangeInfo *ri = &pi->range_values[j];
-            memcpy (SPA_MEMBER (props, pi->offset, void), ri->value, ri->size);
-            SPA_PROPS_INDEX_SET (props, i);
-            break;
-          }
-          break;
-        }
-	case SPA_PROP_RANGE_TYPE_FLAGS:
-          break;
-        default:
-          break;
-      }
-    }
-    mask >>= 1;
-  }
-#endif
   return SPA_RESULT_OK;
 }