Add capture_exampe from V4L2 API spec Draft 0.20

From: Mauro Carvalho Chehab <mchehab@infradead.org>

V4L2 Draft spec have an interesting capture example code. Added it to the tree
to allow testing V4L2 devices.

Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

2 files changed, 674 insertions, 1 deletions

diff --git a/v4l2-apps/test/Makefile b/v4l2-apps/test/Makefile
index 6c1edf6a5..48b9643f8 100644
--- a/v4l2-apps/test/Makefile
+++ b/v4l2-apps/test/Makefile
@@ -7,7 +7,8 @@ binaries = ioctl-test 		\
 	   sliced-vbi-detect 	\
 	   vbi-test 		\
 	   v4lgrab		\
-	   driver-test
+	   driver-test		\
+	   capture_example
 
 .PHONY: all clean install
 
diff --git a/v4l2-apps/test/capture_example.c b/v4l2-apps/test/capture_example.c
new file mode 100644
index 000000000..fda252b61
--- /dev/null
+++ b/v4l2-apps/test/capture_example.c
@@ -0,0 +1,672 @@
+/*
+ *  V4L2 video capture example
+ *
+ *  This program can be used and distributed without restrictions.
+ *
+ *	This program were got from V4L2 API, Draft 0.20
+ *		available at: http://v4l2spec.bytesex.org/
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include <getopt.h>             /* getopt_long() */
+
+#include <fcntl.h>              /* low-level i/o */
+#include <unistd.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+
+#include <asm/types.h>          /* for videodev2.h */
+
+#include <linux/videodev2.h>
+
+#define CLEAR(x) memset (&(x), 0, sizeof (x))
+
+typedef enum {
+	IO_METHOD_READ,
+	IO_METHOD_MMAP,
+	IO_METHOD_USERPTR,
+} io_method;
+
+struct buffer {
+	void *                  start;
+	size_t                  length;
+};
+
+static char *           dev_name        = NULL;
+static io_method        io              = IO_METHOD_MMAP;
+static int              fd              = -1;
+struct buffer *         buffers         = NULL;
+static unsigned int     n_buffers       = 0;
+
+static void
+errno_exit                      (const char *           s)
+{
+	fprintf (stderr, "%s error %d, %s\n",
+		 s, errno, strerror (errno));
+
+	exit (EXIT_FAILURE);
+}
+
+static int
+xioctl                          (int                    fd,
+				 int                    request,
+				 void *                 arg)
+{
+	int r;
+
+	do r = ioctl (fd, request, arg);
+	while (-1 == r && EINTR == errno);
+
+	return r;
+}
+
+static void
+process_image                   (const void *           p)
+{
+	fputc ('.', stdout);
+	fflush (stdout);
+}
+
+static int
+read_frame                      (void)
+{
+	struct v4l2_buffer buf;
+	unsigned int i;
+
+	switch (io) {
+	case IO_METHOD_READ:
+		if (-1 == read (fd, buffers[0].start, buffers[0].length)) {
+			switch (errno) {
+			case EAGAIN:
+				return 0;
+
+			case EIO:
+				/* Could ignore EIO, see spec. */
+
+				/* fall through */
+
+			default:
+				errno_exit ("read");
+			}
+		}
+
+		process_image (buffers[0].start);
+
+		break;
+
+	case IO_METHOD_MMAP:
+		CLEAR (buf);
+
+		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+		buf.memory = V4L2_MEMORY_MMAP;
+
+		if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
+			switch (errno) {
+			case EAGAIN:
+				return 0;
+
+			case EIO:
+				/* Could ignore EIO, see spec. */
+
+				/* fall through */
+
+			default:
+				errno_exit ("VIDIOC_DQBUF");
+			}
+		}
+
+		assert (buf.index < n_buffers);
+
+		process_image (buffers[buf.index].start);
+
+		if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
+			errno_exit ("VIDIOC_QBUF");
+
+		break;
+
+	case IO_METHOD_USERPTR:
+		CLEAR (buf);
+
+		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+		buf.memory = V4L2_MEMORY_USERPTR;
+
+		if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
+			switch (errno) {
+			case EAGAIN:
+				return 0;
+
+			case EIO:
+				/* Could ignore EIO, see spec. */
+
+				/* fall through */
+
+			default:
+				errno_exit ("VIDIOC_DQBUF");
+			}
+		}
+
+		for (i = 0; i < n_buffers; ++i)
+			if (buf.m.userptr == (unsigned long) buffers[i].start
+			    && buf.length == buffers[i].length)
+				break;
+
+		assert (i < n_buffers);
+
+		process_image ((void *) buf.m.userptr);
+
+		if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
+			errno_exit ("VIDIOC_QBUF");
+
+		break;
+	}
+
+	return 1;
+}
+
+static void
+mainloop                        (void)
+{
+	unsigned int count;
+
+	count = 100;
+
+	while (count-- > 0) {
+		for (;;) {
+			fd_set fds;
+			struct timeval tv;
+			int r;
+
+			FD_ZERO (&fds);
+			FD_SET (fd, &fds);
+
+			/* Timeout. */
+			tv.tv_sec = 2;
+			tv.tv_usec = 0;
+
+			r = select (fd + 1, &fds, NULL, NULL, &tv);
+
+			if (-1 == r) {
+				if (EINTR == errno)
+					continue;
+
+				errno_exit ("select");
+			}
+
+			if (0 == r) {
+				fprintf (stderr, "select timeout\n");
+				exit (EXIT_FAILURE);
+			}
+
+			if (read_frame ())
+				break;
+
+			/* EAGAIN - continue select loop. */
+		}
+	}
+}
+
+static void
+stop_capturing                  (void)
+{
+	enum v4l2_buf_type type;
+
+	switch (io) {
+	case IO_METHOD_READ:
+		/* Nothing to do. */
+		break;
+
+	case IO_METHOD_MMAP:
+	case IO_METHOD_USERPTR:
+		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+		if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type))
+			errno_exit ("VIDIOC_STREAMOFF");
+
+		break;
+	}
+}
+
+static void
+start_capturing                 (void)
+{
+	unsigned int i;
+	enum v4l2_buf_type type;
+
+	switch (io) {
+	case IO_METHOD_READ:
+		/* Nothing to do. */
+		break;
+
+	case IO_METHOD_MMAP:
+		for (i = 0; i < n_buffers; ++i) {
+			struct v4l2_buffer buf;
+
+			CLEAR (buf);
+
+			buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+			buf.memory      = V4L2_MEMORY_MMAP;
+			buf.index       = i;
+
+			if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
+				errno_exit ("VIDIOC_QBUF");
+		}
+
+		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+		if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
+			errno_exit ("VIDIOC_STREAMON");
+
+		break;
+
+	case IO_METHOD_USERPTR:
+		for (i = 0; i < n_buffers; ++i) {
+			struct v4l2_buffer buf;
+
+			CLEAR (buf);
+
+			buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+			buf.memory      = V4L2_MEMORY_USERPTR;
+			buf.index       = i;
+			buf.m.userptr   = (unsigned long) buffers[i].start;
+			buf.length      = buffers[i].length;
+
+			if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
+				errno_exit ("VIDIOC_QBUF");
+		}
+
+		type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+		if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
+			errno_exit ("VIDIOC_STREAMON");
+
+		break;
+	}
+}
+
+static void
+uninit_device                   (void)
+{
+	unsigned int i;
+
+	switch (io) {
+	case IO_METHOD_READ:
+		free (buffers[0].start);
+		break;
+
+	case IO_METHOD_MMAP:
+		for (i = 0; i < n_buffers; ++i)
+			if (-1 == munmap (buffers[i].start, buffers[i].length))
+				errno_exit ("munmap");
+		break;
+
+	case IO_METHOD_USERPTR:
+		for (i = 0; i < n_buffers; ++i)
+			free (buffers[i].start);
+		break;
+	}
+
+	free (buffers);
+}
+
+static void
+init_read                       (unsigned int           buffer_size)
+{
+	buffers = calloc (1, sizeof (*buffers));
+
+	if (!buffers) {
+		fprintf (stderr, "Out of memory\n");
+		exit (EXIT_FAILURE);
+	}
+
+	buffers[0].length = buffer_size;
+	buffers[0].start = malloc (buffer_size);
+
+	if (!buffers[0].start) {
+		fprintf (stderr, "Out of memory\n");
+		exit (EXIT_FAILURE);
+	}
+}
+
+static void
+init_mmap                       (void)
+{
+	struct v4l2_requestbuffers req;
+
+	CLEAR (req);
+
+	req.count               = 4;
+	req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	req.memory              = V4L2_MEMORY_MMAP;
+
+	if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
+		if (EINVAL == errno) {
+			fprintf (stderr, "%s does not support "
+				 "memory mapping\n", dev_name);
+			exit (EXIT_FAILURE);
+		} else {
+			errno_exit ("VIDIOC_REQBUFS");
+		}
+	}
+
+	if (req.count < 2) {
+		fprintf (stderr, "Insufficient buffer memory on %s\n",
+			 dev_name);
+		exit (EXIT_FAILURE);
+	}
+
+	buffers = calloc (req.count, sizeof (*buffers));
+
+	if (!buffers) {
+		fprintf (stderr, "Out of memory\n");
+		exit (EXIT_FAILURE);
+	}
+
+	for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
+		struct v4l2_buffer buf;
+
+		CLEAR (buf);
+
+		buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+		buf.memory      = V4L2_MEMORY_MMAP;
+		buf.index       = n_buffers;
+
+		if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))
+			errno_exit ("VIDIOC_QUERYBUF");
+
+		buffers[n_buffers].length = buf.length;
+		buffers[n_buffers].start =
+			mmap (NULL /* start anywhere */,
+			      buf.length,
+			      PROT_READ | PROT_WRITE /* required */,
+			      MAP_SHARED /* recommended */,
+			      fd, buf.m.offset);
+
+		if (MAP_FAILED == buffers[n_buffers].start)
+			errno_exit ("mmap");
+	}
+}
+
+static void
+init_userp                      (unsigned int           buffer_size)
+{
+	struct v4l2_requestbuffers req;
+
+	CLEAR (req);
+
+	req.count               = 4;
+	req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	req.memory              = V4L2_MEMORY_USERPTR;
+
+	if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
+		if (EINVAL == errno) {
+			fprintf (stderr, "%s does not support "
+				 "user pointer i/o\n", dev_name);
+			exit (EXIT_FAILURE);
+		} else {
+			errno_exit ("VIDIOC_REQBUFS");
+		}
+	}
+
+	buffers = calloc (4, sizeof (*buffers));
+
+	if (!buffers) {
+		fprintf (stderr, "Out of memory\n");
+		exit (EXIT_FAILURE);
+	}
+
+	for (n_buffers = 0; n_buffers < 4; ++n_buffers) {
+		buffers[n_buffers].length = buffer_size;
+		buffers[n_buffers].start = malloc (buffer_size);
+
+		if (!buffers[n_buffers].start) {
+			fprintf (stderr, "Out of memory\n");
+			exit (EXIT_FAILURE);
+		}
+	}
+}
+
+static void
+init_device                     (void)
+{
+	struct v4l2_capability cap;
+	struct v4l2_cropcap cropcap;
+	struct v4l2_crop crop;
+	struct v4l2_format fmt;
+	unsigned int min;
+
+	if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
+		if (EINVAL == errno) {
+			fprintf (stderr, "%s is no V4L2 device\n",
+				 dev_name);
+			exit (EXIT_FAILURE);
+		} else {
+			errno_exit ("VIDIOC_QUERYCAP");
+		}
+	}
+
+	if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
+		fprintf (stderr, "%s is no video capture device\n",
+			 dev_name);
+		exit (EXIT_FAILURE);
+	}
+
+	switch (io) {
+	case IO_METHOD_READ:
+		if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
+			fprintf (stderr, "%s does not support read i/o\n",
+				 dev_name);
+			exit (EXIT_FAILURE);
+		}
+
+		break;
+
+	case IO_METHOD_MMAP:
+	case IO_METHOD_USERPTR:
+		if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
+			fprintf (stderr, "%s does not support streaming i/o\n",
+				 dev_name);
+			exit (EXIT_FAILURE);
+		}
+
+		break;
+	}
+
+
+	/* Select video input, video standard and tune here. */
+
+
+	CLEAR (cropcap);
+
+	cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+	if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
+		crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+		crop.c = cropcap.defrect; /* reset to default */
+
+		if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
+			switch (errno) {
+			case EINVAL:
+				/* Cropping not supported. */
+				break;
+			default:
+				/* Errors ignored. */
+				break;
+			}
+		}
+	} else {
+		/* Errors ignored. */
+	}
+
+
+	CLEAR (fmt);
+
+	fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	fmt.fmt.pix.width       = 640;
+	fmt.fmt.pix.height      = 480;
+	fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
+	fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
+
+	if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
+		errno_exit ("VIDIOC_S_FMT");
+
+	/* Note VIDIOC_S_FMT may change width and height. */
+
+	/* Buggy driver paranoia. */
+	min = fmt.fmt.pix.width * 2;
+	if (fmt.fmt.pix.bytesperline < min)
+		fmt.fmt.pix.bytesperline = min;
+	min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
+	if (fmt.fmt.pix.sizeimage < min)
+		fmt.fmt.pix.sizeimage = min;
+
+	switch (io) {
+	case IO_METHOD_READ:
+		init_read (fmt.fmt.pix.sizeimage);
+		break;
+
+	case IO_METHOD_MMAP:
+		init_mmap ();
+		break;
+
+	case IO_METHOD_USERPTR:
+		init_userp (fmt.fmt.pix.sizeimage);
+		break;
+	}
+}
+
+static void
+close_device                    (void)
+{
+	if (-1 == close (fd))
+		errno_exit ("close");
+
+	fd = -1;
+}
+
+static void
+open_device                     (void)
+{
+	struct stat st;
+
+	if (-1 == stat (dev_name, &st)) {
+		fprintf (stderr, "Cannot identify '%s': %d, %s\n",
+			 dev_name, errno, strerror (errno));
+		exit (EXIT_FAILURE);
+	}
+
+	if (!S_ISCHR (st.st_mode)) {
+		fprintf (stderr, "%s is no device\n", dev_name);
+		exit (EXIT_FAILURE);
+	}
+
+	fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
+
+	if (-1 == fd) {
+		fprintf (stderr, "Cannot open '%s': %d, %s\n",
+			 dev_name, errno, strerror (errno));
+		exit (EXIT_FAILURE);
+	}
+}
+
+static void
+usage                           (FILE *                 fp,
+				 int                    argc,
+				 char **                argv)
+{
+	fprintf (fp,
+		 "Usage: %s [options]\n\n"
+		 "Options:\n"
+		 "-d | --device name   Video device name [/dev/video]\n"
+		 "-h | --help          Print this message\n"
+		 "-m | --mmap          Use memory mapped buffers\n"
+		 "-r | --read          Use read() calls\n"
+		 "-u | --userp         Use application allocated buffers\n"
+		 "",
+		 argv[0]);
+}
+
+static const char short_options [] = "d:hmru";
+
+static const struct option
+long_options [] = {
+	{ "device",     required_argument,      NULL,           'd' },
+	{ "help",       no_argument,            NULL,           'h' },
+	{ "mmap",       no_argument,            NULL,           'm' },
+	{ "read",       no_argument,            NULL,           'r' },
+	{ "userp",      no_argument,            NULL,           'u' },
+	{ 0, 0, 0, 0 }
+};
+
+int
+main                            (int                    argc,
+				 char **                argv)
+{
+	dev_name = "/dev/video";
+
+	for (;;) {
+		int index;
+		int c;
+
+		c = getopt_long (argc, argv,
+				 short_options, long_options,
+				 &index);
+
+		if (-1 == c)
+			break;
+
+		switch (c) {
+		case 0: /* getopt_long() flag */
+			break;
+
+		case 'd':
+			dev_name = optarg;
+			break;
+
+		case 'h':
+			usage (stdout, argc, argv);
+			exit (EXIT_SUCCESS);
+
+		case 'm':
+			io = IO_METHOD_MMAP;
+			break;
+
+		case 'r':
+			io = IO_METHOD_READ;
+			break;
+
+		case 'u':
+			io = IO_METHOD_USERPTR;
+			break;
+
+		default:
+			usage (stderr, argc, argv);
+			exit (EXIT_FAILURE);
+		}
+	}
+
+	open_device ();
+
+	init_device ();
+
+	start_capturing ();
+
+	mainloop ();
+
+	stop_capturing ();
+
+	uninit_device ();
+
+	close_device ();
+
+	exit (EXIT_SUCCESS);
+
+	return 0;
+}