[v4l2] Revice log for device open failure
[platform/upstream/gst-plugins-good.git] / sys / v4l2 / v4l2_calls.c
index 4ccbbf5..fb5c1ae 100644 (file)
@@ -1,7 +1,7 @@
 /* GStreamer
  *
  * Copyright (C) 2002 Ronald Bultje <rbultje@ronald.bitfreak.net>
- *               2006 Edgard Lima <edgard.lima@indt.org.br>
+ *               2006 Edgard Lima <edgard.lima@gmail.com>
  *
  * v4l2_calls.c - generic V4L2 calls handling
  *
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+#include <glob.h>
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
 #ifdef __sun
 /* Needed on older Solaris Nevada builds (72 at least) */
 #include <stropts.h>
 #include <sys/ioccom.h>
 #endif
-#include "v4l2_calls.h"
+#include "gstv4l2object.h"
 #include "gstv4l2tuner.h"
-#if 0
-#include "gstv4l2xoverlay.h"
-#endif
 #include "gstv4l2colorbalance.h"
 
 #include "gstv4l2src.h"
 
 #include "gst/gst-i18n-plugin.h"
 
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+enum {
+  V4L2_OPEN_ERROR = 0,
+  V4L2_OPEN_ERROR_STAT_FAILED,
+  V4L2_OPEN_ERROR_NO_DEVICE,
+  V4L2_OPEN_ERROR_NOT_OPEN,
+  V4L2_OPEN_ERROR_NOT_CAPTURE,
+  V4L2_OPEN_ERROR_NOT_OUTPUT
+};
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
+
 GST_DEBUG_CATEGORY_EXTERN (v4l2_debug);
 #define GST_CAT_DEFAULT v4l2_debug
 
@@ -59,7 +70,7 @@ GST_DEBUG_CATEGORY_EXTERN (v4l2_debug);
  *   get the device's capturing capabilities
  * return value: TRUE on success, FALSE on error
  ******************************************************/
-gboolean
+static gboolean
 gst_v4l2_get_capabilities (GstV4l2Object * v4l2object)
 {
   GstElement *e;
@@ -71,14 +82,20 @@ gst_v4l2_get_capabilities (GstV4l2Object * v4l2object)
   if (!GST_V4L2_IS_OPEN (v4l2object))
     return FALSE;
 
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYCAP, &v4l2object->vcap) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_QUERYCAP,
+          &v4l2object->vcap) < 0)
     goto cap_failed;
 
+  if (v4l2object->vcap.capabilities & V4L2_CAP_DEVICE_CAPS)
+    v4l2object->device_caps = v4l2object->vcap.device_caps;
+  else
+    v4l2object->device_caps = v4l2object->vcap.capabilities;
+
   GST_LOG_OBJECT (e, "driver:      '%s'", v4l2object->vcap.driver);
   GST_LOG_OBJECT (e, "card:        '%s'", v4l2object->vcap.card);
   GST_LOG_OBJECT (e, "bus_info:    '%s'", v4l2object->vcap.bus_info);
   GST_LOG_OBJECT (e, "version:     %08x", v4l2object->vcap.version);
-  GST_LOG_OBJECT (e, "capabilites: %08x", v4l2object->vcap.capabilities);
+  GST_LOG_OBJECT (e, "capabilites: %08x", v4l2object->device_caps);
 
   return TRUE;
 
@@ -145,7 +162,7 @@ gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
     memset (&input, 0, sizeof (input));
 
     input.index = n;
-    if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_ENUMINPUT, &input) < 0) {
+    if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_ENUMINPUT, &input) < 0) {
       if (errno == EINVAL || errno == ENOTTY)
         break;                  /* end of enumeration */
       else {
@@ -179,7 +196,7 @@ gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
       channel->flags |= GST_TUNER_CHANNEL_FREQUENCY;
 
       vtun.index = input.tuner;
-      if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &vtun) < 0) {
+      if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &vtun) < 0) {
         GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
             (_("Failed to get setting of tuner %d on device '%s'."),
                 input.tuner, v4l2object->videodev), GST_ERROR_SYSTEM);
