mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-05 07:56:35 +00:00
97aa82387f
Thi introduces new APIs to post a `DEVICE_CHANGED` message on the bus so the application is notifies when a device is modified. For example, if the "defaultness" of a device was changed or any property that can be changed at any time. Atomically changing the device object notifying that way allow us to abtract away the internal threads. New APIS: - gst_message_new_device_changed - gst_message_parse_device_changed - gst_device_provider_device_changed
911 lines
23 KiB
C
911 lines
23 KiB
C
/* GStreamer
|
|
* Copyright (C) 2013 Olivier Crete <olivier.crete@collabora.com>
|
|
*
|
|
* gstdevicemonitor.c: 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:gstdevicemonitor
|
|
* @title: GstDeviceMonitor
|
|
* @short_description: A device monitor and prober
|
|
* @see_also: #GstDevice, #GstDeviceProvider
|
|
*
|
|
* Applications should create a #GstDeviceMonitor when they want
|
|
* to probe, list and monitor devices of a specific type. The
|
|
* #GstDeviceMonitor will create the appropriate
|
|
* #GstDeviceProvider objects and manage them. It will then post
|
|
* messages on its #GstBus for devices that have been added and
|
|
* removed.
|
|
*
|
|
* The device monitor will monitor all devices matching the filters that
|
|
* the application has set.
|
|
*
|
|
* The basic use pattern of a device monitor is as follows:
|
|
* |[
|
|
* static gboolean
|
|
* my_bus_func (GstBus * bus, GstMessage * message, gpointer user_data)
|
|
* {
|
|
* GstDevice *device;
|
|
* gchar *name;
|
|
*
|
|
* switch (GST_MESSAGE_TYPE (message)) {
|
|
* case GST_MESSAGE_DEVICE_ADDED:
|
|
* gst_message_parse_device_added (message, &device);
|
|
* name = gst_device_get_display_name (device);
|
|
* g_print("Device added: %s\n", name);
|
|
* g_free (name);
|
|
* gst_object_unref (device);
|
|
* break;
|
|
* case GST_MESSAGE_DEVICE_REMOVED:
|
|
* gst_message_parse_device_removed (message, &device);
|
|
* name = gst_device_get_display_name (device);
|
|
* g_print("Device removed: %s\n", name);
|
|
* g_free (name);
|
|
* gst_object_unref (device);
|
|
* break;
|
|
* default:
|
|
* break;
|
|
* }
|
|
*
|
|
* return G_SOURCE_CONTINUE;
|
|
* }
|
|
*
|
|
* GstDeviceMonitor *
|
|
* setup_raw_video_source_device_monitor (void) {
|
|
* GstDeviceMonitor *monitor;
|
|
* GstBus *bus;
|
|
* GstCaps *caps;
|
|
*
|
|
* monitor = gst_device_monitor_new ();
|
|
*
|
|
* bus = gst_device_monitor_get_bus (monitor);
|
|
* gst_bus_add_watch (bus, my_bus_func, NULL);
|
|
* gst_object_unref (bus);
|
|
*
|
|
* caps = gst_caps_new_empty_simple ("video/x-raw");
|
|
* gst_device_monitor_add_filter (monitor, "Video/Source", caps);
|
|
* gst_caps_unref (caps);
|
|
*
|
|
* gst_device_monitor_start (monitor);
|
|
*
|
|
* return monitor;
|
|
* }
|
|
* ]|
|
|
*
|
|
* Since: 1.4
|
|
*/
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "gst_private.h"
|
|
#include "gstdevicemonitor.h"
|
|
|
|
struct _GstDeviceMonitorPrivate
|
|
{
|
|
gboolean started;
|
|
|
|
GstBus *bus;
|
|
|
|
GPtrArray *providers;
|
|
guint cookie;
|
|
|
|
GPtrArray *filters;
|
|
|
|
guint last_id;
|
|
GList *hidden;
|
|
gboolean show_all;
|
|
};
|
|
|
|
#define DEFAULT_SHOW_ALL FALSE
|
|
|
|
enum
|
|
{
|
|
PROP_SHOW_ALL = 1,
|
|
};
|
|
|
|
G_DEFINE_TYPE_WITH_PRIVATE (GstDeviceMonitor, gst_device_monitor,
|
|
GST_TYPE_OBJECT);
|
|
|
|
static void gst_device_monitor_dispose (GObject * object);
|
|
|
|
struct DeviceFilter
|
|
{
|
|
guint id;
|
|
|
|
gchar **classesv;
|
|
GstCaps *caps;
|
|
};
|
|
|
|
static void
|
|
device_filter_free (struct DeviceFilter *filter)
|
|
{
|
|
g_strfreev (filter->classesv);
|
|
gst_caps_unref (filter->caps);
|
|
|
|
g_slice_free (struct DeviceFilter, filter);
|
|
}
|
|
|
|
static void
|
|
gst_device_monitor_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstDeviceMonitor *monitor = GST_DEVICE_MONITOR (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_SHOW_ALL:
|
|
g_value_set_boolean (value,
|
|
gst_device_monitor_get_show_all_devices (monitor));
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_device_monitor_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstDeviceMonitor *monitor = GST_DEVICE_MONITOR (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_SHOW_ALL:
|
|
gst_device_monitor_set_show_all_devices (monitor,
|
|
g_value_get_boolean (value));
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
gst_device_monitor_class_init (GstDeviceMonitorClass * klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->get_property = gst_device_monitor_get_property;
|
|
object_class->set_property = gst_device_monitor_set_property;
|
|
object_class->dispose = gst_device_monitor_dispose;
|
|
|
|
g_object_class_install_property (object_class, PROP_SHOW_ALL,
|
|
g_param_spec_boolean ("show-all", "Show All",
|
|
"Show all devices, even those from hidden providers",
|
|
DEFAULT_SHOW_ALL, G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
|
|
}
|
|
|
|
/* must be called with monitor lock */
|
|
static gboolean
|
|
is_provider_hidden (GstDeviceMonitor * monitor, GList * hidden,
|
|
GstDeviceProvider * provider)
|
|
{
|
|
GstDeviceProviderFactory *factory;
|
|
|
|
if (monitor->priv->show_all)
|
|
return FALSE;
|
|
|
|
factory = gst_device_provider_get_factory (provider);
|
|
if (g_list_find_custom (hidden, GST_OBJECT_NAME (factory),
|
|
(GCompareFunc) g_strcmp0))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* must be called with monitor lock */
|
|
static void
|
|
update_hidden_providers_list (GList ** hidden, GstDeviceProvider * provider)
|
|
{
|
|
gchar **obs;
|
|
|
|
obs = gst_device_provider_get_hidden_providers (provider);
|
|
if (obs) {
|
|
gint i;
|
|
|
|
for (i = 0; obs[i]; i++)
|
|
*hidden = g_list_prepend (*hidden, obs[i]);
|
|
|
|
g_free (obs);
|
|
}
|
|
}
|
|
|
|
static void
|
|
bus_sync_message (GstBus * bus, GstMessage * message,
|
|
GstDeviceMonitor * monitor)
|
|
{
|
|
GstMessageType type = GST_MESSAGE_TYPE (message);
|
|
|
|
if (type == GST_MESSAGE_DEVICE_ADDED || type == GST_MESSAGE_DEVICE_REMOVED ||
|
|
type == GST_MESSAGE_DEVICE_CHANGED) {
|
|
gboolean matches = TRUE;
|
|
GstDevice *device;
|
|
GstDeviceProvider *provider;
|
|
|
|
if (type == GST_MESSAGE_DEVICE_ADDED)
|
|
gst_message_parse_device_added (message, &device);
|
|
else if (type == GST_MESSAGE_DEVICE_REMOVED)
|
|
gst_message_parse_device_removed (message, &device);
|
|
else
|
|
gst_message_parse_device_changed (message, &device, NULL);
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
provider =
|
|
GST_DEVICE_PROVIDER (gst_object_get_parent (GST_OBJECT (device)));
|
|
if (is_provider_hidden (monitor, monitor->priv->hidden, provider)) {
|
|
matches = FALSE;
|
|
} else {
|
|
guint i;
|
|
|
|
for (i = 0; i < monitor->priv->filters->len; i++) {
|
|
struct DeviceFilter *filter =
|
|
g_ptr_array_index (monitor->priv->filters, i);
|
|
GstCaps *caps;
|
|
|
|
caps = gst_device_get_caps (device);
|
|
matches = gst_caps_can_intersect (filter->caps, caps) &&
|
|
gst_device_has_classesv (device, filter->classesv);
|
|
gst_caps_unref (caps);
|
|
if (matches)
|
|
break;
|
|
}
|
|
}
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
gst_object_unref (provider);
|
|
gst_object_unref (device);
|
|
|
|
if (matches)
|
|
gst_bus_post (monitor->priv->bus, gst_message_ref (message));
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
gst_device_monitor_init (GstDeviceMonitor * self)
|
|
{
|
|
self->priv = gst_device_monitor_get_instance_private (self);
|
|
|
|
self->priv->show_all = DEFAULT_SHOW_ALL;
|
|
|
|
self->priv->bus = gst_bus_new ();
|
|
gst_bus_set_flushing (self->priv->bus, TRUE);
|
|
|
|
self->priv->providers = g_ptr_array_new ();
|
|
self->priv->filters = g_ptr_array_new_with_free_func (
|
|
(GDestroyNotify) device_filter_free);
|
|
|
|
self->priv->last_id = 1;
|
|
}
|
|
|
|
|
|
static void
|
|
gst_device_monitor_remove (GstDeviceMonitor * self, guint i)
|
|
{
|
|
GstDeviceProvider *provider = g_ptr_array_index (self->priv->providers, i);
|
|
GstBus *bus;
|
|
|
|
g_ptr_array_remove_index (self->priv->providers, i);
|
|
|
|
bus = gst_device_provider_get_bus (provider);
|
|
g_signal_handlers_disconnect_by_func (bus, bus_sync_message, self);
|
|
gst_object_unref (bus);
|
|
|
|
gst_object_unref (provider);
|
|
}
|
|
|
|
static void
|
|
gst_device_monitor_dispose (GObject * object)
|
|
{
|
|
GstDeviceMonitor *self = GST_DEVICE_MONITOR (object);
|
|
|
|
g_return_if_fail (!self->priv->started);
|
|
|
|
if (self->priv->providers) {
|
|
while (self->priv->providers->len)
|
|
gst_device_monitor_remove (self, self->priv->providers->len - 1);
|
|
g_ptr_array_unref (self->priv->providers);
|
|
self->priv->providers = NULL;
|
|
}
|
|
|
|
if (self->priv->filters) {
|
|
g_ptr_array_unref (self->priv->filters);
|
|
self->priv->filters = NULL;
|
|
}
|
|
|
|
gst_object_replace ((GstObject **) & self->priv->bus, NULL);
|
|
|
|
G_OBJECT_CLASS (gst_device_monitor_parent_class)->dispose (object);
|
|
}
|
|
|
|
/**
|
|
* gst_device_monitor_get_devices:
|
|
* @monitor: A #GstDeviceProvider
|
|
*
|
|
* Gets a list of devices from all of the relevant monitors. This may actually
|
|
* probe the hardware if the monitor is not currently started.
|
|
*
|
|
* Returns: (transfer full) (element-type GstDevice) (nullable): a #GList of
|
|
* #GstDevice
|
|
*
|
|
* Since: 1.4
|
|
*/
|
|
|
|
GList *
|
|
gst_device_monitor_get_devices (GstDeviceMonitor * monitor)
|
|
{
|
|
GList *devices = NULL, *hidden = NULL;
|
|
guint i;
|
|
guint cookie;
|
|
|
|
g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), NULL);
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
|
|
if (monitor->priv->filters->len == 0) {
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
GST_WARNING_OBJECT (monitor, "No filters have been set");
|
|
return NULL;
|
|
}
|
|
|
|
if (monitor->priv->providers->len == 0) {
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
GST_WARNING_OBJECT (monitor, "No providers match the current filters");
|
|
return NULL;
|
|
}
|
|
|
|
again:
|
|
|
|
g_list_free_full (devices, gst_object_unref);
|
|
g_list_free_full (hidden, g_free);
|
|
devices = NULL;
|
|
hidden = NULL;
|
|
|
|
cookie = monitor->priv->cookie;
|
|
|
|
for (i = 0; i < monitor->priv->providers->len; i++) {
|
|
GList *tmpdev;
|
|
GstDeviceProvider *provider =
|
|
gst_object_ref (g_ptr_array_index (monitor->priv->providers, i));
|
|
GList *item;
|
|
|
|
if (!is_provider_hidden (monitor, hidden, provider)) {
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
tmpdev = gst_device_provider_get_devices (provider);
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
update_hidden_providers_list (&hidden, provider);
|
|
} else {
|
|
tmpdev = NULL;
|
|
}
|
|
|
|
|
|
for (item = tmpdev; item; item = item->next) {
|
|
GstDevice *dev = GST_DEVICE (item->data);
|
|
GstCaps *caps = gst_device_get_caps (dev);
|
|
guint j;
|
|
|
|
for (j = 0; j < monitor->priv->filters->len; j++) {
|
|
struct DeviceFilter *filter =
|
|
g_ptr_array_index (monitor->priv->filters, j);
|
|
|
|
if (gst_caps_can_intersect (filter->caps, caps) &&
|
|
gst_device_has_classesv (dev, filter->classesv)) {
|
|
devices = g_list_prepend (devices, gst_object_ref (dev));
|
|
break;
|
|
}
|
|
}
|
|
gst_caps_unref (caps);
|
|
}
|
|
|
|
g_list_free_full (tmpdev, gst_object_unref);
|
|
gst_object_unref (provider);
|
|
|
|
if (monitor->priv->cookie != cookie)
|
|
goto again;
|
|
}
|
|
g_list_free_full (hidden, g_free);
|
|
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
return g_list_reverse (devices);
|
|
}
|
|
|
|
/**
|
|
* gst_device_monitor_start:
|
|
* @monitor: A #GstDeviceMonitor
|
|
*
|
|
* 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_device_monitor_start (GstDeviceMonitor * monitor)
|
|
{
|
|
guint cookie, i;
|
|
GList *pending = NULL, *started = NULL, *removed = NULL;
|
|
|
|
g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), FALSE);
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
|
|
if (monitor->priv->filters->len == 0) {
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
GST_WARNING_OBJECT (monitor, "No filters have been set, will expose all "
|
|
"devices found");
|
|
gst_device_monitor_add_filter (monitor, NULL, NULL);
|
|
GST_OBJECT_LOCK (monitor);
|
|
}
|
|
|
|
if (monitor->priv->providers->len == 0) {
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
GST_WARNING_OBJECT (monitor, "No providers match the current filters");
|
|
return FALSE;
|
|
}
|
|
|
|
gst_bus_set_flushing (monitor->priv->bus, FALSE);
|
|
|
|
again:
|
|
cookie = monitor->priv->cookie;
|
|
|
|
g_list_free_full (pending, gst_object_unref);
|
|
pending = NULL;
|
|
removed = started;
|
|
started = NULL;
|
|
|
|
for (i = 0; i < monitor->priv->providers->len; i++) {
|
|
GstDeviceProvider *provider;
|
|
GList *find;
|
|
|
|
provider = g_ptr_array_index (monitor->priv->providers, i);
|
|
|
|
find = g_list_find (removed, provider);
|
|
if (find) {
|
|
/* this was already started, move to started list */
|
|
removed = g_list_remove_link (removed, find);
|
|
started = g_list_concat (started, find);
|
|
} else {
|
|
/* not started, add to pending list */
|
|
pending = g_list_append (pending, gst_object_ref (provider));
|
|
}
|
|
}
|
|
g_list_free_full (removed, gst_object_unref);
|
|
removed = NULL;
|
|
|
|
while (pending) {
|
|
GstDeviceProvider *provider = pending->data;
|
|
|
|
if (gst_device_provider_can_monitor (provider)) {
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
if (!gst_device_provider_start (provider))
|
|
goto start_failed;
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
}
|
|
started = g_list_prepend (started, provider);
|
|
pending = g_list_delete_link (pending, pending);
|
|
|
|
if (monitor->priv->cookie != cookie)
|
|
goto again;
|
|
}
|
|
monitor->priv->started = TRUE;
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
g_list_free_full (started, gst_object_unref);
|
|
|
|
return TRUE;
|
|
|
|
start_failed:
|
|
{
|
|
GST_OBJECT_LOCK (monitor);
|
|
gst_bus_set_flushing (monitor->priv->bus, TRUE);
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
while (started) {
|
|
GstDeviceProvider *provider = started->data;
|
|
|
|
gst_device_provider_stop (provider);
|
|
gst_object_unref (provider);
|
|
|
|
started = g_list_delete_link (started, started);
|
|
}
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_device_monitor_stop:
|
|
* @monitor: A #GstDeviceProvider
|
|
*
|
|
* Stops monitoring the devices.
|
|
*
|
|
* Since: 1.4
|
|
*/
|
|
void
|
|
gst_device_monitor_stop (GstDeviceMonitor * monitor)
|
|
{
|
|
guint i;
|
|
GList *started = NULL;
|
|
|
|
g_return_if_fail (GST_IS_DEVICE_MONITOR (monitor));
|
|
|
|
gst_bus_set_flushing (monitor->priv->bus, TRUE);
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
for (i = 0; i < monitor->priv->providers->len; i++) {
|
|
GstDeviceProvider *provider =
|
|
g_ptr_array_index (monitor->priv->providers, i);
|
|
|
|
started = g_list_prepend (started, gst_object_ref (provider));
|
|
}
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
while (started) {
|
|
GstDeviceProvider *provider = started->data;
|
|
|
|
if (gst_device_provider_can_monitor (provider))
|
|
gst_device_provider_stop (provider);
|
|
|
|
started = g_list_delete_link (started, started);
|
|
gst_object_unref (provider);
|
|
}
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
monitor->priv->started = FALSE;
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
}
|
|
|
|
static void
|
|
provider_hidden (GstDeviceProvider * provider, const gchar * hidden,
|
|
GstDeviceMonitor * monitor)
|
|
{
|
|
GST_OBJECT_LOCK (monitor);
|
|
monitor->priv->hidden =
|
|
g_list_prepend (monitor->priv->hidden, g_strdup (hidden));
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
}
|
|
|
|
static void
|
|
provider_unhidden (GstDeviceProvider * provider, const gchar * hidden,
|
|
GstDeviceMonitor * monitor)
|
|
{
|
|
GList *find;
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
find =
|
|
g_list_find_custom (monitor->priv->hidden, hidden,
|
|
(GCompareFunc) g_strcmp0);
|
|
if (find) {
|
|
g_free (find->data);
|
|
monitor->priv->hidden = g_list_delete_link (monitor->priv->hidden, find);
|
|
}
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
}
|
|
|
|
/**
|
|
* gst_device_monitor_add_filter:
|
|
* @monitor: a device monitor
|
|
* @classes: (allow-none): device classes to use as filter or %NULL for any class
|
|
* @caps: (allow-none): the #GstCaps to filter or %NULL for ANY
|
|
*
|
|
* Adds a filter for which #GstDevice will be monitored, any device that matches
|
|
* all these classes and the #GstCaps will be returned.
|
|
*
|
|
* If this function is called multiple times to add more filters, each will be
|
|
* matched independently. That is, adding more filters will not further restrict
|
|
* what devices are matched.
|
|
*
|
|
* The #GstCaps supported by the device as returned by gst_device_get_caps() are
|
|
* not intersected with caps filters added using this function.
|
|
*
|
|
* Filters must be added before the #GstDeviceMonitor is started.
|
|
*
|
|
* Returns: The id of the new filter or 0 if no provider matched the filter's
|
|
* classes.
|
|
*
|
|
* Since: 1.4
|
|
*/
|
|
guint
|
|
gst_device_monitor_add_filter (GstDeviceMonitor * monitor,
|
|
const gchar * classes, GstCaps * caps)
|
|
{
|
|
GList *factories = NULL;
|
|
struct DeviceFilter *filter;
|
|
guint id = 0;
|
|
gboolean matched = FALSE;
|
|
|
|
g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), 0);
|
|
g_return_val_if_fail (!monitor->priv->started, 0);
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
|
|
filter = g_slice_new0 (struct DeviceFilter);
|
|
filter->id = monitor->priv->last_id++;
|
|
if (caps)
|
|
filter->caps = gst_caps_ref (caps);
|
|
else
|
|
filter->caps = gst_caps_new_any ();
|
|
if (classes)
|
|
filter->classesv = g_strsplit (classes, "/", 0);
|
|
|
|
factories = gst_device_provider_factory_list_get_device_providers (1);
|
|
|
|
while (factories) {
|
|
GstDeviceProviderFactory *factory = factories->data;
|
|
|
|
if (gst_device_provider_factory_has_classesv (factory, filter->classesv)) {
|
|
GstDeviceProvider *provider;
|
|
|
|
provider = gst_device_provider_factory_get (factory);
|
|
|
|
if (provider) {
|
|
guint i;
|
|
|
|
for (i = 0; i < monitor->priv->providers->len; i++) {
|
|
if (g_ptr_array_index (monitor->priv->providers, i) == provider) {
|
|
gst_object_unref (provider);
|
|
provider = NULL;
|
|
matched = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (provider) {
|
|
GstBus *bus = gst_device_provider_get_bus (provider);
|
|
|
|
update_hidden_providers_list (&monitor->priv->hidden, provider);
|
|
g_signal_connect (provider, "provider-hidden",
|
|
(GCallback) provider_hidden, monitor);
|
|
g_signal_connect (provider, "provider-unhidden",
|
|
(GCallback) provider_unhidden, monitor);
|
|
|
|
matched = TRUE;
|
|
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->providers, provider);
|
|
monitor->priv->cookie++;
|
|
}
|
|
}
|
|
|
|
factories = g_list_remove (factories, factory);
|
|
gst_object_unref (factory);
|
|
}
|
|
|
|
/* Ensure there is no leak here */
|
|
g_assert (factories == NULL);
|
|
|
|
if (matched)
|
|
id = filter->id;
|
|
g_ptr_array_add (monitor->priv->filters, filter);
|
|
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
return id;
|
|
}
|
|
|
|
/**
|
|
* gst_device_monitor_remove_filter:
|
|
* @monitor: a device monitor
|
|
* @filter_id: the id of the filter
|
|
*
|
|
* Removes a filter from the #GstDeviceMonitor using the id that was returned
|
|
* by gst_device_monitor_add_filter().
|
|
*
|
|
* Returns: %TRUE of the filter id was valid, %FALSE otherwise
|
|
*
|
|
* Since: 1.4
|
|
*/
|
|
gboolean
|
|
gst_device_monitor_remove_filter (GstDeviceMonitor * monitor, guint filter_id)
|
|
{
|
|
guint i, j;
|
|
gboolean removed = FALSE;
|
|
|
|
g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), FALSE);
|
|
g_return_val_if_fail (!monitor->priv->started, FALSE);
|
|
g_return_val_if_fail (filter_id > 0, FALSE);
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
for (i = 0; i < monitor->priv->filters->len; i++) {
|
|
struct DeviceFilter *filter = g_ptr_array_index (monitor->priv->filters, i);
|
|
|
|
if (filter->id == filter_id) {
|
|
g_ptr_array_remove_index (monitor->priv->filters, i);
|
|
removed = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (removed) {
|
|
for (i = 0; i < monitor->priv->providers->len; i++) {
|
|
GstDeviceProvider *provider =
|
|
g_ptr_array_index (monitor->priv->providers, i);
|
|
GstDeviceProviderFactory *factory =
|
|
gst_device_provider_get_factory (provider);
|
|
gboolean valid = FALSE;
|
|
|
|
for (j = 0; j < monitor->priv->filters->len; j++) {
|
|
struct DeviceFilter *filter =
|
|
g_ptr_array_index (monitor->priv->filters, j);
|
|
|
|
if (gst_device_provider_factory_has_classesv (factory,
|
|
filter->classesv)) {
|
|
valid = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!valid) {
|
|
monitor->priv->cookie++;
|
|
gst_device_monitor_remove (monitor, i);
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
return removed;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* gst_device_monitor_new:
|
|
*
|
|
* Create a new #GstDeviceMonitor
|
|
*
|
|
* Returns: (transfer full): a new device monitor.
|
|
*
|
|
* Since: 1.4
|
|
*/
|
|
GstDeviceMonitor *
|
|
gst_device_monitor_new (void)
|
|
{
|
|
GstDeviceMonitor *monitor;
|
|
|
|
monitor = g_object_new (GST_TYPE_DEVICE_MONITOR, NULL);
|
|
|
|
/* Clear floating flag */
|
|
gst_object_ref_sink (monitor);
|
|
|
|
return monitor;
|
|
}
|
|
|
|
/**
|
|
* gst_device_monitor_get_bus:
|
|
* @monitor: a #GstDeviceProvider
|
|
*
|
|
* Gets the #GstBus of this #GstDeviceMonitor
|
|
*
|
|
* Returns: (transfer full): a #GstBus
|
|
*
|
|
* Since: 1.4
|
|
*/
|
|
GstBus *
|
|
gst_device_monitor_get_bus (GstDeviceMonitor * monitor)
|
|
{
|
|
g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), NULL);
|
|
|
|
return gst_object_ref (monitor->priv->bus);
|
|
}
|
|
|
|
/**
|
|
* gst_device_monitor_get_providers:
|
|
* @monitor: a #GstDeviceMonitor
|
|
*
|
|
* Get a list of the currently selected device provider factories.
|
|
*
|
|
* This
|
|
*
|
|
* Returns: (transfer full) (array zero-terminated=1) (element-type gchar*):
|
|
* A list of device provider factory names that are currently being
|
|
* monitored by @monitor or %NULL when nothing is being monitored.
|
|
*
|
|
* Since: 1.6
|
|
*/
|
|
gchar **
|
|
gst_device_monitor_get_providers (GstDeviceMonitor * monitor)
|
|
{
|
|
guint i, len;
|
|
gchar **res = NULL;
|
|
|
|
g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), NULL);
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
len = monitor->priv->providers->len;
|
|
if (len == 0)
|
|
goto done;
|
|
|
|
res = g_new (gchar *, len + 1);
|
|
|
|
for (i = 0; i < len; i++) {
|
|
GstDeviceProvider *provider =
|
|
g_ptr_array_index (monitor->priv->providers, i);
|
|
GstDeviceProviderFactory *factory =
|
|
gst_device_provider_get_factory (provider);
|
|
|
|
res[i] = g_strdup (GST_OBJECT_NAME (factory));
|
|
}
|
|
res[i] = NULL;
|
|
|
|
done:
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* gst_device_monitor_set_show_all_devices:
|
|
* @monitor: a #GstDeviceMonitor
|
|
* @show_all: show all devices
|
|
*
|
|
* Set if all devices should be visible, even those devices from hidden
|
|
* providers. Setting @show_all to true might show some devices multiple times.
|
|
*
|
|
* Since: 1.6
|
|
*/
|
|
void
|
|
gst_device_monitor_set_show_all_devices (GstDeviceMonitor * monitor,
|
|
gboolean show_all)
|
|
{
|
|
g_return_if_fail (GST_IS_DEVICE_MONITOR (monitor));
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
monitor->priv->show_all = show_all;
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
}
|
|
|
|
/**
|
|
* gst_device_monitor_get_show_all_devices:
|
|
* @monitor: a #GstDeviceMonitor
|
|
*
|
|
* Get if @monitor is curretly showing all devices, even those from hidden
|
|
* providers.
|
|
*
|
|
* Returns: %TRUE when all devices will be shown.
|
|
*
|
|
* Since: 1.6
|
|
*/
|
|
gboolean
|
|
gst_device_monitor_get_show_all_devices (GstDeviceMonitor * monitor)
|
|
{
|
|
gboolean res;
|
|
|
|
g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), FALSE);
|
|
|
|
GST_OBJECT_LOCK (monitor);
|
|
res = monitor->priv->show_all;
|
|
GST_OBJECT_UNLOCK (monitor);
|
|
|
|
return res;
|
|
}
|