Improve padding

Write out 0 while padding to make sure all memory is initialized
Remove the fd from the loop before destroying the node.

pinos/server/client-node.c

@@ -1124,10 +1124,6 @@ proxy_clear (SpaProxy *this)
     if (this->out_ports[i].valid)
       clear_port (this, &this->out_ports[i], SPA_DIRECTION_OUTPUT, i);
   }
-  if (this->data_source.fd != -1) {
-    spa_loop_remove_source (this->data_loop, &this->data_source);
-    close (this->data_source.fd);
-  }
 
   return SPA_RESULT_OK;
 }
@@ -1137,6 +1133,7 @@ client_node_resource_destroy (PinosResource *resource)
 {
   PinosClientNode *this = resource->object;
   PinosClientNodeImpl *impl = SPA_CONTAINER_OF (this, PinosClientNodeImpl, this);
+  SpaProxy *proxy = &impl->proxy;
 
   pinos_log_debug ("client-node %p: destroy", impl);
   pinos_signal_emit (&this->destroy_signal, this);
@@ -1147,6 +1144,12 @@ client_node_resource_destroy (PinosResource *resource)
   pinos_signal_remove (&impl->loop_changed);
   pinos_signal_remove (&impl->transport_changed);
 
+  if (proxy->data_source.fd != -1) {
+    spa_loop_remove_source (proxy->data_loop, &proxy->data_source);
+    close (proxy->data_source.fd);
+    proxy->data_source.fd = -1;
+  }
+
   pinos_node_destroy (this->node);
 }
 

pinos/server/node.c

@@ -241,8 +241,10 @@ send_clock_update (PinosNode *this)
     cu.ticks = 0;
     cu.monotonic_time = 0;
   }
+  cu.offset = 0;
   cu.scale = (1 << 16) | 1;
   cu.state = SPA_CLOCK_STATE_RUNNING;
+  cu.latency = 0;
 
   if ((res = spa_node_send_command (this->node, &cu.command)) < 0)
     pinos_log_debug ("got error %d", res);

spa/include/spa/format-builder.h

@@ -40,7 +40,7 @@ spa_pod_builder_push_format (SpaPODBuilder *builder,
                         { { sizeof (uint32_t), SPA_POD_TYPE_INT }, media_type }, 0,
                         { { sizeof (uint32_t), SPA_POD_TYPE_INT }, media_subtype }, 0 } };
   return spa_pod_builder_push (builder, frame, &p.pod,
-                               spa_pod_builder_raw (builder, &p, sizeof(p), false));
+                               spa_pod_builder_raw (builder, &p, sizeof(p)));
 }
 
 static inline uint32_t

spa/include/spa/pod-builder.h

@@ -71,19 +71,44 @@ spa_pod_builder_push (SpaPODBuilder *builder,
   return ref;
 }
 
