testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_QUERYBUF.c

/*
 * v4l-test: Test environment for Video For Linux Two API
 *
 *  5 May 2009  0.1  First release
 *
 * Written by Márton Németh <nm127@freemail.hu>
 * 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);
}