@@ -216,11 +233,11 @@ gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
     GstTunerNorm *norm;
 
     /* fill in defaults */
-    standard.frameperiod.numerator = 0;
-    standard.frameperiod.denominator = 1;
+    standard.frameperiod.numerator = 1;
+    standard.frameperiod.denominator = 0;
     standard.index = n;
 
-    if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_ENUMSTD, &standard) < 0) {
+    if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_ENUMSTD, &standard) < 0) {
       if (errno == EINVAL || errno == ENOTTY)
         break;                  /* end of enumeration */
 #ifdef ENODATA
@@ -238,17 +255,17 @@ gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
     }
 
     GST_DEBUG_OBJECT (e, "    '%s', fps: %d / %d",
-        standard.name, standard.frameperiod.numerator,
-        standard.frameperiod.denominator);
+        standard.name, standard.frameperiod.denominator,
+        standard.frameperiod.numerator);
 
     v4l2norm = g_object_new (GST_TYPE_V4L2_TUNER_NORM, NULL);
     norm = GST_TUNER_NORM (v4l2norm);
     norm->label = g_strdup ((const gchar *) standard.name);
     gst_value_set_fraction (&norm->framerate,
-        standard.frameperiod.numerator, standard.frameperiod.denominator);
+        standard.frameperiod.denominator, standard.frameperiod.numerator);
     v4l2norm->index = standard.id;
 