-static inline void
+static inline uint32_t
-spa_pod_builder_advance (SpaPODBuilder *builder, uint32_t size, bool pad)
+spa_pod_builder_raw (SpaPODBuilder *builder, const void *data, uint32_t size)
 {
-  if (pad)
+  uint32_t ref;
-    size = SPA_ROUND_UP_N (size, 8);
+  SpaPODFrame *f;
 
-  if (size > 0) {
+  if (builder->write) {
-    SpaPODFrame *f;
+    ref = builder->write (builder, -1, data, size);
-
+  } else {
-    builder->offset += size;
+    ref = builder->offset;
-    for (f = builder->stack; f; f = f->parent)
+    if (ref + size > builder->size)
-      f->pod.size += size;
+      ref = -1;
+    else
+      memcpy (builder->data + ref, data, size);
   }
+
+  builder->offset += size;
+  for (f = builder->stack; f; f = f->parent)
+    f->pod.size += size;
+
+  return ref;
+}
+
+static void
+spa_pod_builder_pad (SpaPODBuilder *builder, uint32_t size)
+{
+  uint64_t zeroes = 0;
+  size = SPA_ROUND_UP_N (size, 8) - size;
+  if (size)
+    spa_pod_builder_raw (builder, &zeroes, size);
+}
+
+static inline uint32_t
+spa_pod_builder_raw_padded (SpaPODBuilder *builder, const void *data, uint32_t size)
+{
+  uint32_t ref = spa_pod_builder_raw (builder, data, size);
+  spa_pod_builder_pad (builder, size);
+  return ref;
 }
 
 static inline void
@@ -99,44 +124,14 @@ spa_pod_builder_pop (SpaPODBuilder *builder,
   builder->stack = frame->parent;
   builder->in_array = (builder->stack && (builder->stack->pod.type == SPA_POD_TYPE_ARRAY ||
                                           builder->stack->pod.type == SPA_POD_TYPE_PROP));
-  spa_pod_builder_advance (builder, SPA_ROUND_UP_N(builder->offset, 8) - builder->offset, false);
+  spa_pod_builder_pad (builder, builder->offset);
-}
-
-static inline uint32_t
-spa_pod_builder_raw (SpaPODBuilder *builder, const void *data, uint32_t size, bool pad)
-{
-  uint32_t ref;
-
-  if (builder->write) {
-    ref = builder->write (builder, -1, data, size);
-  } else {
-    ref = builder->offset;
-    if (ref + size > builder->size)
-      ref = -1;
-    else
-      memcpy (builder->data + ref, data, size);
-  }
-  spa_pod_builder_advance (builder, size, pad);
-
-  return ref;
-}
-
-static inline uint32_t
-spa_pod_builder_string_body (SpaPODBuilder *builder,
-                             const char    *str,
-                             uint32_t       len)
-{
-  uint32_t out = spa_pod_builder_raw (builder, str, len, true);
-  if (out != -1)
-    *SPA_MEMBER (builder->data, out + len-1, char) = '\0';
-  return out;
 }
 
 static inline uint32_t
 spa_pod_builder_primitive (SpaPODBuilder *builder, const SpaPOD *p)
 {
   const void *data;
-  uint32_t size;
+  uint32_t size, ref;
 
   if (builder->in_array && !builder->first) {
     data = SPA_POD_BODY_CONST (p);
@@ -146,7 +141,10 @@ spa_pod_builder_primitive (SpaPODBuilder *builder, const SpaPOD *p)
     size = SPA_POD_SIZE (p);
     builder->first = false;
   }
-  return spa_pod_builder_raw (builder, data, size, !builder->in_array);
+  ref = spa_pod_builder_raw (builder, data, size);
+  if (!builder->in_array)
+    spa_pod_builder_pad (builder, size);
+  return ref;
 }
 
 static inline uint32_t
@@ -195,10 +193,10 @@ static inline uint32_t
 spa_pod_builder_string_len (SpaPODBuilder *builder, const char *str, uint32_t len)
 {
   const SpaPODString p = { { len, SPA_POD_TYPE_STRING } };
-  uint32_t out = spa_pod_builder_raw (builder, &p, sizeof (p) , false);
+  uint32_t ref = spa_pod_builder_raw (builder, &p, sizeof (p));
-  if (spa_pod_builder_string_body (builder, str, len) == -1)
+  if (spa_pod_builder_raw_padded (builder, str, len) == -1)
-    out = -1;
+    ref = -1;
-  return out;
+  return ref;
 }
 
 static inline uint32_t
@@ -212,10 +210,10 @@ static inline uint32_t
 spa_pod_builder_bytes (SpaPODBuilder *builder, const void *bytes, uint32_t len)
 {
   const SpaPODBytes p = { { len, SPA_POD_TYPE_BYTES } };
-  uint32_t out = spa_pod_builder_raw (builder, &p, sizeof (p) , false);
+  uint32_t ref = spa_pod_builder_raw (builder, &p, sizeof (p));
-  if (spa_pod_builder_raw (builder, bytes, len, true) == -1)
+  if (spa_pod_builder_raw_padded (builder, bytes, len) == -1)
-    out = -1;
+    ref = -1;
-  return out;
+  return ref;
 }
 
 static inline uint32_t
@@ -238,7 +236,7 @@ spa_pod_builder_push_array (SpaPODBuilder  *builder,
 {
   const SpaPODArray p = { { sizeof (SpaPODArrayBody) - sizeof (SpaPOD), SPA_POD_TYPE_ARRAY }, { { 0, 0 } } };
   return spa_pod_builder_push (builder, frame, &p.pod,
-                               spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD), false));
+                               spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD)));
 }
 
 static inline uint32_t
