Attachment #174472 for bug #250079

Lines 550-555 return 0; Link Here

(-)configure.ac (+6 lines)
550	fi	550	fi
551	])	551	])
552		552
		553	if test x$HAVE_GST_V4L2 = xyes; then
		554	PKG_CHECK_MODULES(LIBV4L2, libv4l2, [have_libv4l2=yes], [have_libv4l2=no])
		555	AC_DEFINE([HAVE_LIBV4L2], test x$have_libv4l2 = xyes,
		556	[Whether libv4l2 is available for video buffer conversion])
		557	fi
		558
553	dnl Check for X11	559	dnl Check for X11
554	translit(dnm, m, l) AM_CONDITIONAL(USE_X, true)	560	translit(dnm, m, l) AM_CONDITIONAL(USE_X, true)
555	AG_GST_CHECK_FEATURE(X, [X libraries and plugins],	561	AG_GST_CHECK_FEATURE(X, [X libraries and plugins],




libgstvideo4linux2_la_CFLAGS =   $(GST_PLUGINS_BASE_CFLAGS) \
				 $(GST_BASE_CFLAGS) \
				 $(GST_CFLAGS) \
				 $(X_CFLAGS) \
				 $(LIBV4L2_CFLAGS)

libgstvideo4linux2_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)

libgstvideo4linux2_la_LIBADD =   $(GST_PLUGINS_BASE_LIBS) \
				 $(GST_BASE_LIBS) \
				 -lgstinterfaces-$(GST_MAJORMINOR) \
				 $(GST_LIBS) \
				 $(xv_libs) \
				 $(LIBV4L2_LIBS)

noinst_HEADERS = gstv4l2object.h v4l2_calls.h \
		 gstv4l2src.h v4l2src_calls.h \

Lines 1162-1168 gst_v4l2src_get_read (GstV4l2Src * v4l2s Link Here

(-)sys/v4l2/gstv4l2src.c (-1 / +1 lines)
1162		1162
1163	do {	1163	do {
1164	amount =	1164	amount =
1165	read (v4l2src->v4l2object->video_fd, GST_BUFFER_DATA (*buf),	1165	v4l2_read (v4l2src->v4l2object->video_fd, GST_BUFFER_DATA (*buf),
1166	buffersize);	1166	buffersize);
1167	if (amount == buffersize) {	1167	if (amount == buffersize) {
1168	break;	1168	break;




  if (!GST_V4L2_IS_OPEN (v4l2object))
    return FALSE;

  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYCAP, &v4l2object->vcap) < 0)
    goto cap_failed;

  GST_LOG_OBJECT (e, "driver:      '%s'", v4l2object->vcap.driver);

    GstTunerChannel *channel;

    input.index = n;
    if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_ENUMINPUT, &input) < 0) {
      if (errno == EINVAL)
        break;                  /* end of enumeration */
      else {

      channel->flags |= GST_TUNER_CHANNEL_FREQUENCY;

      vtun.index = input.tuner;
      if (v4l2_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);

    standard.frameperiod.denominator = 0;
    standard.index = n;

    if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_ENUMSTD, &standard) < 0) {
      if (errno == EINVAL || errno == ENOTTY)
        break;                  /* end of enumeration */
      else {

    }

    control.id = n;
    if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYCTRL, &control) < 0) {
      if (errno == EINVAL) {
        if (n < V4L2_CID_PRIVATE_BASE)
          /* continue so that we also check private controls */

      menu.id = n;
      for (i = 0;; i++) {
        menu.index = i;
        if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYMENU, &menu) < 0) {
          if (errno == EINVAL)
            break;              /* end of enumeration */
          else {

gst_v4l2_open (GstV4l2Object * v4l2object)
{
  struct stat st;
  int libv4l2_fd;

  GST_DEBUG_OBJECT (v4l2object->element, "Trying to open device %s",
      v4l2object->videodev);

  if (!GST_V4L2_IS_OPEN (v4l2object))
    goto not_open;

  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
     cam format to normal formats conversion). Chances are big we will still
     fail then though, as normally v4l2_fd_open only fails if the device is not
     a v4l2 device. */
  if (libv4l2_fd != -1)
    v4l2object->video_fd = libv4l2_fd;

  /* get capabilities, error will be posted */
  if (!gst_v4l2_get_capabilities (v4l2object))
    goto error;

  {
    if (GST_V4L2_IS_OPEN (v4l2object)) {
      /* close device */
      v4l2_close (v4l2object->video_fd);
      v4l2object->video_fd = -1;
    }
    /* empty lists */

  GST_V4L2_CHECK_NOT_ACTIVE (v4l2object);

  /* close device */
  v4l2_close (v4l2object->video_fd);
  v4l2object->video_fd = -1;

  /* empty lists */

  if (!GST_V4L2_IS_OPEN (v4l2object))
    return FALSE;

  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_STD, norm) < 0)
    goto std_failed;

  return TRUE;

  if (!GST_V4L2_IS_OPEN (v4l2object))
    return FALSE;

  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_STD, &norm) < 0)
    goto std_failed;

  return TRUE;

  channel = gst_tuner_get_channel (GST_TUNER (v4l2object->element));

  freq.tuner = tunernum;
  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq) < 0)
    goto freq_failed;

  *frequency = freq.frequency * channel->freq_multiplicator;


  freq.tuner = tunernum;
  /* fill in type - ignore error */
  v4l2_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)
    goto freq_failed;

  return TRUE;

    return FALSE;

  tuner.index = tunernum;
  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &tuner) < 0)
    goto tuner_failed;

  *signal_strength = tuner.signal;


  control.id = attribute_num;

  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_CTRL, &control) < 0)
    goto ctrl_failed;

  *value = control.value;


  control.id = attribute_num;
  control.value = value;
  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_CTRL, &control) < 0)
    goto ctrl_failed;

  return TRUE;

  if (!GST_V4L2_IS_OPEN (v4l2object))
    return FALSE;

  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_INPUT, &n) < 0)
    goto input_failed;

  *input = n;

  if (!GST_V4L2_IS_OPEN (v4l2object))
    return FALSE;

  if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_INPUT, &input) < 0)
    goto input_failed;

  return TRUE;




#include "gstv4l2object.h"
#include "gst/gst-i18n-plugin.h"

#ifdef HAVE_LIBV4L2
#include <libv4l2.h>
#else
#define v4l2_fd_open(fd, flags) (fd)
#define v4l2_close close
#define v4l2_dup dup
#define v4l2_ioctl ioctl
#define v4l2_read read
#define v4l2_mmap mmap
#define v4l2_munmap munmap
#endif

/* simple check whether the device is open */
#define GST_V4L2_IS_OPEN(v4l2object) \

Lines 1131-1136 USE_OSX_VIDEO_FALSE Link Here

(-)configure (+73 lines)
1131	XVIDEO_LIBS	1131	XVIDEO_LIBS
1132	USE_GST_V4L2_TRUE	1132	USE_GST_V4L2_TRUE
1133	USE_GST_V4L2_FALSE	1133	USE_GST_V4L2_FALSE
		1134	LIBV4L2_CFLAGS
		1135	LIBV4L2_LIBS