-    GST_DEBUG_OBJECT (v4l2object->element, "index=%08x, label=%s",
+    GST_DEBUG_OBJECT (v4l2object->dbg_obj, "index=%08x, label=%s",
         (unsigned int) v4l2norm->index, norm->label);
 
     v4l2object->norms = g_list_prepend (v4l2object->norms, (gpointer) norm);
@@ -278,7 +295,8 @@ gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
     GST_DEBUG_OBJECT (e, "checking control %08x", n);
 
     control.id = n | next;
-    if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYCTRL, &control) < 0) {
+    if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_QUERYCTRL,
+            &control) < 0) {
       if (next) {
         if (n > 0) {
           GST_DEBUG_OBJECT (e, "controls finished");
@@ -336,7 +354,7 @@ gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
       }
       default:
         GST_DEBUG_OBJECT (e,
-            "Control type for '%s' not suppored for extra controls.",
+            "Control type for '%s' not supported for extra controls.",
             control.name);
         break;
     }
@@ -356,6 +374,12 @@ gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
       case V4L2_CID_AUTOGAIN:
       case V4L2_CID_GAIN:
       case V4L2_CID_SHARPNESS:
+#ifdef TIZEN_FEATURE_V4L2_ADDITIONAL_CID_SUPPORT
+      case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
+      case V4L2_CID_EXPOSURE_AUTO:
+      case V4L2_CID_EXPOSURE_ABSOLUTE:
+      case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
+#endif /* TIZEN_FEATURE_V4L2_ADDITIONAL_CID_SUPPORT */
         /* we only handle these for now (why?) */
         break;
       case V4L2_CID_HFLIP:
@@ -403,7 +427,8 @@ gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
       menu.id = n;
       for (i = 0;; i++) {
         menu.index = i;
-        if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYMENU, &menu) < 0) {
+        if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_QUERYMENU,
+                &menu) < 0) {
           if (errno == EINVAL)
             break;              /* end of enumeration */
           else {
@@ -456,7 +481,7 @@ gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
 static void
 gst_v4l2_empty_lists (GstV4l2Object * v4l2object)
 {
-  GST_DEBUG_OBJECT (v4l2object->element, "deleting enumerations");
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "deleting enumerations");
 
   g_list_foreach (v4l2object->channels, (GFunc) g_object_unref, NULL);
   g_list_free (v4l2object->channels);
@@ -484,16 +509,17 @@ gst_v4l2_adjust_buf_type (GstV4l2Object * v4l2object)
    * in a contiguous manner. In this case the first v4l2 plane
    * contains all the gst planes.
    */
-#define CHECK_CAPS (V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_VIDEO_M2M_MPLANE)
   switch (v4l2object->type) {
     case V4L2_BUF_TYPE_VIDEO_OUTPUT:
-      if (v4l2object->vcap.capabilities & CHECK_CAPS) {
+      if (v4l2object->device_caps &
+          (V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_VIDEO_M2M_MPLANE)) {
         GST_DEBUG ("adjust type to multi-planar output");
         v4l2object->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
       }
       break;
     case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-      if (v4l2object->vcap.capabilities & CHECK_CAPS) {
+      if (v4l2object->device_caps &
+          (V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_VIDEO_M2M_MPLANE)) {
         GST_DEBUG ("adjust type to multi-planar capture");
         v4l2object->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
       }
@@ -501,7 +527,6 @@ gst_v4l2_adjust_buf_type (GstV4l2Object * v4l2object)
     default:
       break;
   }
-#undef CHECK_CAPS
 }
 
 /******************************************************
@@ -513,9 +538,20 @@ gboolean
 gst_v4l2_open (GstV4l2Object * v4l2object)
 {
   struct stat st;
-  int libv4l2_fd;
+  int libv4l2_fd = -1;
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+  int error_type = V4L2_OPEN_ERROR_STAT_FAILED;
+  int device_index = 0;
+  glob_t glob_buf;
+
+  memset (&glob_buf, 0x0, sizeof(glob_t));
 
-  GST_DEBUG_OBJECT (v4l2object->element, "Trying to open device %s",
+  if (!v4l2object) {
+    GST_ERROR ("v4l2object is NULL");
+    return FALSE;
+  }
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "Trying to open device %s",
       v4l2object->videodev);
 
   GST_V4L2_CHECK_NOT_OPEN (v4l2object);
@@ -525,22 +561,52 @@ gst_v4l2_open (GstV4l2Object * v4l2object)
   if (!v4l2object->videodev)
     v4l2object->videodev = g_strdup ("/dev/video");
 
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+  if (!v4l2object->videodev) {
+    GST_ERROR_OBJECT (v4l2object->element, "videodev is NULL");
+    return FALSE;
+  }
+
+CHECK_AGAIN:
+  /* check if it is a device */
+  if (stat (v4l2object->videodev, &st) == -1) {
+    error_type = V4L2_OPEN_ERROR_STAT_FAILED;
+    goto pre_error_check;
+  }
+
+  if (!S_ISCHR (st.st_mode)) {
+    error_type = V4L2_OPEN_ERROR_NO_DEVICE;
+    goto pre_error_check;
+  }
+#else /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
   /* check if it is a device */
   if (stat (v4l2object->videodev, &st) == -1)
     goto stat_failed;
 
   if (!S_ISCHR (st.st_mode))
     goto no_device;
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
 
   /* open the device */
   v4l2object->video_fd =
       open (v4l2object->videodev, O_RDWR /* | O_NONBLOCK */ );
 
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+  if (!GST_V4L2_IS_OPEN (v4l2object)) {
+    error_type = V4L2_OPEN_ERROR_NOT_OPEN;
+    goto pre_error_check;
+  }
+#else /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
   if (!GST_V4L2_IS_OPEN (v4l2object))
     goto not_open;
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
+
+#ifdef HAVE_LIBV4L2
+  if (v4l2object->fd_open)
+    libv4l2_fd = v4l2object->fd_open (v4l2object->video_fd,
+        V4L2_ENABLE_ENUM_FMT_EMULATION);
+#endif
 
-  libv4l2_fd = v4l2_fd_open (v4l2object->video_fd,
-      V4L2_ENABLE_ENUM_FMT_EMULATION);
   /* Note the v4l2_xxx functions are designed so that if they get passed an
      unknown fd, the will behave exactly as their regular xxx counterparts, so
      if v4l2_fd_open fails, we continue as normal (missing the libv4l2 custom
@@ -551,53 +617,141 @@ gst_v4l2_open (GstV4l2Object * v4l2object)
     v4l2object->video_fd = libv4l2_fd;
 
   /* get capabilities, error will be posted */
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+  if (!gst_v4l2_get_capabilities (v4l2object)) {
+    error_type = V4L2_OPEN_ERROR;
+    goto pre_error_check;
+  }
+
+  GST_INFO_OBJECT (v4l2object->element, "device_caps 0x%x", v4l2object->device_caps);
+
+  if (GST_IS_V4L2SRC (v4l2object->element) &&
+      (!(v4l2object->device_caps & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_CAPTURE_MPLANE)) ||
+       (v4l2object->device_caps & (V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_VIDEO_OUTPUT_MPLANE)))) {
+    error_type = V4L2_OPEN_ERROR_NOT_CAPTURE;
+    goto pre_error_check;
+  }
+
+  if (GST_IS_V4L2SINK (v4l2object->element) &&
+      !(v4l2object->device_caps & (V4L2_CAP_VIDEO_OUTPUT |
+              V4L2_CAP_VIDEO_OUTPUT_MPLANE))) {
+    error_type = V4L2_OPEN_ERROR_NOT_OUTPUT;
+    goto pre_error_check;
+  }
+#else /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
   if (!gst_v4l2_get_capabilities (v4l2object))
     goto error;
 
   /* do we need to be a capture device? */
   if (GST_IS_V4L2SRC (v4l2object->element) &&
-      !(v4l2object->vcap.capabilities & (V4L2_CAP_VIDEO_CAPTURE |
+      !(v4l2object->device_caps & (V4L2_CAP_VIDEO_CAPTURE |
               V4L2_CAP_VIDEO_CAPTURE_MPLANE)))
     goto not_capture;
 
   if (GST_IS_V4L2SINK (v4l2object->element) &&
-      !(v4l2object->vcap.capabilities & (V4L2_CAP_VIDEO_OUTPUT |
+      !(v4l2object->device_caps & (V4L2_CAP_VIDEO_OUTPUT |
               V4L2_CAP_VIDEO_OUTPUT_MPLANE)))
     goto not_output;
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
 
   if (GST_IS_V4L2_VIDEO_DEC (v4l2object->element) &&
-      /* Today's M2M device only expose M2M */
-      !((v4l2object->vcap.capabilities & (V4L2_CAP_VIDEO_M2M |
-                  V4L2_CAP_VIDEO_M2M_MPLANE)) ||
-          /* But legacy driver may expose both CAPTURE and OUTPUT */
-          ((v4l2object->vcap.capabilities &
-                  (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_CAPTURE_MPLANE)) &&
-              (v4l2object->vcap.capabilities &
-                  (V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_VIDEO_OUTPUT_MPLANE)))))
+      !GST_V4L2_IS_M2M (v4l2object->device_caps))
     goto not_m2m;
 
   gst_v4l2_adjust_buf_type (v4l2object);
 
   /* create enumerations, posts errors. */
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+  if (!gst_v4l2_fill_lists (v4l2object)) {
+    error_type = V4L2_OPEN_ERROR;
+    goto pre_error_check;
+  }
+#else /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
   if (!gst_v4l2_fill_lists (v4l2object))
     goto error;
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
 
-  GST_INFO_OBJECT (v4l2object->element,
+  GST_INFO_OBJECT (v4l2object->dbg_obj,
       "Opened device '%s' (%s) successfully",
       v4l2object->vcap.card, v4l2object->videodev);
 
   if (v4l2object->extra_controls)
     gst_v4l2_set_controls (v4l2object, v4l2object->extra_controls);
 
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+  globfree (&glob_buf);
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
+
   /* UVC devices are never interlaced, and doing VIDIOC_TRY_FMT on them
    * causes expensive and slow USB IO, so don't probe them for interlaced
    */
-  if (!strcmp ((char *) v4l2object->vcap.driver, "uvcusb")) {
+  if (!strcmp ((char *) v4l2object->vcap.driver, "uvcusb") ||
+      !strcmp ((char *) v4l2object->vcap.driver, "uvcvideo")) {
     v4l2object->never_interlaced = TRUE;
   }
 
   return TRUE;
 
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+pre_error_check:
+  {
+    if (v4l2object->auto_scan_device == FALSE) {
+      GST_WARNING_OBJECT (v4l2object->element, "auto scan device disabled");
+      goto error;
+    }
+
+    GST_ERROR_OBJECT (v4l2object->element, "device[%s] failed, error[%d]",
+      v4l2object->videodev, error_type);
+
+    if (GST_IS_V4L2SRC (v4l2object->element) && glob_buf.gl_pathc == 0) {
+      if (glob("/dev/video*", 0, 0, &glob_buf) != 0) {
+        GST_WARNING_OBJECT (v4l2object->element, "glob failed");
+      }
+    }
+
+    if (glob_buf.gl_pathc > 0 && device_index < glob_buf.gl_pathc) {
+      if (v4l2object->videodev)
+        g_free (v4l2object->videodev);
+
+      v4l2object->videodev = g_strdup (glob_buf.gl_pathv[device_index]);
+      if (v4l2object->videodev) {
+        device_index++;
+
+        GST_INFO_OBJECT (v4l2object->element, "check device [%s]",
+          v4l2object->videodev);
+
+        if (GST_V4L2_IS_OPEN (v4l2object)) {
+          /* close device */
+          v4l2_close (v4l2object->video_fd);
+          v4l2object->video_fd = -1;
+        }
+        /* empty lists */
+        gst_v4l2_empty_lists (v4l2object);
+
+        goto CHECK_AGAIN;
+      } else {
+        GST_WARNING_OBJECT (v4l2object->element, "g_strdup failed [%s]",
+          glob_buf.gl_pathv[device_index]);
+      }
+    }
+
+    switch (error_type) {
+    case V4L2_OPEN_ERROR_STAT_FAILED:
+      goto stat_failed;
+    case V4L2_OPEN_ERROR_NO_DEVICE:
+      goto no_device;
+    case V4L2_OPEN_ERROR_NOT_OPEN:
+      goto not_open;
+    case V4L2_OPEN_ERROR_NOT_CAPTURE:
+      goto not_capture;
+    case V4L2_OPEN_ERROR_NOT_OUTPUT:
+      goto not_output;
+    default:
+      goto error;
+    }
+  }
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
+
   /* ERRORS */
 stat_failed:
   {
@@ -625,7 +779,7 @@ not_capture:
     GST_ELEMENT_ERROR (v4l2object->element, RESOURCE, NOT_FOUND,
         (_("Device '%s' is not a capture device."),
             v4l2object->videodev),
-        ("Capabilities: 0x%x", v4l2object->vcap.capabilities));
+        ("Capabilities: 0x%x", v4l2object->device_caps));
     goto error;
   }
 not_output:
@@ -633,7 +787,7 @@ not_output:
     GST_ELEMENT_ERROR (v4l2object->element, RESOURCE, NOT_FOUND,
         (_("Device '%s' is not a output device."),
             v4l2object->videodev),
-        ("Capabilities: 0x%x", v4l2object->vcap.capabilities));
+        ("Capabilities: 0x%x", v4l2object->device_caps));
     goto error;
   }
 not_m2m:
@@ -641,19 +795,23 @@ not_m2m:
     GST_ELEMENT_ERROR (v4l2object->element, RESOURCE, NOT_FOUND,
         (_("Device '%s' is not a M2M device."),
             v4l2object->videodev),
-        ("Capabilities: 0x%x", v4l2object->vcap.capabilities));
+        ("Capabilities: 0x%x", v4l2object->device_caps));
     goto error;
   }
 error:
   {
     if (GST_V4L2_IS_OPEN (v4l2object)) {
       /* close device */
-      v4l2_close (v4l2object->video_fd);
+      v4l2object->close (v4l2object->video_fd);
       v4l2object->video_fd = -1;
     }
     /* empty lists */
     gst_v4l2_empty_lists (v4l2object);
 
+#ifdef TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE
+    globfree (&glob_buf);
+#endif /* TIZEN_FEATURE_V4L2SRC_AUTO_SCAN_DEVICE_NODE */
+
     return FALSE;
   }
 }
@@ -661,7 +819,7 @@ error:
 gboolean
 gst_v4l2_dup (GstV4l2Object * v4l2object, GstV4l2Object * other)
 {
-  GST_DEBUG_OBJECT (v4l2object->element, "Trying to dup device %s",
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "Trying to dup device %s",
       other->videodev);
 
   GST_V4L2_CHECK_OPEN (other);
@@ -670,20 +828,22 @@ gst_v4l2_dup (GstV4l2Object * v4l2object, GstV4l2Object * other)
   GST_V4L2_CHECK_NOT_ACTIVE (v4l2object);
 
   v4l2object->vcap = other->vcap;
+  v4l2object->device_caps = other->device_caps;
   gst_v4l2_adjust_buf_type (v4l2object);
 
-  v4l2object->video_fd = v4l2_dup (other->video_fd);
+  v4l2object->video_fd = v4l2object->dup (other->video_fd);
   if (!GST_V4L2_IS_OPEN (v4l2object))
     goto not_open;
 
   g_free (v4l2object->videodev);
   v4l2object->videodev = g_strdup (other->videodev);
 
-  GST_INFO_OBJECT (v4l2object->element,
+  GST_INFO_OBJECT (v4l2object->dbg_obj,
       "Cloned device '%s' (%s) successfully",
       v4l2object->vcap.card, v4l2object->videodev);
 
   v4l2object->never_interlaced = other->never_interlaced;
+  v4l2object->no_initial_format = other->no_initial_format;
 
   return TRUE;
 
@@ -706,14 +866,14 @@ not_open:
 gboolean
 gst_v4l2_close (GstV4l2Object * v4l2object)
 {
-  GST_DEBUG_OBJECT (v4l2object->element, "Trying to close %s",
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "Trying to close %s",
       v4l2object->videodev);
 
   GST_V4L2_CHECK_OPEN (v4l2object);
   GST_V4L2_CHECK_NOT_ACTIVE (v4l2object);
 
   /* close device */
-  v4l2_close (v4l2object->video_fd);
+  v4l2object->close (v4l2object->video_fd);
   v4l2object->video_fd = -1;
 
   /* empty lists */
@@ -731,12 +891,12 @@ gst_v4l2_close (GstV4l2Object * v4l2object)
 gboolean
 gst_v4l2_get_norm (GstV4l2Object * v4l2object, v4l2_std_id * norm)
 {
-  GST_DEBUG_OBJECT (v4l2object->element, "getting norm");
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "getting norm");
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
     return FALSE;
 
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_STD, norm) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_STD, norm) < 0)
     goto std_failed;
 
   return TRUE;
@@ -759,13 +919,13 @@ std_failed:
 gboolean
 gst_v4l2_set_norm (GstV4l2Object * v4l2object, v4l2_std_id norm)
 {
-  GST_DEBUG_OBJECT (v4l2object->element, "trying to set norm to "
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to set norm to "
       "%" G_GINT64_MODIFIER "x", (guint64) norm);
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
     return FALSE;
 
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_STD, &norm) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_STD, &norm) < 0)
     goto std_failed;
 
   return TRUE;