@@ -252,10 +250,10 @@ spa_pod_builder_array (SpaPODBuilder *builder,
     { (uint32_t)(sizeof (SpaPODArrayBody) + n_elems * child_size), SPA_POD_TYPE_ARRAY },
     { { child_size, child_type } }
   };
-  uint32_t out = spa_pod_builder_raw (builder, &p, sizeof(p), true);
+  uint32_t ref = spa_pod_builder_raw_padded (builder, &p, sizeof(p));
-  if (spa_pod_builder_raw (builder, elems, child_size * n_elems, true) == -1)
+  if (spa_pod_builder_raw_padded (builder, elems, child_size * n_elems) == -1)
-    out = -1;
+    ref = -1;
-  return out;
+  return ref;
 }
 
 static inline uint32_t
@@ -264,7 +262,7 @@ spa_pod_builder_push_struct (SpaPODBuilder  *builder,
 {
   const SpaPODStruct p = { { 0, SPA_POD_TYPE_STRUCT } };
   return spa_pod_builder_push (builder, frame, &p.pod,
-                               spa_pod_builder_raw (builder, &p, sizeof(p), false));
+                               spa_pod_builder_raw (builder, &p, sizeof(p)));
 }
 
 static inline uint32_t
@@ -275,7 +273,7 @@ spa_pod_builder_push_object (SpaPODBuilder  *builder,
 {
   const SpaPODObject p = { { sizeof (SpaPODObjectBody), SPA_POD_TYPE_OBJECT }, { id, type } };
   return spa_pod_builder_push (builder, frame, &p.pod,
-                               spa_pod_builder_raw (builder, &p, sizeof(p), false));
+                               spa_pod_builder_raw (builder, &p, sizeof(p)));
 }
 
 static inline uint32_t
@@ -287,7 +285,7 @@ spa_pod_builder_push_prop (SpaPODBuilder *builder,
   const SpaPODProp p = { { sizeof (SpaPODPropBody) - sizeof(SpaPOD), SPA_POD_TYPE_PROP},
                          { key, flags | SPA_POD_PROP_RANGE_NONE, { 0, 0 } } };
   return spa_pod_builder_push (builder, frame, &p.pod,
-                               spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD), false));
+                               spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD)));
 }
 
 static inline void
@@ -393,7 +391,7 @@ spa_pod_builder_addv (SpaPODBuilder *builder,
       case SPA_POD_TYPE_POD:
       {
         SpaPOD *value = va_arg (args, SpaPOD *);
-        spa_pod_builder_raw (builder, value, SPA_POD_SIZE (value), true);
+        spa_pod_builder_raw_padded (builder, value, SPA_POD_SIZE (value));
         break;
       }
     }

spa/lib/props.c

