3 * Copyright (C) 2002 Ronald Bultje <rbultje@ronald.bitfreak.net>
4 * 2006 Edgard Lima <edgard.lima@gmail.com>
6 * v4l2_calls.c - generic V4L2 calls handling
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
28 #include <sys/types.h>
31 #include <sys/ioctl.h>
37 /* Needed on older Solaris Nevada builds (72 at least) */
39 #include <sys/ioccom.h>
41 #include "gstv4l2object.h"
42 #include "gstv4l2tuner.h"
43 #include "gstv4l2colorbalance.h"
45 #include "gstv4l2src.h"
46 #include "gstv4l2sink.h"
47 #include "gstv4l2videodec.h"
49 #include "gst/gst-i18n-plugin.h"
51 GST_DEBUG_CATEGORY_EXTERN (v4l2_debug);
52 #define GST_CAT_DEFAULT v4l2_debug
54 /******************************************************
55 * gst_v4l2_get_capabilities():
56 * get the device's capturing capabilities
57 * return value: TRUE on success, FALSE on error
58 ******************************************************/
60 gst_v4l2_get_capabilities (GstV4l2Object * v4l2object)
64 e = v4l2object->element;
66 GST_DEBUG_OBJECT (e, "getting capabilities");
68 if (!GST_V4L2_IS_OPEN (v4l2object))
71 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_QUERYCAP,
72 &v4l2object->vcap) < 0)
75 if (v4l2object->vcap.capabilities & V4L2_CAP_DEVICE_CAPS)
76 v4l2object->device_caps = v4l2object->vcap.device_caps;
78 v4l2object->device_caps = v4l2object->vcap.capabilities;
80 GST_LOG_OBJECT (e, "driver: '%s'", v4l2object->vcap.driver);
81 GST_LOG_OBJECT (e, "card: '%s'", v4l2object->vcap.card);
82 GST_LOG_OBJECT (e, "bus_info: '%s'", v4l2object->vcap.bus_info);
83 GST_LOG_OBJECT (e, "version: %08x", v4l2object->vcap.version);
84 GST_LOG_OBJECT (e, "capabilities: %08x", v4l2object->device_caps);
91 GST_ELEMENT_ERROR (v4l2object->element, RESOURCE, SETTINGS,
92 (_("Error getting capabilities for device '%s': "
93 "It isn't a v4l2 driver. Check if it is a v4l1 driver."),
94 v4l2object->videodev), GST_ERROR_SYSTEM);
99 /******************************************************
100 * The video4linux command line tool v4l2-ctrl
101 * normalises the names of the controls received from
104 * "Exposure (absolute)" -> "exposure_absolute"
106 * We follow their lead here. @name is modified
108 ******************************************************/
110 gst_v4l2_normalise_control_name (gchar * name)
113 for (i = 0, j = 0; name[j]; ++j) {
114 if (g_ascii_isalnum (name[j])) {
115 if (i > 0 && !g_ascii_isalnum (name[j - 1]))
117 name[i++] = g_ascii_tolower (name[j]);
123 /******************************************************
124 * gst_v4l2_empty_lists() and gst_v4l2_fill_lists():
125 * fill/empty the lists of enumerations
126 * return value: TRUE on success, FALSE on error
127 ******************************************************/
129 gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
132 struct v4l2_queryctrl control = { 0, };
136 e = v4l2object->element;
138 GST_DEBUG_OBJECT (e, "getting enumerations");
139 GST_V4L2_CHECK_OPEN (v4l2object);
141 GST_DEBUG_OBJECT (e, " channels");
142 /* and now, the channels */
144 struct v4l2_input input;
145 GstV4l2TunerChannel *v4l2channel;
146 GstTunerChannel *channel;
148 memset (&input, 0, sizeof (input));
151 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_ENUMINPUT, &input) < 0) {
152 if (errno == EINVAL || errno == ENOTTY)
153 break; /* end of enumeration */
155 GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
156 (_("Failed to query attributes of input %d in device %s"),
157 n, v4l2object->videodev),
158 ("Failed to get %d in input enumeration for %s. (%d - %s)",
159 n, v4l2object->videodev, errno, strerror (errno)));
164 GST_LOG_OBJECT (e, " index: %d", input.index);
165 GST_LOG_OBJECT (e, " name: '%s'", input.name);
166 GST_LOG_OBJECT (e, " type: %08x", input.type);
167 GST_LOG_OBJECT (e, " audioset: %08x", input.audioset);
168 GST_LOG_OBJECT (e, " std: %016" G_GINT64_MODIFIER "x",
169 (guint64) input.std);
170 GST_LOG_OBJECT (e, " status: %08x", input.status);
172 v4l2channel = g_object_new (GST_TYPE_V4L2_TUNER_CHANNEL, NULL);
173 channel = GST_TUNER_CHANNEL (v4l2channel);
174 channel->label = g_strdup ((const gchar *) input.name);
175 channel->flags = GST_TUNER_CHANNEL_INPUT;
176 v4l2channel->index = n;
178 if (input.type == V4L2_INPUT_TYPE_TUNER) {
179 struct v4l2_tuner vtun;
181 v4l2channel->tuner = input.tuner;
182 channel->flags |= GST_TUNER_CHANNEL_FREQUENCY;
184 vtun.index = input.tuner;
185 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &vtun) < 0) {
186 GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
187 (_("Failed to get setting of tuner %d on device '%s'."),
188 input.tuner, v4l2object->videodev), GST_ERROR_SYSTEM);
189 g_object_unref (G_OBJECT (channel));
193 channel->freq_multiplicator =
194 62.5 * ((vtun.capability & V4L2_TUNER_CAP_LOW) ? 1 : 1000);
195 channel->min_frequency = vtun.rangelow * channel->freq_multiplicator;
196 channel->max_frequency = vtun.rangehigh * channel->freq_multiplicator;
197 channel->min_signal = 0;
198 channel->max_signal = 0xffff;
200 if (input.audioset) {
201 /* we take the first. We don't care for
202 * the others for now */
203 while (!(input.audioset & (1 << v4l2channel->audio)))
204 v4l2channel->audio++;
205 channel->flags |= GST_TUNER_CHANNEL_AUDIO;
208 v4l2object->channels =
209 g_list_prepend (v4l2object->channels, (gpointer) channel);
211 v4l2object->channels = g_list_reverse (v4l2object->channels);
213 GST_DEBUG_OBJECT (e, " norms");
216 struct v4l2_standard standard = { 0, };
217 GstV4l2TunerNorm *v4l2norm;
221 /* fill in defaults */
222 standard.frameperiod.numerator = 1;
223 standard.frameperiod.denominator = 0;
226 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_ENUMSTD, &standard) < 0) {
227 if (errno == EINVAL || errno == ENOTTY)
228 break; /* end of enumeration */
230 else if (errno == ENODATA)
231 break; /* end of enumeration, as of Linux 3.7-rc1 */
234 GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
235 (_("Failed to query norm on device '%s'."),
236 v4l2object->videodev),
237 ("Failed to get attributes for norm %d on divide '%s'. (%d - %s)",
238 n, v4l2object->videodev, errno, strerror (errno)));
243 GST_DEBUG_OBJECT (e, " '%s', fps: %d / %d",
244 standard.name, standard.frameperiod.denominator,
245 standard.frameperiod.numerator);
247 v4l2norm = g_object_new (GST_TYPE_V4L2_TUNER_NORM, NULL);
248 norm = GST_TUNER_NORM (v4l2norm);
249 norm->label = g_strdup ((const gchar *) standard.name);
250 gst_value_set_fraction (&norm->framerate,
251 standard.frameperiod.denominator, standard.frameperiod.numerator);
252 v4l2norm->index = standard.id;
254 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "index=%08x, label=%s",
255 (unsigned int) v4l2norm->index, norm->label);
257 v4l2object->norms = g_list_prepend (v4l2object->norms, (gpointer) norm);
259 v4l2object->norms = g_list_reverse (v4l2object->norms);
261 GST_DEBUG_OBJECT (e, " controls+menus");
263 /* and lastly, controls+menus (if appropriate) */
264 next = V4L2_CTRL_FLAG_NEXT_CTRL;
269 GstV4l2ColorBalanceChannel *v4l2channel;
270 GstColorBalanceChannel *channel;
276 /* when we reached the last official CID, continue with private CIDs */
277 if (n == V4L2_CID_LASTP1) {
278 GST_DEBUG_OBJECT (e, "checking private CIDs");
279 n = V4L2_CID_PRIVATE_BASE;
281 GST_DEBUG_OBJECT (e, "checking control %08x", n);
283 control.id = n | next;
284 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_QUERYCTRL,
288 GST_DEBUG_OBJECT (e, "controls finished");
291 GST_DEBUG_OBJECT (e, "V4L2_CTRL_FLAG_NEXT_CTRL not supported.");
297 if (errno == EINVAL || errno == ENOTTY || errno == EIO || errno == ENOENT) {
298 if (n < V4L2_CID_PRIVATE_BASE) {
299 GST_DEBUG_OBJECT (e, "skipping control %08x", n);
300 /* continue so that we also check private controls */
301 n = V4L2_CID_PRIVATE_BASE - 1;
304 GST_DEBUG_OBJECT (e, "controls finished");
308 GST_WARNING_OBJECT (e, "Failed querying control %d on device '%s'. "
309 "(%d - %s)", n, v4l2object->videodev, errno, strerror (errno));
313 /* bogus driver might mess with id in unexpected ways (e.g. set to 0), so
314 * make sure to simply try all if V4L2_CTRL_FLAG_NEXT_CTRL not supported */
317 if (control.flags & V4L2_CTRL_FLAG_DISABLED) {
318 GST_DEBUG_OBJECT (e, "skipping disabled control");
322 if (control.type == V4L2_CTRL_TYPE_CTRL_CLASS) {
323 GST_DEBUG_OBJECT (e, "starting control class '%s'", control.name);
327 switch (control.type) {
328 case V4L2_CTRL_TYPE_INTEGER:
329 case V4L2_CTRL_TYPE_BOOLEAN:
330 case V4L2_CTRL_TYPE_MENU:
331 case V4L2_CTRL_TYPE_INTEGER_MENU:
332 case V4L2_CTRL_TYPE_BITMASK:
333 case V4L2_CTRL_TYPE_BUTTON:
334 case V4L2_CTRL_TYPE_STRING:{
335 control.name[31] = '\0';
336 gst_v4l2_normalise_control_name ((gchar *) control.name);
337 g_datalist_id_set_data (&v4l2object->controls,
338 g_quark_from_string ((const gchar *) control.name),
339 GINT_TO_POINTER (n));
344 "Control type for '%s' not supported for extra controls.",
350 case V4L2_CID_BRIGHTNESS:
351 case V4L2_CID_CONTRAST:
352 case V4L2_CID_SATURATION:
354 case V4L2_CID_BLACK_LEVEL:
355 case V4L2_CID_AUTO_WHITE_BALANCE:
356 case V4L2_CID_DO_WHITE_BALANCE:
357 case V4L2_CID_RED_BALANCE:
358 case V4L2_CID_BLUE_BALANCE:
360 case V4L2_CID_EXPOSURE:
361 case V4L2_CID_AUTOGAIN:
363 case V4L2_CID_SHARPNESS:
364 /* we only handle these for now (why?) */
368 case V4L2_CID_PAN_RESET:
369 case V4L2_CID_TILT_RESET:
370 /* not handled here, handled by VideoOrientation interface */
373 case V4L2_CID_AUDIO_VOLUME:
374 case V4L2_CID_AUDIO_BALANCE:
375 case V4L2_CID_AUDIO_BASS:
376 case V4L2_CID_AUDIO_TREBLE:
377 case V4L2_CID_AUDIO_MUTE:
378 case V4L2_CID_AUDIO_LOUDNESS:
379 /* FIXME: We should implement GstMixer interface instead */
380 /* but let's not be pedantic and make element more useful for now */
382 case V4L2_CID_ALPHA_COMPONENT:
383 v4l2object->has_alpha_component = TRUE;
387 "ControlID %s (%x) unhandled, FIXME", control.name, n);
394 GST_DEBUG_OBJECT (e, "Adding ControlID %s (%x)", control.name, n);
395 v4l2channel = g_object_new (GST_TYPE_V4L2_COLOR_BALANCE_CHANNEL, NULL);
396 channel = GST_COLOR_BALANCE_CHANNEL (v4l2channel);
397 channel->label = g_strdup ((const gchar *) control.name);
401 /* FIXME: it will be need just when handling private controls
402 *(currently none of base controls are of this type) */
403 if (control.type == V4L2_CTRL_TYPE_MENU) {
404 struct v4l2_querymenu menu, *mptr;
411 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_QUERYMENU,
414 break; /* end of enumeration */
416 GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
417 (_("Failed getting controls attributes on device '%s'."),
418 v4l2object->videodev),
419 ("Failed to get %d in menu enumeration for %s. (%d - %s)",
420 n, v4l2object->videodev, errno, strerror (errno)));
424 mptr = g_malloc (sizeof (menu));
425 memcpy (mptr, &menu, sizeof (menu));
426 menus = g_list_append (menus, mptr);
429 v4l2object->menus = g_list_append (v4l2object->menus, menus);
432 switch (control.type) {
433 case V4L2_CTRL_TYPE_INTEGER:
434 channel->min_value = control.minimum;
435 channel->max_value = control.maximum;
437 case V4L2_CTRL_TYPE_BOOLEAN:
438 channel->min_value = FALSE;
439 channel->max_value = TRUE;
442 /* FIXME we should find out how to handle V4L2_CTRL_TYPE_BUTTON.
443 BUTTON controls like V4L2_CID_DO_WHITE_BALANCE can just be set (1) or
444 unset (0), but can't be queried */
446 "Control with non supported type %s (%x), type=%d",
447 control.name, n, control.type);
448 channel->min_value = channel->max_value = 0;
453 g_list_prepend (v4l2object->colors, (gpointer) channel);
455 v4l2object->colors = g_list_reverse (v4l2object->colors);
457 GST_DEBUG_OBJECT (e, "done");
463 gst_v4l2_empty_lists (GstV4l2Object * v4l2object)
465 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "deleting enumerations");
467 g_list_foreach (v4l2object->channels, (GFunc) g_object_unref, NULL);
468 g_list_free (v4l2object->channels);
469 v4l2object->channels = NULL;
471 g_list_foreach (v4l2object->norms, (GFunc) g_object_unref, NULL);
472 g_list_free (v4l2object->norms);
473 v4l2object->norms = NULL;
475 g_list_foreach (v4l2object->colors, (GFunc) g_object_unref, NULL);
476 g_list_free (v4l2object->colors);
477 v4l2object->colors = NULL;
479 g_datalist_clear (&v4l2object->controls);
483 gst_v4l2_adjust_buf_type (GstV4l2Object * v4l2object)
485 /* when calling gst_v4l2_object_new the user decides the initial type
486 * so adjust it if multi-planar is supported
487 * the driver should make it exclusive. So the driver should
488 * not support both MPLANE and non-PLANE.
489 * Because even when using MPLANE it still possibles to use it
490 * in a contiguous manner. In this case the first v4l2 plane
491 * contains all the gst planes.
493 switch (v4l2object->type) {
494 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
495 if (v4l2object->device_caps &
496 (V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_VIDEO_M2M_MPLANE)) {
497 GST_DEBUG ("adjust type to multi-planar output");
498 v4l2object->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
501 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
502 if (v4l2object->device_caps &
503 (V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_VIDEO_M2M_MPLANE)) {
504 GST_DEBUG ("adjust type to multi-planar capture");
505 v4l2object->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
513 /******************************************************
515 * open the video device (v4l2object->videodev)
516 * return value: TRUE on success, FALSE on error
517 ******************************************************/
519 gst_v4l2_open (GstV4l2Object * v4l2object, GstV4l2Error * error)
524 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "Trying to open device %s",
525 v4l2object->videodev);
527 GST_V4L2_CHECK_NOT_OPEN (v4l2object);
528 GST_V4L2_CHECK_NOT_ACTIVE (v4l2object);
530 /* be sure we have a device */
531 if (!v4l2object->videodev)
532 v4l2object->videodev = g_strdup ("/dev/video");
534 /* check if it is a device */
535 if (stat (v4l2object->videodev, &st) == -1)
538 if (!S_ISCHR (st.st_mode))
541 /* open the device */
542 v4l2object->video_fd =
543 open (v4l2object->videodev, O_RDWR /* | O_NONBLOCK */ );
545 if (!GST_V4L2_IS_OPEN (v4l2object))
549 if (v4l2object->fd_open)
550 libv4l2_fd = v4l2object->fd_open (v4l2object->video_fd,
551 V4L2_ENABLE_ENUM_FMT_EMULATION);
554 /* Note the v4l2_xxx functions are designed so that if they get passed an
555 unknown fd, the will behave exactly as their regular xxx counterparts, so
556 if v4l2_fd_open fails, we continue as normal (missing the libv4l2 custom
557 cam format to normal formats conversion). Chances are big we will still
558 fail then though, as normally v4l2_fd_open only fails if the device is not
560 if (libv4l2_fd != -1)
561 v4l2object->video_fd = libv4l2_fd;
563 /* get capabilities, error will be posted */
564 if (!gst_v4l2_get_capabilities (v4l2object))
567 /* do we need to be a capture device? */
568 if (GST_IS_V4L2SRC (v4l2object->element) &&
569 !(v4l2object->device_caps & (V4L2_CAP_VIDEO_CAPTURE |
570 V4L2_CAP_VIDEO_CAPTURE_MPLANE)))
573 if (GST_IS_V4L2SINK (v4l2object->element) &&
574 !(v4l2object->device_caps & (V4L2_CAP_VIDEO_OUTPUT |
575 V4L2_CAP_VIDEO_OUTPUT_MPLANE)))
578 if (GST_IS_V4L2_VIDEO_DEC (v4l2object->element) &&
579 !GST_V4L2_IS_M2M (v4l2object->device_caps))
582 gst_v4l2_adjust_buf_type (v4l2object);
584 /* create enumerations, posts errors. */
585 if (!gst_v4l2_fill_lists (v4l2object))
588 GST_INFO_OBJECT (v4l2object->dbg_obj,
589 "Opened device '%s' (%s) successfully",
590 v4l2object->vcap.card, v4l2object->videodev);
592 if (v4l2object->extra_controls)
593 gst_v4l2_set_controls (v4l2object, v4l2object->extra_controls);
595 /* UVC devices are never interlaced, and doing VIDIOC_TRY_FMT on them
596 * causes expensive and slow USB IO, so don't probe them for interlaced
598 if (!strcmp ((char *) v4l2object->vcap.driver, "uvcusb") ||
599 !strcmp ((char *) v4l2object->vcap.driver, "uvcvideo")) {
600 v4l2object->never_interlaced = TRUE;
608 GST_V4L2_ERROR (error, RESOURCE, NOT_FOUND,
609 (_("Cannot identify device '%s'."), v4l2object->videodev),
615 GST_V4L2_ERROR (error, RESOURCE, NOT_FOUND,
616 (_("This isn't a device '%s'."), v4l2object->videodev),
622 GST_V4L2_ERROR (error, RESOURCE, OPEN_READ_WRITE,
623 (_("Could not open device '%s' for reading and writing."),
624 v4l2object->videodev), GST_ERROR_SYSTEM);
629 GST_V4L2_ERROR (error, RESOURCE, NOT_FOUND,
630 (_("Device '%s' is not a capture device."), v4l2object->videodev),
631 ("Capabilities: 0x%x", v4l2object->device_caps));
636 GST_V4L2_ERROR (error, RESOURCE, NOT_FOUND,
637 (_("Device '%s' is not a output device."), v4l2object->videodev),
638 ("Capabilities: 0x%x", v4l2object->device_caps));
643 GST_V4L2_ERROR (error, RESOURCE, NOT_FOUND,
644 (_("Device '%s' is not a M2M device."), v4l2object->videodev),
645 ("Capabilities: 0x%x", v4l2object->device_caps));
650 if (GST_V4L2_IS_OPEN (v4l2object)) {
652 v4l2object->close (v4l2object->video_fd);
653 v4l2object->video_fd = -1;
656 gst_v4l2_empty_lists (v4l2object);
663 gst_v4l2_dup (GstV4l2Object * v4l2object, GstV4l2Object * other)
665 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "Trying to dup device %s",
668 GST_V4L2_CHECK_OPEN (other);
669 GST_V4L2_CHECK_NOT_OPEN (v4l2object);
670 GST_V4L2_CHECK_NOT_ACTIVE (other);
671 GST_V4L2_CHECK_NOT_ACTIVE (v4l2object);
673 v4l2object->vcap = other->vcap;
674 v4l2object->device_caps = other->device_caps;
675 gst_v4l2_adjust_buf_type (v4l2object);
677 v4l2object->video_fd = v4l2object->dup (other->video_fd);
678 if (!GST_V4L2_IS_OPEN (v4l2object))
681 g_free (v4l2object->videodev);
682 v4l2object->videodev = g_strdup (other->videodev);
684 GST_INFO_OBJECT (v4l2object->dbg_obj,
685 "Cloned device '%s' (%s) successfully",
686 v4l2object->vcap.card, v4l2object->videodev);
688 v4l2object->never_interlaced = other->never_interlaced;
689 v4l2object->no_initial_format = other->no_initial_format;
695 GST_ELEMENT_ERROR (v4l2object->element, RESOURCE, OPEN_READ_WRITE,
696 (_("Could not dup device '%s' for reading and writing."),
697 v4l2object->videodev), GST_ERROR_SYSTEM);
704 /******************************************************
706 * close the video device (v4l2object->video_fd)
707 * return value: TRUE on success, FALSE on error
708 ******************************************************/
710 gst_v4l2_close (GstV4l2Object * v4l2object)
712 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "Trying to close %s",
713 v4l2object->videodev);
715 GST_V4L2_CHECK_OPEN (v4l2object);
716 GST_V4L2_CHECK_NOT_ACTIVE (v4l2object);
719 v4l2object->close (v4l2object->video_fd);
720 v4l2object->video_fd = -1;
723 gst_v4l2_empty_lists (v4l2object);
729 /******************************************************
730 * gst_v4l2_get_norm()
731 * Get the norm of the current device
732 * return value: TRUE on success, FALSE on error
733 ******************************************************/
735 gst_v4l2_get_norm (GstV4l2Object * v4l2object, v4l2_std_id * norm)
737 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "getting norm");
739 if (!GST_V4L2_IS_OPEN (v4l2object))
742 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_STD, norm) < 0)
750 GST_DEBUG ("Failed to get the current norm for device %s",
751 v4l2object->videodev);
757 /******************************************************
758 * gst_v4l2_set_norm()
759 * Set the norm of the current device
760 * return value: TRUE on success, FALSE on error
761 ******************************************************/
763 gst_v4l2_set_norm (GstV4l2Object * v4l2object, v4l2_std_id norm)
765 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to set norm to "
766 "%" G_GINT64_MODIFIER "x", (guint64) norm);
768 if (!GST_V4L2_IS_OPEN (v4l2object))
771 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_STD, &norm) < 0)
779 GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
780 (_("Failed to set norm for device '%s'."),
781 v4l2object->videodev), GST_ERROR_SYSTEM);
786 /******************************************************
787 * gst_v4l2_get_frequency():
788 * get the current frequency
789 * return value: TRUE on success, FALSE on error
790 ******************************************************/
792 gst_v4l2_get_frequency (GstV4l2Object * v4l2object,
793 gint tunernum, gulong * frequency)
795 struct v4l2_frequency freq = { 0, };
797 GstTunerChannel *channel;
799 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "getting current tuner frequency");
801 if (!GST_V4L2_IS_OPEN (v4l2object))
804 channel = gst_tuner_get_channel (GST_TUNER (v4l2object->element));
806 freq.tuner = tunernum;
807 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq) < 0)
810 *frequency = freq.frequency * channel->freq_multiplicator;
817 GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
818 (_("Failed to get current tuner frequency for device '%s'."),
819 v4l2object->videodev), GST_ERROR_SYSTEM);
825 /******************************************************
826 * gst_v4l2_set_frequency():
828 * return value: TRUE on success, FALSE on error
829 ******************************************************/
831 gst_v4l2_set_frequency (GstV4l2Object * v4l2object,
832 gint tunernum, gulong frequency)
834 struct v4l2_frequency freq = { 0, };
836 GstTunerChannel *channel;
838 GST_DEBUG_OBJECT (v4l2object->dbg_obj,
839 "setting current tuner frequency to %lu", frequency);
841 if (!GST_V4L2_IS_OPEN (v4l2object))
844 channel = gst_tuner_get_channel (GST_TUNER (v4l2object->element));
846 freq.tuner = tunernum;
847 /* fill in type - ignore error */
848 (void) v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq);
849 freq.frequency = frequency / channel->freq_multiplicator;
851 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_FREQUENCY, &freq) < 0)
859 GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
860 (_("Failed to set current tuner frequency for device '%s' to %lu Hz."),
861 v4l2object->videodev, frequency), GST_ERROR_SYSTEM);
866 /******************************************************
867 * gst_v4l2_signal_strength():
868 * get the strength of the signal on the current input
869 * return value: TRUE on success, FALSE on error
870 ******************************************************/
872 gst_v4l2_signal_strength (GstV4l2Object * v4l2object,
873 gint tunernum, gulong * signal_strength)
875 struct v4l2_tuner tuner = { 0, };
877 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to get signal strength");
879 if (!GST_V4L2_IS_OPEN (v4l2object))
882 tuner.index = tunernum;
883 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &tuner) < 0)
886 *signal_strength = tuner.signal;
893 GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
894 (_("Failed to get signal strength for device '%s'."),
895 v4l2object->videodev), GST_ERROR_SYSTEM);
900 /******************************************************
901 * gst_v4l2_get_attribute():
902 * try to get the value of one specific attribute
903 * return value: TRUE on success, FALSE on error
904 ******************************************************/
906 gst_v4l2_get_attribute (GstV4l2Object * v4l2object,
907 int attribute_num, int *value)
909 struct v4l2_control control = { 0, };
911 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "getting value of attribute %d",
914 if (!GST_V4L2_IS_OPEN (v4l2object))
917 control.id = attribute_num;
919 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_CTRL, &control) < 0)
922 *value = control.value;
929 GST_WARNING_OBJECT (v4l2object,
930 _("Failed to get value for control %d on device '%s'."),
931 attribute_num, v4l2object->videodev);
937 /******************************************************
938 * gst_v4l2_set_attribute():
939 * try to set the value of one specific attribute
940 * return value: TRUE on success, FALSE on error
941 ******************************************************/
943 gst_v4l2_set_attribute (GstV4l2Object * v4l2object,
944 int attribute_num, const int value)
946 struct v4l2_control control = { 0, };
948 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "setting value of attribute %d to %d",
949 attribute_num, value);
951 if (!GST_V4L2_IS_OPEN (v4l2object))
954 control.id = attribute_num;
955 control.value = value;
956 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_CTRL, &control) < 0)
964 GST_WARNING_OBJECT (v4l2object,
965 _("Failed to set value %d for control %d on device '%s'."),
966 value, attribute_num, v4l2object->videodev);
971 /******************************************************
972 * gst_v4l2_set_string_attribute():
973 * try to set the string value of one specific attribute
974 * return value: TRUE on success, FALSE on error
975 ******************************************************/
977 gst_v4l2_set_string_attribute (GstV4l2Object * v4l2object,
978 int attribute_num, const char *value)
980 struct v4l2_ext_controls ctrls = { {0}, 1 };
981 struct v4l2_ext_control ctrl;
982 struct v4l2_queryctrl control = { 0, };
984 if (!GST_V4L2_IS_OPEN (v4l2object))
987 control.id = attribute_num;
988 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_QUERYCTRL, &control) < 0) {
989 GST_WARNING_OBJECT (v4l2object,
990 "Failed to find control %d on device '%s'.",
991 attribute_num, v4l2object->videodev);
995 if (control.type != V4L2_CTRL_TYPE_STRING) {
996 GST_WARNING_OBJECT (v4l2object,
997 "control %d is not string type on device '%s'.",
998 attribute_num, v4l2object->videodev);
1002 ctrl.id = attribute_num;
1003 ctrl.size = strlen (value) + 1;
1004 ctrl.string = g_malloc (ctrl.size);
1005 strcpy (ctrl.string, value);
1007 ctrls.which = V4L2_CTRL_ID2WHICH (attribute_num);
1009 ctrls.controls = &ctrl;
1011 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "setting value of attribute %d to %s",
1012 attribute_num, value);
1014 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_EXT_CTRLS, &ctrls) < 0)
1017 g_free (ctrl.string);
1024 GST_WARNING_OBJECT (v4l2object,
1025 _("Failed to set value %s for control %d on device '%s'."),
1026 value, attribute_num, v4l2object->videodev);
1027 g_free (ctrl.string);
1033 set_control (GQuark field_id, const GValue * value, gpointer user_data)
1035 GstV4l2Object *v4l2object = user_data;
1036 GQuark normalised_field_id;
1039 /* 32 bytes is the maximum size for a control name according to v4l2 */
1042 /* Backwards compatibility: in the past GStreamer would normalise strings in
1043 a subtly different way to v4l2-ctl. e.g. the kernel's "Focus (absolute)"
1044 would become "focus__absolute_" whereas now it becomes "focus_absolute".
1045 Please remove the following in GStreamer 1.5 for 1.6 */
1046 strncpy (name, g_quark_to_string (field_id), sizeof (name));
1048 gst_v4l2_normalise_control_name (name);
1049 normalised_field_id = g_quark_from_string (name);
1050 if (normalised_field_id != field_id)
1051 g_warning ("In GStreamer 1.4 the way V4L2 control names were normalised "
1052 "changed. Instead of setting \"%s\" please use \"%s\". The former is "
1053 "deprecated and will be removed in a future version of GStreamer",
1054 g_quark_to_string (field_id), name);
1055 field_id = normalised_field_id;
1057 d = g_datalist_id_get_data (&v4l2object->controls, field_id);
1059 GST_WARNING_OBJECT (v4l2object,
1060 "Control '%s' does not exist or has an unsupported type.",
1061 g_quark_to_string (field_id));
1064 if (G_VALUE_HOLDS (value, G_TYPE_INT)) {
1065 gst_v4l2_set_attribute (v4l2object, GPOINTER_TO_INT (d),
1066 g_value_get_int (value));
1067 } else if (G_VALUE_HOLDS (value, G_TYPE_STRING)) {
1068 gst_v4l2_set_string_attribute (v4l2object, GPOINTER_TO_INT (d),
1069 g_value_get_string (value));
1071 GST_WARNING_OBJECT (v4l2object,
1072 "no compatible value expected for control '%s'.",
1073 g_quark_to_string (field_id));
1080 gst_v4l2_set_controls (GstV4l2Object * v4l2object, GstStructure * controls)
1082 return gst_structure_foreach (controls, set_control, v4l2object);
1086 gst_v4l2_get_input (GstV4l2Object * v4l2object, guint32 * input)
1090 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to get input");
1092 if (!GST_V4L2_IS_OPEN (v4l2object))
1095 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_INPUT, &n) < 0)
1100 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "input: %u", n);
1106 if (v4l2object->device_caps & V4L2_CAP_TUNER) {
1107 /* only give a warning message if driver actually claims to have tuner
1110 GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
1111 (_("Failed to get current input on device '%s'. May be it is a radio device"), v4l2object->videodev), GST_ERROR_SYSTEM);
1117 gst_v4l2_set_input (GstV4l2Object * v4l2object, guint32 input)
1119 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to set input to %u", input);
1121 if (!GST_V4L2_IS_OPEN (v4l2object))
1124 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_INPUT, &input) < 0)
1131 if (v4l2object->device_caps & V4L2_CAP_TUNER) {
1132 /* only give a warning message if driver actually claims to have tuner
1135 GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
1136 (_("Failed to set input %u on device %s."),
1137 input, v4l2object->videodev), GST_ERROR_SYSTEM);
1143 gst_v4l2_query_input (GstV4l2Object * obj, struct v4l2_input * input)
1147 ret = obj->ioctl (obj->video_fd, VIDIOC_ENUMINPUT, input);
1149 GST_WARNING_OBJECT (obj->dbg_obj, "Failed to read input state: %s (%i)",
1150 g_strerror (errno), errno);
1158 gst_v4l2_get_output (GstV4l2Object * v4l2object, guint32 * output)
1162 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to get output");
1164 if (!GST_V4L2_IS_OPEN (v4l2object))
1167 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_OUTPUT, &n) < 0)
1172 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "output: %u", n);
1178 if (v4l2object->device_caps & V4L2_CAP_TUNER) {
1179 /* only give a warning message if driver actually claims to have tuner
1182 GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
1183 (_("Failed to get current output on device '%s'. May be it is a radio device"), v4l2object->videodev), GST_ERROR_SYSTEM);
1189 gst_v4l2_set_output (GstV4l2Object * v4l2object, guint32 output)
1191 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to set output to %u", output);
1193 if (!GST_V4L2_IS_OPEN (v4l2object))
1196 if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_OUTPUT, &output) < 0)
1203 if (v4l2object->device_caps & V4L2_CAP_TUNER) {
1204 /* only give a warning message if driver actually claims to have tuner
1207 GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
1208 (_("Failed to set output %u on device %s."),
1209 output, v4l2object->videodev), GST_ERROR_SYSTEM);
1214 static const gchar *
1215 gst_v4l2_event_to_string (guint32 event)
1218 case V4L2_EVENT_ALL:
1220 case V4L2_EVENT_VSYNC:
1222 case V4L2_EVENT_EOS:
1224 case V4L2_EVENT_CTRL:
1226 case V4L2_EVENT_FRAME_SYNC:
1227 return "FRAME_SYNC";
1228 case V4L2_EVENT_SOURCE_CHANGE:
1229 return "SOURCE_CHANGE";
1230 case V4L2_EVENT_MOTION_DET:
1231 return "MOTION_DET";
1240 gst_v4l2_subscribe_event (GstV4l2Object * v4l2object, guint32 event, guint32 id)
1242 struct v4l2_event_subscription sub = {.type = event,.id = id, };
1245 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "Subscribing to '%s' event",
1246 gst_v4l2_event_to_string (event));
1248 if (!GST_V4L2_IS_OPEN (v4l2object))
1251 ret = v4l2object->ioctl (v4l2object->video_fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
1260 if (errno == ENOTTY || errno == EINVAL) {
1261 GST_DEBUG_OBJECT (v4l2object->dbg_obj,
1262 "Cannot subscribe to '%s' event: %s",
1263 gst_v4l2_event_to_string (event), "not supported");
1265 GST_ERROR_OBJECT (v4l2object->dbg_obj,
1266 "Cannot subscribe to '%s' event: %s",
1267 gst_v4l2_event_to_string (event), g_strerror (errno));
1274 gst_v4l2_dequeue_event (GstV4l2Object * v4l2object, struct v4l2_event * event)
1278 if (!GST_V4L2_IS_OPEN (v4l2object))
1281 ret = v4l2object->ioctl (v4l2object->video_fd, VIDIOC_DQEVENT, event);
1284 GST_ERROR_OBJECT (v4l2object->dbg_obj, "DQEVENT failed: %s",
1285 g_strerror (errno));
1289 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "Dequeued a '%s' event.",
1290 gst_v4l2_event_to_string (event->type));
1296 gst_v4l2_set_dv_timings (GstV4l2Object * v4l2object,
1297 struct v4l2_dv_timings * timings)
1301 if (!GST_V4L2_IS_OPEN (v4l2object))
1304 ret = v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_DV_TIMINGS, timings);
1307 GST_ERROR_OBJECT (v4l2object->dbg_obj, "S_DV_TIMINGS failed: %s (%i)",
1308 g_strerror (errno), errno);
1316 gst_v4l2_query_dv_timings (GstV4l2Object * v4l2object,
1317 struct v4l2_dv_timings * timings)
1321 if (!GST_V4L2_IS_OPEN (v4l2object))
1324 ret = v4l2object->ioctl (v4l2object->video_fd, VIDIOC_QUERY_DV_TIMINGS,
1330 GST_DEBUG_OBJECT (v4l2object->dbg_obj,
1331 "QUERY_DV_TIMINGS not supported for this input/output");
1334 GST_DEBUG_OBJECT (v4l2object->dbg_obj,
1335 "No timings could be detected because no signal was found.");
1338 GST_INFO_OBJECT (v4l2object->dbg_obj,
1339 "The signal was unstable and the hardware could not lock on to it.");
1342 GST_INFO_OBJECT (v4l2object->dbg_obj,
1343 "Timings were found, but they are out of range of the hardware capabilities.");
1346 GST_ERROR_OBJECT (v4l2object->dbg_obj,
1347 "QUERY_DV_TIMINGS failed: %s (%i)", g_strerror (errno), errno);
1354 if (timings->type != V4L2_DV_BT_656_1120) {
1355 GST_FIXME_OBJECT (v4l2object->dbg_obj, "Unsupported DV Timings type (%i)",
1360 GST_DEBUG_OBJECT (v4l2object->dbg_obj, "Detected DV Timings (%i x %i)",
1361 timings->bt.width, timings->bt.height);