@@ -793,7 +953,7 @@ gst_v4l2_get_frequency (GstV4l2Object * v4l2object,
 
   GstTunerChannel *channel;
 
-  GST_DEBUG_OBJECT (v4l2object->element, "getting current tuner frequency");
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "getting current tuner frequency");
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
     return FALSE;
@@ -801,7 +961,7 @@ gst_v4l2_get_frequency (GstV4l2Object * v4l2object,
   channel = gst_tuner_get_channel (GST_TUNER (v4l2object->element));
 
   freq.tuner = tunernum;
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq) < 0)
     goto freq_failed;
 
   *frequency = freq.frequency * channel->freq_multiplicator;
@@ -832,7 +992,7 @@ gst_v4l2_set_frequency (GstV4l2Object * v4l2object,
 
   GstTunerChannel *channel;
 
-  GST_DEBUG_OBJECT (v4l2object->element,
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj,
       "setting current tuner frequency to %lu", frequency);
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
@@ -842,10 +1002,10 @@ gst_v4l2_set_frequency (GstV4l2Object * v4l2object,
 
   freq.tuner = tunernum;
   /* fill in type - ignore error */
-  v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq);
+  (void) v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq);
   freq.frequency = frequency / channel->freq_multiplicator;
 
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_FREQUENCY, &freq) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_FREQUENCY, &freq) < 0)
     goto freq_failed;
 
   return TRUE;