1134	XMKMF	1136	XMKMF
1135	X_CFLAGS	1137	X_CFLAGS
1136	X_PRE_LIBS	1138	X_PRE_LIBS
Lines 1286-1291 GST_PLUGINS_BASE_CFLAGS Link Here
1286	GST_PLUGINS_BASE_LIBS	1288	GST_PLUGINS_BASE_LIBS
1287	GTK2_CFLAGS	1289	GTK2_CFLAGS
1288	GTK2_LIBS	1290	GTK2_LIBS
		1291	LIBV4L2_CFLAGS
		1292	LIBV4L2_LIBS
1289	XMKMF	1293	XMKMF
1290	XFIXES_CFLAGS	1294	XFIXES_CFLAGS
1291	XFIXES_LIBS	1295	XFIXES_LIBS
Lines 2093-2098 Some influential environment variables: Link Here
2093	linker flags for GST_PLUGINS_BASE, overriding pkg-config	2097	linker flags for GST_PLUGINS_BASE, overriding pkg-config
2094	GTK2_CFLAGS C compiler flags for GTK2, overriding pkg-config	2098	GTK2_CFLAGS C compiler flags for GTK2, overriding pkg-config
2095	GTK2_LIBS linker flags for GTK2, overriding pkg-config	2099	GTK2_LIBS linker flags for GTK2, overriding pkg-config
		2100	LIBV4L2_CFLAGS
		2101	C compiler flags for LIBV4L2, overriding pkg-config
		2102	LIBV4L2_LIBS
		2103	linker flags for LIBV4L2, overriding pkg-config
