Add monitor interface

Add an interface to monitor devices and helper program
Add v4l2 monitor
Add simple dictionary with key/value pairs

pinos/modules/spa/spa-alsa-sink.c

@@ -76,11 +76,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
       continue;
 
     handle = calloc (1, factory->size);
-    if ((res = factory->init (factory, handle)) < 0) {
+    if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
       g_error ("can't make factory instance: %d", res);
       return res;
     }
-    if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
+    if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
       g_error ("can't get interface %d", res);
       return res;
     }

pinos/modules/spa/spa-audiotestsrc.c

@@ -69,11 +69,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
       continue;
 
     handle = calloc (1, factory->size);
-    if ((res = factory->init (factory, handle)) < 0) {
+    if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
       g_error ("can't make factory instance: %d", res);
       return res;
     }
-    if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
+    if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
       g_error ("can't get interface %d", res);
       return res;
     }

pinos/modules/spa/spa-v4l2-source.c

@@ -79,11 +79,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
       continue;
 
     handle = calloc (1, factory->size);
-    if ((res = factory->init (factory, handle)) < 0) {
+    if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
       g_error ("can't make factory instance: %d", res);
       return res;
     }
-    if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
+    if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
       g_error ("can't get interface %d", res);
       return res;
     }

pinos/server/client-node.c

@@ -249,7 +249,7 @@ make_node (SpaNode **node, const char *lib, const char *name)
       continue;
 
     handle = calloc (1, factory->size);