@@ -871,13 +1031,13 @@ gst_v4l2_signal_strength (GstV4l2Object * v4l2object,
 {
   struct v4l2_tuner tuner = { 0, };
 
-  GST_DEBUG_OBJECT (v4l2object->element, "trying to get signal strength");
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to get signal strength");
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
     return FALSE;
 
   tuner.index = tunernum;
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &tuner) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &tuner) < 0)
     goto tuner_failed;
 
   *signal_strength = tuner.signal;
@@ -905,7 +1065,7 @@ gst_v4l2_get_attribute (GstV4l2Object * v4l2object,
 {
   struct v4l2_control control = { 0, };
 
-  GST_DEBUG_OBJECT (v4l2object->element, "getting value of attribute %d",
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "getting value of attribute %d",
       attribute_num);
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
@@ -913,7 +1073,7 @@ gst_v4l2_get_attribute (GstV4l2Object * v4l2object,
 
   control.id = attribute_num;
 
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_CTRL, &control) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_CTRL, &control) < 0)
     goto ctrl_failed;
 
   *value = control.value;
@@ -923,9 +1083,9 @@ gst_v4l2_get_attribute (GstV4l2Object * v4l2object,
   /* ERRORS */
 ctrl_failed:
   {
-    GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
-        (_("Failed to get value for control %d on device '%s'."),
-            attribute_num, v4l2object->videodev), GST_ERROR_SYSTEM);
+    GST_WARNING_OBJECT (v4l2object,
+        _("Failed to get value for control %d on device '%s'."),
+        attribute_num, v4l2object->videodev);
     return FALSE;
   }
 }
