2 * Copyright (C) 2013 Olivier Crete <olivier.crete@collabora.com>
4 * gstdevicemonitor.c: device monitor
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 02111-1307, USA.
23 * SECTION:gstdevicemonitor
24 * @title: GstDeviceMonitor
25 * @short_description: A device monitor and prober
26 * @see_also: #GstDevice, #GstDeviceProvider
28 * Applications should create a #GstDeviceMonitor when they want
29 * to probe, list and monitor devices of a specific type. The
30 * #GstDeviceMonitor will create the appropriate
31 * #GstDeviceProvider objects and manage them. It will then post
32 * messages on its #GstBus for devices that have been added and
35 * The device monitor will monitor all devices matching the filters that
36 * the application has set.
38 * The basic use pattern of a device monitor is as follows:
41 * my_bus_func (GstBus * bus, GstMessage * message, gpointer user_data)
46 * switch (GST_MESSAGE_TYPE (message)) {
47 * case GST_MESSAGE_DEVICE_ADDED:
48 * gst_message_parse_device_added (message, &device);
49 * name = gst_device_get_display_name (device);
50 * g_print("Device added: %s\n", name);
52 * gst_object_unref (device);
54 * case GST_MESSAGE_DEVICE_REMOVED:
55 * gst_message_parse_device_removed (message, &device);
56 * name = gst_device_get_display_name (device);
57 * g_print("Device removed: %s\n", name);
59 * gst_object_unref (device);
65 * return G_SOURCE_CONTINUE;
69 * setup_raw_video_source_device_monitor (void) {
70 * GstDeviceMonitor *monitor;
74 * monitor = gst_device_monitor_new ();
76 * bus = gst_device_monitor_get_bus (monitor);
77 * gst_bus_add_watch (bus, my_bus_func, NULL);
78 * gst_object_unref (bus);
80 * caps = gst_caps_new_empty_simple ("video/x-raw");
81 * gst_device_monitor_add_filter (monitor, "Video/Source", caps);
82 * gst_caps_unref (caps);
84 * gst_device_monitor_start (monitor);
98 #include "gst_private.h"
99 #include "gstdevicemonitor.h"
101 struct _GstDeviceMonitorPrivate
107 GPtrArray *providers;
117 #define DEFAULT_SHOW_ALL FALSE
124 G_DEFINE_TYPE_WITH_PRIVATE (GstDeviceMonitor, gst_device_monitor,
127 static void gst_device_monitor_dispose (GObject * object);
138 device_filter_free (struct DeviceFilter *filter)
140 g_strfreev (filter->classesv);
141 gst_caps_unref (filter->caps);
143 g_slice_free (struct DeviceFilter, filter);
147 gst_device_monitor_get_property (GObject * object, guint prop_id,
148 GValue * value, GParamSpec * pspec)
150 GstDeviceMonitor *monitor = GST_DEVICE_MONITOR (object);
154 g_value_set_boolean (value,
155 gst_device_monitor_get_show_all_devices (monitor));
158 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
164 gst_device_monitor_set_property (GObject * object, guint prop_id,
165 const GValue * value, GParamSpec * pspec)
167 GstDeviceMonitor *monitor = GST_DEVICE_MONITOR (object);
171 gst_device_monitor_set_show_all_devices (monitor,
172 g_value_get_boolean (value));
175 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
182 gst_device_monitor_class_init (GstDeviceMonitorClass * klass)
184 GObjectClass *object_class = G_OBJECT_CLASS (klass);
186 object_class->get_property = gst_device_monitor_get_property;
187 object_class->set_property = gst_device_monitor_set_property;
188 object_class->dispose = gst_device_monitor_dispose;
190 g_object_class_install_property (object_class, PROP_SHOW_ALL,
191 g_param_spec_boolean ("show-all", "Show All",
192 "Show all devices, even those from hidden providers",
193 DEFAULT_SHOW_ALL, G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
196 /* must be called with monitor lock */
198 is_provider_hidden (GstDeviceMonitor * monitor, GList * hidden,
199 GstDeviceProvider * provider)
201 GstDeviceProviderFactory *factory;
203 if (monitor->priv->show_all)
206 factory = gst_device_provider_get_factory (provider);
207 if (g_list_find_custom (hidden, GST_OBJECT_NAME (factory),
208 (GCompareFunc) g_strcmp0))
214 /* must be called with monitor lock */
216 update_hidden_providers_list (GList ** hidden, GstDeviceProvider * provider)
220 obs = gst_device_provider_get_hidden_providers (provider);
224 for (i = 0; obs[i]; i++)
225 *hidden = g_list_prepend (*hidden, obs[i]);
232 bus_sync_message (GstBus * bus, GstMessage * message,
233 GstDeviceMonitor * monitor)
235 GstMessageType type = GST_MESSAGE_TYPE (message);
237 if (type == GST_MESSAGE_DEVICE_ADDED || type == GST_MESSAGE_DEVICE_REMOVED ||
238 type == GST_MESSAGE_DEVICE_CHANGED) {
239 gboolean matches = TRUE;
241 GstDeviceProvider *provider;
243 if (type == GST_MESSAGE_DEVICE_ADDED)
244 gst_message_parse_device_added (message, &device);
245 else if (type == GST_MESSAGE_DEVICE_REMOVED)
246 gst_message_parse_device_removed (message, &device);
248 gst_message_parse_device_changed (message, &device, NULL);
250 GST_OBJECT_LOCK (monitor);
252 GST_DEVICE_PROVIDER (gst_object_get_parent (GST_OBJECT (device)));
253 if (is_provider_hidden (monitor, monitor->priv->hidden, provider)) {
258 for (i = 0; i < monitor->priv->filters->len; i++) {
259 struct DeviceFilter *filter =
260 g_ptr_array_index (monitor->priv->filters, i);
263 caps = gst_device_get_caps (device);
264 matches = gst_caps_can_intersect (filter->caps, caps) &&
265 gst_device_has_classesv (device, filter->classesv);
266 gst_caps_unref (caps);
271 GST_OBJECT_UNLOCK (monitor);
273 gst_object_unref (provider);
274 gst_object_unref (device);
277 gst_bus_post (monitor->priv->bus, gst_message_ref (message));
283 gst_device_monitor_init (GstDeviceMonitor * self)
285 self->priv = gst_device_monitor_get_instance_private (self);
287 self->priv->show_all = DEFAULT_SHOW_ALL;
289 self->priv->bus = gst_bus_new ();
290 gst_bus_set_flushing (self->priv->bus, TRUE);
292 self->priv->providers = g_ptr_array_new ();
293 self->priv->filters = g_ptr_array_new_with_free_func (
294 (GDestroyNotify) device_filter_free);
296 self->priv->last_id = 1;
301 gst_device_monitor_remove (GstDeviceMonitor * self, guint i)
303 GstDeviceProvider *provider = g_ptr_array_index (self->priv->providers, i);
306 g_ptr_array_remove_index (self->priv->providers, i);
308 bus = gst_device_provider_get_bus (provider);
309 g_signal_handlers_disconnect_by_func (bus, bus_sync_message, self);
310 gst_object_unref (bus);
312 gst_object_unref (provider);
316 gst_device_monitor_dispose (GObject * object)
318 GstDeviceMonitor *self = GST_DEVICE_MONITOR (object);
320 g_return_if_fail (!self->priv->started);
322 if (self->priv->providers) {
323 while (self->priv->providers->len)
324 gst_device_monitor_remove (self, self->priv->providers->len - 1);
325 g_ptr_array_unref (self->priv->providers);
326 self->priv->providers = NULL;
329 if (self->priv->filters) {
330 g_ptr_array_unref (self->priv->filters);
331 self->priv->filters = NULL;
334 gst_object_replace ((GstObject **) & self->priv->bus, NULL);
336 G_OBJECT_CLASS (gst_device_monitor_parent_class)->dispose (object);
340 * gst_device_monitor_get_devices:
341 * @monitor: A #GstDeviceProvider
343 * Gets a list of devices from all of the relevant monitors. This may actually
344 * probe the hardware if the monitor is not currently started.
346 * Returns: (transfer full) (element-type GstDevice) (nullable): a #GList of
353 gst_device_monitor_get_devices (GstDeviceMonitor * monitor)
355 GList *devices = NULL, *hidden = NULL;
359 g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), NULL);
361 GST_OBJECT_LOCK (monitor);
363 if (monitor->priv->filters->len == 0) {
364 GST_OBJECT_UNLOCK (monitor);
365 GST_WARNING_OBJECT (monitor, "No filters have been set");
369 if (monitor->priv->providers->len == 0) {
370 GST_OBJECT_UNLOCK (monitor);
371 GST_WARNING_OBJECT (monitor, "No providers match the current filters");
377 g_list_free_full (devices, gst_object_unref);
378 g_list_free_full (hidden, g_free);
382 cookie = monitor->priv->cookie;
384 for (i = 0; i < monitor->priv->providers->len; i++) {
386 GstDeviceProvider *provider =
387 gst_object_ref (g_ptr_array_index (monitor->priv->providers, i));
390 if (!is_provider_hidden (monitor, hidden, provider)) {
391 GST_OBJECT_UNLOCK (monitor);
393 tmpdev = gst_device_provider_get_devices (provider);
395 GST_OBJECT_LOCK (monitor);
396 update_hidden_providers_list (&hidden, provider);
402 for (item = tmpdev; item; item = item->next) {
403 GstDevice *dev = GST_DEVICE (item->data);
404 GstCaps *caps = gst_device_get_caps (dev);
407 for (j = 0; j < monitor->priv->filters->len; j++) {
408 struct DeviceFilter *filter =
409 g_ptr_array_index (monitor->priv->filters, j);
411 if (gst_caps_can_intersect (filter->caps, caps) &&
412 gst_device_has_classesv (dev, filter->classesv)) {
413 devices = g_list_prepend (devices, gst_object_ref (dev));
417 gst_caps_unref (caps);
420 g_list_free_full (tmpdev, gst_object_unref);
421 gst_object_unref (provider);
423 if (monitor->priv->cookie != cookie)
426 g_list_free_full (hidden, g_free);
428 GST_OBJECT_UNLOCK (monitor);
430 return g_list_reverse (devices);
434 * gst_device_monitor_start:
435 * @monitor: A #GstDeviceMonitor
437 * Starts monitoring the devices, one this has succeeded, the
438 * %GST_MESSAGE_DEVICE_ADDED and %GST_MESSAGE_DEVICE_REMOVED messages
439 * will be emitted on the bus when the list of devices changes.
441 * Returns: %TRUE if the device monitoring could be started
447 gst_device_monitor_start (GstDeviceMonitor * monitor)
450 GList *pending = NULL, *started = NULL, *removed = NULL;
452 g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), FALSE);
454 GST_OBJECT_LOCK (monitor);
456 if (monitor->priv->filters->len == 0) {
457 GST_OBJECT_UNLOCK (monitor);
458 GST_WARNING_OBJECT (monitor, "No filters have been set, will expose all "
460 gst_device_monitor_add_filter (monitor, NULL, NULL);
461 GST_OBJECT_LOCK (monitor);
464 if (monitor->priv->providers->len == 0) {
465 GST_OBJECT_UNLOCK (monitor);
466 GST_WARNING_OBJECT (monitor, "No providers match the current filters");
470 gst_bus_set_flushing (monitor->priv->bus, FALSE);
473 cookie = monitor->priv->cookie;
475 g_list_free_full (pending, gst_object_unref);
480 for (i = 0; i < monitor->priv->providers->len; i++) {
481 GstDeviceProvider *provider;
484 provider = g_ptr_array_index (monitor->priv->providers, i);
486 find = g_list_find (removed, provider);
488 /* this was already started, move to started list */
489 removed = g_list_remove_link (removed, find);
490 started = g_list_concat (started, find);
492 /* not started, add to pending list */
493 pending = g_list_append (pending, gst_object_ref (provider));
496 g_list_free_full (removed, gst_object_unref);
500 GstDeviceProvider *provider = pending->data;
502 if (gst_device_provider_can_monitor (provider)) {
503 GST_OBJECT_UNLOCK (monitor);
505 if (!gst_device_provider_start (provider))
508 GST_OBJECT_LOCK (monitor);
510 started = g_list_prepend (started, provider);
511 pending = g_list_delete_link (pending, pending);
513 if (monitor->priv->cookie != cookie)
516 monitor->priv->started = TRUE;
517 GST_OBJECT_UNLOCK (monitor);
519 g_list_free_full (started, gst_object_unref);
525 GST_OBJECT_LOCK (monitor);
526 gst_bus_set_flushing (monitor->priv->bus, TRUE);
527 GST_OBJECT_UNLOCK (monitor);
530 GstDeviceProvider *provider = started->data;
532 gst_device_provider_stop (provider);
533 gst_object_unref (provider);
535 started = g_list_delete_link (started, started);
542 * gst_device_monitor_stop:
543 * @monitor: A #GstDeviceProvider
545 * Stops monitoring the devices.
550 gst_device_monitor_stop (GstDeviceMonitor * monitor)
553 GList *started = NULL;
555 g_return_if_fail (GST_IS_DEVICE_MONITOR (monitor));
557 gst_bus_set_flushing (monitor->priv->bus, TRUE);
559 GST_OBJECT_LOCK (monitor);
560 for (i = 0; i < monitor->priv->providers->len; i++) {
561 GstDeviceProvider *provider =
562 g_ptr_array_index (monitor->priv->providers, i);
564 started = g_list_prepend (started, gst_object_ref (provider));
566 GST_OBJECT_UNLOCK (monitor);
569 GstDeviceProvider *provider = started->data;
571 if (gst_device_provider_can_monitor (provider))
572 gst_device_provider_stop (provider);
574 started = g_list_delete_link (started, started);
575 gst_object_unref (provider);
578 GST_OBJECT_LOCK (monitor);
579 monitor->priv->started = FALSE;
580 GST_OBJECT_UNLOCK (monitor);
585 provider_hidden (GstDeviceProvider * provider, const gchar * hidden,
586 GstDeviceMonitor * monitor)
588 GST_OBJECT_LOCK (monitor);
589 monitor->priv->hidden =
590 g_list_prepend (monitor->priv->hidden, g_strdup (hidden));
591 GST_OBJECT_UNLOCK (monitor);
595 provider_unhidden (GstDeviceProvider * provider, const gchar * hidden,
596 GstDeviceMonitor * monitor)
600 GST_OBJECT_LOCK (monitor);
602 g_list_find_custom (monitor->priv->hidden, hidden,
603 (GCompareFunc) g_strcmp0);
606 monitor->priv->hidden = g_list_delete_link (monitor->priv->hidden, find);
608 GST_OBJECT_UNLOCK (monitor);
612 * gst_device_monitor_add_filter:
613 * @monitor: a device monitor
614 * @classes: (allow-none): device classes to use as filter or %NULL for any class
615 * @caps: (allow-none): the #GstCaps to filter or %NULL for ANY
617 * Adds a filter for which #GstDevice will be monitored, any device that matches
618 * all these classes and the #GstCaps will be returned.
620 * If this function is called multiple times to add more filters, each will be
621 * matched independently. That is, adding more filters will not further restrict
622 * what devices are matched.
624 * The #GstCaps supported by the device as returned by gst_device_get_caps() are
625 * not intersected with caps filters added using this function.
627 * Filters must be added before the #GstDeviceMonitor is started.
629 * Returns: The id of the new filter or 0 if no provider matched the filter's
635 gst_device_monitor_add_filter (GstDeviceMonitor * monitor,
636 const gchar * classes, GstCaps * caps)
638 GList *factories = NULL;
639 struct DeviceFilter *filter;
641 gboolean matched = FALSE;
643 g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), 0);
644 g_return_val_if_fail (!monitor->priv->started, 0);
646 GST_OBJECT_LOCK (monitor);
648 filter = g_slice_new0 (struct DeviceFilter);
649 filter->id = monitor->priv->last_id++;
651 filter->caps = gst_caps_ref (caps);
653 filter->caps = gst_caps_new_any ();
655 filter->classesv = g_strsplit (classes, "/", 0);
657 factories = gst_device_provider_factory_list_get_device_providers (1);
660 GstDeviceProviderFactory *factory = factories->data;
662 if (gst_device_provider_factory_has_classesv (factory, filter->classesv)) {
663 GstDeviceProvider *provider;
665 provider = gst_device_provider_factory_get (factory);
670 for (i = 0; i < monitor->priv->providers->len; i++) {
671 if (g_ptr_array_index (monitor->priv->providers, i) == provider) {
672 gst_object_unref (provider);
681 GstBus *bus = gst_device_provider_get_bus (provider);
683 update_hidden_providers_list (&monitor->priv->hidden, provider);
684 g_signal_connect (provider, "provider-hidden",
685 (GCallback) provider_hidden, monitor);
686 g_signal_connect (provider, "provider-unhidden",
687 (GCallback) provider_unhidden, monitor);
690 gst_bus_enable_sync_message_emission (bus);
691 g_signal_connect (bus, "sync-message",
692 G_CALLBACK (bus_sync_message), monitor);
693 gst_object_unref (bus);
694 g_ptr_array_add (monitor->priv->providers, provider);
695 monitor->priv->cookie++;
699 factories = g_list_remove (factories, factory);
700 gst_object_unref (factory);
703 /* Ensure there is no leak here */
704 g_assert (factories == NULL);
708 g_ptr_array_add (monitor->priv->filters, filter);
710 GST_OBJECT_UNLOCK (monitor);
716 * gst_device_monitor_remove_filter:
717 * @monitor: a device monitor
718 * @filter_id: the id of the filter
720 * Removes a filter from the #GstDeviceMonitor using the id that was returned
721 * by gst_device_monitor_add_filter().
723 * Returns: %TRUE of the filter id was valid, %FALSE otherwise
728 gst_device_monitor_remove_filter (GstDeviceMonitor * monitor, guint filter_id)
731 gboolean removed = FALSE;
733 g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), FALSE);
734 g_return_val_if_fail (!monitor->priv->started, FALSE);
735 g_return_val_if_fail (filter_id > 0, FALSE);
737 GST_OBJECT_LOCK (monitor);
738 for (i = 0; i < monitor->priv->filters->len; i++) {
739 struct DeviceFilter *filter = g_ptr_array_index (monitor->priv->filters, i);
741 if (filter->id == filter_id) {
742 g_ptr_array_remove_index (monitor->priv->filters, i);
749 for (i = 0; i < monitor->priv->providers->len; i++) {
750 GstDeviceProvider *provider =
751 g_ptr_array_index (monitor->priv->providers, i);
752 GstDeviceProviderFactory *factory =
753 gst_device_provider_get_factory (provider);
754 gboolean valid = FALSE;
756 for (j = 0; j < monitor->priv->filters->len; j++) {
757 struct DeviceFilter *filter =
758 g_ptr_array_index (monitor->priv->filters, j);
760 if (gst_device_provider_factory_has_classesv (factory,
768 monitor->priv->cookie++;
769 gst_device_monitor_remove (monitor, i);
775 GST_OBJECT_UNLOCK (monitor);
783 * gst_device_monitor_new:
785 * Create a new #GstDeviceMonitor
787 * Returns: (transfer full): a new device monitor.
792 gst_device_monitor_new (void)
794 GstDeviceMonitor *monitor;
796 monitor = g_object_new (GST_TYPE_DEVICE_MONITOR, NULL);
798 /* Clear floating flag */
799 gst_object_ref_sink (monitor);
805 * gst_device_monitor_get_bus:
806 * @monitor: a #GstDeviceProvider
808 * Gets the #GstBus of this #GstDeviceMonitor
810 * Returns: (transfer full): a #GstBus
815 gst_device_monitor_get_bus (GstDeviceMonitor * monitor)
817 g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), NULL);
819 return gst_object_ref (monitor->priv->bus);
823 * gst_device_monitor_get_providers:
824 * @monitor: a #GstDeviceMonitor
826 * Get a list of the currently selected device provider factories.
830 * Returns: (transfer full) (array zero-terminated=1) (element-type gchar*):
831 * A list of device provider factory names that are currently being
832 * monitored by @monitor or %NULL when nothing is being monitored.
837 gst_device_monitor_get_providers (GstDeviceMonitor * monitor)
842 g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), NULL);
844 GST_OBJECT_LOCK (monitor);
845 len = monitor->priv->providers->len;
849 res = g_new (gchar *, len + 1);
851 for (i = 0; i < len; i++) {
852 GstDeviceProvider *provider =
853 g_ptr_array_index (monitor->priv->providers, i);
854 GstDeviceProviderFactory *factory =
855 gst_device_provider_get_factory (provider);
857 res[i] = g_strdup (GST_OBJECT_NAME (factory));
862 GST_OBJECT_UNLOCK (monitor);
868 * gst_device_monitor_set_show_all_devices:
869 * @monitor: a #GstDeviceMonitor
870 * @show_all: show all devices
872 * Set if all devices should be visible, even those devices from hidden
873 * providers. Setting @show_all to true might show some devices multiple times.
878 gst_device_monitor_set_show_all_devices (GstDeviceMonitor * monitor,
881 g_return_if_fail (GST_IS_DEVICE_MONITOR (monitor));
883 GST_OBJECT_LOCK (monitor);
884 monitor->priv->show_all = show_all;
885 GST_OBJECT_UNLOCK (monitor);
889 * gst_device_monitor_get_show_all_devices:
890 * @monitor: a #GstDeviceMonitor
892 * Get if @monitor is curretly showing all devices, even those from hidden
895 * Returns: %TRUE when all devices will be shown.
900 gst_device_monitor_get_show_all_devices (GstDeviceMonitor * monitor)
904 g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), FALSE);
906 GST_OBJECT_LOCK (monitor);
907 res = monitor->priv->show_all;
908 GST_OBJECT_UNLOCK (monitor);