Hi,
here is the v4l-test 0.14 version also.
Changes:
Test cases added for VIDIOC_QUERYBUF;
Debug functions separated
Signed-off-by: Márton Németh <[email protected]>
Regards,
Márton Németh
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/doc/index.html ltp/testcases/kernel/device-drivers/v4l/user_space/doc/index.html
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/doc/index.html 2009-05-08 07:38:26.000000000 +0200
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/doc/index.html 2009-05-07 22:51:14.000000000 +0200
@@ -2,7 +2,7 @@
<html>
<head>
<meta content="text/html;charset=UTF-8" http-equiv="Content-Type">
- <title>v4l-test: Test environment for Video For Linux Two API</title>
+ <title>v4l-test: Test environment for Video For Linux Two (V4L2) API</title>
</head>
<body>
<p>
@@ -18,7 +18,7 @@
</p>
<hr style="width: 100%; height: 2px;">
-<h1>v4l-test: Test environment for Video For Linux Two API</h1>
+<h1>v4l-test: Test environment for Video For Linux Two (V4L2) API</h1>
<p>
Download <a href="http://sourceforge.net/project/showfiles.php?group_id=247983";>v4l-test</a>
or visit <a href="http://sourceforge.net/projects/v4l-test/";>v4l-test project page</a> at
@@ -390,7 +390,7 @@ implemented test cases.</p>
</tr>
<tr>
<td>ioctl <a href="spec/r13022.htm">VIDIOC_QUERYBUF</a></td>
- <td>no</td>
+ <td>yes, only when STREAM_OFF</td>
<td>Opt.</td>
</tr>
<tr>
@@ -480,6 +480,10 @@ There migth be similar projects which al
So far I could find the following:
</p>
<ul>
+ <li>A <a href="http://www.linuxtv.org/wiki/index.php/V4L_Test_Suite";>
+ list of V4L and V4L2 test drivers and applications</a> at
+ <a href="http://www.linuxtv.org/wiki/index.php/Main_Page";>LinuxTV Wiki</a>
+ </li>
<li><a href="http://www.linuxowl.com/v4ltest.html";>v4ltest</a><br>
</li>
<li>test cases in <a href="http://linuxtv.org/hg/dvb-apps/file";>dvb-apps repository</a>, under /test directory
@@ -516,7 +520,7 @@ The following documents and articles are
<p>Any feedbacks, comments, ideas, etc. are welcome at the author's email address.</p>
<hr style="width: 100%; height: 2px;">
<p>Last changed:
-Wed Apr 29 20:39:28 CEST 2009
+Thu May 7 22:51:07 CEST 2009
</p>
<p>
<a href="http://validator.w3.org/check?uri=referer";><img
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/doc/results.html ltp/testcases/kernel/device-drivers/v4l/user_space/doc/results.html
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/doc/results.html 2009-04-21 11:23:00.000000000 +0200
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/doc/results.html 2009-04-29 21:22:49.000000000 +0200
@@ -49,10 +49,23 @@ project or during developing it.
</li>
<li>
- <a href="http://lkml.org/lkml/2009/4/18/104";>
+ <a href="http://marc.info/?l=linux-kernel&m=124022459714644&w=2";>
[PATCH]: uvcvideo: fill reserved fields with zero of VIDIOC_QUERYMENU
</a>
</li>
+
+ <li>
+ <a href="http://marc.info/?l=linux-kernel&m=124103154820106&w=2";>
+ [PATCH] v4l2: modify return value of VIDIOC_REQBUFS ioctl
+ </a>
+ </li>
+
+ <li>
+ <a href="http://marc.info/?l=linux-kernel&m=124103154820111&w=2";>
+ [PATCH] v4l2: fill the reserved fields of VIDIOC_REQBUFS ioctl
+ </a>
+ </li>
+
</ul>
<p>In the out-of-tree <a href="http://mcentral.de/hg/~mrec/em28xx-new";>em28xx-new driver</a>
@@ -81,7 +94,7 @@ the following problems were identified w
<hr style="width: 100%; height: 2px;">
<p>Last changed:
-Sun Apr 19 13:03:50 CEST 2009
+Wed Apr 29 21:21:38 CEST 2009
</p>
<p>
<a href="http://validator.w3.org/check?uri=referer";><img
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/Makefile ltp/testcases/kernel/device-drivers/v4l/user_space/Makefile
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/Makefile 2009-05-08 07:38:26.000000000 +0200
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/Makefile 2009-05-07 21:22:50.000000000 +0200
@@ -1,6 +1,8 @@
#
# v4l-test: Test environment for Video For Linux Two API
#
+# 7 May 2009 0.16 v4l2_show.c added
+# 5 May 2009 0.15 test_VIDIOC_QUERYBUF.c added
# 25 Apr 2009 0.14 test_VIDIOC_REQBUFS.c added
# 5 Apr 2009 0.13 test_VIDIOC_QUERYMENU.c added
# 4 Apr 2009 0.12 test_VIDIOC_FMT.c added
@@ -62,7 +64,9 @@ OBJS = dev_video.o \
test_VIDIOC_PARM.o \
test_VIDIOC_FMT.o \
test_VIDIOC_REQBUFS.o \
+ test_VIDIOC_QUERYBUF.o \
test_invalid_ioctl.o \
+ v4l2_show.o \
v4l2_test.o
all: $(OBJS)
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/README ltp/testcases/kernel/device-drivers/v4l/user_space/README
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/README 2009-05-08 07:38:26.000000000 +0200
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/README 2009-05-07 22:53:53.000000000 +0200
@@ -3,6 +3,8 @@
Release History
---------------
+ 7 May 2009 0.14 Test cases added for VIDIOC_QUERYBUF;
+ Debug functions separated
29 Apr 2009 0.13 Added string content validation;
Test cases added for VIDIOC_REQBUFS
19 Apr 2009 0.12 Test cases added for VIDIOC_S_FMT;
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_QUERYBUF.c ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_QUERYBUF.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_QUERYBUF.c 1970-01-01 01:00:00.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_QUERYBUF.c 2009-05-07 21:20:50.000000000 +0200
@@ -0,0 +1,427 @@
+/*
+ * v4l-test: Test environment for Video For Linux Two API
+ *
+ * 5 May 2009 0.1 First release
+ *
+ * Written by Márton Németh <[email protected]>
+ * Released under GPL
+ */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <string.h>
+
+#include <linux/videodev2.h>
+#include <linux/errno.h>
+
+#include <CUnit/CUnit.h>
+
+#include "v4l2_test.h"
+#include "v4l2_show.h"
+#include "dev_video.h"
+#include "video_limits.h"
+
+#include "test_VIDIOC_REQBUFS.h"
+
+static void do_VIDIOC_QUERYBUF(enum v4l2_memory memory,
+ enum v4l2_buf_type type, __u32 count, int expected_ret_req) {
+ int ret_req, errno_req;
+ int ret_query, errno_query;
+ struct v4l2_requestbuffers reqbuf;
+ struct v4l2_buffer buf;
+ __u32 i;
+ unsigned int j;
+ const enum v4l2_buf_type buffer_types[] = {
+ 0,
+ V4L2_BUF_TYPE_VIDEO_CAPTURE,
+ V4L2_BUF_TYPE_VIDEO_OUTPUT,
+ V4L2_BUF_TYPE_VIDEO_OVERLAY,
+ V4L2_BUF_TYPE_VBI_CAPTURE,
+ V4L2_BUF_TYPE_VBI_OUTPUT,
+ V4L2_BUF_TYPE_SLICED_VBI_CAPTURE,
+ V4L2_BUF_TYPE_SLICED_VBI_OUTPUT,
+ V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY,
+ V4L2_BUF_TYPE_PRIVATE-1,
+ V4L2_BUF_TYPE_PRIVATE,
+ V4L2_BUF_TYPE_PRIVATE+1,
+ S32_MAX,
+ (__s32)((__u32)S32_MAX+1),
+ U32_MAX-1,
+ U32_MAX
+ };
+
+ memset(&reqbuf, 0, sizeof(reqbuf));
+ reqbuf.count = count;
+ reqbuf.type = type;
+ reqbuf.memory = memory;
+
+ ret_req = ioctl(get_video_fd(), VIDIOC_REQBUFS, &reqbuf);
+ errno_req = errno;
+
+ if (expected_ret_req == 0) {
+ CU_ASSERT_EQUAL(ret_req, 0);
+ } else {
+ CU_ASSERT_EQUAL(ret_req, -1);
+ CU_ASSERT_EQUAL(errno_req, EINVAL);
+ }
+
+ dprintf("\t%s:%u: VIDIOC_REQBUF, count=%u, type=%i, memory=%i, ret_req=%i, errno_req=%i\n",
+ __FILE__, __LINE__, count, type, memory, ret_req, errno_req);
+
+ if (ret_req == 0) {
+ show_v4l2_requestbuffers(&reqbuf);
+ }
+
+ if (ret_req != 0) {
+ reqbuf.count = 0;
+ }
+
+ for (i = 0; i < reqbuf.count; i++) {
+ memset(&buf, 0xff, sizeof(buf));
+ buf.type = type;
+ buf.index = i;
+
+ ret_query = ioctl(get_video_fd(), VIDIOC_QUERYBUF, &buf);
+ errno_query = errno;
+
+ CU_ASSERT_EQUAL(buf.index, i);
+ CU_ASSERT_EQUAL(buf.type, type);
+ //CU_ASSERT_EQUAL(buf.bytesused, ???);
+ CU_ASSERT_EQUAL(buf.flags & ~(V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE), 0);
+ //CU_ASSERT_EQUAL(buf.field, ???);
+ //CU_ASSERT_EQUAL(buf.timestamp.tv_sec, ???);
+ //CU_ASSERT_EQUAL(buf.timestamp.tv_usec, ???);
+ //CU_ASSERT_EQUAL(buf.timecode.type, ???);
+ //CU_ASSERT_EQUAL(buf.timecode.flags, ???);
+ //CU_ASSERT_EQUAL(buf.timecode.frames, ???);
+ //CU_ASSERT_EQUAL(buf.timecode.seconds, ???);
+ //CU_ASSERT_EQUAL(buf.timecode.minutes, ???);
+ //CU_ASSERT_EQUAL(buf.timecode.hours, ???);
+ //CU_ASSERT_EQUAL(buf.timecode.userbits[0], ???);
+ //CU_ASSERT_EQUAL(buf.timecode.userbits[1], ???);
+ //CU_ASSERT_EQUAL(buf.timecode.userbits[2], ???);
+ //CU_ASSERT_EQUAL(buf.timecode.userbits[3], ???);
+ //CU_ASSERT_EQUAL(buf.sequence, ???);
+ CU_ASSERT_EQUAL(buf.memory, memory);
+ //CU_ASSERT_EQUAL(buf.m.userptr, ???);
+ //CU_ASSERT_EQUAL(buf.m.offset, ???);
+ CU_ASSERT(0 < buf.length);
+ //CU_ASSERT_EQUAL(buf.input, ???);
+ CU_ASSERT_EQUAL(buf.reserved, 0);
+
+ dprintf("\t%s:%u: VIDIOC_QUERYBUF, type=%i, index=%u, ret_query=%i, errno_query=%i\n",
+ __FILE__, __LINE__, buf.type, buf.index, ret_query, errno_query);
+ if (ret_query == 0)
+ show_v4l2_buffer(&buf);
+
+ }
+
+ /* Check for not buffer types which do not match the VIDIOC_REQBUF
+ * buffer type
+ */
+ for (i = 0; i < reqbuf.count; i++) {
+ for (j = 0; j < sizeof(buffer_types)/sizeof(*buffer_types); j++) {
+ if (buffer_types[j] != type) {
+ memset(&buf, 0xff, sizeof(buf));
+ buf.type = buffer_types[j];
+ buf.index = i;
+
+ ret_query = ioctl(get_video_fd(), VIDIOC_QUERYBUF, &buf);
+ errno_query = errno;
+
+ CU_ASSERT_EQUAL(ret_query, -1);
+ CU_ASSERT_EQUAL(errno_query, EINVAL);
+
+ dprintf("\t%s:%u: VIDIOC_QUERYBUF, type=%i, index=%u, ret_query=%i, errno_query=%i\n",
+ __FILE__, __LINE__, buf.type, buf.index, ret_query, errno_query);
+ if (ret_query == 0)
+ show_v4l2_buffer(&buf);
+ }
+ }
+ }
+
+ memset(&buf, 0xff, sizeof(buf));
+ buf.type = type;
+ buf.index = reqbuf.count;
+
+ ret_query = ioctl(get_video_fd(), VIDIOC_QUERYBUF, &buf);
+ errno_query = errno;
+
+ dprintf("\t%s:%u: VIDIOC_QUERYBUF, type=%i, index=%u, ret_query=%i, errno_query=%i\n",
+ __FILE__, __LINE__, buf.type, buf.index, ret_query, errno_query);
+
+ CU_ASSERT_EQUAL(ret_query, -1);
+ CU_ASSERT_EQUAL(errno_query, EINVAL);
+
+ if (reqbuf.count < (__u32)S16_MIN) {
+ memset(&buf, 0xff, sizeof(buf));
+ buf.type = type;
+ buf.index = (__u32)S16_MIN;
+
+ ret_query = ioctl(get_video_fd(), VIDIOC_QUERYBUF, &buf);
+ errno_query = errno;
+
+ dprintf("\t%s:%u: VIDIOC_QUERYBUF, type=%i, index=%u, ret_query=%i, errno_query=%i\n",
+ __FILE__, __LINE__, buf.type, buf.index, ret_query, errno_query);
+
+ CU_ASSERT_EQUAL(ret_query, -1);
+ CU_ASSERT_EQUAL(errno_query, EINVAL);
+ }
+
+ if (reqbuf.count < (__u32)S16_MAX) {
+ memset(&buf, 0xff, sizeof(buf));
+ buf.type = type;
+ buf.index = (__u32)S16_MAX;
+
+ ret_query = ioctl(get_video_fd(), VIDIOC_QUERYBUF, &buf);
+ errno_query = errno;
+
+ dprintf("\t%s:%u: VIDIOC_QUERYBUF, type=%i, index=%u, ret_query=%i, errno_query=%i\n",
+ __FILE__, __LINE__, buf.type, buf.index, ret_query, errno_query);
+
+ CU_ASSERT_EQUAL(ret_query, -1);
+ CU_ASSERT_EQUAL(errno_query, EINVAL);
+ }
+
+ if (reqbuf.count < U32_MAX) {
+ memset(&buf, 0xff, sizeof(buf));
+ buf.type = type;
+ buf.index = U32_MAX;
+
+ ret_query = ioctl(get_video_fd(), VIDIOC_QUERYBUF, &buf);
+ errno_query = errno;
+
+ dprintf("\t%s:%u: VIDIOC_QUERYBUF, type=%i, index=%u, ret_query=%i, errno_query=%i\n",
+ __FILE__, __LINE__, buf.type, buf.index, ret_query, errno_query);
+
+ CU_ASSERT_EQUAL(ret_query, -1);
+ CU_ASSERT_EQUAL(errno_query, EINVAL);
+ }
+
+
+
+ memset(&reqbuf, 0, sizeof(reqbuf));
+ reqbuf.count = 0;
+ reqbuf.type = type;
+ reqbuf.memory = V4L2_MEMORY_MMAP;
+
+ ret_req = ioctl(get_video_fd(), VIDIOC_REQBUFS, &reqbuf);
+ errno_req = errno;
+
+ dprintf("\t%s:%u: VIDIOC_REQBUF, count=%u, ret_req=%i, errno_req=%i\n",
+ __FILE__, __LINE__, count, ret_req, errno_req);
+
+ if (expected_ret_req == 0) {
+ CU_ASSERT_EQUAL(ret_req, 0);
+ } else {
+ CU_ASSERT_EQUAL(ret_req, -1);
+ CU_ASSERT_EQUAL(errno_req, EINVAL);
+ }
+ if (ret_req == 0) {
+ show_v4l2_requestbuffers(&reqbuf);
+ }
+}
+
+void test_VIDIOC_QUERYBUF_capture_mmap() {
+ int ret_cap, errno_cap;
+ struct v4l2_capability cap;
+ int expected_ret_req;
+
+ memset(&cap, 0, sizeof(cap));
+
+ ret_cap = ioctl(get_video_fd(), VIDIOC_QUERYCAP, &cap);
+ errno_cap = errno;
+
+ if (ret_cap == 0 &&
+ (cap.capabilities & V4L2_CAP_STREAMING) &&
+ (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
+ expected_ret_req = 0;
+ } else {
+ expected_ret_req = -1;
+ }
+
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_CAPTURE, 1, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_CAPTURE, 2, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_CAPTURE, 3, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_CAPTURE, 4, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_CAPTURE, (__u32)S16_MIN, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_CAPTURE, (__u32)S16_MAX, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_CAPTURE, U32_MAX, expected_ret_req);
+}
+
+void test_VIDIOC_QUERYBUF_capture_userptr() {
+ int ret_cap, errno_cap;
+ int ret_req, errno_req;
+ struct v4l2_capability cap;
+ struct v4l2_requestbuffers reqbuf;
+ int expected_ret_req;
+
+ memset(&cap, 0, sizeof(cap));
+
+ ret_cap = ioctl(get_video_fd(), VIDIOC_QUERYCAP, &cap);
+ errno_cap = errno;
+
+ memset(&reqbuf, 0, sizeof(reqbuf));
+ reqbuf.count = 2;
+ reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ reqbuf.memory = V4L2_MEMORY_USERPTR;
+
+ ret_req = ioctl(get_video_fd(), VIDIOC_REQBUFS, &reqbuf);
+ errno_req = errno;
+
+ dprintf("\t%s:%u: VIDIOC_REQBUF, count=%u, ret_req=%i, errno_req=%i\n",
+ __FILE__, __LINE__, reqbuf.count, ret_req, errno_req);
+
+ if (ret_cap == 0 &&
+ (cap.capabilities & V4L2_CAP_STREAMING) &&
+ (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) &&
+ ret_req == 0) {
+ expected_ret_req = 0;
+ } else {
+ expected_ret_req = -1;
+ }
+
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_CAPTURE, 1, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_CAPTURE, 2, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_CAPTURE, 3, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_CAPTURE, 4, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_CAPTURE, (__u32)S16_MIN, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_CAPTURE, (__u32)S16_MAX, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_CAPTURE, U32_MAX, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_CAPTURE, 0, expected_ret_req);
+}
+
+void test_VIDIOC_QUERYBUF_output_mmap() {
+ int ret_cap, errno_cap;
+ struct v4l2_capability cap;
+ int expected_ret_req;
+
+ memset(&cap, 0, sizeof(cap));
+
+ ret_cap = ioctl(get_video_fd(), VIDIOC_QUERYCAP, &cap);
+ errno_cap = errno;
+
+ if (ret_cap == 0 &&
+ (cap.capabilities & V4L2_CAP_STREAMING) &&
+ (cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
+ expected_ret_req = 0;
+ } else {
+ expected_ret_req = -1;
+ }
+
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT, 1, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT, 2, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT, 3, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT, 4, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT, (__u32)S16_MIN, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT, (__u32)S16_MAX, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT, U32_MAX, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0, expected_ret_req);
+}
+
+void test_VIDIOC_QUERYBUF_output_userptr() {
+ int ret_cap, errno_cap;
+ int ret_req, errno_req;
+ struct v4l2_capability cap;
+ struct v4l2_requestbuffers reqbuf;
+ int expected_ret_req;
+
+ memset(&cap, 0, sizeof(cap));
+
+ ret_cap = ioctl(get_video_fd(), VIDIOC_QUERYCAP, &cap);
+ errno_cap = errno;
+
+ memset(&reqbuf, 0, sizeof(reqbuf));
+ reqbuf.count = 2;
+ reqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+ reqbuf.memory = V4L2_MEMORY_USERPTR;
+
+ ret_req = ioctl(get_video_fd(), VIDIOC_REQBUFS, &reqbuf);
+ errno_req = errno;
+
+ dprintf("\t%s:%u: VIDIOC_REQBUF, count=%u, ret_req=%i, errno_req=%i\n",
+ __FILE__, __LINE__, reqbuf.count, ret_req, errno_req);
+
+ if (ret_cap == 0 &&
+ (cap.capabilities & V4L2_CAP_STREAMING) &&
+ (cap.capabilities & V4L2_CAP_VIDEO_OUTPUT) &&
+ ret_req == 0) {
+ expected_ret_req = 0;
+ } else {
+ expected_ret_req = -1;
+ }
+
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT, 1, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT, 2, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT, 3, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT, 4, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT, (__u32)S16_MIN, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT, (__u32)S16_MAX, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT, U32_MAX, expected_ret_req);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT, 0, expected_ret_req);
+}
+
+void test_VIDIOC_QUERYBUF_overlay_capture() {
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_OVERLAY, V4L2_BUF_TYPE_VIDEO_CAPTURE, 2, -1);
+}
+
+void test_VIDIOC_QUERYBUF_overlay_output() {
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_OVERLAY, V4L2_BUF_TYPE_VIDEO_OUTPUT, 2, -1);
+}
+
+void test_VIDIOC_QUERYBUF_invalid_memory_capture() {
+ do_VIDIOC_QUERYBUF(SINT_MIN, V4L2_BUF_TYPE_VIDEO_CAPTURE, 2, -1);
+ do_VIDIOC_QUERYBUF(0, V4L2_BUF_TYPE_VIDEO_CAPTURE, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_OVERLAY+1, V4L2_BUF_TYPE_VIDEO_CAPTURE, 2, -1);
+ do_VIDIOC_QUERYBUF(SINT_MAX, V4L2_BUF_TYPE_VIDEO_CAPTURE, 2, -1);
+}
+
+void test_VIDIOC_QUERYBUF_invalid_memory_output() {
+ do_VIDIOC_QUERYBUF(SINT_MIN, V4L2_BUF_TYPE_VIDEO_OUTPUT, 2, -1);
+ do_VIDIOC_QUERYBUF(0, V4L2_BUF_TYPE_VIDEO_OUTPUT, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_OVERLAY+1, V4L2_BUF_TYPE_VIDEO_OUTPUT, 2, -1);
+ do_VIDIOC_QUERYBUF(SINT_MAX, V4L2_BUF_TYPE_VIDEO_OUTPUT, 2, -1);
+}
+
+void test_VIDIOC_QUERYBUF_invalid_type_mmap() {
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, 0, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OVERLAY, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VBI_CAPTURE, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VBI_OUTPUT, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_SLICED_VBI_CAPTURE, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_SLICED_VBI_OUTPUT, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_PRIVATE-1, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_PRIVATE, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, V4L2_BUF_TYPE_PRIVATE+1, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, S32_MAX, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, (__s32)((__u32)S32_MAX+1), 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, U32_MAX-1, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_MMAP, U32_MAX, 2, -1);
+}
+
+void test_VIDIOC_QUERYBUF_invalid_type_userptr() {
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, 0, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OVERLAY, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VBI_CAPTURE, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VBI_OUTPUT, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_SLICED_VBI_CAPTURE, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_SLICED_VBI_OUTPUT, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_PRIVATE-1, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_PRIVATE, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, V4L2_BUF_TYPE_PRIVATE+1, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, S32_MAX, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, (__s32)((__u32)S32_MAX+1), 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, U32_MAX-1, 2, -1);
+ do_VIDIOC_QUERYBUF(V4L2_MEMORY_USERPTR, U32_MAX, 2, -1);
+}
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_QUERYBUF.h ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_QUERYBUF.h
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_QUERYBUF.h 1970-01-01 01:00:00.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_QUERYBUF.h 2009-05-05 22:53:14.000000000 +0200
@@ -0,0 +1,19 @@
+/*
+ * v4l-test: Test environment for Video For Linux Two API
+ *
+ * 5 May 2009 0.1 First release
+ *
+ * Written by Márton Németh <[email protected]>
+ * Released under GPL
+ */
+
+void test_VIDIOC_QUERYBUF_capture_mmap(void);
+void test_VIDIOC_QUERYBUF_capture_userptr(void);
+void test_VIDIOC_QUERYBUF_output_mmap(void);
+void test_VIDIOC_QUERYBUF_output_userptr(void);
+void test_VIDIOC_QUERYBUF_overlay_capture(void);
+void test_VIDIOC_QUERYBUF_overlay_output(void);
+void test_VIDIOC_QUERYBUF_invalid_memory_capture(void);
+void test_VIDIOC_QUERYBUF_invalid_memory_output(void);
+void test_VIDIOC_QUERYBUF_invalid_type_mmap(void);
+void test_VIDIOC_QUERYBUF_invalid_type_userptr(void);
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_REQBUFS.c ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_REQBUFS.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_REQBUFS.c 2009-05-08 07:38:26.000000000 +0200
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_REQBUFS.c 2009-05-07 21:21:39.000000000 +0200
@@ -1,6 +1,7 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 7 May 2009 0.2 show_v4l2_*() function extracted to v4l2_show.c
* 29 Apr 2009 0.1 First release
*
* Written by Márton Németh <[email protected]>
@@ -22,26 +23,12 @@
#include <CUnit/CUnit.h>
#include "v4l2_test.h"
+#include "v4l2_show.h"
#include "dev_video.h"
#include "video_limits.h"
#include "test_VIDIOC_REQBUFS.h"
-static void show_v4l2_requestbuffers(struct v4l2_requestbuffers *reqbuf) {
- dprintf("\treqbuf = { "
- ".count=%u, "
- ".type=%i, "
- ".memory=%i, "
- ".reserved = { 0x%X, 0x%X } "
- "}\n",
- reqbuf->count,
- reqbuf->type,
- reqbuf->memory,
- reqbuf->reserved[0],
- reqbuf->reserved[1]
- );
-}
-
static void do_VIDIOC_REQBUFS_capture_mmap(__u32 count) {
int ret_cap, errno_cap;
int ret_req, errno_req;
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/v4l2_show.c ltp/testcases/kernel/device-drivers/v4l/user_space/v4l2_show.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/v4l2_show.c 1970-01-01 01:00:00.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/v4l2_show.c 2009-05-07 21:19:40.000000000 +0200
@@ -0,0 +1,116 @@
+/*
+ * v4l-test: Test environment for Video For Linux Two API
+ *
+ * 7 May 2009 0.1 First release
+ *
+ * Written by Márton Németh <[email protected]>
+ * Released under GPL
+ */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <string.h>
+
+#include <linux/videodev2.h>
+#include <linux/errno.h>
+
+#include <CUnit/CUnit.h>
+
+#include "v4l2_test.h"
+#include "dev_video.h"
+#include "video_limits.h"
+
+#include "test_VIDIOC_REQBUFS.h"
+
+void show_v4l2_requestbuffers(struct v4l2_requestbuffers *reqbuf) {
+ dprintf("\treqbuf = { "
+ ".count=%u, "
+ ".type=%i, "
+ ".memory=%i, "
+ ".reserved = { 0x%X, 0x%X } "
+ "}\n",
+ reqbuf->count,
+ reqbuf->type,
+ reqbuf->memory,
+ reqbuf->reserved[0],
+ reqbuf->reserved[1]
+ );
+}
+
+void show_v4l2_buffer(struct v4l2_buffer *buf) {
+ unsigned int i;
+
+ dprintf("\tbuf = { "
+ ".index=%u, "
+ ".type=%i, "
+ ".bytesused=%u, "
+ ".flags=0x%x, "
+ ".field=%i, "
+ ".timestamp = { tv_sec=%lu, tv_usec=%lu }, "
+ ".timecode = { "
+ ".type=%u, "
+ ".flags=0x%x, "
+ ".frames=%u, "
+ ".seconds=%u, "
+ ".minutes=%u, "
+ ".hours=%u, "
+ ".userbits = { 0x%x, 0x%x, 0x%x, 0x%x } "
+ " }, "
+ ".sequence=%u, "
+ ".memory=%i, ",
+ buf->index,
+ buf->type,
+ buf->bytesused,
+ buf->flags,
+ buf->field,
+ buf->timestamp.tv_sec,
+ buf->timestamp.tv_usec,
+ buf->timecode.type,
+ buf->timecode.flags,
+ buf->timecode.frames,
+ buf->timecode.seconds,
+ buf->timecode.minutes,
+ buf->timecode.hours,
+ buf->timecode.userbits[0],
+ buf->timecode.userbits[1],
+ buf->timecode.userbits[2],
+ buf->timecode.userbits[3],
+ buf->sequence,
+ buf->memory
+ );
+
+ switch (buf->memory) {
+ case V4L2_MEMORY_USERPTR:
+ dprintf(".m.userptr=0x%lx, ",
+ buf->m.userptr);
+ for (i = sizeof(buf->m.userptr); i < sizeof(buf->m); i++) {
+ dprintf("((__u8*)&.m)[%u]=0x%x, ",
+ i, ((__u8*)&buf->m)[i]);
+ }
+ break;
+ case V4L2_MEMORY_MMAP:
+ case V4L2_MEMORY_OVERLAY:
+ default:
+ dprintf(".m.offset=%u, ",
+ buf->m.offset);
+ for (i = sizeof(buf->m.offset); i < sizeof(buf->m); i++) {
+ dprintf("((__u8*)&.m)[%u]=0x%x, ",
+ i, ((__u8*)&buf->m)[i]);
+ }
+ }
+
+ dprintf(".length=%u, "
+ ".input=%u, "
+ ".reserved=0x%x "
+ "}\n",
+ buf->length,
+ buf->input,
+ buf->reserved
+ );
+
+}
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/v4l2_show.h ltp/testcases/kernel/device-drivers/v4l/user_space/v4l2_show.h
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/v4l2_show.h 1970-01-01 01:00:00.000000000 +0100
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/v4l2_show.h 2009-05-07 21:20:25.000000000 +0200
@@ -0,0 +1,13 @@
+/*
+ * v4l-test: Test environment for Video For Linux Two API
+ *
+ * 7 May 2009 0.1 First release
+ *
+ * Written by Márton Németh <[email protected]>
+ * Released under GPL
+ */
+
+#include <linux/videodev2.h>
+
+void show_v4l2_requestbuffers(struct v4l2_requestbuffers *reqbuf);
+void show_v4l2_buffer(struct v4l2_buffer *buf);
diff -uprN ltp.orig/testcases/kernel/device-drivers/v4l/user_space/v4l2_test.c ltp/testcases/kernel/device-drivers/v4l/user_space/v4l2_test.c
--- ltp.orig/testcases/kernel/device-drivers/v4l/user_space/v4l2_test.c 2009-05-08 07:38:26.000000000 +0200
+++ ltp/testcases/kernel/device-drivers/v4l/user_space/v4l2_test.c 2009-05-07 21:17:56.000000000 +0200
@@ -1,6 +1,7 @@
/*
* v4l-test: Test environment for Video For Linux Two API
*
+ * 5 May 2009 0.22 Test cases added for VIDIOC_QUERYBUF
* 29 Apr 2009 0.21 Test cases added for VIDIOC_REQBUFS
* 18 Apr 2009 0.20 NULL parameter test suite split to read only, write only
* and write/read ioctl suite
@@ -83,6 +84,7 @@
#include "test_VIDIOC_FMT.h"
#include "test_VIDIOC_REQBUFS.h"
+#include "test_VIDIOC_QUERYBUF.h"
#include "test_VIDIOC_LOG_STATUS.h"
#include "test_invalid_ioctl.h"
@@ -247,6 +249,17 @@ static CU_TestInfo suite_buffs[] = {
{ "VIDIOC_REQBUFS with invalid type parameter, memory mapped i/o", test_VIDIOC_REQUBUFS_invalid_type_mmap },
{ "VIDIOC_REQBUFS with invalid type parameter, user pointer i/o", test_VIDIOC_REQUBUFS_invalid_type_userptr },
+ { "VIDIOC_QUERYBUF with memory map capture streaming i/o", test_VIDIOC_QUERYBUF_capture_mmap },
+ { "VIDIOC_QUERYBUF with user pointer capture streaming i/o", test_VIDIOC_QUERYBUF_capture_userptr },
+ { "VIDIOC_QUERYBUF with memory map output streaming i/o", test_VIDIOC_QUERYBUF_output_mmap },
+ { "VIDIOC_QUERYBUF with user pointer output streaming i/o", test_VIDIOC_QUERYBUF_output_userptr },
+ { "VIDIOC_QUERYBUF with overlay capture (invalid)", test_VIDIOC_QUERYBUF_overlay_capture },
+ { "VIDIOC_QUERYBUF with overlay output (invalid)", test_VIDIOC_QUERYBUF_overlay_output },
+ { "VIDIOC_QUERYBUF with invalid memory parameter, capture", test_VIDIOC_QUERYBUF_invalid_memory_capture },
+ { "VIDIOC_QUERYBUF with invalid memory parameter, output", test_VIDIOC_QUERYBUF_invalid_memory_output },
+ { "VIDIOC_QUERYBUF with invalid type parameter, memory mapped i/o", test_VIDIOC_QUERYBUF_invalid_type_mmap },
+ { "VIDIOC_QUERYBUF with invalid type parameter, user pointer i/o", test_VIDIOC_QUERYBUF_invalid_type_userptr },
+
CU_TEST_INFO_NULL,
};
------------------------------------------------------------------------------
The NEW KODAK i700 Series Scanners deliver under ANY circumstances! Your
production scanning environment may not be a perfect world - but thanks to
Kodak, there's a perfect scanner to get the job done! With the NEW KODAK i700
Series Scanner you'll get full speed at 300 dpi even with all image
processing features enabled. http://p.sf.net/sfu/kodak-com
_______________________________________________
Ltp-list mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/ltp-list
