/* This file is a copy of cheese-camera-device-monitor.c from Tpaw. We * just renamespaced it to avoid conflicts when linking on libcheese. */ /* * Copyright © 2007,2008 Jaap Haitsma * Copyright © 2007-2009 daniel g. siegel * Copyright © 2008 Ryan Zeigler * Copyright © 2010 Filippo Argiolas * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser 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 */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #ifdef HAVE_UDEV #define G_UDEV_API_IS_SUBJECT_TO_CHANGE 1 #include #else #include #include #include #if USE_SYS_VIDEOIO_H > 0 #include #include #elif defined (__sun) #include #include #endif /* USE_SYS_VIDEOIO_H */ #endif #include "cheese-camera-device-monitor.h" /** * SECTION:cheese-camera-device-monitor * @short_description: Simple object to enumerate v4l devices * @include: cheese/cheese-camera-device-monitor.h * * #TpawCameraDeviceMonitor provides a basic interface for * video4linux device enumeration and hotplugging. * * It uses either GUdev or some platform specific code to list video * devices. It is also capable (right now in linux only, with the * udev backend) to monitor device plugging and emit a * TpawCameraDeviceMonitor::added or * TpawCameraDeviceMonitor::removed signal when an event happens. */ G_DEFINE_TYPE (TpawCameraDeviceMonitor, tpaw_camera_device_monitor, G_TYPE_OBJECT) #define TPAW_CAMERA_DEVICE_MONITOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \ TPAW_TYPE_CAMERA_DEVICE_MONITOR, \ TpawCameraDeviceMonitorPrivate)) #define TPAW_CAMERA_DEVICE_MONITOR_ERROR tpaw_camera_device_monitor_error_quark () #define DEBUG_FLAG TPAW_DEBUG_OTHER #include "tpaw-debug.h" enum TpawCameraDeviceMonitorError { TPAW_CAMERA_DEVICE_MONITOR_ERROR_UNKNOWN, TPAW_CAMERA_DEVICE_MONITOR_ERROR_ELEMENT_NOT_FOUND }; typedef struct { #ifdef HAVE_UDEV GUdevClient *client; #else guint filler; #endif /* HAVE_UDEV */ } TpawCameraDeviceMonitorPrivate; enum { ADDED, REMOVED, LAST_SIGNAL }; static guint monitor_signals[LAST_SIGNAL]; #if 0 GQuark tpaw_camera_device_monitor_error_quark (void) { return g_quark_from_static_string ("tpaw-camera-error-quark"); } #endif #ifdef HAVE_UDEV static void tpaw_camera_device_monitor_added (TpawCameraDeviceMonitor *monitor, GUdevDevice *udevice) { const char *device_file; const char *product_name; const char *vendor; const char *product; const char *bus; gint vendor_id = 0; gint product_id = 0; gint v4l_version = 0; const gchar *devpath = g_udev_device_get_property (udevice, "DEVPATH"); DEBUG ("Checking udev device '%s'", devpath); bus = g_udev_device_get_property (udevice, "ID_BUS"); if (g_strcmp0 (bus, "usb") == 0) { vendor = g_udev_device_get_property (udevice, "ID_VENDOR_ID"); if (vendor != NULL) vendor_id = g_ascii_strtoll (vendor, NULL, 16); product = g_udev_device_get_property (udevice, "ID_MODEL_ID"); if (product != NULL) product_id = g_ascii_strtoll (product, NULL, 16); if (vendor_id == 0 || product_id == 0) { DEBUG ("Error getting vendor and product id"); } else { DEBUG ("Found device %04x:%04x, getting capabilities...", vendor_id, product_id); } } else { DEBUG ("Not an usb device, skipping vendor and model id retrieval"); } device_file = g_udev_device_get_device_file (udevice); if (device_file == NULL) { DEBUG ("Error getting V4L device"); return; } /* vbi devices support capture capability too, but cannot be used, * so detect them by device name */ if (strstr (device_file, "vbi")) { DEBUG ("Skipping vbi device: %s", device_file); return; } v4l_version = g_udev_device_get_property_as_int (udevice, "ID_V4L_VERSION"); if (v4l_version == 2 || v4l_version == 1) { const char *caps; caps = g_udev_device_get_property (udevice, "ID_V4L_CAPABILITIES"); if (caps == NULL || strstr (caps, ":capture:") == NULL) { DEBUG ("Device %s seems to not have the capture capability, (radio tuner?)" "Removing it from device list.", device_file); return; } product_name = g_udev_device_get_property (udevice, "ID_V4L_PRODUCT"); } else if (v4l_version == 0) { DEBUG ("Fix your udev installation to include v4l_id, ignoring %s", device_file); return; } else { g_assert_not_reached (); } g_signal_emit (monitor, monitor_signals[ADDED], 0, devpath, device_file, product_name, v4l_version); } static void tpaw_camera_device_monitor_removed (TpawCameraDeviceMonitor *monitor, GUdevDevice *udevice) { g_signal_emit (monitor, monitor_signals[REMOVED], 0, g_udev_device_get_property (udevice, "DEVPATH")); } static void tpaw_camera_device_monitor_uevent_cb (GUdevClient *client, const gchar *action, GUdevDevice *udevice, TpawCameraDeviceMonitor *monitor) { if (g_str_equal (action, "remove")) tpaw_camera_device_monitor_removed (monitor, udevice); else if (g_str_equal (action, "add")) tpaw_camera_device_monitor_added (monitor, udevice); } /** * tpaw_camera_device_monitor_coldplug: * @monitor: a #TpawCameraDeviceMonitor object. * * Will actively look for plugged in cameras and emit * ::added for those new cameras. * This is only required when your program starts, so as to connect * to those signals before they are emitted. */ void tpaw_camera_device_monitor_coldplug (TpawCameraDeviceMonitor *monitor) { TpawCameraDeviceMonitorPrivate *priv = TPAW_CAMERA_DEVICE_MONITOR_GET_PRIVATE (monitor); GList *devices, *l; gint i = 0; if (priv->client == NULL) return; DEBUG ("Probing devices with udev..."); devices = g_udev_client_query_by_subsystem (priv->client, "video4linux"); /* Initialize camera structures */ for (l = devices; l != NULL; l = l->next) { tpaw_camera_device_monitor_added (monitor, l->data); g_object_unref (l->data); i++; } g_list_free (devices); if (i == 0) DEBUG ("No device found"); } #else /* HAVE_UDEV */ void tpaw_camera_device_monitor_coldplug (TpawCameraDeviceMonitor *monitor) { #if 0 TpawCameraDeviceMonitorPrivate *priv = TPAW_CAMERA_DEVICE_MONITOR_GET_PRIVATE (monitor); struct v4l2_capability v2cap; struct video_capability v1cap; int fd, ok; if ((fd = open (device_path, O_RDONLY | O_NONBLOCK)) < 0) { g_warning ("Failed to open %s: %s", device_path, strerror (errno)); return; } ok = ioctl (fd, VIDIOC_QUERYCAP, &v2cap); if (ok < 0) { ok = ioctl (fd, VIDIOCGCAP, &v1cap); if (ok < 0) { g_warning ("Error while probing v4l capabilities for %s: %s", device_path, strerror (errno)); close (fd); return; } g_print ("Detected v4l device: %s\n", v1cap.name); g_print ("Device type: %d\n", v1cap.type); gstreamer_src = "v4lsrc"; product_name = v1cap.name; } else { guint cap = v2cap.capabilities; g_print ("Detected v4l2 device: %s\n", v2cap.card); g_print ("Driver: %s, version: %d\n", v2cap.driver, v2cap.version); /* g_print ("Bus info: %s\n", v2cap.bus_info); */ /* Doesn't seem anything useful */ g_print ("Capabilities: 0x%08X\n", v2cap.capabilities); if (!(cap & V4L2_CAP_VIDEO_CAPTURE)) { g_print ("Device %s seems to not have the capture capability, (radio tuner?)\n" "Removing it from device list.\n", device_path); close (fd); return; } gstreamer_src = "v4l2src"; product_name = (char *) v2cap.card; } close (fd); GList *devices, *l; g_print ("Probing devices with udev...\n"); if (priv->client == NULL) return; devices = g_udev_client_query_by_subsystem (priv->client, "video4linux"); /* Initialize camera structures */ for (l = devices; l != NULL; l = l->next) { tpaw_camera_device_monitor_added (monitor, l->data); g_object_unref (l->data); } g_list_free (devices); #endif } #endif /* HAVE_UDEV */ static void tpaw_camera_device_monitor_finalize (GObject *object) { #ifdef HAVE_UDEV TpawCameraDeviceMonitor *monitor = TPAW_CAMERA_DEVICE_MONITOR (object); TpawCameraDeviceMonitorPrivate *priv = TPAW_CAMERA_DEVICE_MONITOR_GET_PRIVATE (monitor); if (priv->client != NULL) { g_object_unref (priv->client); priv->client = NULL; } #endif /* HAVE_UDEV */ G_OBJECT_CLASS (tpaw_camera_device_monitor_parent_class)->finalize (object); } static void tpaw_camera_device_monitor_class_init (TpawCameraDeviceMonitorClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); object_class->finalize = tpaw_camera_device_monitor_finalize; /** * TpawCameraDeviceMonitor::added: * @device: A private object representing the newly added camera. * @id: Device unique identifier. * @device: Device file name (e.g. /dev/video2). * @product_name: Device product name (human readable, intended to be displayed in a UI). * @api_version: Supported video4linux API: 1 for v4l, 2 for v4l2. * * The ::added signal is emitted when a camera is added, or on start-up * after #tpaw_camera_device_monitor_colplug is called. **/ monitor_signals[ADDED] = g_signal_new ("added", G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (TpawCameraDeviceMonitorClass, added), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); /** * TpawCameraDeviceMonitor::removed: * @device: A private object representing the newly added camera * @id: Device unique identifier. * * The ::removed signal is emitted when a camera is un-plugged, or * disabled on the system. **/ monitor_signals[REMOVED] = g_signal_new ("removed", G_OBJECT_CLASS_TYPE (klass), G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, G_STRUCT_OFFSET (TpawCameraDeviceMonitorClass, removed), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, G_TYPE_STRING); g_type_class_add_private (klass, sizeof (TpawCameraDeviceMonitorPrivate)); } static void tpaw_camera_device_monitor_init (TpawCameraDeviceMonitor *monitor) { #ifdef HAVE_UDEV TpawCameraDeviceMonitorPrivate *priv = TPAW_CAMERA_DEVICE_MONITOR_GET_PRIVATE (monitor); const gchar *const subsystems[] = {"video4linux", NULL}; priv->client = g_udev_client_new (subsystems); g_signal_connect (G_OBJECT (priv->client), "uevent", G_CALLBACK (tpaw_camera_device_monitor_uevent_cb), monitor); #endif /* HAVE_UDEV */ } /** * tpaw_camera_device_monitor_new: * * Returns a new #TpawCameraDeviceMonitor object. * * Return value: a new #TpawCameraDeviceMonitor object. **/ TpawCameraDeviceMonitor * tpaw_camera_device_monitor_new (void) { return g_object_new (TPAW_TYPE_CAMERA_DEVICE_MONITOR, NULL); } /* * vim: sw=2 ts=8 cindent noai bs=2 */