-    if ((res = factory->init (factory, handle)) < 0) {
+    if ((res = factory->init (factory, handle, NULL)) < 0) {
       g_error ("can't make factory instance: %d", res);
       return res;
     }

spa/include/spa/clock.h

@@ -57,6 +57,12 @@ struct _SpaClock {
   /* the total size of this clock. This can be used to expand this
    * structure in the future */
   size_t size;
+  /**
+   * SpaClock::info
+   *
+   * Extra information about the clock
+   */
+  const SpaDict *info;
   /**
    * SpaClock::state:
    *

spa/include/spa/debug.h

@@ -29,12 +29,14 @@ extern "C" {
 #include <spa/buffer.h>
 #include <spa/props.h>
 #include <spa/format.h>
+#include <spa/dict.h>
 
 SpaResult spa_debug_port_info (const SpaPortInfo *info);
 SpaResult spa_debug_buffer (const SpaBuffer *buffer);
 SpaResult spa_debug_props (const SpaProps *props, bool print_ranges);
 SpaResult spa_debug_format (const SpaFormat *format);
 SpaResult spa_debug_dump_mem  (const void *data, size_t size);
+SpaResult spa_debug_dict  (const SpaDict *dict);
 
 #ifdef __cplusplus
 }  /* extern "C" */

spa/include/spa/dict.h

@@ -0,0 +1,45 @@
+/* Simple Plugin API
+ * Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __SPA_DICT_H__
+#define __SPA_DICT_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _SpaDict SpaDict;
+
+#include <spa/defs.h>
+
+typedef struct {
+  const char *key;
+  const char *value;
+} SpaDictItem;
+
+struct _SpaDict {
+  unsigned int  n_items;
+  SpaDictItem  *items;
+};
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif /* __SPA_DICT_H__ */

spa/include/spa/monitor.h

@@ -0,0 +1,150 @@
+/* Simple Plugin API
+ * Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __SPA_MONITOR_H__
+#define __SPA_MONITOR_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct _SpaMonitor SpaMonitor;
+
+#include <spa/defs.h>
+#include <spa/dict.h>
+#include <spa/plugin.h>
+
+typedef enum {
+  SPA_MONITOR_ITEM_FLAG_NONE    = 0,
+} SpaMonitorItemFlags;
+
+/**
+ * SpaMonitorItemState:
+ * @SPA_MONITOR_ITEM_STATE_AVAILABLE: The item is available
+ * @SPA_MONITOR_ITEM_STATE_DISABLED: the item is disabled
+ * @SPA_MONITOR_ITEM_STATE_UNAVAILABLE: the item is unavailable
+ */
+typedef enum {
+  SPA_MONITOR_ITEM_STATE_AVAILABLE,
+  SPA_MONITOR_ITEM_STATE_DISABLED,
+  SPA_MONITOR_ITEM_STATE_UNAVAILABLE,
+} SpaMonitorItemState;
+
+typedef struct {
+  const char              *id;
+  SpaMonitorItemFlags      flags;
+  SpaMonitorItemState      state;
+  const char              *name;
+  const char              *klass;
+  const SpaDict           *info;
+  const SpaHandleFactory  *factory;
+  const void              *config;
+} SpaMonitorItem;
+
+/**
+ * SpaMonitorEventType:
+ * @SPA_MONITOR_EVENT_TYPE_INVALID: invalid event
+ * @SPA_MONITOR_EVENT_TYPE_ADDED: an item was added, data points to #SpaMonitorItem
+ * @SPA_MONITOR_EVENT_TYPE_REMOVED: an item was removed, data points to #SpaMonitorItem
+ * @SPA_MONITOR_EVENT_TYPE_CHANGED: an item was changed, data points to #SpaMonitorItem
+ * @SPA_MONITOR_EVENT_TYPE_ADD_POLL: add fd for polling, data points to #SpaPollItem
+ * @SPA_MONITOR_EVENT_TYPE_UPDATE_POLL: update fd for polling, data points to #SpaPollItem
+ * @SPA_MONITOR_EVENT_TYPE_REMOVE_POLL: remov fd for polling, data points to #SpaPollItem
+ */
+typedef enum {
+  SPA_MONITOR_EVENT_TYPE_INVALID = 0,
+  SPA_MONITOR_EVENT_TYPE_ADDED,
+  SPA_MONITOR_EVENT_TYPE_REMOVED,
+  SPA_MONITOR_EVENT_TYPE_CHANGED,
+  SPA_MONITOR_EVENT_TYPE_ADD_POLL,
+  SPA_MONITOR_EVENT_TYPE_UPDATE_POLL,
+  SPA_MONITOR_EVENT_TYPE_REMOVE_POLL,
+} SpaMonitorEventType;
+
+typedef struct {
+  SpaMonitorEventType  type;
+  void                *data;
+  size_t               size;
+} SpaMonitorEvent;
+
+/**
+ * SpaMonitorCallback:
+ * @node: a #SpaMonitor emiting the event
+ * @event: the event that was emited
+ * @user_data: user data provided when registering the callback
+ *
+ * This will be called when a monitor event is notified
+ * on @monitor.
+ */
+typedef void   (*SpaMonitorEventCallback)  (SpaMonitor      *monitor,
+                                            SpaMonitorEvent *event,
+                                            void            *user_data);
+
+#define SPA_INTERFACE_ID_MONITOR                   2
+#define SPA_INTERFACE_ID_MONITOR_NAME              "Monitor interface"
+#define SPA_INTERFACE_ID_MONITOR_DESCRIPTION       "Device Monitor interface"
+
+/**
+ * SpaMonitor:
+ *
+ * The device monitor interface.
+ */
+struct _SpaMonitor {
+  /* pointer to the handle owning this interface */
+  SpaHandle *handle;
+  /**
+   * SpaMonitor::info
+   *
+   * Extra information about the monitor
+   */
+  const SpaDict * info;
+
+  /* the total size of this monitor. This can be used to expand this
+   * structure in the future */
+  size_t size;
+
+  /**
+   * SpaMonitor::set_event_callback:
+   * @monitor: a #SpaMonitor
+   * @callback: a #SpaMonitorEventCallback
+   * @user_data: extra user data
+   *
+   * Set an event callback to receive asynchronous notifications from
+   * the monitor.
+   *
+   * Returns: #SPA_RESULT_OK on success
+   */
+  SpaResult  (*set_event_callback)   (SpaMonitor              *monitor,
+                                      SpaMonitorEventCallback  callback,
+                                      void                    *user_data);
+
+  SpaResult  (*enum_items)           (SpaMonitor              *monitor,
+                                      SpaMonitorItem         **item,
+                                      void                   **state);
+
+};
+
+#define spa_monitor_set_event_callback(m,...) (m)->set_event_callback((m),__VA_ARGS__)
+#define spa_monitor_enum_items(m,...)         (m)->enum_items((m),__VA_ARGS__)
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif /* __SPA_MONITOR_H__ */

spa/include/spa/plugin.h

@@ -25,7 +25,7 @@ extern "C" {
 #endif
 
 #include <spa/defs.h>
-#include <spa/props.h>
+#include <spa/dict.h>
 
 typedef struct _SpaHandle SpaHandle;
 typedef struct _SpaHandleFactory SpaHandleFactory;
@@ -90,7 +90,7 @@ struct _SpaHandleFactory {
    *
    * Extra information about the handles of this factory.
    */
-  const SpaProps * info;
+  const SpaDict * info;
   /**
    * SpaHandleFactory::size
    *
@@ -102,6 +102,8 @@ struct _SpaHandleFactory {
    * SpaHandleFactory::init
    * @factory: a #SpaHandleFactory
    * @handle: a pointer to memory
+   * @config: extra handle specific config information, usually obtained from
+   *          a #SpaMonitor.
    *
    * Initialize an instance of this factory. The caller should allocate
    * memory at least SpaHandleFactory::size bytes and pass this as @handle.
@@ -111,7 +113,8 @@ struct _SpaHandleFactory {
    *          #SPA_RESULT_INVALID_ARGUMENTS when factory or handle are %NULL
    */
   SpaResult   (*init)                 (const SpaHandleFactory  *factory,
-                                       SpaHandle               *handle);
+                                       SpaHandle               *handle,
+                                       const void              *config);
 
   /**
    * SpaHandle::enum_interface_info:

spa/include/spa/props.h

@@ -158,7 +158,7 @@ typedef struct {
  *             properties. Can be %NULL when unspecified.
  * @unset_mask: mask of unset properties. For each property in @prop_info there
  *              is a corresponding bit that specifies if the property is currently
- *              unset. When more that 32 properties are present, more uint32_t
+ *              unset. When more than 32 properties are present, more uint32_t
  *              fields follow this one.
  *
  * Generic propertiers.

spa/lib/debug.c

@@ -497,3 +497,17 @@ spa_debug_format (const SpaFormat *format)
   }
   return SPA_RESULT_OK;
 }
+
+SpaResult
+spa_debug_dict (const SpaDict *dict)
+{
+  unsigned int i;
+
+  if (dict == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  for (i = 0; i < dict->n_items; i++)
+    fprintf (stderr, "          %s = \"%s\"\n", dict->items[i].key, dict->items[i].value);
+
+  return SPA_RESULT_OK;
+}

spa/meson.build

@@ -8,6 +8,7 @@ avcodec_dep = dependency('libavcodec')
 avformat_dep = dependency('libavformat')
 avfilter_dep = dependency('libavfilter')
 libva_dep = dependency('libva')
+libudev_dep = dependency('libudev')
 
 cc = meson.get_compiler('c')
 

spa/plugins/alsa/alsa-sink.c

@@ -702,7 +702,8 @@ alsa_sink_clear (SpaHandle *handle)
 
 static SpaResult
 alsa_sink_init (const SpaHandleFactory  *factory,
-                SpaHandle               *handle)
+                SpaHandle               *handle,
+                const void              *config)
 {
   SpaALSASink *this;
 

spa/plugins/audiomixer/audiomixer.c

@@ -780,7 +780,8 @@ spa_audiomixer_clear (SpaHandle *handle)
 
 static SpaResult
 spa_audiomixer_init (const SpaHandleFactory *factory,
-                     SpaHandle              *handle)
+                     SpaHandle              *handle,
+                     const void             *config)
 {
   SpaAudioMixer *this;
 

spa/plugins/audiotestsrc/audiotestsrc.c

@@ -841,7 +841,8 @@ audiotestsrc_clear (SpaHandle *handle)
 
 static SpaResult
 audiotestsrc_init (const SpaHandleFactory  *factory,
-                   SpaHandle               *handle)
+                   SpaHandle               *handle,
+                   const void              *config)
 {
   SpaAudioTestSrc *this;
 

spa/plugins/ffmpeg/ffmpeg.c

@@ -30,7 +30,8 @@ SpaResult spa_ffmpeg_enc_init (SpaHandle *handle);
 
 static SpaResult
 ffmpeg_dec_init (const SpaHandleFactory  *factory,
-                 SpaHandle               *handle)
+                 SpaHandle               *handle,
+                 const void              *config)
 {
   if (factory == NULL || handle == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;
@@ -40,7 +41,8 @@ ffmpeg_dec_init (const SpaHandleFactory  *factory,
 
 static SpaResult
 ffmpeg_enc_init (const SpaHandleFactory  *factory,
-                 SpaHandle               *handle)
+                 SpaHandle               *handle,
+                 const void              *config)
 {
   if (factory == NULL || handle == NULL)
     return SPA_RESULT_INVALID_ARGUMENTS;

spa/plugins/remote/proxy.c

@@ -1152,7 +1152,8 @@ proxy_clear (SpaHandle *handle)
 
 static SpaResult
 proxy_init (const SpaHandleFactory  *factory,
-            SpaHandle               *handle)
+            SpaHandle               *handle,
+            const void              *config)
 {
   SpaProxy *this;
 

spa/plugins/v4l2/meson.build

@@ -1,9 +1,10 @@
 v4l2_sources = ['v4l2.c',
+                'v4l2-monitor.c',
                 'v4l2-source.c']
 
 v4l2lib = shared_library('spa-v4l2',
                           v4l2_sources,
                           include_directories : inc,
-                          dependencies : v4l2_dep,
+                          dependencies : [ v4l2_dep, libudev_dep ],
                           link_with : spalib,
                           install : true)

spa/plugins/v4l2/v4l2-monitor.c

@@ -0,0 +1,405 @@
+/* Spa V4l2 Monitor
+ * Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <poll.h>
+
+#include <libudev.h>
+
+#include <spa/poll.h>
+#include <spa/monitor.h>
+#include <spa/memory.h>
+#include <spa/debug.h>
+
+typedef struct _SpaV4l2Monitor SpaV4l2Monitor;
+
+typedef struct {
+  SpaMonitorItem item;
+  struct udev_device *udevice;
+  SpaDict     info;
+  SpaDictItem info_items[32];
+} V4l2Item;
+
+struct _SpaV4l2Monitor {
+  SpaHandle handle;
+  SpaMonitor monitor;
+
+  SpaMonitorEventCallback event_cb;
+  void *user_data;
+
+  struct udev* udev;
+  struct udev_monitor *umonitor;
+  struct udev_enumerate *enumerate;
+
+  V4l2Item uitem;
+
+  int fd;
+  SpaPollFd fds[1];
+  SpaPollItem poll;
+};
+
+static SpaResult
+v4l2_udev_open (SpaV4l2Monitor *this)
+{
+  if (this->udev != NULL)
+    return SPA_RESULT_OK;
+
+  this->udev = udev_new ();
+
+  return SPA_RESULT_OK;
+}
+
+static void
+fill_item (V4l2Item *item, struct udev_device *udevice)
+{
+  unsigned int i;
+  const char *str;
+
+  if (item->udevice)
+    udev_device_unref (item->udevice);
+  item->udevice = udevice;
+  if (udevice == NULL)
+    return;
+
+  item->item.id = udev_device_get_devnode (item->udevice);
+  item->item.flags = 0;
+  item->item.state = SPA_MONITOR_ITEM_STATE_AVAILABLE;
+  item->item.klass = "Video/Source";
+  item->item.info = &item->info;
+  item->item.factory = NULL;
+  item->item.config = NULL;
+
+  item->info.items = item->info_items;
+
+  i = 0;
+  item->info_items[i].key = "udev-probed";
+  item->info_items[i++].value = "1";
+  item->info_items[i].key = "device.api";
+  item->info_items[i++].value = "v4l2";
+  item->info_items[i].key = "device.path";
+  item->info_items[i++].value = udev_device_get_devnode (item->udevice);
+
+  str = udev_device_get_property_value (item->udevice, "ID_PATH");
+  if (!(str && *str))
+    str = udev_device_get_syspath (item->udevice);
+  if (str && *str) {
+    item->info_items[i].key = "device.bus_path";
+    item->info_items[i++].value = str;
+  }
+  if ((str = udev_device_get_syspath (item->udevice)) && *str) {
+    item->info_items[i].key = "sysfs.path";
+    item->info_items[i++].value = str;
+  }
+  if ((str = udev_device_get_property_value (item->udevice, "ID_ID")) && *str) {
+    item->info_items[i].key = "udev.id";
+    item->info_items[i++].value = str;
+  }
+  if ((str = udev_device_get_property_value (item->udevice, "ID_BUS")) && *str) {
+    item->info_items[i].key = "device.bus";
+    item->info_items[i++].value = str;
+  }
+  if ((str = udev_device_get_property_value (item->udevice, "SUBSYSTEM")) && *str) {
+    item->info_items[i].key = "device.subsystem";
+    item->info_items[i++].value = str;
+  }
+  if ((str = udev_device_get_property_value (item->udevice, "ID_VENDOR_ID")) && *str) {
+    item->info_items[i].key = "device.vendor.id";
+    item->info_items[i++].value = str;
+  }
+  str = udev_device_get_property_value (item->udevice, "ID_VENDOR_FROM_DATABASE");
+  if (!(str && *str)) {
+    str = udev_device_get_property_value (item->udevice, "ID_VENDOR_ENC");
+    if (!(str && *str)) {
+      str = udev_device_get_property_value (item->udevice, "ID_VENDOR");
+    }
+  }
+  if (str && *str) {
+    item->info_items[i].key = "device.vendor.name";
+    item->info_items[i++].value = str;
+  }
+  if ((str = udev_device_get_property_value (item->udevice, "ID_MODEL_ID")) && *str) {
+    item->info_items[i].key = "device.product.id";
+    item->info_items[i++].value = str;
+  }
+  str = udev_device_get_property_value (item->udevice, "ID_V4L_PRODUCT");
+  if (!(str && *str)) {
+    str = udev_device_get_property_value (item->udevice, "ID_MODEL_FROM_DATABASE");
+    if (!(str && *str)) {
+      str = udev_device_get_property_value (item->udevice, "ID_MODEL_ENC");
+      if (!(str && *str)) {
+        str = udev_device_get_property_value (item->udevice, "ID_MODEL");
+      }
+    }
+  }
+  if (str && *str) {
+    item->info_items[i].key = "device.product.name";
+    item->info_items[i++].value = str;
+    item->item.name = str;
+  } else {
+    item->item.name = "Unknown";
+  }
+  if ((str = udev_device_get_property_value (item->udevice, "ID_SERIAL")) && *str) {
+    item->info_items[i].key = "device.serial";
+    item->info_items[i++].value = str;
+  }
+  if ((str = udev_device_get_property_value (item->udevice, "ID_V4L_CAPABILITIES")) && *str) {
+    item->info_items[i].key = "device.capabilities";
+    item->info_items[i++].value = str;
+  }
+  item->info.n_items = i;
+}
+
+
+static int
+v4l2_on_fd_events (SpaPollNotifyData *data)
+{
+  SpaV4l2Monitor *this = data->user_data;
+  struct udev_device *dev;
+  const char *action;
+  SpaMonitorEvent event;
+
+  dev = udev_monitor_receive_device (this->umonitor);
+  fill_item (&this->uitem, dev);
+  if (dev == NULL)
+    return 0;
+
+  if ((action = udev_device_get_action (dev)) == NULL)
+    action = "change";
+
+  if (strcmp (action, "add") == 0) {
+    event.type = SPA_MONITOR_EVENT_TYPE_ADDED;
+  } else if (strcmp (action, "change") == 0) {
+    event.type = SPA_MONITOR_EVENT_TYPE_CHANGED;
+  } else if (strcmp (action, "remove") == 0) {
+    event.type = SPA_MONITOR_EVENT_TYPE_REMOVED;
+  }
+  event.data = &this->uitem.item;
+  event.size = sizeof (this->uitem);
+  this->event_cb (&this->monitor, &event, this->user_data);
+
+  return 0;
+}
+
+static SpaResult
+spa_v4l2_monitor_set_event_callback (SpaMonitor              *monitor,
+                                     SpaMonitorEventCallback  callback,
+                                     void                    *user_data)
+{
+  SpaResult res;
+  SpaV4l2Monitor *this;
+  SpaMonitorEvent event;
+
+  if (monitor == NULL || monitor->handle == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  this = (SpaV4l2Monitor *) monitor->handle;
+
+  this->event_cb = callback;
+  this->user_data = user_data;
+
+  if (callback) {
+    if ((res = v4l2_udev_open (this)) < 0)
+      return res;
+
+    this->umonitor = udev_monitor_new_from_netlink (this->udev, "udev");
+    if (!this->umonitor)
+      return SPA_RESULT_ERROR;
+
+    udev_monitor_filter_add_match_subsystem_devtype (this->umonitor,
+                                                     "video4linux",
+                                                     NULL);
+
+    udev_monitor_enable_receiving (this->umonitor);
+    this->fd = udev_monitor_get_fd (this->umonitor);;
+
+    event.type = SPA_MONITOR_EVENT_TYPE_ADD_POLL;
+    event.data = &this->poll;
+    event.size = sizeof (this->poll);
+
+    this->fds[0].fd = this->fd;
+    this->fds[0].events = POLLIN | POLLPRI | POLLERR;
+    this->fds[0].revents = 0;
+
+    this->poll.id = 0;
+    this->poll.enabled = true;
+    this->poll.fds = this->fds;
+    this->poll.n_fds = 1;
+    this->poll.idle_cb = NULL;
+    this->poll.before_cb = NULL;
+    this->poll.after_cb = v4l2_on_fd_events;
+    this->poll.user_data = this;
+    this->event_cb (&this->monitor, &event, this->user_data);
+  } else {
+    event.type = SPA_MONITOR_EVENT_TYPE_REMOVE_POLL;
+    event.data = &this->poll;
+    event.size = sizeof (this->poll);
+    this->event_cb (&this->monitor, &event, this->user_data);
+  }
+
+  return SPA_RESULT_OK;
+}
+
+static SpaResult
+spa_v4l2_monitor_enum_items (SpaMonitor       *monitor,
+                             SpaMonitorItem  **item,
+                             void            **state)
+{
+  SpaResult res;
+  SpaV4l2Monitor *this;
+  struct udev_list_entry *devices;
+  struct udev_device *dev;
+
+  if (monitor == NULL || monitor->handle == NULL || item == NULL || state == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  this = (SpaV4l2Monitor *) monitor->handle;
+
+  if ((res = v4l2_udev_open (this)) < 0)
+    return res;
+
+  if (*state == NULL) {
+    if (this->enumerate)
+      udev_enumerate_unref (this->enumerate);
+    this->enumerate = udev_enumerate_new (this->udev);
+
+    udev_enumerate_add_match_subsystem (this->enumerate, "video4linux");
+    udev_enumerate_scan_devices (this->enumerate);
+
+    devices = udev_enumerate_get_list_entry (this->enumerate);
+    if (devices == NULL)
+      return SPA_RESULT_ENUM_END;
+  } else {
+    devices = *state;
+  }
+
+  if (*state == (void*)1) {
+    fill_item (&this->uitem, NULL);
+    return SPA_RESULT_ENUM_END;
+  }
+
+  dev = udev_device_new_from_syspath (this->udev,
+                                      udev_list_entry_get_name (devices));
+
+  fill_item (&this->uitem, dev);
+  if (dev == NULL)
+    return SPA_RESULT_ENUM_END;
+
+  *item = &this->uitem.item;
+
+  if ((*state = udev_list_entry_get_next (devices)) == NULL)
+    *state = (void*)1;
+
+  return SPA_RESULT_OK;
+}
+
+static const SpaMonitor v4l2monitor = {
+  NULL,
+  NULL,
+  sizeof (SpaMonitor),
+  spa_v4l2_monitor_set_event_callback,
+  spa_v4l2_monitor_enum_items,
+};
+
+static SpaResult
+spa_v4l2_monitor_get_interface (SpaHandle               *handle,
+                                uint32_t                 interface_id,
+                                void                   **interface)
+{
+  SpaV4l2Monitor *this;
+
+  if (handle == NULL || interface == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  this = (SpaV4l2Monitor *) handle;
+
+  switch (interface_id) {
+    case SPA_INTERFACE_ID_MONITOR:
+      *interface = &this->monitor;
+      break;
+    default:
+      return SPA_RESULT_UNKNOWN_INTERFACE;
+  }
+  return SPA_RESULT_OK;
+}
+
+static SpaResult
+v4l2_monitor_clear (SpaHandle *handle)
+{
+  return SPA_RESULT_OK;
+}
+
+static SpaResult
+v4l2_monitor_init (const SpaHandleFactory  *factory,
+                   SpaHandle               *handle,
+                   const void              *config)
+{
+  SpaV4l2Monitor *this;
+
+  if (factory == NULL || handle == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  handle->get_interface = spa_v4l2_monitor_get_interface;
+  handle->clear = v4l2_monitor_clear,
+
+  this = (SpaV4l2Monitor *) handle;
+  this->monitor = v4l2monitor;
+  this->monitor.handle = handle;
+
+  return SPA_RESULT_OK;
+}
+
+static const SpaInterfaceInfo v4l2_monitor_interfaces[] =
+{
+  { SPA_INTERFACE_ID_MONITOR,
+    SPA_INTERFACE_ID_MONITOR_NAME,
+    SPA_INTERFACE_ID_MONITOR_DESCRIPTION,
+  },
+};
+
+static SpaResult
+v4l2_monitor_enum_interface_info (const SpaHandleFactory  *factory,
+                                  const SpaInterfaceInfo **info,
+                                  void                   **state)
+{
+  int index;
+
+  if (factory == NULL || info == NULL || state == NULL)
+    return SPA_RESULT_INVALID_ARGUMENTS;
+
+  index = (*state == NULL ? 0 : *(int*)state);
+
+  if (index < 0 || index >= SPA_N_ELEMENTS (v4l2_monitor_interfaces))
+    return SPA_RESULT_ENUM_END;
+
+  *info = &v4l2_monitor_interfaces[index];
+  *(int*)state = ++index;
+  return SPA_RESULT_OK;
+}
+
+const SpaHandleFactory spa_v4l2_monitor_factory =
+{ "v4l2-monitor",
+  NULL,
+  sizeof (SpaV4l2Monitor),
+  v4l2_monitor_init,
+  v4l2_monitor_enum_interface_info,
+};

spa/plugins/v4l2/v4l2-source.c

@@ -44,6 +44,7 @@ static void
 reset_v4l2_source_props (SpaV4l2SourceProps *props)
 {
   strncpy (props->device, default_device, 64);
+  props->props.unset_mask = 7;
 }
 
 #define MAX_BUFFERS     256
@@ -793,6 +794,7 @@ spa_v4l2_source_clock_get_time (SpaClock         *clock,
 static const SpaClock v4l2source_clock = {
   NULL,
   sizeof (SpaClock),
+  NULL,
   SPA_CLOCK_STATE_STOPPED,
   spa_v4l2_source_clock_get_props,
   spa_v4l2_source_clock_set_props,
@@ -832,7 +834,8 @@ v4l2_source_clear (SpaHandle *handle)
 
 static SpaResult
 v4l2_source_init (const SpaHandleFactory  *factory,
-                  SpaHandle               *handle)
+                  SpaHandle               *handle,
+                  const void              *config)
 {
   SpaV4l2Source *this;
 

spa/plugins/v4l2/v4l2-utils.c

@@ -31,6 +31,11 @@ spa_v4l2_open (SpaV4l2Source *this)
   if (state->opened)
     return 0;
 
+  if (props->props.unset_mask & 1) {
+    fprintf(stderr, "Device property not set\n");
+    return -1;
+  }
+
   fprintf (stderr, "Playback device is '%s'\n", props->device);
 
   if (stat (props->device, &st) < 0) {

spa/plugins/v4l2/v4l2.c

@@ -21,6 +21,7 @@
 #include <spa/node.h>
 
 extern const SpaHandleFactory spa_v4l2_source_factory;
+extern const SpaHandleFactory spa_v4l2_monitor_factory;
 
 SpaResult
 spa_enum_handle_factory (const SpaHandleFactory **factory,
@@ -37,6 +38,9 @@ spa_enum_handle_factory (const SpaHandleFactory **factory,
     case 0:
       *factory = &spa_v4l2_source_factory;
       break;
+    case 1:
+      *factory = &spa_v4l2_monitor_factory;
+      break;
     default:
       return SPA_RESULT_ENUM_END;
   }

spa/plugins/volume/volume.c

@@ -676,7 +676,8 @@ volume_clear (SpaHandle *handle)
 
 static SpaResult
 volume_init (const SpaHandleFactory  *factory,
-             SpaHandle               *handle)
+             SpaHandle               *handle,
+             const void              *config)
 {
   SpaVolume *this;
 

spa/plugins/xv/xv-sink.c

@@ -555,7 +555,8 @@ xv_sink_clear (SpaHandle *handle)
 
 static SpaResult
 xv_sink_init (const SpaHandleFactory  *factory,
-              SpaHandle               *handle)
+              SpaHandle               *handle,
+              const void              *config)
 {
   SpaXvSink *this;
 

spa/tests/test-mixer.c

@@ -74,11 +74,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
       continue;
 
     handle = calloc (1, factory->size);
-    if ((res = factory->init (factory, handle)) < 0) {
+    if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
       printf ("can't make factory instance: %d\n", res);
       return res;
     }
-    if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
+    if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
       printf ("can't get interface %d\n", res);
       return res;
     }

spa/tests/test-v4l2.c

@@ -95,11 +95,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
       continue;
 
     handle = calloc (1, factory->size);
-    if ((res = factory->init (factory, handle)) < 0) {
+    if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
       printf ("can't make factory instance: %d\n", res);
       return res;
     }
-    if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
+    if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
       printf ("can't get interface %d\n", res);
       return res;
     }
@@ -402,7 +402,6 @@ run_async_source (AppData *data)
 {
   SpaResult res;
   SpaNodeCommand cmd;
-  bool done = false;
   int err;
 
   cmd.type = SPA_NODE_COMMAND_START;
@@ -415,23 +414,7 @@ run_async_source (AppData *data)
     data->running = false;
   }
 
-  while (!done) {
+  sleep (10);
-    SDL_Event event;
-
-    while (SDL_PollEvent (&event)) {
-      switch (event.type) {
-        case SDL_KEYDOWN:
-          if (event.key.keysym.sym == SDLK_ESCAPE) {
-            done = SDL_TRUE;
-          }
-          break;
-        case SDL_QUIT:
-          done = SDL_TRUE;
-          break;
-      }
-      sleep (1);
-    }
-  }
 
   if (data->running) {
     data->running = false;

spa/tools/meson.build

@@ -3,3 +3,9 @@ executable('spa-inspect', 'spa-inspect.c',
            dependencies : [dl_lib],
            link_with : spalib,
            install : true)
+
+executable('spa-monitor', 'spa-monitor.c',
+           include_directories : inc,
+           dependencies : [dl_lib],
+           link_with : spalib,
+           install : true)

spa/tools/spa-inspect.c

@@ -35,18 +35,18 @@ inspect_node (SpaNode *node)
   SpaFormat *format;
   void *state = NULL;
 
-  if ((res = node->get_props (node, &props)) < 0)
+  if ((res = spa_node_get_props (node, &props)) < 0)
     printf ("can't get properties: %d\n", res);
   else
     spa_debug_props (props, true);
 
-  if ((res = node->get_n_ports (node, &n_input, &max_input, &n_output, &max_output)) < 0)
+  if ((res = spa_node_get_n_ports (node, &n_input, &max_input, &n_output, &max_output)) < 0)
     printf ("can't get n_ports: %d\n", res);
   else
     printf ("supported ports %d %d %d %d\n", n_input, max_input, n_output, max_output);
 
   while (true) {
-    if ((res = node->port_enum_formats (node, 0, &format, NULL, &state)) < 0) {
+    if ((res = spa_node_port_enum_formats (node, 0, &format, NULL, &state)) < 0) {
       if (res != SPA_RESULT_ENUM_END)
         printf ("got error %d\n", res);
       break;
@@ -54,7 +54,7 @@ inspect_node (SpaNode *node)
     if (format)
       spa_debug_format (format);
   }
-  if ((res = node->port_get_props (node, 0, &props)) < 0)
+  if ((res = spa_node_port_get_props (node, 0, &props)) < 0)
     printf ("port_get_props error: %d\n", res);
   else
     spa_debug_props (props, true);
@@ -71,12 +71,12 @@ inspect_factory (const SpaHandleFactory *factory)
   printf ("factory name:\t\t'%s'\n", factory->name);
   printf ("factory info:\n");
   if (factory->info)
-    spa_debug_props (factory->info, true);
+    spa_debug_dict (factory->info);
   else
     printf ("  none\n");
 
   handle = calloc (1, factory->size);
-  if ((res = factory->init (factory, handle)) < 0) {
+  if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
     printf ("can't make factory instance: %d\n", res);
     return;
   }
@@ -86,7 +86,7 @@ inspect_factory (const SpaHandleFactory *factory)
   while (true) {
     const SpaInterfaceInfo *info;
 
-    if ((res = factory->enum_interface_info (factory, &info, &state)) < 0) {
+    if ((res = spa_handle_factory_enum_interface_info (factory, &info, &state)) < 0) {
       if (res == SPA_RESULT_ENUM_END)
         break;
       else
@@ -94,7 +94,7 @@ inspect_factory (const SpaHandleFactory *factory)
     }
     printf (" interface: (%d) '%s' : '%s'\n", info->interface_id, info->name, info->description);
 
-    if ((res = handle->get_interface (handle, info->interface_id, &interface)) < 0) {
+    if ((res = spa_handle_get_interface (handle, info->interface_id, &interface)) < 0) {
       printf ("can't get interface: %d\n", res);
       continue;
     }
@@ -118,6 +118,11 @@ main (int argc, char *argv[])
   SpaEnumHandleFactoryFunc enum_func;
   void *state = NULL;
 
+  if (argc < 2) {
+    printf ("usage: %s <plugin.so>\n", argv[0]);
+    return -1;
+  }
+
   if ((handle = dlopen (argv[1], RTLD_NOW)) == NULL) {
     printf ("can't load %s\n", argv[1]);
     return -1;

spa/tools/spa-monitor.c

@@ -0,0 +1,229 @@
+/* Pinos
+ * Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <poll.h>
+
+#include <spa/monitor.h>
+#include <spa/poll.h>
+#include <spa/debug.h>
+
+static void
+inspect_item (SpaMonitorItem *item)
+{
+  fprintf (stderr, "  name:  %s\n", item->name);
+  fprintf (stderr, "  class: %s\n", item->klass);
+  if (item->info)
+    spa_debug_dict (item->info);
+}
+
+typedef struct {
+  unsigned int n_poll;
+  SpaPollItem poll[16];
+
+  bool rebuild_fds;
+  SpaPollFd fds[16];
+  unsigned int n_fds;
+} PollData;
+
+static void
+on_monitor_event  (SpaMonitor      *monitor,
+                   SpaMonitorEvent *event,
+                   void            *user_data)
+{
+  PollData *data = user_data;
+
+  switch (event->type) {
+    case SPA_MONITOR_EVENT_TYPE_ADDED:
+    {
+      SpaMonitorItem *item = event->data;
+      fprintf (stderr, "added:\n");
+      inspect_item (item);
+      break;
+    }
+    case SPA_MONITOR_EVENT_TYPE_REMOVED:
+    {
+      SpaMonitorItem *item = event->data;
+      fprintf (stderr, "removed:\n");
+      inspect_item (item);
+      break;
+    }
+    case SPA_MONITOR_EVENT_TYPE_CHANGED:
+    {
+      SpaMonitorItem *item = event->data;
+      fprintf (stderr, "changed:\n");
+      inspect_item (item);
+      break;
+    }
+    case SPA_MONITOR_EVENT_TYPE_ADD_POLL:
+    {
+      SpaPollItem *item = event->data;
+
+      data->poll[data->n_poll] = *item;
+      data->n_poll++;
+      if (item->n_fds)
+        data->rebuild_fds = true;
+      break;
+    }
+
+    case SPA_MONITOR_EVENT_TYPE_UPDATE_POLL:
+      break;
+    case SPA_MONITOR_EVENT_TYPE_REMOVE_POLL:
+      break;
+    default:
+      break;
+  }
+}
+
+static void
+handle_monitor (SpaMonitor *monitor)
+{
+  SpaResult res;
+  void *state = NULL;
+  PollData data = { 0, };
+
+  if (monitor->info)
+    spa_debug_dict (monitor->info);
+
+  while (true) {
+    SpaMonitorItem *item;
+
+    if ((res = spa_monitor_enum_items (monitor, &item, &state)) < 0) {
+      if (res != SPA_RESULT_ENUM_END)
+        printf ("spa_monitor_enum_items: got error %d\n", res);
+      break;
+    }
+    inspect_item (item);
+  }
+
+  spa_monitor_set_event_callback (monitor, on_monitor_event, &data);
+
+  while (true) {
+    SpaPollNotifyData ndata;
+    int i, j, r;
+
+    /* rebuild */
+    if (data.rebuild_fds) {
+      data.n_fds = 0;
+      for (i = 0; i < data.n_poll; i++) {
+        SpaPollItem *p = &data.poll[i];
+
+        if (!p->enabled)
+          continue;
+
+        for (j = 0; j < p->n_fds; j++)
+          data.fds[data.n_fds + j] = p->fds[j];
+        p->fds = &data.fds[data.n_fds];
+        data.n_fds += p->n_fds;
+      }
+      data.rebuild_fds = false;
+    }
+
+    r = poll ((struct pollfd *) data.fds, data.n_fds, -1);
+    if (r < 0) {
+      if (errno == EINTR)
+        continue;
+      break;
+    }
+    if (r == 0) {
+      fprintf (stderr, "monitor %p: select timeout", monitor);
+      break;
+    }
+
+    /* after */
+    for (i = 0; i < data.n_poll; i++) {
+      SpaPollItem *p = &data.poll[i];
+
+      if (p->enabled && p->after_cb) {
+        ndata.fds = p->fds;
+        ndata.n_fds = p->n_fds;
+        ndata.user_data = p->user_data;
+        p->after_cb (&ndata);
+      }
+    }
+  }
+}
+
+int
+main (int argc, char *argv[])
+{
+  SpaResult res;
+  void *handle;
+  SpaEnumHandleFactoryFunc enum_func;
+  void *fstate = NULL;
+
+  if (argc < 2) {
+    printf ("usage: %s <plugin.so>\n", argv[0]);
+    return -1;
+  }
+
+  if ((handle = dlopen (argv[1], RTLD_NOW)) == NULL) {
+    printf ("can't load %s\n", argv[1]);
+    return -1;
+  }
+  if ((enum_func = dlsym (handle, "spa_enum_handle_factory")) == NULL) {
+    printf ("can't find function\n");
+    return -1;
+  }
+
+  while (true) {
+    const SpaHandleFactory *factory;
+    void *istate = NULL;
+
+    if ((res = enum_func (&factory, &fstate)) < 0) {
+      if (res != SPA_RESULT_ENUM_END)
+        printf ("can't enumerate factories: %d\n", res);
+      break;
+    }
+
+    while (true) {
+      const SpaInterfaceInfo *info;
+
+      if ((res = spa_handle_factory_enum_interface_info (factory, &info, &istate)) < 0) {
+        if (res != SPA_RESULT_ENUM_END)
+          printf ("can't enumerate interfaces: %d\n", res);
+        break;
+      }
+
+      if (info->interface_id == SPA_INTERFACE_ID_MONITOR) {
+        SpaHandle *handle;
+        void *interface;
+
+        handle = calloc (1, factory->size);
+        if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
+          printf ("can't make factory instance: %d\n", res);
+          continue;
+        }
+
+        if ((res = spa_handle_get_interface (handle, info->interface_id, &interface)) < 0) {
+          printf ("can't get interface: %d\n", res);
+          continue;
+        }
+        handle_monitor (interface);
+      }
+    }
+  }
+
+  return 0;
+}