diff options
Diffstat (limited to 'sys/v4l2/gstv4l2object.c')
| -rw-r--r-- | sys/v4l2/gstv4l2object.c | 519 |
1 files changed, 519 insertions, 0 deletions
diff --git a/sys/v4l2/gstv4l2object.c b/sys/v4l2/gstv4l2object.c new file mode 100644 index 00000000..941f9a6a --- /dev/null +++ b/sys/v4l2/gstv4l2object.c @@ -0,0 +1,519 @@ +/* + * GStreamer gstv4l2object.c: base class for V4L2 elements + * Copyright (C) 2001-2002 Ronald Bultje <rbultje@ronald.bitfreak.net> + * Copyright (C) 2006 Edgard Lima <edgard.lima@indt.org.br> + * + * 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. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <sys/stat.h> +#include <fcntl.h> +#include <errno.h> +#include <unistd.h> +#include <string.h> + +#include "v4l2_calls.h" +#include "gstv4l2tuner.h" +#ifdef HAVE_XVIDEO +#include "gstv4l2xoverlay.h" +#endif +#include "gstv4l2colorbalance.h" + +OPEN_V4L2OBJECT_PROPS CLOSE_V4L2OBJECT_PROPS const GList * +gst_v4l2_probe_get_properties (GstPropertyProbe * probe) +{ + GObjectClass *klass = G_OBJECT_GET_CLASS (probe); + static GList *list = NULL; + + /* well, not perfect, but better than no locking at all. + * In the worst case we leak a list node, so who cares? */ + GST_CLASS_LOCK (GST_OBJECT_CLASS (klass)); + + if (!list) { + list = g_list_append (NULL, g_object_class_find_property (klass, "device")); + } + + GST_CLASS_UNLOCK (GST_OBJECT_CLASS (klass)); + + return list; +} + +static gboolean +gst_v4l2_class_probe_devices (GstElementClass * klass, gboolean check, + GList ** klass_devices) +{ + static gboolean init = FALSE; + static GList *devices = NULL; + + if (!init && !check) { + gchar *dev_base[] = { "/dev/video", "/dev/v4l2/video", NULL }; + gint base, n, fd; + + while (devices) { + GList *item = devices; + gchar *device = item->data; + + devices = g_list_remove (devices, item); + g_free (device); + } + + /* + * detect /dev entries + */ + for (n = 0; n < 64; n++) { + for (base = 0; dev_base[base] != NULL; base++) { + struct stat s; + gchar *device = g_strdup_printf ("%s%d", + dev_base[base], + n); + + /* + * does the /dev/ entry exist at all? + */ + if (stat (device, &s) == 0) { + /* + * yes: is a device attached? + */ + if (S_ISCHR (s.st_mode)) { + + if ((fd = open (device, O_RDWR | O_NONBLOCK)) > 0 || errno == EBUSY) { + if (fd > 0) + close (fd); + + devices = g_list_append (devices, device); + break; + } + } + } + g_free (device); + } + } + + init = TRUE; + } + + *klass_devices = devices; + + return init; +} + +void +gst_v4l2_probe_probe_property (GstPropertyProbe * probe, + guint prop_id, const GParamSpec * pspec, GList ** klass_devices) +{ + GstElementClass *klass = GST_ELEMENT_GET_CLASS (probe); + + switch (prop_id) { + case PROP_DEVICE: + gst_v4l2_class_probe_devices (klass, FALSE, klass_devices); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); + break; + } +} + +gboolean +gst_v4l2_probe_needs_probe (GstPropertyProbe * probe, + guint prop_id, const GParamSpec * pspec, GList ** klass_devices) +{ + GstElementClass *klass = GST_ELEMENT_GET_CLASS (probe); + gboolean ret = FALSE; + + switch (prop_id) { + case PROP_DEVICE: + ret = !gst_v4l2_class_probe_devices (klass, TRUE, klass_devices); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); + break; + } + + return ret; + +} + +static GValueArray * +gst_v4l2_class_list_devices (GstElementClass * klass, GList ** klass_devices) +{ + GValueArray *array; + GValue value = { 0 }; + GList *item; + + if (!*klass_devices) + return NULL; + + array = g_value_array_new (g_list_length (*klass_devices)); + item = *klass_devices; + g_value_init (&value, G_TYPE_STRING); + while (item) { + gchar *device = item->data; + + g_value_set_string (&value, device); + g_value_array_append (array, &value); + + item = item->next; + } + g_value_unset (&value); + + return array; +} + +GValueArray * +gst_v4l2_probe_get_values (GstPropertyProbe * probe, + guint prop_id, const GParamSpec * pspec, GList ** klass_devices) +{ + GstElementClass *klass = GST_ELEMENT_GET_CLASS (probe); + GValueArray *array = NULL; + + switch (prop_id) { + case PROP_DEVICE: + array = gst_v4l2_class_list_devices (klass, klass_devices); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (probe, prop_id, pspec); + break; + } + + return array; +} + +#define GST_TYPE_V4L2_DEVICE_FLAGS (gst_v4l2_device_get_type ()) +GType +gst_v4l2_device_get_type (void) +{ + static GType v4l2_device_type = 0; + + if (v4l2_device_type == 0) { + static const GFlagsValue values[] = { + {V4L2_CAP_VIDEO_CAPTURE, "CAPTURE", + "Device supports video capture"}, + {V4L2_CAP_VIDEO_OUTPUT, "PLAYBACK", + "Device supports video playback"}, + {V4L2_CAP_VIDEO_OVERLAY, "OVERLAY", + "Device supports video overlay"}, + + {V4L2_CAP_VBI_CAPTURE, "VBI_CAPTURE", + "Device supports the VBI capture"}, + {V4L2_CAP_VBI_OUTPUT, "VBI_OUTPUT", + "Device supports the VBI output"}, + + {V4L2_CAP_TUNER, "TUNER", + "Device has a tuner or modulator"}, + {V4L2_CAP_AUDIO, "AUDIO", + "Device has audio inputs or outputs"}, + + {0, NULL, NULL} + }; + + v4l2_device_type = + g_flags_register_static ("GstV4l2DeviceTypeFlags", values); + } + + return v4l2_device_type; +} + +void +gst_v4l2object_install_properties_helper (GObjectClass * gobject_class) +{ + + g_object_class_install_property + (G_OBJECT_CLASS (gobject_class), PROP_DEVICE, + g_param_spec_string ("device", + "Device", "Device location", NULL, G_PARAM_READWRITE)); + g_object_class_install_property + (G_OBJECT_CLASS (gobject_class), + PROP_DEVICE_NAME, + g_param_spec_string ("device_name", + "Device name", "Name of the device", NULL, G_PARAM_READABLE)); + g_object_class_install_property + (G_OBJECT_CLASS (gobject_class), PROP_FLAGS, + g_param_spec_flags ("flags", "Flags", + "Device type flags", + GST_TYPE_V4L2_DEVICE_FLAGS, 0, G_PARAM_READABLE)); + g_object_class_install_property + (gobject_class, PROP_STD, + g_param_spec_string ("std", "std", + "standard (norm) to use", NULL, G_PARAM_READWRITE)); + g_object_class_install_property + (gobject_class, PROP_INPUT, + g_param_spec_string ("input", + "input", + "input/output (channel) to switch to", NULL, G_PARAM_READWRITE)); + g_object_class_install_property + (gobject_class, PROP_FREQUENCY, + g_param_spec_ulong ("frequency", + "frequency", + "frequency to tune to (in Hz)", 0, G_MAXULONG, 0, G_PARAM_READWRITE)); + +} + +GstV4l2Object * +gst_v4l2object_new (GstElement * element, + GstV4l2GetInOutFunction get_in_out_func, + GstV4l2SetInOutFunction set_in_out_func, + GstV4l2UpdateFpsFunction update_fps_func) +{ + + GstV4l2Object *v4l2object; + + /* + * some default values + */ + + v4l2object = g_new0 (GstV4l2Object, 1); + + v4l2object->element = element; + v4l2object->get_in_out_func = get_in_out_func; + v4l2object->set_in_out_func = set_in_out_func; + v4l2object->update_fps_func = update_fps_func; + + v4l2object->video_fd = -1; + v4l2object->buffer = NULL; + v4l2object->videodev = g_strdup ("/dev/video0"); + + v4l2object->stds = NULL; + v4l2object->inputs = NULL; + v4l2object->colors = NULL; + + v4l2object->xwindow_id = 0; + + return v4l2object; + +} + + +void +gst_v4l2object_destroy (GstV4l2Object ** v4l2object) +{ + + if (*v4l2object) { + + if ((*v4l2object)->videodev) { + g_free ((*v4l2object)->videodev); + (*v4l2object)->videodev = NULL; + } + + g_free (*v4l2object); + *v4l2object = NULL; + + } + +} + + +gboolean +gst_v4l2object_set_property_helper (GstV4l2Object * v4l2object, + guint prop_id, const GValue * value, GParamSpec * pspec) +{ + + switch (prop_id) { + case PROP_DEVICE: + if (v4l2object->videodev) + g_free (v4l2object->videodev); + v4l2object->videodev = g_strdup (g_value_get_string (value)); + break; + case PROP_STD: + if (GST_V4L2_IS_OPEN (v4l2object)) { + GstTuner *tuner = GST_TUNER (v4l2object->element); + GstTunerNorm *norm = gst_tuner_find_norm_by_name (tuner, + (gchar *) + g_value_get_string (value)); + + if (norm) { + /* like gst_tuner_set_norm (tuner, norm) + without g_object_notify */ + gst_v4l2_tuner_set_norm (v4l2object, norm); + } + } else { + g_free (v4l2object->std); + v4l2object->std = g_value_dup_string (value); + } + break; + case PROP_INPUT: + if (GST_V4L2_IS_OPEN (v4l2object)) { + GstTuner *tuner = GST_TUNER (v4l2object->element); + GstTunerChannel *channel = gst_tuner_find_channel_by_name (tuner, + (gchar *) + g_value_get_string (value)); + + if (channel) { + /* like gst_tuner_set_channel (tuner, channel) + without g_object_notify */ + gst_v4l2_tuner_set_channel (v4l2object, channel); + } + } else { + g_free (v4l2object->input); + v4l2object->input = g_value_dup_string (value); + } + break; + case PROP_FREQUENCY: + if (GST_V4L2_IS_OPEN (v4l2object)) { + GstTuner *tuner = GST_TUNER (v4l2object->element); + GstTunerChannel *channel = gst_tuner_get_channel (tuner); + + if (channel && + GST_TUNER_CHANNEL_HAS_FLAG (channel, GST_TUNER_CHANNEL_FREQUENCY)) { + /* like + gst_tuner_set_frequency (tuner, channel, g_value_get_ulong (value)) + without g_object_notify */ + gst_v4l2_tuner_set_frequency (v4l2object, channel, + g_value_get_ulong (value)); + } + } else { + v4l2object->frequency = g_value_get_ulong (value); + } + break; + default: + return FALSE; + break; + } + + return TRUE; + +} + + +gboolean +gst_v4l2object_get_property_helper (GstV4l2Object * v4l2object, + guint prop_id, GValue * value, GParamSpec * pspec) +{ + switch (prop_id) { + case PROP_DEVICE: + g_value_set_string (value, v4l2object->videodev); + break; + case PROP_DEVICE_NAME: + { + gchar *new = NULL; + + if (GST_V4L2_IS_OPEN (v4l2object)) + new = (gchar *) v4l2object->vcap.card; + g_value_set_string (value, new); + break; + } + case PROP_FLAGS: + { + guint flags = 0; + + if (GST_V4L2_IS_OPEN (v4l2object)) { + flags |= v4l2object->vcap.capabilities & + (V4L2_CAP_VIDEO_CAPTURE | + V4L2_CAP_VIDEO_OUTPUT | + V4L2_CAP_VIDEO_OVERLAY | V4L2_CAP_TUNER | V4L2_CAP_AUDIO); + if (v4l2object->vcap.capabilities & V4L2_CAP_AUDIO) + flags |= V4L2_FBUF_CAP_CHROMAKEY; + } + g_value_set_flags (value, flags); + break; + } + case PROP_STD: + g_value_set_string (value, v4l2object->std); + break; + case PROP_INPUT: + g_value_set_string (value, v4l2object->input); + break; + case PROP_FREQUENCY: + g_value_set_ulong (value, v4l2object->frequency); + break; + default: + return FALSE; + break; + } + + return TRUE; + +} + +static void +gst_v4l2_set_defaults (GstV4l2Object * v4l2object) +{ + GstTunerNorm *norm = NULL; + GstTunerChannel *channel = NULL; + GstTuner *tuner = GST_TUNER (v4l2object->element); + + if (v4l2object->std) + norm = gst_tuner_find_norm_by_name (tuner, v4l2object->std); + if (norm) { + gst_tuner_set_norm (tuner, norm); + } else { + norm = + GST_TUNER_NORM (gst_tuner_get_norm (GST_TUNER (v4l2object->element))); + if (norm) { + v4l2object->std = g_strdup (norm->label); + gst_tuner_norm_changed (tuner, norm); + g_object_notify (G_OBJECT (v4l2object->element), "std"); + } + } + + if (v4l2object->input) + channel = gst_tuner_find_channel_by_name (tuner, v4l2object->input); + if (channel) { + gst_tuner_set_channel (tuner, channel); + } else { + channel = + GST_TUNER_CHANNEL (gst_tuner_get_channel (GST_TUNER (v4l2object-> + element))); + v4l2object->input = g_strdup (channel->label); + gst_tuner_channel_changed (tuner, channel); + g_object_notify (G_OBJECT (v4l2object->element), "input"); + } + + if (GST_TUNER_CHANNEL_HAS_FLAG (channel, GST_TUNER_CHANNEL_FREQUENCY)) { + if (v4l2object->frequency != 0) { + gst_tuner_set_frequency (tuner, channel, v4l2object->frequency); + } else { + v4l2object->frequency = gst_tuner_get_frequency (tuner, channel); + if (v4l2object->frequency == 0) { + /* guess */ + gst_tuner_set_frequency (tuner, channel, 1000); + } else { + g_object_notify (G_OBJECT (v4l2object->element), "frequency"); + } + } + } +} + + +gboolean +gst_v4l2object_start (GstV4l2Object * v4l2object) +{ + if (gst_v4l2_open (v4l2object)) + gst_v4l2_set_defaults (v4l2object); + else + return FALSE; + + +#ifdef HAVE_XVIDEO + gst_v4l2_xoverlay_start (v4l2object); +#endif + + return TRUE; +} + +gboolean +gst_v4l2object_stop (GstV4l2Object * v4l2object) +{ + +#ifdef HAVE_XVIDEO + gst_v4l2_xoverlay_stop (v4l2object); +#endif + + if (!gst_v4l2_close (v4l2object)) + return FALSE; + + return TRUE; +} |