gst/gstglobaldevicemonitor.c - mtk-gstreamer-debian - Git at Google

 /* GStreamer
  * Copyright (C) 2013 Olivier Crete <olivier.crete@collabora.com>
  *
  * gstglobaldevicemonitor.c: Global device monitor
  *
  * 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., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */

 /**
  * SECTION:gstglobaldevicemonitor
  * @short_description: A global device monitor and prober
  * @see_also: #GstDevice, #GstDeviceMonitor
  *
  * Applications should create a #GstGlobalDeviceMonitor when they want
  * to probe, list and monitor devices of a specific type. The
  * #GstGlobalDeviceMonitor will create the appropriate
  * #GstDeviceMonitor objects and manage them. It will then post
  * messages on its #GstBus for devices that have been added and
  * removed.
  *
  * Since: 1.4
  */


 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif

 #include "gst_private.h"
 #include "gstglobaldevicemonitor.h"

 struct _GstGlobalDeviceMonitorPrivate
 {
   gboolean started;

   GstBus *bus;

   GPtrArray *monitors;
   guint cookie;

   GstCaps *caps;
   gchar *classes;
 };


 G_DEFINE_TYPE (GstGlobalDeviceMonitor, gst_global_device_monitor,
     GST_TYPE_OBJECT);

 static void gst_global_device_monitor_dispose (GObject * object);

 static void
 gst_global_device_monitor_class_init (GstGlobalDeviceMonitorClass * klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);

   g_type_class_add_private (klass, sizeof (GstGlobalDeviceMonitorPrivate));

   object_class->dispose = gst_global_device_monitor_dispose;
 }

 static void
 bus_sync_message (GstBus * bus, GstMessage * message,
     GstGlobalDeviceMonitor * monitor)
 {
   GstMessageType type = GST_MESSAGE_TYPE (message);

   if (type == GST_MESSAGE_DEVICE_ADDED || type == GST_MESSAGE_DEVICE_REMOVED) {
     gboolean matches;
     GstCaps *caps;
     GstDevice *device;

     if (type == GST_MESSAGE_DEVICE_ADDED)
       gst_message_parse_device_added (message, &device);
     else
       gst_message_parse_device_removed (message, &device);

     GST_OBJECT_LOCK (monitor);
     caps = gst_device_get_caps (device);
     matches = gst_caps_can_intersect (monitor->priv->caps, caps) &&
         gst_device_has_classes (device, monitor->priv->classes);
     gst_caps_unref (caps);
     GST_OBJECT_UNLOCK (monitor);

     if (matches)
       gst_bus_post (monitor->priv->bus, gst_message_ref (message));
   }
 }


 static void
 gst_global_device_monitor_init (GstGlobalDeviceMonitor * self)
 {
   GList *factories;

   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
       GST_TYPE_GLOBAL_DEVICE_MONITOR, GstGlobalDeviceMonitorPrivate);

   self->priv->bus = gst_bus_new ();
   gst_bus_set_flushing (self->priv->bus, TRUE);

   self->priv->monitors = g_ptr_array_new ();
   self->priv->caps = gst_caps_new_any ();
   self->priv->classes = g_strdup ("");

   factories =
       gst_device_monitor_factory_list_get_device_monitors (self->priv->classes,
       1);

   while (factories) {
     GstDeviceMonitorFactory *factory = factories->data;
     GstDeviceMonitor *monitor;

     factories = g_list_remove (factories, factory);

     monitor = gst_device_monitor_factory_get (factory);
     if (monitor) {
       GstBus *bus = gst_device_monitor_get_bus (monitor);

       gst_bus_enable_sync_message_emission (bus);
       g_signal_connect (bus, "sync-message",
           G_CALLBACK (bus_sync_message), self);
       g_ptr_array_add (self->priv->monitors, monitor);
     }

     gst_object_unref (factory);
   }
 }


 static void
 gst_global_device_monitor_remove (GstGlobalDeviceMonitor * self, guint i)
 {
   GstDeviceMonitor *monitor = g_ptr_array_index (self->priv->monitors, i);
   GstBus *bus;

   g_ptr_array_remove_index_fast (self->priv->monitors, i);

   bus = gst_device_monitor_get_bus (monitor);
   g_signal_handlers_disconnect_by_func (bus, bus_sync_message, self);
   gst_object_unref (bus);

   gst_object_unref (monitor);
 }

 static void
 gst_global_device_monitor_dispose (GObject * object)
 {
   GstGlobalDeviceMonitor *self = GST_GLOBAL_DEVICE_MONITOR (object);

   g_return_if_fail (self->priv->started == FALSE);

   if (self->priv->monitors) {
     while (self->priv->monitors->len)
       gst_global_device_monitor_remove (self, self->priv->monitors->len - 1);
     g_ptr_array_unref (self->priv->monitors);
     self->priv->monitors = NULL;
   }

   gst_caps_replace (&self->priv->caps, NULL);
   g_free (self->priv->classes);
   gst_object_replace ((GstObject **) & self->priv->bus, NULL);

   G_OBJECT_CLASS (gst_global_device_monitor_parent_class)->dispose (object);
 }

 /**
  * gst_global_device_monitor_get_devices:
  * @monitor: A #GstDeviceMonitor
  *
  * Gets a list of devices from all of the relevant monitors. This may actually
  * probe the hardware if the global monitor is not currently started.
  *
  * Returns: (transfer full) (element-type GstDevice): a #GList of
  *   #GstDevice
  *
  * Since: 1.4
  */

 GList *
 gst_global_device_monitor_get_devices (GstGlobalDeviceMonitor * monitor)
 {
   GList *devices = NULL;
   guint i;
   guint cookie;

   g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), NULL);

   GST_OBJECT_LOCK (monitor);

 again:

   g_list_free_full (devices, gst_object_unref);
   devices = NULL;

   cookie = monitor->priv->cookie;

   for (i = 0; i < monitor->priv->monitors->len; i++) {
     GList *tmpdev;
     GstDeviceMonitor *device_monitor =
         gst_object_ref (g_ptr_array_index (monitor->priv->monitors, i));
     GList *item;

     GST_OBJECT_UNLOCK (monitor);

     tmpdev = gst_device_monitor_get_devices (device_monitor);

     for (item = tmpdev; item; item = item->next) {
       GstDevice *dev = GST_DEVICE (item->data);
       GstCaps *caps = gst_device_get_caps (dev);

       if (gst_caps_can_intersect (monitor->priv->caps, caps) &&
           gst_device_has_classes (dev, monitor->priv->classes))
         devices = g_list_prepend (devices, gst_object_ref (dev));
       gst_caps_unref (caps);
     }

     g_list_free_full (tmpdev, gst_object_unref);
     gst_object_unref (device_monitor);

     GST_OBJECT_LOCK (monitor);

     if (monitor->priv->cookie != cookie)
       goto again;
   }

   GST_OBJECT_UNLOCK (monitor);

   return devices;
 }

 /**
  * gst_global_device_monitor_start:
  * @monitor: A #GstGlobalDeviceMonitor
  *
  * Starts monitoring the devices, one this has succeeded, the
  * %GST_MESSAGE_DEVICE_ADDED and %GST_MESSAGE_DEVICE_REMOVED messages
  * will be emitted on the bus when the list of devices changes.
  *
  * Returns: %TRUE if the device monitoring could be started
  *
  * Since: 1.4
  */

 gboolean
 gst_global_device_monitor_start (GstGlobalDeviceMonitor * monitor)
 {
   guint i;

   g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), FALSE);

   GST_OBJECT_LOCK (monitor);

   if (monitor->priv->monitors->len == 0) {
     GST_OBJECT_UNLOCK (monitor);
     return FALSE;
   }

   gst_bus_set_flushing (monitor->priv->bus, FALSE);

   for (i = 0; i < monitor->priv->monitors->len; i++) {
     if (!gst_device_monitor_start (g_ptr_array_index (monitor->priv->monitors,
                 i))) {
       gst_bus_set_flushing (monitor->priv->bus, TRUE);

       for (; i != 0; i--)
         gst_device_monitor_stop (g_ptr_array_index (monitor->priv->monitors,
                 i - 1));

       GST_OBJECT_UNLOCK (monitor);
       return FALSE;
     }
   }

   monitor->priv->started = TRUE;
   GST_OBJECT_UNLOCK (monitor);

   return TRUE;
 }

 /**
  * gst_global_device_monitor_stop:
  * @monitor: A #GstDeviceMonitor
  *
  * Stops monitoring the devices.
  *
  * Since: 1.4
  */
 void
 gst_global_device_monitor_stop (GstGlobalDeviceMonitor * monitor)
 {
   guint i;

   g_return_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor));

   gst_bus_set_flushing (monitor->priv->bus, TRUE);

   GST_OBJECT_LOCK (monitor);
   for (i = 0; i < monitor->priv->monitors->len; i++)
     gst_device_monitor_stop (g_ptr_array_index (monitor->priv->monitors, i));
   monitor->priv->started = FALSE;
   GST_OBJECT_UNLOCK (monitor);

 }

 /**
  * gst_global_device_monitor_set_classes_filter:
  * @monitor: the global device monitor
  * @classes: device classes to use as filter
  *
  * Filter devices monitored by device class, e.g. in case you are only
  * interested in a certain type of device like audio devices or
  * video sources.
  *
  * Since: 1.4
  */
 void
 gst_global_device_monitor_set_classes_filter (GstGlobalDeviceMonitor * monitor,
     const gchar * classes)
 {
   GList *factories = NULL;
   guint i;

   g_return_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor));
   g_return_if_fail (!monitor->priv->started);

   GST_OBJECT_LOCK (monitor);
   if (!strcmp (monitor->priv->classes, classes)) {
     GST_OBJECT_UNLOCK (monitor);
     return;
   }

   g_free (monitor->priv->classes);
   monitor->priv->classes = g_strdup (classes);

   factories = gst_device_monitor_factory_list_get_device_monitors (classes, 1);

   for (i = 0; i < monitor->priv->monitors->len; i++) {
     GstDeviceMonitor *dev_monitor;
     GstDeviceMonitorFactory *f;
     GList *item;

     dev_monitor = g_ptr_array_index (monitor->priv->monitors, i);
     f = gst_device_monitor_get_factory (dev_monitor);

     item = g_list_find (factories, f);

     if (item) {
       /* If the item is in our list, then remove it from the list of factories,
        * we don't have it to re-create it later
        */
       factories = g_list_remove_link (factories, item);
       gst_object_unref (f);
     } else {
       /* If it's not in our list, them remove it from the list of monitors.
        */

       monitor->priv->cookie++;
       gst_global_device_monitor_remove (monitor, i);
       i--;
     }
   }

   while (factories) {
     GstDeviceMonitorFactory *factory = factories->data;
     GstDeviceMonitor *device_monitor;

     factories = g_list_remove (factories, factory);

     device_monitor = gst_device_monitor_factory_get (factory);
     if (device_monitor) {
       GstBus *bus = gst_device_monitor_get_bus (device_monitor);

       gst_bus_enable_sync_message_emission (bus);
       g_signal_connect (bus, "sync-message",
           G_CALLBACK (bus_sync_message), monitor);
       gst_object_unref (bus);
       g_ptr_array_add (monitor->priv->monitors, device_monitor);
       monitor->priv->cookie++;
     }

     gst_object_unref (factory);
   }

   GST_OBJECT_UNLOCK (monitor);
 }

 /**
  * gst_global_device_monitor_get_classes_filter:
  * @monitor: the global device monitor
  *
  * Return the type (device classes) filter active for device filtering.
  *
  * Returns: string of device classes that are being filtered.
  *
  * Since: 1.4
  */
 gchar *
 gst_global_device_monitor_get_classes_filter (GstGlobalDeviceMonitor * monitor)
 {
   gchar *res;

   g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), 0);

   GST_OBJECT_LOCK (monitor);
   res = g_strdup (monitor->priv->classes);
   GST_OBJECT_UNLOCK (monitor);

   return res;
 }

 /**
  * gst_global_device_monitor_set_caps_filter:
  * @monitor: the global device monitor
  * @caps: caps to filter
  *
  * Set caps to use as filter for devices. By default ANY caps are used,
  * meaning no caps filter is active.
  *
  * Since: 1.4
  */
 void
 gst_global_device_monitor_set_caps_filter (GstGlobalDeviceMonitor * monitor,
     GstCaps * caps)
 {
   g_return_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor));
   g_return_if_fail (GST_IS_CAPS (caps));

   GST_OBJECT_LOCK (monitor);
   gst_caps_replace (&monitor->priv->caps, caps);
   GST_OBJECT_UNLOCK (monitor);
 }

 /**
  * gst_global_device_monitor_get_caps_filter:
  * @monitor: a global device monitor
  *
  * Get the #GstCaps filter set by gst_global_device_monitor_set_caps_filter().
  *
  * Returns: (transfer full): the filter caps that are active (or ANY caps)
  *
  * Since: 1.4
  */
 GstCaps *
 gst_global_device_monitor_get_caps_filter (GstGlobalDeviceMonitor * monitor)
 {
   GstCaps *res;

   g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), NULL);

   GST_OBJECT_LOCK (monitor);
   res = gst_caps_ref (monitor->priv->caps);
   GST_OBJECT_UNLOCK (monitor);

   return res;
 }

 /**
  * gst_global_device_monitor_new:
  *
  * Create a new #GstGlobalDeviceMonitor
  *
  * Returns: (transfer full): a new global device monitor.
  *
  * Since: 1.4
  */
 GstGlobalDeviceMonitor *
 gst_global_device_monitor_new (void)
 {
   return g_object_new (GST_TYPE_GLOBAL_DEVICE_MONITOR, NULL);
 }

 /**
  * gst_global_device_monitor_get_bus:
  * @monitor: a #GstDeviceMonitor
  *
  * Gets the #GstBus of this #GstGlobalDeviceMonitor
  *
  * Returns: (transfer full): a #GstBus
  *
  * Since: 1.4
  */
 GstBus *
 gst_global_device_monitor_get_bus (GstGlobalDeviceMonitor * monitor)
 {
   g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), NULL);

   return gst_object_ref (monitor->priv->bus);
 }
	/* GStreamer
	* Copyright (C) 2013 Olivier Crete <olivier.crete@collabora.com>
	*
	* gstglobaldevicemonitor.c: Global device monitor
	*
	* 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., 59 Temple Place - Suite 330,
	* Boston, MA 02111-1307, USA.
	*/

	/**
	* SECTION:gstglobaldevicemonitor
	* @short_description: A global device monitor and prober
	* @see_also: #GstDevice, #GstDeviceMonitor
	*
	* Applications should create a #GstGlobalDeviceMonitor when they want
	* to probe, list and monitor devices of a specific type. The
	* #GstGlobalDeviceMonitor will create the appropriate
	* #GstDeviceMonitor objects and manage them. It will then post
	* messages on its #GstBus for devices that have been added and
	* removed.
	*
	* Since: 1.4
	*/


	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#include "gst_private.h"
	#include "gstglobaldevicemonitor.h"

	struct _GstGlobalDeviceMonitorPrivate
	{
	gboolean started;

	GstBus *bus;

	GPtrArray *monitors;
	guint cookie;

	GstCaps *caps;
	gchar *classes;
	};


	G_DEFINE_TYPE (GstGlobalDeviceMonitor, gst_global_device_monitor,
	GST_TYPE_OBJECT);

	static void gst_global_device_monitor_dispose (GObject * object);

	static void
	gst_global_device_monitor_class_init (GstGlobalDeviceMonitorClass * klass)
	{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);

	g_type_class_add_private (klass, sizeof (GstGlobalDeviceMonitorPrivate));

	object_class->dispose = gst_global_device_monitor_dispose;
	}

	static void
	bus_sync_message (GstBus * bus, GstMessage * message,
	GstGlobalDeviceMonitor * monitor)
	{
	GstMessageType type = GST_MESSAGE_TYPE (message);

	if (type == GST_MESSAGE_DEVICE_ADDED \|\| type == GST_MESSAGE_DEVICE_REMOVED) {
	gboolean matches;
	GstCaps *caps;
	GstDevice *device;

	if (type == GST_MESSAGE_DEVICE_ADDED)
	gst_message_parse_device_added (message, &device);
	else
	gst_message_parse_device_removed (message, &device);

	GST_OBJECT_LOCK (monitor);
	caps = gst_device_get_caps (device);
	matches = gst_caps_can_intersect (monitor->priv->caps, caps) &&
	gst_device_has_classes (device, monitor->priv->classes);
	gst_caps_unref (caps);
	GST_OBJECT_UNLOCK (monitor);

	if (matches)
	gst_bus_post (monitor->priv->bus, gst_message_ref (message));
	}
	}


	static void
	gst_global_device_monitor_init (GstGlobalDeviceMonitor * self)
	{
	GList *factories;

	self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
	GST_TYPE_GLOBAL_DEVICE_MONITOR, GstGlobalDeviceMonitorPrivate);

	self->priv->bus = gst_bus_new ();
	gst_bus_set_flushing (self->priv->bus, TRUE);

	self->priv->monitors = g_ptr_array_new ();
	self->priv->caps = gst_caps_new_any ();
	self->priv->classes = g_strdup ("");

	factories =
	gst_device_monitor_factory_list_get_device_monitors (self->priv->classes,
	1);

	while (factories) {
	GstDeviceMonitorFactory *factory = factories->data;
	GstDeviceMonitor *monitor;

	factories = g_list_remove (factories, factory);

	monitor = gst_device_monitor_factory_get (factory);
	if (monitor) {
	GstBus *bus = gst_device_monitor_get_bus (monitor);

	gst_bus_enable_sync_message_emission (bus);
	g_signal_connect (bus, "sync-message",
	G_CALLBACK (bus_sync_message), self);
	g_ptr_array_add (self->priv->monitors, monitor);
	}

	gst_object_unref (factory);
	}
	}


	static void
	gst_global_device_monitor_remove (GstGlobalDeviceMonitor * self, guint i)
	{
	GstDeviceMonitor *monitor = g_ptr_array_index (self->priv->monitors, i);
	GstBus *bus;

	g_ptr_array_remove_index_fast (self->priv->monitors, i);

	bus = gst_device_monitor_get_bus (monitor);
	g_signal_handlers_disconnect_by_func (bus, bus_sync_message, self);
	gst_object_unref (bus);

	gst_object_unref (monitor);
	}

	static void
	gst_global_device_monitor_dispose (GObject * object)
	{
	GstGlobalDeviceMonitor *self = GST_GLOBAL_DEVICE_MONITOR (object);

	g_return_if_fail (self->priv->started == FALSE);

	if (self->priv->monitors) {
	while (self->priv->monitors->len)
	gst_global_device_monitor_remove (self, self->priv->monitors->len - 1);
	g_ptr_array_unref (self->priv->monitors);
	self->priv->monitors = NULL;
	}

	gst_caps_replace (&self->priv->caps, NULL);
	g_free (self->priv->classes);
	gst_object_replace ((GstObject **) & self->priv->bus, NULL);

	G_OBJECT_CLASS (gst_global_device_monitor_parent_class)->dispose (object);
	}

	/**
	* gst_global_device_monitor_get_devices:
	* @monitor: A #GstDeviceMonitor
	*
	* Gets a list of devices from all of the relevant monitors. This may actually
	* probe the hardware if the global monitor is not currently started.
	*
	* Returns: (transfer full) (element-type GstDevice): a #GList of
	* #GstDevice
	*
	* Since: 1.4
	*/

	GList *
	gst_global_device_monitor_get_devices (GstGlobalDeviceMonitor * monitor)
	{
	GList *devices = NULL;
	guint i;
	guint cookie;

	g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), NULL);

	GST_OBJECT_LOCK (monitor);

	again:

	g_list_free_full (devices, gst_object_unref);
	devices = NULL;

	cookie = monitor->priv->cookie;

	for (i = 0; i < monitor->priv->monitors->len; i++) {
	GList *tmpdev;
	GstDeviceMonitor *device_monitor =
	gst_object_ref (g_ptr_array_index (monitor->priv->monitors, i));
	GList *item;

	GST_OBJECT_UNLOCK (monitor);

	tmpdev = gst_device_monitor_get_devices (device_monitor);

	for (item = tmpdev; item; item = item->next) {
	GstDevice *dev = GST_DEVICE (item->data);
	GstCaps *caps = gst_device_get_caps (dev);

	if (gst_caps_can_intersect (monitor->priv->caps, caps) &&
	gst_device_has_classes (dev, monitor->priv->classes))
	devices = g_list_prepend (devices, gst_object_ref (dev));
	gst_caps_unref (caps);
	}

	g_list_free_full (tmpdev, gst_object_unref);
	gst_object_unref (device_monitor);

	GST_OBJECT_LOCK (monitor);

	if (monitor->priv->cookie != cookie)
	goto again;
	}

	GST_OBJECT_UNLOCK (monitor);

	return devices;
	}

	/**
	* gst_global_device_monitor_start:
	* @monitor: A #GstGlobalDeviceMonitor
	*
	* Starts monitoring the devices, one this has succeeded, the
	* %GST_MESSAGE_DEVICE_ADDED and %GST_MESSAGE_DEVICE_REMOVED messages
	* will be emitted on the bus when the list of devices changes.
	*
	* Returns: %TRUE if the device monitoring could be started
	*
	* Since: 1.4
	*/

	gboolean
	gst_global_device_monitor_start (GstGlobalDeviceMonitor * monitor)
	{
	guint i;

	g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), FALSE);

	GST_OBJECT_LOCK (monitor);

	if (monitor->priv->monitors->len == 0) {
	GST_OBJECT_UNLOCK (monitor);
	return FALSE;
	}

	gst_bus_set_flushing (monitor->priv->bus, FALSE);

	for (i = 0; i < monitor->priv->monitors->len; i++) {
	if (!gst_device_monitor_start (g_ptr_array_index (monitor->priv->monitors,
	i))) {
	gst_bus_set_flushing (monitor->priv->bus, TRUE);

	for (; i != 0; i--)
	gst_device_monitor_stop (g_ptr_array_index (monitor->priv->monitors,
	i - 1));

	GST_OBJECT_UNLOCK (monitor);
	return FALSE;
	}
	}

	monitor->priv->started = TRUE;
	GST_OBJECT_UNLOCK (monitor);

	return TRUE;
	}

	/**
	* gst_global_device_monitor_stop:
	* @monitor: A #GstDeviceMonitor
	*
	* Stops monitoring the devices.
	*
	* Since: 1.4
	*/
	void
	gst_global_device_monitor_stop (GstGlobalDeviceMonitor * monitor)
	{
	guint i;

	g_return_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor));

	gst_bus_set_flushing (monitor->priv->bus, TRUE);

	GST_OBJECT_LOCK (monitor);
	for (i = 0; i < monitor->priv->monitors->len; i++)
	gst_device_monitor_stop (g_ptr_array_index (monitor->priv->monitors, i));
	monitor->priv->started = FALSE;
	GST_OBJECT_UNLOCK (monitor);

	}

	/**
	* gst_global_device_monitor_set_classes_filter:
	* @monitor: the global device monitor
	* @classes: device classes to use as filter
	*
	* Filter devices monitored by device class, e.g. in case you are only
	* interested in a certain type of device like audio devices or
	* video sources.
	*
	* Since: 1.4
	*/
	void
	gst_global_device_monitor_set_classes_filter (GstGlobalDeviceMonitor * monitor,
	const gchar * classes)
	{
	GList *factories = NULL;
	guint i;

	g_return_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor));
	g_return_if_fail (!monitor->priv->started);

	GST_OBJECT_LOCK (monitor);
	if (!strcmp (monitor->priv->classes, classes)) {
	GST_OBJECT_UNLOCK (monitor);
	return;
	}

	g_free (monitor->priv->classes);
	monitor->priv->classes = g_strdup (classes);

	factories = gst_device_monitor_factory_list_get_device_monitors (classes, 1);

	for (i = 0; i < monitor->priv->monitors->len; i++) {
	GstDeviceMonitor *dev_monitor;
	GstDeviceMonitorFactory *f;
	GList *item;

	dev_monitor = g_ptr_array_index (monitor->priv->monitors, i);
	f = gst_device_monitor_get_factory (dev_monitor);

	item = g_list_find (factories, f);

	if (item) {
	/* If the item is in our list, then remove it from the list of factories,
	* we don't have it to re-create it later
	*/
	factories = g_list_remove_link (factories, item);
	gst_object_unref (f);
	} else {
	/* If it's not in our list, them remove it from the list of monitors.
	*/

	monitor->priv->cookie++;
	gst_global_device_monitor_remove (monitor, i);
	i--;
	}
	}

	while (factories) {
	GstDeviceMonitorFactory *factory = factories->data;
	GstDeviceMonitor *device_monitor;

	factories = g_list_remove (factories, factory);

	device_monitor = gst_device_monitor_factory_get (factory);
	if (device_monitor) {
	GstBus *bus = gst_device_monitor_get_bus (device_monitor);

	gst_bus_enable_sync_message_emission (bus);
	g_signal_connect (bus, "sync-message",
	G_CALLBACK (bus_sync_message), monitor);
	gst_object_unref (bus);
	g_ptr_array_add (monitor->priv->monitors, device_monitor);
	monitor->priv->cookie++;
	}

	gst_object_unref (factory);
	}

	GST_OBJECT_UNLOCK (monitor);
	}

	/**
	* gst_global_device_monitor_get_classes_filter:
	* @monitor: the global device monitor
	*
	* Return the type (device classes) filter active for device filtering.
	*
	* Returns: string of device classes that are being filtered.
	*
	* Since: 1.4
	*/
	gchar *
	gst_global_device_monitor_get_classes_filter (GstGlobalDeviceMonitor * monitor)
	{
	gchar *res;

	g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), 0);

	GST_OBJECT_LOCK (monitor);
	res = g_strdup (monitor->priv->classes);
	GST_OBJECT_UNLOCK (monitor);

	return res;
	}

	/**
	* gst_global_device_monitor_set_caps_filter:
	* @monitor: the global device monitor
	* @caps: caps to filter
	*
	* Set caps to use as filter for devices. By default ANY caps are used,
	* meaning no caps filter is active.
	*
	* Since: 1.4
	*/
	void
	gst_global_device_monitor_set_caps_filter (GstGlobalDeviceMonitor * monitor,
	GstCaps * caps)
	{
	g_return_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor));
	g_return_if_fail (GST_IS_CAPS (caps));

	GST_OBJECT_LOCK (monitor);
	gst_caps_replace (&monitor->priv->caps, caps);
	GST_OBJECT_UNLOCK (monitor);
	}

	/**
	* gst_global_device_monitor_get_caps_filter:
	* @monitor: a global device monitor
	*
	* Get the #GstCaps filter set by gst_global_device_monitor_set_caps_filter().
	*
	* Returns: (transfer full): the filter caps that are active (or ANY caps)
	*
	* Since: 1.4
	*/
	GstCaps *
	gst_global_device_monitor_get_caps_filter (GstGlobalDeviceMonitor * monitor)
	{
	GstCaps *res;

	g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), NULL);

	GST_OBJECT_LOCK (monitor);
	res = gst_caps_ref (monitor->priv->caps);
	GST_OBJECT_UNLOCK (monitor);

	return res;
	}

	/**
	* gst_global_device_monitor_new:
	*
	* Create a new #GstGlobalDeviceMonitor
	*
	* Returns: (transfer full): a new global device monitor.
	*
	* Since: 1.4
	*/
	GstGlobalDeviceMonitor *
	gst_global_device_monitor_new (void)
	{
	return g_object_new (GST_TYPE_GLOBAL_DEVICE_MONITOR, NULL);
	}

	/**
	* gst_global_device_monitor_get_bus:
	* @monitor: a #GstDeviceMonitor
	*
	* Gets the #GstBus of this #GstGlobalDeviceMonitor
	*
	* Returns: (transfer full): a #GstBus
	*
	* Since: 1.4
	*/
	GstBus *
	gst_global_device_monitor_get_bus (GstGlobalDeviceMonitor * monitor)
	{
	g_return_val_if_fail (GST_IS_GLOBAL_DEVICE_MONITOR (monitor), NULL);

	return gst_object_ref (monitor->priv->bus);
	}