@@ -942,7 +1102,7 @@ gst_v4l2_set_attribute (GstV4l2Object * v4l2object,
 {
   struct v4l2_control control = { 0, };
 
-  GST_DEBUG_OBJECT (v4l2object->element, "setting value of attribute %d to %d",
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "setting value of attribute %d to %d",
       attribute_num, value);
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
@@ -950,7 +1110,7 @@ gst_v4l2_set_attribute (GstV4l2Object * v4l2object,
 
   control.id = attribute_num;
   control.value = value;
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_CTRL, &control) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_CTRL, &control) < 0)
     goto ctrl_failed;
 
   return TRUE;
@@ -958,9 +1118,9 @@ gst_v4l2_set_attribute (GstV4l2Object * v4l2object,
   /* ERRORS */
 ctrl_failed:
   {
-    GST_ELEMENT_WARNING (v4l2object->element, RESOURCE, SETTINGS,
-        (_("Failed to set value %d for control %d on device '%s'."),
-            value, attribute_num, v4l2object->videodev), GST_ERROR_SYSTEM);
+    GST_WARNING_OBJECT (v4l2object,
+        _("Failed to set value %d for control %d on device '%s'."),
+        value, attribute_num, v4l2object->videodev);
     return FALSE;
   }
 }
@@ -1018,23 +1178,23 @@ gst_v4l2_get_input (GstV4l2Object * v4l2object, gint * input)
 {
   gint n;
 
-  GST_DEBUG_OBJECT (v4l2object->element, "trying to get input");
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to get input");
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
     return FALSE;
 
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_INPUT, &n) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_INPUT, &n) < 0)
     goto input_failed;
 
   *input = n;
 