@@ -154,7 +154,7 @@ spa_props_filter (SpaPODBuilder  *b,
 
     if (filter == NULL || (p2 = find_prop (filter, filter_size, p1->body.key)) == NULL) {
       /* no filter, copy the complete property */
-      spa_pod_builder_raw (b, p1, SPA_POD_SIZE (p1), true);
+      spa_pod_builder_raw_padded (b, p1, SPA_POD_SIZE (p1));
       continue;
     }
 
@@ -170,7 +170,7 @@ spa_props_filter (SpaPODBuilder  *b,
                                 spa_pod_builder_push_prop (b, &f, p1->body.key, SPA_POD_PROP_FLAG_READWRITE),
                                 SpaPODProp);
     /* default value */
-    spa_pod_builder_raw (b, &p1->body.value, sizeof (p1->body.value) + p1->body.value.size, false);
+    spa_pod_builder_raw (b, &p1->body.value, sizeof (p1->body.value) + p1->body.value.size);
 
     alt1 = SPA_MEMBER (p1, sizeof (SpaPODProp), void);
     nalt1 = SPA_POD_PROP_N_VALUES (p1);
@@ -200,7 +200,7 @@ spa_props_filter (SpaPODBuilder  *b,
       for (j = 0, a1 = alt1; j < nalt1; j++, a1 += p1->body.value.size) {
         for (k = 0, a2 = alt2; k < nalt2; k++, a2 += p2->body.value.size) {
           if (compare_value (p1->body.value.type, a1, a2) == 0) {
-            spa_pod_builder_raw (b, a1, p1->body.value.size, false);
+            spa_pod_builder_raw (b, a1, p1->body.value.size);
             n_copied++;
           }
         }
@@ -219,7 +219,7 @@ spa_props_filter (SpaPODBuilder  *b,
           continue;
         if (compare_value (p1->body.value.type, a1, a2 + p2->body.value.size) > 0)
           continue;
-        spa_pod_builder_raw (b, a1, p1->body.value.size, false);
+        spa_pod_builder_raw (b, a1, p1->body.value.size);
         n_copied++;
       }
       if (n_copied == 0)
@@ -241,7 +241,7 @@ spa_props_filter (SpaPODBuilder  *b,
           continue;
         if (compare_value (p1->body.value.type, a2, a1 + p1->body.value.size) > 0)
           continue;
-        spa_pod_builder_raw (b, a2, p2->body.value.size, false);
+        spa_pod_builder_raw (b, a2, p2->body.value.size);
         n_copied++;
       }
       if (n_copied == 0)
@@ -251,17 +251,17 @@ spa_props_filter (SpaPODBuilder  *b,
 
     if (rt1 == SPA_POD_PROP_RANGE_MIN_MAX && rt2 == SPA_POD_PROP_RANGE_MIN_MAX) {
       if (compare_value (p1->body.value.type, alt1, alt2) < 0)
-        spa_pod_builder_raw (b, alt2, p2->body.value.size, false);
+        spa_pod_builder_raw (b, alt2, p2->body.value.size);
       else
-        spa_pod_builder_raw (b, alt1, p1->body.value.size, false);
+        spa_pod_builder_raw (b, alt1, p1->body.value.size);
 
       alt1 += p1->body.value.size;
       alt2 += p2->body.value.size;
 
       if (compare_value (p1->body.value.type, alt1, alt2) < 0)
-        spa_pod_builder_raw (b, alt1, p1->body.value.size, false);
+        spa_pod_builder_raw (b, alt1, p1->body.value.size);
       else
-        spa_pod_builder_raw (b, alt2, p2->body.value.size, false);
+        spa_pod_builder_raw (b, alt2, p2->body.value.size);
 
       np->body.flags |= SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET;
     }

spa/lib/video-raw.c

@@ -142,7 +142,7 @@ spa_format_filter (const SpaFormat  *format,
     return SPA_RESULT_INVALID_ARGUMENTS;
 
   if (filter == NULL) {
-    spa_pod_builder_raw (result, format, SPA_POD_SIZE (format), true);
+    spa_pod_builder_raw_padded (result, format, SPA_POD_SIZE (format));
     return SPA_RESULT_OK;
   }
 

spa/tests/test-props.c

@@ -143,7 +143,7 @@ main (int argc, char *argv[])
                              SPA_PROP_ID_VIDEO_SIZE,
                              SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
   spa_pod_builder_rectangle (&b, 320, 240);
-  spa_pod_builder_raw (&b, size_min_max, sizeof(size_min_max), false);
+  spa_pod_builder_raw (&b, size_min_max, sizeof(size_min_max));
   spa_pod_builder_pop (&b, &frame[1]);
 
   SpaFraction rate_min_max[] = { { 0, 1 }, { INT32_MAX, 1 } };
@@ -151,7 +151,7 @@ main (int argc, char *argv[])
                              SPA_PROP_ID_VIDEO_FRAMERATE,
                              SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
   spa_pod_builder_fraction (&b, 25, 1);
-  spa_pod_builder_raw (&b, rate_min_max, sizeof(rate_min_max), false);
+  spa_pod_builder_raw (&b, rate_min_max, sizeof(rate_min_max));
   spa_pod_builder_pop (&b, &frame[1]);
 
   spa_pod_builder_pop (&b, &frame[0]);

spa/tests/test-props2.c

@@ -65,7 +65,7 @@ main (int argc, char *argv[])
   spa_pod_builder_push_prop (&b, &frame[1],
                              3, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
   spa_pod_builder_rectangle (&b, 320, 240);
-  spa_pod_builder_raw (&b, sizes, sizeof (sizes), false);
+  spa_pod_builder_raw (&b, sizes, sizeof (sizes));
   spa_pod_builder_pop (&b, &frame[1]);
 
   spa_pod_builder_push_prop (&b, &frame[1], 4, SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_READABLE);