2096	XMKMF Path to xmkmf, Makefile generator for X Window System	2104	XMKMF Path to xmkmf, Makefile generator for X Window System
2097	XFIXES_CFLAGS	2105	XFIXES_CFLAGS
2098	C compiler flags for XFIXES, overriding pkg-config	2106	C compiler flags for XFIXES, overriding pkg-config
Lines 37088-37093 else Link Here
37088	fi	37096	fi
37089		37097
37090		37098
		37099	if test x$HAVE_GST_V4L2 = xyes; then
		37100
		37101	pkg_failed=no
		37102	{ echo "$as_me:$LINENO: checking for LIBV4L2" >&5
		37103	echo $ECHO_N "checking for LIBV4L2... " >&6; }
		37104
		37105	if test -n "$PKG_CONFIG"; then
		37106	if test -n "$LIBV4L2_CFLAGS"; then
		37107	pkg_cv_LIBV4L2_CFLAGS="$LIBV4L2_CFLAGS"
		37108	else
		37109	if test -n "$PKG_CONFIG" && \
		37110	{ (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"libv4l2\"") >&5
		37111	($PKG_CONFIG --exists --print-errors "libv4l2") 2>&5
		37112	ac_status=$?
		37113	echo "$as_me:$LINENO: \$? = $ac_status" >&5
		37114	(exit $ac_status); }; then
		37115	pkg_cv_LIBV4L2_CFLAGS=`$PKG_CONFIG --cflags "libv4l2" 2>/dev/null`
		37116	else
		37117	pkg_failed=yes
		37118	fi
		37119	fi
		37120	else
		37121	pkg_failed=untried
		37122	fi
		37123	if test -n "$PKG_CONFIG"; then
		37124	if test -n "$LIBV4L2_LIBS"; then
		37125	pkg_cv_LIBV4L2_LIBS="$LIBV4L2_LIBS"
		37126	else
		37127	if test -n "$PKG_CONFIG" && \
		37128	{ (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"libv4l2\"") >&5
		37129	($PKG_CONFIG --exists --print-errors "libv4l2") 2>&5
		37130	ac_status=$?
		37131	echo "$as_me:$LINENO: \$? = $ac_status" >&5
		37132	(exit $ac_status); }; then
		37133	pkg_cv_LIBV4L2_LIBS=`$PKG_CONFIG --libs "libv4l2" 2>/dev/null`
		37134	else
		37135	pkg_failed=yes
		37136	fi
		37137	fi
		37138	else
		37139	pkg_failed=untried
		37140	fi
		37141
		37142	if test $pkg_failed = yes; then
		37143	LIBV4L2_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "libv4l2"`
		37144	# Put the nasty error message in config.log where it belongs
		37145	echo "$LIBV4L2_PKG_ERRORS" 1>&5
		37146
		37147	have_libv4l2=no
		37148	elif test $pkg_failed = untried; then
		37149	have_libv4l2=no
		37150	else
		37151	LIBV4L2_CFLAGS=$pkg_cv_LIBV4L2_CFLAGS
		37152	LIBV4L2_LIBS=$pkg_cv_LIBV4L2_LIBS
		37153	{ echo "$as_me:$LINENO: result: yes" >&5
		37154	echo "yes" >&6; }
		37155	have_libv4l2=yes
		37156	fi
		37157
		37158	cat >>confdefs.h <<\_ACEOF
		37159	#define HAVE_LIBV4L2 test x$have_libv4l2 = xyes
		37160	_ACEOF
		37161
		37162	fi
37163
37091		37164
37092	{ echo "$as_me:$LINENO: checking for X" >&5	37165	{ echo "$as_me:$LINENO: checking for X" >&5
37093	echo $ECHO_N "checking for X... $ECHO_C" >&6; }	37166	echo $ECHO_N "checking for X... $ECHO_C" >&6; }




LIBOIL_LIBS = @LIBOIL_LIBS@
LIBPNG_CFLAGS = @LIBPNG_CFLAGS@
LIBPNG_LIBS = @LIBPNG_LIBS@
LIBV4L2_CFLAGS =
LIBV4L2_LIBS = -lv4l2 -lv4lconvert
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LN_S = @LN_S@

libgstvideo4linux2_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) \
				 $(GST_BASE_CFLAGS) \
				 $(GST_CFLAGS) \
				 $(X_CFLAGS) \
				 $(LIBV4L2_CFLAGS)

libgstvideo4linux2_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
libgstvideo4linux2_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) \
				 $(GST_BASE_LIBS) \
				 -lgstinterfaces-$(GST_MAJORMINOR) \
				 $(GST_LIBS) \
				 $(xv_libs) \
				 $(LIBV4L2_LIBS)

noinst_HEADERS = gstv4l2object.h v4l2_calls.h \
		 gstv4l2src.h v4l2src_calls.h \

Lines 173-178 Link Here

(-)config.h.in~ (+3 lines)
173	/* Define to enable Portable Network Graphics library (used by png). */	173	/* Define to enable Portable Network Graphics library (used by png). */
174	#undef HAVE_LIBPNG	174	#undef HAVE_LIBPNG
175		175
		176	/* Whether libv4l2 is available for video buffer conversion */
		177	#undef HAVE_LIBV4L2
		178
176	/* Define to 1 if you have the <memory.h> header file. */	179	/* Define to 1 if you have the <memory.h> header file. */
177	#undef HAVE_MEMORY_H	180	#undef HAVE_MEMORY_H
178		181




    pool->num_live_buffers--;

  if (pool->running) {
    if (v4l2_ioctl (pool->video_fd, VIDIOC_QBUF, &buffer->vbuffer) < 0) {
      GST_WARNING ("could not requeue buffer %p %d", buffer, index);
    } else {
      /* FIXME: check that the caps didn't change */

  if (!resuscitated) {
    GST_LOG ("buffer %p not recovered, unmapping", buffer);
    gst_mini_object_unref (GST_MINI_OBJECT (pool));
    v4l2_munmap ((void *) GST_BUFFER_DATA (buffer), buffer->vbuffer.length);

    GST_MINI_OBJECT_CLASS (v4l2buffer_parent_class)->finalize (GST_MINI_OBJECT
        (buffer));

  ret->vbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  ret->vbuffer.memory = V4L2_MEMORY_MMAP;

  if (v4l2_ioctl (pool->video_fd, VIDIOC_QUERYBUF, &ret->vbuffer) < 0)
    goto querybuf_failed;

  GST_LOG ("  index:     %u", ret->vbuffer.index);

  GST_LOG ("  length:    %u", ret->vbuffer.length);
  GST_LOG ("  input:     %u", ret->vbuffer.input);

  data = (guint8 *) v4l2_mmap (0, ret->vbuffer.length,
      PROT_READ | PROT_WRITE, MAP_SHARED, pool->video_fd,
      ret->vbuffer.m.offset);


  pool->lock = NULL;

  if (pool->video_fd >= 0)
    v4l2_close (pool->video_fd);

  if (pool->buffers) {
    g_free (pool->buffers);


  pool = (GstV4l2BufferPool *) gst_mini_object_new (GST_TYPE_V4L2_BUFFER_POOL);

  pool->video_fd = v4l2_dup (fd);
  if (pool->video_fd < 0)
    goto dup_failed;



    GST_LOG ("enqueue pool buffer %d", n);

    if (v4l2_ioctl (pool->video_fd, VIDIOC_QBUF, buf) < 0)
      goto queue_failed;
  }
  pool->running = TRUE;

    format->index = n;
    format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if (v4l2_ioctl (v4l2src->v4l2object->video_fd, VIDIOC_ENUM_FMT, format) < 0) {
      if (errno == EINVAL) {
        g_free (format);
        break;                  /* end of enumeration */


  /* keep in mind that v4l2 gives us frame intervals (durations); we invert the
   * fraction to get framerate */
  if (v4l2_ioctl (fd, VIDIOC_ENUM_FRAMEINTERVALS, &ival) < 0)
    goto enum_frameintervals_failed;

  if (ival.type == V4L2_FRMIVAL_TYPE_DISCRETE) {

      gst_value_list_append_value (&rates, &rate);

      ival.index++;
    } while (v4l2_ioctl (fd, VIDIOC_ENUM_FRAMEINTERVALS, &ival) >= 0);
  } else if (ival.type == V4L2_FRMIVAL_TYPE_STEPWISE) {
    GValue min = { 0, };
    GValue step = { 0, };


  GST_DEBUG_OBJECT (v4l2src, "Enumerating frame sizes");

  if (v4l2_ioctl (fd, VIDIOC_ENUM_FRAMESIZES, &size) < 0)
    goto enum_framesizes_failed;

  if (size.type == V4L2_FRMSIZE_TYPE_DISCRETE) {

        results = g_list_prepend (results, tmp);

      size.index++;
    } while (v4l2_ioctl (fd, VIDIOC_ENUM_FRAMESIZES, &size) >= 0);
    GST_DEBUG_OBJECT (v4l2src, "done iterating discrete frame sizes");
  } else if (size.type == V4L2_FRMSIZE_TYPE_STEPWISE) {
    GST_DEBUG_OBJECT (v4l2src, "we have stepwise frame sizes:");

  buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  buffer.memory = V4L2_MEMORY_MMAP;

  while (v4l2_ioctl (v4l2src->v4l2object->video_fd, VIDIOC_DQBUF, &buffer) < 0) {

    GST_WARNING_OBJECT (v4l2src,
        "problem grabbing frame %d (ix=%d), trials=%d, pool-ct=%d, buf.flags=%d",

  memset (&format, 0x00, sizeof (struct v4l2_format));
  format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  if (v4l2_ioctl (fd, VIDIOC_G_FMT, &format) < 0)
    goto get_fmt_failed;

  format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

   *  combined, there are other modes for requesting fields individually) */
  format.fmt.pix.field = V4L2_FIELD_INTERLACED;

  if (v4l2_ioctl (fd, VIDIOC_S_FMT, &format) < 0) {
    if (errno != EINVAL)
      goto set_fmt_failed;


    format.fmt.pix.height = height;
    format.fmt.pix.pixelformat = pixelformat;
    format.fmt.pix.field = V4L2_FIELD_NONE;
    if (v4l2_ioctl (fd, VIDIOC_S_FMT, &format) < 0)
      goto set_fmt_failed;
  }



  memset (&stream, 0x00, sizeof (struct v4l2_streamparm));
  stream.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  if (v4l2_ioctl (fd, VIDIOC_G_PARM, &stream) < 0) {
    GST_ELEMENT_WARNING (v4l2src, RESOURCE, SETTINGS,
        (_("Could not get parameters on device '%s'"),
            v4l2src->v4l2object->videodev), GST_ERROR_SYSTEM);

  stream.parm.capture.timeperframe.denominator = fps_n;

  /* some cheap USB cam's won't accept any change */
  if (v4l2_ioctl (fd, VIDIOC_S_PARM, &stream) < 0) {
    GST_ELEMENT_WARNING (v4l2src, RESOURCE, SETTINGS,
        (_("Video input device did not accept new frame rate setting.")),
        GST_ERROR_SYSTEM);

    breq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    breq.memory = V4L2_MEMORY_MMAP;

    if (v4l2_ioctl (fd, VIDIOC_REQBUFS, &breq) < 0)
      goto reqbufs_failed;

    GST_LOG_OBJECT (v4l2src, " count:  %u", breq.count);

    if (!gst_v4l2_buffer_pool_activate (v4l2src->pool, v4l2src))
      goto pool_activate_failed;

    if (v4l2_ioctl (fd, VIDIOC_STREAMON, &type) < 0)
      goto streamon_failed;
  }


  if (v4l2src->use_mmap) {
    /* we actually need to sync on all queued buffers but not
     * on the non-queued ones */
    if (v4l2_ioctl (v4l2src->v4l2object->video_fd, VIDIOC_STREAMOFF, &type) < 0)
      goto streamoff_failed;
  }


  fmt.fmt.pix.pixelformat = pixelformat;
  fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

  r = v4l2_ioctl (fd, VIDIOC_TRY_FMT, &fmt);
  if (r < 0 && errno == EINVAL) {
    /* try again with progressive video */
    fmt.fmt.pix.width = *width;
    fmt.fmt.pix.height = *height;
    fmt.fmt.pix.pixelformat = pixelformat;
    fmt.fmt.pix.field = V4L2_FIELD_NONE;
    r = v4l2_ioctl (fd, VIDIOC_TRY_FMT, &fmt);
  }

  if (r < 0) {

    fmt.fmt.pix.width = *width;
    fmt.fmt.pix.height = *height;

    r = v4l2_ioctl (fd, VIDIOC_S_FMT, &fmt);
    if (r < 0 && errno == EINVAL) {
      /* try again with progressive video */
      fmt.fmt.pix.width = *width;
      fmt.fmt.pix.height = *height;
      fmt.fmt.pix.pixelformat = pixelformat;
      fmt.fmt.pix.field = V4L2_FIELD_NONE;
      r = v4l2_ioctl (fd, VIDIOC_S_FMT, &fmt);
    }

    if (r < 0)

Return to bug 250079

Lines 75-81 gst_v4l2_get_capabilities (GstV4l2Object Link Here

(-)sys/v4l2/v4l2_calls.c (-18 / +30 lines)
75	if (!GST_V4L2_IS_OPEN (v4l2object))	75	if (!GST_V4L2_IS_OPEN (v4l2object))
76	return FALSE;	76	return FALSE;
77		77
78	if (ioctl (v4l2object->video_fd, VIDIOC_QUERYCAP, &v4l2object->vcap) < 0)	78	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYCAP, &v4l2object->vcap) < 0)
79	goto cap_failed;	79	goto cap_failed;
80		80
81	GST_LOG_OBJECT (e, "driver: '%s'", v4l2object->vcap.driver);	81	GST_LOG_OBJECT (e, "driver: '%s'", v4l2object->vcap.driver);
Lines 124-130 gst_v4l2_fill_lists (GstV4l2Object * v4l Link Here
124	GstTunerChannel *channel;	124	GstTunerChannel *channel;
125		125
126	input.index = n;	126	input.index = n;
127	if (ioctl (v4l2object->video_fd, VIDIOC_ENUMINPUT, &input) < 0) {	127	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_ENUMINPUT, &input) < 0) {
128	if (errno == EINVAL)	128	if (errno == EINVAL)
129	break; /* end of enumeration */	129	break; /* end of enumeration */
130	else {	130	else {
Lines 157-163 gst_v4l2_fill_lists (GstV4l2Object * v4l Link Here
157	channel->flags \|= GST_TUNER_CHANNEL_FREQUENCY;	157	channel->flags \|= GST_TUNER_CHANNEL_FREQUENCY;
158		158
159	vtun.index = input.tuner;	159	vtun.index = input.tuner;
160	if (ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &vtun) < 0) {	160	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &vtun) < 0) {
161	GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,	161	GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
162	(_("Failed to get setting of tuner %d on device '%s'."),	162	(_("Failed to get setting of tuner %d on device '%s'."),
163	input.tuner, v4l2object->videodev), GST_ERROR_SYSTEM);	163	input.tuner, v4l2object->videodev), GST_ERROR_SYSTEM);
Lines 197-203 gst_v4l2_fill_lists (GstV4l2Object * v4l Link Here
197	standard.frameperiod.denominator = 0;	197	standard.frameperiod.denominator = 0;
198	standard.index = n;	198	standard.index = n;
199		199
200	if (ioctl (v4l2object->video_fd, VIDIOC_ENUMSTD, &standard) < 0) {	200	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_ENUMSTD, &standard) < 0) {
201	if (errno == EINVAL \|\| errno == ENOTTY)	201	if (errno == EINVAL \|\| errno == ENOTTY)
202	break; /* end of enumeration */	202	break; /* end of enumeration */
203	else {	203	else {
Lines 242-248 gst_v4l2_fill_lists (GstV4l2Object * v4l Link Here
242	}	242	}
243		243
244	control.id = n;	244	control.id = n;
245	if (ioctl (v4l2object->video_fd, VIDIOC_QUERYCTRL, &control) < 0) {	245	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYCTRL, &control) < 0) {
246	if (errno == EINVAL) {	246	if (errno == EINVAL) {
247	if (n < V4L2_CID_PRIVATE_BASE)	247	if (n < V4L2_CID_PRIVATE_BASE)
248	/* continue so that we also check private controls */	248	/* continue so that we also check private controls */
Lines 323-329 gst_v4l2_fill_lists (GstV4l2Object * v4l Link Here
323	menu.id = n;	323	menu.id = n;
324	for (i = 0;; i++) {	324	for (i = 0;; i++) {
325	menu.index = i;	325	menu.index = i;
326	if (ioctl (v4l2object->video_fd, VIDIOC_QUERYMENU, &menu) < 0) {	326	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYMENU, &menu) < 0) {
327	if (errno == EINVAL)	327	if (errno == EINVAL)
328	break; /* end of enumeration */	328	break; /* end of enumeration */
329	else {	329	else {
Lines 398-403 gboolean Link Here
398	gst_v4l2_open (GstV4l2Object * v4l2object)	398	gst_v4l2_open (GstV4l2Object * v4l2object)
399	{	399	{
400	struct stat st;	400	struct stat st;
		401	int libv4l2_fd;
401		402
402	GST_DEBUG_OBJECT (v4l2object->element, "Trying to open device %s",	403	GST_DEBUG_OBJECT (v4l2object->element, "Trying to open device %s",
403	v4l2object->videodev);	404	v4l2object->videodev);
Lines 423-428 gst_v4l2_open (GstV4l2Object * v4l2objec Link Here
423	if (!GST_V4L2_IS_OPEN (v4l2object))	424	if (!GST_V4L2_IS_OPEN (v4l2object))
424	goto not_open;	425	goto not_open;
425		426
		427	libv4l2_fd = v4l2_fd_open(v4l2object->video_fd,
		428	V4L2_ENABLE_ENUM_FMT_EMULATION);
		429	/* Note the v4l2_xxx functions are designed so that if they get passed an
		430	unknown fd, the will behave exactly as their regular xxx counterparts, so
		431	if v4l2_fd_open fails, we continue as normal (missing the libv4l2 custom
		432	cam format to normal formats conversion). Chances are big we will still
		433	fail then though, as normally v4l2_fd_open only fails if the device is not
		434	a v4l2 device. */
		435	if (libv4l2_fd != -1)
		436	v4l2object->video_fd = libv4l2_fd;
		437
426	/* get capabilities, error will be posted */	438	/* get capabilities, error will be posted */
427	if (!gst_v4l2_get_capabilities (v4l2object))	439	if (!gst_v4l2_get_capabilities (v4l2object))
428	goto error;	440	goto error;
Lines 476-482 error: Link Here
476	{	488	{
477	if (GST_V4L2_IS_OPEN (v4l2object)) {	489	if (GST_V4L2_IS_OPEN (v4l2object)) {
478	/* close device */	490	/* close device */
479	close (v4l2object->video_fd);	491	v4l2_close (v4l2object->video_fd);
480	v4l2object->video_fd = -1;	492	v4l2object->video_fd = -1;
481	}	493	}
482	/* empty lists */	494	/* empty lists */
Lines 502-508 gst_v4l2_close (GstV4l2Object * v4l2obje Link Here
502	GST_V4L2_CHECK_NOT_ACTIVE (v4l2object);	514	GST_V4L2_CHECK_NOT_ACTIVE (v4l2object);
503		515
504	/* close device */	516	/* close device */
505	close (v4l2object->video_fd);	517	v4l2_close (v4l2object->video_fd);
506	v4l2object->video_fd = -1;	518	v4l2object->video_fd = -1;
507		519
508	/* empty lists */	520	/* empty lists */
Lines 525-531 gst_v4l2_get_norm (GstV4l2Object * v4l2o Link Here
525	if (!GST_V4L2_IS_OPEN (v4l2object))	537	if (!GST_V4L2_IS_OPEN (v4l2object))
526	return FALSE;	538	return FALSE;
527		539
528	if (ioctl (v4l2object->video_fd, VIDIOC_G_STD, norm) < 0)	540	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_STD, norm) < 0)
529	goto std_failed;	541	goto std_failed;
530		542
531	return TRUE;	543	return TRUE;
Lines 553-559 gst_v4l2_set_norm (GstV4l2Object * v4l2o Link Here
553	if (!GST_V4L2_IS_OPEN (v4l2object))	565	if (!GST_V4L2_IS_OPEN (v4l2object))
554	return FALSE;	566	return FALSE;
555		567
556	if (ioctl (v4l2object->video_fd, VIDIOC_S_STD, &norm) < 0)	568	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_STD, &norm) < 0)
557	goto std_failed;	569	goto std_failed;
558		570
559	return TRUE;	571	return TRUE;
Lines 589-595 gst_v4l2_get_frequency (GstV4l2Object * Link Here
589	channel = gst_tuner_get_channel (GST_TUNER (v4l2object->element));	601	channel = gst_tuner_get_channel (GST_TUNER (v4l2object->element));
590		602
591	freq.tuner = tunernum;	603	freq.tuner = tunernum;
592	if (ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq) < 0)	604	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq) < 0)
593	goto freq_failed;	605	goto freq_failed;
594		606
595	frequency = freq.frequency channel->freq_multiplicator;	607	frequency = freq.frequency channel->freq_multiplicator;
Lines 630-639 gst_v4l2_set_frequency (GstV4l2Object * Link Here
630		642
631	freq.tuner = tunernum;	643	freq.tuner = tunernum;
632	/* fill in type - ignore error */	644	/* fill in type - ignore error */
633	ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq);	645	v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_FREQUENCY, &freq);
634	freq.frequency = frequency / channel->freq_multiplicator;	646	freq.frequency = frequency / channel->freq_multiplicator;
635		647
636	if (ioctl (v4l2object->video_fd, VIDIOC_S_FREQUENCY, &freq) < 0)	648	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_FREQUENCY, &freq) < 0)
637	goto freq_failed;	649	goto freq_failed;
638		650
639	return TRUE;	651	return TRUE;
Lines 665-671 gst_v4l2_signal_strength (GstV4l2Object Link Here
665	return FALSE;	677	return FALSE;
666		678
667	tuner.index = tunernum;	679	tuner.index = tunernum;
668	if (ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &tuner) < 0)	680	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &tuner) < 0)
669	goto tuner_failed;	681	goto tuner_failed;
670		682
671	*signal_strength = tuner.signal;	683	*signal_strength = tuner.signal;
Lines 701-707 gst_v4l2_get_attribute (GstV4l2Object * Link Here
701		713
702	control.id = attribute_num;	714	control.id = attribute_num;
703		715
704	if (ioctl (v4l2object->video_fd, VIDIOC_G_CTRL, &control) < 0)	716	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_CTRL, &control) < 0)
705	goto ctrl_failed;	717	goto ctrl_failed;
706		718
707	*value = control.value;	719	*value = control.value;
Lines 738-744 gst_v4l2_set_attribute (GstV4l2Object * Link Here
738		750
739	control.id = attribute_num;	751	control.id = attribute_num;
740	control.value = value;	752	control.value = value;
741	if (ioctl (v4l2object->video_fd, VIDIOC_S_CTRL, &control) < 0)	753	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_CTRL, &control) < 0)
742	goto ctrl_failed;	754	goto ctrl_failed;
743		755
744	return TRUE;	756	return TRUE;
Lines 763-769 gst_v4l2_get_input (GstV4l2Object * v4l2 Link Here
763	if (!GST_V4L2_IS_OPEN (v4l2object))	775	if (!GST_V4L2_IS_OPEN (v4l2object))
764	return FALSE;	776	return FALSE;
765		777
766	if (ioctl (v4l2object->video_fd, VIDIOC_G_INPUT, &n) < 0)	778	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_INPUT, &n) < 0)
767	goto input_failed;	779	goto input_failed;
768		780
769	*input = n;	781	*input = n;
Lines 789-795 gst_v4l2_set_input (GstV4l2Object * v4l2 Link Here
789	if (!GST_V4L2_IS_OPEN (v4l2object))	801	if (!GST_V4L2_IS_OPEN (v4l2object))
790	return FALSE;	802	return FALSE;
791		803
792	if (ioctl (v4l2object->video_fd, VIDIOC_S_INPUT, &input) < 0)	804	if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_S_INPUT, &input) < 0)
793	goto input_failed;	805	goto input_failed;
794		806
795	return TRUE;	807	return TRUE;

Lines 319-324 LIBOIL_CFLAGS = @LIBOIL_CFLAGS@ Link Here

(-)sys/v4l2/Makefile.in~ (-2 / +6 lines)
319	LIBOIL_LIBS = @LIBOIL_LIBS@	319	LIBOIL_LIBS = @LIBOIL_LIBS@
320	LIBPNG_CFLAGS = @LIBPNG_CFLAGS@	320	LIBPNG_CFLAGS = @LIBPNG_CFLAGS@
321	LIBPNG_LIBS = @LIBPNG_LIBS@	321	LIBPNG_LIBS = @LIBPNG_LIBS@
		322	LIBV4L2_CFLAGS =
		323	LIBV4L2_LIBS = -lv4l2 -lv4lconvert
322	LIBS = @LIBS@	324	LIBS = @LIBS@
323	LIBTOOL = @LIBTOOL@	325	LIBTOOL = @LIBTOOL@
324	LN_S = @LN_S@	326	LN_S = @LN_S@
Lines 615-628 libgstvideo4linux2_la_SOURCES = gstv4l2. Link Here
615	libgstvideo4linux2_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) \	615	libgstvideo4linux2_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) \
616	$(GST_BASE_CFLAGS) \	616	$(GST_BASE_CFLAGS) \
617	$(GST_CFLAGS) \	617	$(GST_CFLAGS) \
618	$(X_CFLAGS)	618	$(X_CFLAGS) \
		619	$(LIBV4L2_CFLAGS)
619		620
620	libgstvideo4linux2_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)	621	libgstvideo4linux2_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
621	libgstvideo4linux2_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) \	622	libgstvideo4linux2_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) \
622	$(GST_BASE_LIBS) \	623	$(GST_BASE_LIBS) \
623	-lgstinterfaces-$(GST_MAJORMINOR) \	624	-lgstinterfaces-$(GST_MAJORMINOR) \
624	$(GST_LIBS) \	625	$(GST_LIBS) \
625	$(xv_libs)	626	$(xv_libs) \
		627	$(LIBV4L2_LIBS)
626		628
627	noinst_HEADERS = gstv4l2object.h v4l2_calls.h \	629	noinst_HEADERS = gstv4l2object.h v4l2_calls.h \
628	gstv4l2src.h v4l2src_calls.h \	630	gstv4l2src.h v4l2src_calls.h \

Lines 88-94 gst_v4l2_buffer_finalize (GstV4l2Buffer Link Here

(-)sys/v4l2/v4l2src_calls.c.libv4l (-25 / +25 lines)
88	pool->num_live_buffers--;	88	pool->num_live_buffers--;
89		89
90	if (pool->running) {	90	if (pool->running) {
91	if (ioctl (pool->video_fd, VIDIOC_QBUF, &buffer->vbuffer) < 0) {	91	if (v4l2_ioctl (pool->video_fd, VIDIOC_QBUF, &buffer->vbuffer) < 0) {
92	GST_WARNING ("could not requeue buffer %p %d", buffer, index);	92	GST_WARNING ("could not requeue buffer %p %d", buffer, index);
93	} else {	93	} else {
94	/* FIXME: check that the caps didn't change */	94	/* FIXME: check that the caps didn't change */
Lines 106-112 gst_v4l2_buffer_finalize (GstV4l2Buffer Link Here
106	if (!resuscitated) {	106	if (!resuscitated) {
107	GST_LOG ("buffer %p not recovered, unmapping", buffer);	107	GST_LOG ("buffer %p not recovered, unmapping", buffer);
108	gst_mini_object_unref (GST_MINI_OBJECT (pool));	108	gst_mini_object_unref (GST_MINI_OBJECT (pool));
109	munmap ((void *) GST_BUFFER_DATA (buffer), buffer->vbuffer.length);	109	v4l2_munmap ((void *) GST_BUFFER_DATA (buffer), buffer->vbuffer.length);
110		110
111	GST_MINI_OBJECT_CLASS (v4l2buffer_parent_class)->finalize (GST_MINI_OBJECT	111	GST_MINI_OBJECT_CLASS (v4l2buffer_parent_class)->finalize (GST_MINI_OBJECT
112	(buffer));	112	(buffer));
Lines 165-171 gst_v4l2_buffer_new (GstV4l2BufferPool * Link Here
165	ret->vbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	165	ret->vbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
166	ret->vbuffer.memory = V4L2_MEMORY_MMAP;	166	ret->vbuffer.memory = V4L2_MEMORY_MMAP;
167		167
168	if (ioctl (pool->video_fd, VIDIOC_QUERYBUF, &ret->vbuffer) < 0)	168	if (v4l2_ioctl (pool->video_fd, VIDIOC_QUERYBUF, &ret->vbuffer) < 0)
169	goto querybuf_failed;	169	goto querybuf_failed;
170		170
171	GST_LOG (" index: %u", ret->vbuffer.index);	171	GST_LOG (" index: %u", ret->vbuffer.index);
Lines 179-185 gst_v4l2_buffer_new (GstV4l2BufferPool * Link Here
179	GST_LOG (" length: %u", ret->vbuffer.length);	179	GST_LOG (" length: %u", ret->vbuffer.length);
180	GST_LOG (" input: %u", ret->vbuffer.input);	180	GST_LOG (" input: %u", ret->vbuffer.input);
181		181
182	data = (guint8 *) mmap (0, ret->vbuffer.length,	182	data = (guint8 *) v4l2_mmap (0, ret->vbuffer.length,
183	PROT_READ \| PROT_WRITE, MAP_SHARED, pool->video_fd,	183	PROT_READ \| PROT_WRITE, MAP_SHARED, pool->video_fd,
184	ret->vbuffer.m.offset);	184	ret->vbuffer.m.offset);
185		185
Lines 229-235 gst_v4l2_buffer_pool_finalize (GstV4l2Bu Link Here
229	pool->lock = NULL;	229	pool->lock = NULL;
230		230
231	if (pool->video_fd >= 0)	231	if (pool->video_fd >= 0)
232	close (pool->video_fd);	232	v4l2_close (pool->video_fd);
233		233
234	if (pool->buffers) {	234	if (pool->buffers) {
235	g_free (pool->buffers);	235	g_free (pool->buffers);
Lines 292-298 gst_v4l2_buffer_pool_new (GstV4l2Src * v Link Here
292		292
293	pool = (GstV4l2BufferPool *) gst_mini_object_new (GST_TYPE_V4L2_BUFFER_POOL);	293	pool = (GstV4l2BufferPool *) gst_mini_object_new (GST_TYPE_V4L2_BUFFER_POOL);
294		294
295	pool->video_fd = dup (fd);	295	pool->video_fd = v4l2_dup (fd);
296	if (pool->video_fd < 0)	296	if (pool->video_fd < 0)
297	goto dup_failed;	297	goto dup_failed;
298		298
Lines 344-350 gst_v4l2_buffer_pool_activate (GstV4l2Bu Link Here
344		344
345	GST_LOG ("enqueue pool buffer %d", n);	345	GST_LOG ("enqueue pool buffer %d", n);
346		346
347	if (ioctl (pool->video_fd, VIDIOC_QBUF, buf) < 0)	347	if (v4l2_ioctl (pool->video_fd, VIDIOC_QBUF, buf) < 0)
348	goto queue_failed;	348	goto queue_failed;
349	}	349	}
350	pool->running = TRUE;	350	pool->running = TRUE;
Lines 519-525 gst_v4l2src_fill_format_list (GstV4l2Src Link Here
519	format->index = n;	519	format->index = n;
520	format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	520	format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
521		521
522	if (ioctl (v4l2src->v4l2object->video_fd, VIDIOC_ENUM_FMT, format) < 0) {	522	if (v4l2_ioctl (v4l2src->v4l2object->video_fd, VIDIOC_ENUM_FMT, format) < 0) {
523	if (errno == EINVAL) {	523	if (errno == EINVAL) {
524	g_free (format);	524	g_free (format);
525	break; /* end of enumeration */	525	break; /* end of enumeration */
Lines 595-601 gst_v4l2src_probe_caps_for_format_and_si Link Here
595		595
596	/* keep in mind that v4l2 gives us frame intervals (durations); we invert the	596	/* keep in mind that v4l2 gives us frame intervals (durations); we invert the
597	* fraction to get framerate */	597	* fraction to get framerate */
598	if (ioctl (fd, VIDIOC_ENUM_FRAMEINTERVALS, &ival) < 0)	598	if (v4l2_ioctl (fd, VIDIOC_ENUM_FRAMEINTERVALS, &ival) < 0)
599	goto enum_frameintervals_failed;	599	goto enum_frameintervals_failed;
600		600
601	if (ival.type == V4L2_FRMIVAL_TYPE_DISCRETE) {	601	if (ival.type == V4L2_FRMIVAL_TYPE_DISCRETE) {
Lines 621-627 gst_v4l2src_probe_caps_for_format_and_si Link Here
621	gst_value_list_append_value (&rates, &rate);	621	gst_value_list_append_value (&rates, &rate);
622		622
623	ival.index++;	623	ival.index++;
624	} while (ioctl (fd, VIDIOC_ENUM_FRAMEINTERVALS, &ival) >= 0);	624	} while (v4l2_ioctl (fd, VIDIOC_ENUM_FRAMEINTERVALS, &ival) >= 0);
625	} else if (ival.type == V4L2_FRMIVAL_TYPE_STEPWISE) {	625	} else if (ival.type == V4L2_FRMIVAL_TYPE_STEPWISE) {
626	GValue min = { 0, };	626	GValue min = { 0, };
627	GValue step = { 0, };	627	GValue step = { 0, };
Lines 782-788 gst_v4l2src_probe_caps_for_format (GstV4 Link Here
782		782
783	GST_DEBUG_OBJECT (v4l2src, "Enumerating frame sizes");	783	GST_DEBUG_OBJECT (v4l2src, "Enumerating frame sizes");
784		784
785	if (ioctl (fd, VIDIOC_ENUM_FRAMESIZES, &size) < 0)	785	if (v4l2_ioctl (fd, VIDIOC_ENUM_FRAMESIZES, &size) < 0)
786	goto enum_framesizes_failed;	786	goto enum_framesizes_failed;
787		787
788	if (size.type == V4L2_FRMSIZE_TYPE_DISCRETE) {	788	if (size.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
Lines 802-808 gst_v4l2src_probe_caps_for_format (GstV4 Link Here
802	results = g_list_prepend (results, tmp);	802	results = g_list_prepend (results, tmp);
803		803
804	size.index++;	804	size.index++;
805	} while (ioctl (fd, VIDIOC_ENUM_FRAMESIZES, &size) >= 0);	805	} while (v4l2_ioctl (fd, VIDIOC_ENUM_FRAMESIZES, &size) >= 0);
806	GST_DEBUG_OBJECT (v4l2src, "done iterating discrete frame sizes");	806	GST_DEBUG_OBJECT (v4l2src, "done iterating discrete frame sizes");
807	} else if (size.type == V4L2_FRMSIZE_TYPE_STEPWISE) {	807	} else if (size.type == V4L2_FRMSIZE_TYPE_STEPWISE) {
808	GST_DEBUG_OBJECT (v4l2src, "we have stepwise frame sizes:");	808	GST_DEBUG_OBJECT (v4l2src, "we have stepwise frame sizes:");
Lines 972-978 gst_v4l2src_grab_frame (GstV4l2Src * v4l Link Here
972	buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	972	buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
973	buffer.memory = V4L2_MEMORY_MMAP;	973	buffer.memory = V4L2_MEMORY_MMAP;
974		974
975	while (ioctl (v4l2src->v4l2object->video_fd, VIDIOC_DQBUF, &buffer) < 0) {	975	while (v4l2_ioctl (v4l2src->v4l2object->video_fd, VIDIOC_DQBUF, &buffer) < 0) {
976		976
977	GST_WARNING_OBJECT (v4l2src,	977	GST_WARNING_OBJECT (v4l2src,
978	"problem grabbing frame %d (ix=%d), trials=%d, pool-ct=%d, buf.flags=%d",	978	"problem grabbing frame %d (ix=%d), trials=%d, pool-ct=%d, buf.flags=%d",
Lines 1190-1196 gst_v4l2src_set_capture (GstV4l2Src * v4 Link Here
1190	memset (&format, 0x00, sizeof (struct v4l2_format));	1190	memset (&format, 0x00, sizeof (struct v4l2_format));
1191	format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	1191	format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1192		1192
1193	if (ioctl (fd, VIDIOC_G_FMT, &format) < 0)	1193	if (v4l2_ioctl (fd, VIDIOC_G_FMT, &format) < 0)
1194	goto get_fmt_failed;	1194	goto get_fmt_failed;
1195		1195
1196	format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	1196	format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
Lines 1202-1208 gst_v4l2src_set_capture (GstV4l2Src * v4 Link Here
1202	* combined, there are other modes for requesting fields individually) */	1202	* combined, there are other modes for requesting fields individually) */
1203	format.fmt.pix.field = V4L2_FIELD_INTERLACED;	1203	format.fmt.pix.field = V4L2_FIELD_INTERLACED;
1204		1204
1205	if (ioctl (fd, VIDIOC_S_FMT, &format) < 0) {	1205	if (v4l2_ioctl (fd, VIDIOC_S_FMT, &format) < 0) {
1206	if (errno != EINVAL)	1206	if (errno != EINVAL)
1207	goto set_fmt_failed;	1207	goto set_fmt_failed;
1208		1208
Lines 1211-1217 gst_v4l2src_set_capture (GstV4l2Src * v4 Link Here
1211	format.fmt.pix.height = height;	1211	format.fmt.pix.height = height;
1212	format.fmt.pix.pixelformat = pixelformat;	1212	format.fmt.pix.pixelformat = pixelformat;
1213	format.fmt.pix.field = V4L2_FIELD_NONE;	1213	format.fmt.pix.field = V4L2_FIELD_NONE;
1214	if (ioctl (fd, VIDIOC_S_FMT, &format) < 0)	1214	if (v4l2_ioctl (fd, VIDIOC_S_FMT, &format) < 0)
1215	goto set_fmt_failed;	1215	goto set_fmt_failed;
1216	}	1216	}
1217		1217
Lines 1226-1232 gst_v4l2src_set_capture (GstV4l2Src * v4 Link Here
1226		1226
1227	memset (&stream, 0x00, sizeof (struct v4l2_streamparm));	1227	memset (&stream, 0x00, sizeof (struct v4l2_streamparm));
1228	stream.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	1228	stream.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1229	if (ioctl (fd, VIDIOC_G_PARM, &stream) < 0) {	1229	if (v4l2_ioctl (fd, VIDIOC_G_PARM, &stream) < 0) {
1230	GST_ELEMENT_WARNING (v4l2src, RESOURCE, SETTINGS,	1230	GST_ELEMENT_WARNING (v4l2src, RESOURCE, SETTINGS,
1231	(_("Could not get parameters on device '%s'"),	1231	(_("Could not get parameters on device '%s'"),
1232	v4l2src->v4l2object->videodev), GST_ERROR_SYSTEM);	1232	v4l2src->v4l2object->videodev), GST_ERROR_SYSTEM);
Lines 1256-1262 gst_v4l2src_set_capture (GstV4l2Src * v4 Link Here
1256	stream.parm.capture.timeperframe.denominator = fps_n;	1256	stream.parm.capture.timeperframe.denominator = fps_n;
1257		1257
1258	/* some cheap USB cam's won't accept any change */	1258	/* some cheap USB cam's won't accept any change */
1259	if (ioctl (fd, VIDIOC_S_PARM, &stream) < 0) {	1259	if (v4l2_ioctl (fd, VIDIOC_S_PARM, &stream) < 0) {
1260	GST_ELEMENT_WARNING (v4l2src, RESOURCE, SETTINGS,	1260	GST_ELEMENT_WARNING (v4l2src, RESOURCE, SETTINGS,
1261	(_("Video input device did not accept new frame rate setting.")),	1261	(_("Video input device did not accept new frame rate setting.")),
1262	GST_ERROR_SYSTEM);	1262	GST_ERROR_SYSTEM);
Lines 1338-1344 gst_v4l2src_capture_init (GstV4l2Src * v Link Here
1338	breq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;	1338	breq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1339	breq.memory = V4L2_MEMORY_MMAP;	1339	breq.memory = V4L2_MEMORY_MMAP;
1340		1340
1341	if (ioctl (fd, VIDIOC_REQBUFS, &breq) < 0)	1341	if (v4l2_ioctl (fd, VIDIOC_REQBUFS, &breq) < 0)
1342	goto reqbufs_failed;	1342	goto reqbufs_failed;
1343		1343
1344	GST_LOG_OBJECT (v4l2src, " count: %u", breq.count);	1344	GST_LOG_OBJECT (v4l2src, " count: %u", breq.count);
Lines 1433-1439 gst_v4l2src_capture_start (GstV4l2Src * Link Here
1433	if (!gst_v4l2_buffer_pool_activate (v4l2src->pool, v4l2src))	1433	if (!gst_v4l2_buffer_pool_activate (v4l2src->pool, v4l2src))
1434	goto pool_activate_failed;	1434	goto pool_activate_failed;
1435		1435
1436	if (ioctl (fd, VIDIOC_STREAMON, &type) < 0)	1436	if (v4l2_ioctl (fd, VIDIOC_STREAMON, &type) < 0)
1437	goto streamon_failed;	1437	goto streamon_failed;
1438	}	1438	}
1439		1439
Lines 1478-1484 gst_v4l2src_capture_stop (GstV4l2Src * v Link Here
1478	if (v4l2src->use_mmap) {	1478	if (v4l2src->use_mmap) {
1479	/* we actually need to sync on all queued buffers but not	1479	/* we actually need to sync on all queued buffers but not
1480	* on the non-queued ones */	1480	* on the non-queued ones */
1481	if (ioctl (v4l2src->v4l2object->video_fd, VIDIOC_STREAMOFF, &type) < 0)	1481	if (v4l2_ioctl (v4l2src->v4l2object->video_fd, VIDIOC_STREAMOFF, &type) < 0)
1482	goto streamoff_failed;	1482	goto streamoff_failed;
1483	}	1483	}
1484		1484
Lines 1554-1567 gst_v4l2src_get_nearest_size (GstV4l2Src Link Here
1554	fmt.fmt.pix.pixelformat = pixelformat;	1554	fmt.fmt.pix.pixelformat = pixelformat;
1555	fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;	1555	fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
1556		1556
1557	r = ioctl (fd, VIDIOC_TRY_FMT, &fmt);	1557	r = v4l2_ioctl (fd, VIDIOC_TRY_FMT, &fmt);
1558	if (r < 0 && errno == EINVAL) {	1558	if (r < 0 && errno == EINVAL) {
1559	/* try again with progressive video */	1559	/* try again with progressive video */
1560	fmt.fmt.pix.width = *width;	1560	fmt.fmt.pix.width = *width;
1561	fmt.fmt.pix.height = *height;	1561	fmt.fmt.pix.height = *height;
1562	fmt.fmt.pix.pixelformat = pixelformat;	1562	fmt.fmt.pix.pixelformat = pixelformat;
1563	fmt.fmt.pix.field = V4L2_FIELD_NONE;	1563	fmt.fmt.pix.field = V4L2_FIELD_NONE;
1564	r = ioctl (fd, VIDIOC_TRY_FMT, &fmt);	1564	r = v4l2_ioctl (fd, VIDIOC_TRY_FMT, &fmt);
1565	}	1565	}
1566		1566
1567	if (r < 0) {	1567	if (r < 0) {
Lines 1581-1594 gst_v4l2src_get_nearest_size (GstV4l2Src Link Here
1581	fmt.fmt.pix.width = *width;	1581	fmt.fmt.pix.width = *width;
1582	fmt.fmt.pix.height = *height;	1582	fmt.fmt.pix.height = *height;
1583		1583
1584	r = ioctl (fd, VIDIOC_S_FMT, &fmt);	1584	r = v4l2_ioctl (fd, VIDIOC_S_FMT, &fmt);
1585	if (r < 0 && errno == EINVAL) {	1585	if (r < 0 && errno == EINVAL) {
1586	/* try again with progressive video */	1586	/* try again with progressive video */
1587	fmt.fmt.pix.width = *width;	1587	fmt.fmt.pix.width = *width;
1588	fmt.fmt.pix.height = *height;	1588	fmt.fmt.pix.height = *height;
1589	fmt.fmt.pix.pixelformat = pixelformat;	1589	fmt.fmt.pix.pixelformat = pixelformat;
1590	fmt.fmt.pix.field = V4L2_FIELD_NONE;	1590	fmt.fmt.pix.field = V4L2_FIELD_NONE;
1591	r = ioctl (fd, VIDIOC_S_FMT, &fmt);	1591	r = v4l2_ioctl (fd, VIDIOC_S_FMT, &fmt);
1592	}	1592	}
1593		1593
1594	if (r < 0)	1594	if (r < 0)

Lines 22-36 libgstvideo4linux2_la_SOURCES = gstv4l2. Link Here

(-)sys/v4l2/Makefile.am (-3 / +5 lines)
22	libgstvideo4linux2_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) \	22	libgstvideo4linux2_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) \
23	$(GST_BASE_CFLAGS) \	23	$(GST_BASE_CFLAGS) \
24	$(GST_CFLAGS) \	24	$(GST_CFLAGS) \
25	$(X_CFLAGS)	25	$(X_CFLAGS) \
26		26	$(LIBV4L2_CFLAGS)
		27
27	libgstvideo4linux2_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)	28	libgstvideo4linux2_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
28		29
29	libgstvideo4linux2_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) \	30	libgstvideo4linux2_la_LIBADD = $(GST_PLUGINS_BASE_LIBS) \
30	$(GST_BASE_LIBS) \	31	$(GST_BASE_LIBS) \
31	-lgstinterfaces-$(GST_MAJORMINOR) \	32	-lgstinterfaces-$(GST_MAJORMINOR) \
32	$(GST_LIBS) \	33	$(GST_LIBS) \
33	$(xv_libs)	34	$(xv_libs) \
		35	$(LIBV4L2_LIBS)
34		36
35	noinst_HEADERS = gstv4l2object.h v4l2_calls.h \	37	noinst_HEADERS = gstv4l2object.h v4l2_calls.h \
36	gstv4l2src.h v4l2src_calls.h \	38	gstv4l2src.h v4l2src_calls.h \

Lines 27-32 Link Here

(-)sys/v4l2/v4l2_calls.h (+11 lines)
27	#include "gstv4l2object.h"	27	#include "gstv4l2object.h"
28	#include "gst/gst-i18n-plugin.h"	28	#include "gst/gst-i18n-plugin.h"
29		29
		30	#ifdef HAVE_LIBV4L2
		31	#include <libv4l2.h>
		32	#else
		33	#define v4l2_fd_open(fd, flags) (fd)
		34	#define v4l2_close close
		35	#define v4l2_dup dup
		36	#define v4l2_ioctl ioctl
		37	#define v4l2_read read
		38	#define v4l2_mmap mmap
		39	#define v4l2_munmap munmap
		40	#endif
30		41
31	/* simple check whether the device is open */	42	/* simple check whether the device is open */
32	#define GST_V4L2_IS_OPEN(v4l2object) \	43	#define GST_V4L2_IS_OPEN(v4l2object) \