-  GST_DEBUG_OBJECT (v4l2object->element, "input: %d", n);
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "input: %d", n);
 
   return TRUE;
 
   /* ERRORS */
 input_failed:
-  if (v4l2object->vcap.capabilities & V4L2_CAP_TUNER) {
+  if (v4l2object->device_caps & V4L2_CAP_TUNER) {
     /* only give a warning message if driver actually claims to have tuner
      * support
      */
@@ -1047,19 +1207,19 @@ input_failed:
 gboolean
 gst_v4l2_set_input (GstV4l2Object * v4l2object, gint input)
 {
-  GST_DEBUG_OBJECT (v4l2object->element, "trying to set input to %d", input);
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to set input to %d", input);
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
     return FALSE;
 
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_INPUT, &input) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_INPUT, &input) < 0)
     goto input_failed;
 
   return TRUE;
 
   /* ERRORS */
 input_failed:
-  if (v4l2object->vcap.capabilities & V4L2_CAP_TUNER) {
+  if (v4l2object->device_caps & V4L2_CAP_TUNER) {
     /* only give a warning message if driver actually claims to have tuner
      * support
      */
@@ -1075,23 +1235,23 @@ gst_v4l2_get_output (GstV4l2Object * v4l2object, gint * output)
 {
   gint n;
 
-  GST_DEBUG_OBJECT (v4l2object->element, "trying to get output");
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to get output");
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
     return FALSE;
 
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_OUTPUT, &n) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_OUTPUT, &n) < 0)
     goto output_failed;
 
   *output = n;
 
-  GST_DEBUG_OBJECT (v4l2object->element, "output: %d", n);
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "output: %d", n);
 
   return TRUE;
 
   /* ERRORS */
 output_failed:
-  if (v4l2object->vcap.capabilities & V4L2_CAP_TUNER) {
+  if (v4l2object->device_caps & V4L2_CAP_TUNER) {
     /* only give a warning message if driver actually claims to have tuner
      * support
      */
@@ -1104,19 +1264,19 @@ output_failed:
 gboolean
 gst_v4l2_set_output (GstV4l2Object * v4l2object, gint output)
 {
-  GST_DEBUG_OBJECT (v4l2object->element, "trying to set output to %d", output);
+  GST_DEBUG_OBJECT (v4l2object->dbg_obj, "trying to set output to %d", output);
 
   if (!GST_V4L2_IS_OPEN (v4l2object))
     return FALSE;
 
-  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_OUTPUT, &output) < 0)
+  if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_OUTPUT, &output) < 0)
     goto output_failed;
 
   return TRUE;
 
   /* ERRORS */
 output_failed:
-  if (v4l2object->vcap.capabilities & V4L2_CAP_TUNER) {
+  if (v4l2object->device_caps & V4L2_CAP_TUNER) {
     /* only give a warning message if driver actually claims to have tuner
      * support
      */