| /* |
| * v4l-test: Test environment for Video For Linux Two API |
| * |
| * 20 Apr 2009 0.9 Added string content validation |
| * 18 Apr 2009 0.8 More strict check for strings |
| * 13 Apr 2009 0.7 Also show type in debug output; |
| * Add some debug output |
| * 3 Apr 2009 0.6 Test case for NULL parameter reworked |
| * 28 Mar 2009 0.5 Clean up ret and errno variable names and dprintf() output |
| * 18 Mar 2009 0.4 Duplicated test for V4L2_BUF_TYPE_VIDEO_CAPTURE removed |
| * 1 Jan 2009 0.3 Test cases added for index=S32_MAX and S32_MAX+1; |
| * Test functions renamed |
| * 22 Dec 2008 0.2 Test case with NULL parameter added |
| * 18 Dec 2008 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 <CUnit/Basic.h> |
| |
| #include "v4l2_test.h" |
| #include "dev_video.h" |
| #include "video_limits.h" |
| #include "v4l2_validator.h" |
| |
| #include "test_VIDIOC_ENUM_FMT.h" |
| |
| static void do_enumerate_formats(enum v4l2_buf_type type) { |
| int ret_enum, errno_enum; |
| struct v4l2_fmtdesc format; |
| struct v4l2_fmtdesc format2; |
| __u32 i; |
| |
| i = 0; |
| do { |
| memset(&format, 0xff, sizeof(format)); |
| format.index = i; |
| format.type = type; |
| |
| ret_enum = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_enum = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, index=%u, type=%i, ret_enum=%i, errno_enum=%i\n", |
| __FILE__, __LINE__, i, type, ret_enum, errno_enum); |
| if (ret_enum == 0) { |
| CU_ASSERT_EQUAL(ret_enum, 0); |
| CU_ASSERT_EQUAL(format.index, i); |
| //CU_ASSERT_EQUAL(format.type, ?); |
| //CU_ASSERT_EQUAL(format.flags, ?); |
| |
| CU_ASSERT(0 < strlen( (char*)format.description )); |
| CU_ASSERT(valid_string((char*)format.description, sizeof(format.description))); |
| |
| //CU_ASSERT_EQUAL(format.pixelformat, ?); |
| CU_ASSERT_EQUAL(format.reserved[0], 0); |
| CU_ASSERT_EQUAL(format.reserved[1], 0); |
| CU_ASSERT_EQUAL(format.reserved[2], 0); |
| CU_ASSERT_EQUAL(format.reserved[3], 0); |
| |
| /* Check if the unused bytes of the description string is also filled |
| * with zeros. Also check if there is any padding byte between |
| * any two fields then this padding byte is also filled with zeros. |
| */ |
| memset(&format2, 0, sizeof(format2)); |
| format2.index = format.index; |
| format2.type = format.type; |
| format2.flags = format.flags; |
| strncpy((char*)format2.description, (char*)format.description, sizeof(format2.description)); |
| format2.pixelformat = format.pixelformat; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| |
| dprintf("\tformat = {.index=%u, .type=0x%X, .flags=0x%X, " |
| ".description=\"%s\", .pixelformat=0x%X, " |
| ".reserved[]={ 0x%X, 0x%X, 0x%X, 0x%X } }\n", |
| format.index, |
| format.type, |
| format.flags, |
| format.description, |
| format.pixelformat, |
| format.reserved[0], |
| format.reserved[1], |
| format.reserved[2], |
| format.reserved[3] |
| ); |
| |
| } else { |
| CU_ASSERT_EQUAL(ret_enum, -1); |
| CU_ASSERT_EQUAL(errno_enum, EINVAL); |
| |
| memset(&format2, 0xff, sizeof(format2)); |
| format2.index = i; |
| format2.type = type; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| |
| } |
| i++; |
| } while (ret_enum == 0); |
| |
| } |
| |
| void test_VIDIOC_ENUM_FMT() { |
| do_enumerate_formats(V4L2_BUF_TYPE_VIDEO_CAPTURE); |
| do_enumerate_formats(V4L2_BUF_TYPE_VIDEO_OUTPUT); |
| do_enumerate_formats(V4L2_BUF_TYPE_VIDEO_OVERLAY); |
| do_enumerate_formats(V4L2_BUF_TYPE_VBI_CAPTURE); |
| do_enumerate_formats(V4L2_BUF_TYPE_VBI_OUTPUT); |
| do_enumerate_formats(V4L2_BUF_TYPE_SLICED_VBI_CAPTURE); |
| do_enumerate_formats(V4L2_BUF_TYPE_SLICED_VBI_OUTPUT); |
| do_enumerate_formats(V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY); |
| do_enumerate_formats(V4L2_BUF_TYPE_PRIVATE); |
| } |
| |
| void test_VIDIOC_ENUM_FMT_S32_MAX() { |
| int ret_enum, errno_enum; |
| struct v4l2_fmtdesc format; |
| struct v4l2_fmtdesc format2; |
| |
| /* test invalid index */ |
| memset(&format, 0xff, sizeof(format)); |
| format.index = (__u32)S32_MAX; |
| format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| ret_enum = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_enum = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, index=%u, type=%i, ret_enum=%i, errno_enum=%i\n", |
| __FILE__, __LINE__, format.index, format.type, ret_enum, errno_enum); |
| |
| CU_ASSERT_EQUAL(ret_enum, -1); |
| CU_ASSERT_EQUAL(errno_enum, EINVAL); |
| |
| /* Check whether the original format struct is untouched */ |
| memset(&format2, 0xff, sizeof(format2)); |
| format2.index = (__u32)S32_MAX; |
| format2.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| } |
| |
| void test_VIDIOC_ENUM_FMT_S32_MAX_1() { |
| int ret_enum, errno_enum; |
| struct v4l2_fmtdesc format; |
| struct v4l2_fmtdesc format2; |
| |
| /* test invalid index */ |
| memset(&format, 0xff, sizeof(format)); |
| format.index = ((__u32)S32_MAX)+1; |
| format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| ret_enum = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_enum = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, index=%u, type=%i, ret_enum=%i, errno_enum=%i\n", |
| __FILE__, __LINE__, format.index, format.type, ret_enum, errno_enum); |
| |
| CU_ASSERT_EQUAL(ret_enum, -1); |
| CU_ASSERT_EQUAL(errno_enum, EINVAL); |
| |
| /* Check whether the original format struct is untouched */ |
| memset(&format2, 0xff, sizeof(format2)); |
| format2.index = ((__u32)S32_MAX)+1; |
| format2.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| } |
| |
| void test_VIDIOC_ENUM_FMT_U32_MAX() { |
| int ret_enum, errno_enum; |
| struct v4l2_fmtdesc format; |
| struct v4l2_fmtdesc format2; |
| |
| /* test invalid index */ |
| memset(&format, 0xff, sizeof(format)); |
| format.index = U32_MAX; |
| format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| ret_enum = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_enum = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, index=%u, type=%i, ret_enum=%i, errno_enum=%i\n", |
| __FILE__, __LINE__, format.index, format.type, ret_enum, errno_enum); |
| |
| CU_ASSERT_EQUAL(ret_enum, -1); |
| CU_ASSERT_EQUAL(errno_enum, EINVAL); |
| |
| /* Check whether the original format struct is untouched */ |
| memset(&format2, 0xff, sizeof(format2)); |
| format2.index = U32_MAX; |
| format2.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| } |
| |
| void test_VIDIOC_ENUM_FMT_invalid_type() { |
| int ret_enum, errno_enum; |
| struct v4l2_fmtdesc format; |
| struct v4l2_fmtdesc format2; |
| int i; |
| |
| /* In this test case the .index is valid (0) and only the .type |
| * is invalid. The .type filed is an enum which is stored in an 'int'. |
| */ |
| |
| /* test invalid .type=0 */ |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = 0; |
| ret_enum = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_enum = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, index=%u, type=%i, ret_enum=%i, errno_enum=%i\n", |
| __FILE__, __LINE__, format.index, format.type, ret_enum, errno_enum); |
| |
| CU_ASSERT_EQUAL(ret_enum, -1); |
| CU_ASSERT_EQUAL(errno_enum, EINVAL); |
| |
| /* Check whether the original format struct is untouched */ |
| memset(&format2, 0xff, sizeof(format2)); |
| format2.index = 0; |
| format2.type = 0; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| |
| /* test invalid .type=SINT_MIN */ |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = SINT_MIN; |
| ret_enum = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_enum = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, index=%u, type=%i, ret_enum=%i, errno_enum=%i\n", |
| __FILE__, __LINE__, format.index, format.type, ret_enum, errno_enum); |
| |
| CU_ASSERT_EQUAL(ret_enum, -1); |
| CU_ASSERT_EQUAL(errno_enum, EINVAL); |
| |
| /* Check whether the original format struct is untouched */ |
| memset(&format2, 0xff, sizeof(format2)); |
| format2.index = 0; |
| format2.type = SINT_MIN; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| |
| /* test invalid .type=-1 */ |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = -1; |
| ret_enum = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_enum = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, index=%u, type=%i, ret_enum=%i, errno_enum=%i\n", |
| __FILE__, __LINE__, format.index, format.type, ret_enum, errno_enum); |
| |
| CU_ASSERT_EQUAL(ret_enum, -1); |
| CU_ASSERT_EQUAL(errno_enum, EINVAL); |
| |
| /* Check whether the original format struct is untouched */ |
| memset(&format2, 0xff, sizeof(format2)); |
| format2.index = 0; |
| format2.type = -1; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| |
| /* test invalid .type= 8..0x7F */ |
| for (i = V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY+1; i < V4L2_BUF_TYPE_PRIVATE; i++) { |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = i; |
| ret_enum = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_enum = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, index=%u, type=%i, ret_enum=%i, errno_enum=%i\n", |
| __FILE__, __LINE__, format.index, format.type, ret_enum, errno_enum); |
| |
| CU_ASSERT_EQUAL(ret_enum, -1); |
| CU_ASSERT_EQUAL(errno_enum, EINVAL); |
| |
| /* Check whether the original format struct is untouched */ |
| memset(&format2, 0xff, sizeof(format2)); |
| format2.index = 0; |
| format2.type = i; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| } |
| |
| /* .type = 0x80..0x7FFF FFFF is the private range */ |
| |
| /* Assume that 0x7FFF FFFF is invalid in the private range. |
| * This might be a wrong assumption, but let's have a test case like |
| * this for now. |
| */ |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = SINT_MAX; |
| ret_enum = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_enum = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, index=%u, type=%i, ret_enum=%i, errno_enum=%i\n", |
| __FILE__, __LINE__, format.index, format.type, ret_enum, errno_enum); |
| |
| CU_ASSERT_EQUAL(ret_enum, -1); |
| CU_ASSERT_EQUAL(errno_enum, EINVAL); |
| |
| /* Check whether the original format struct is untouched */ |
| memset(&format2, 0xff, sizeof(format2)); |
| format2.index = 0; |
| format2.type = SINT_MAX; |
| CU_ASSERT_EQUAL(memcmp(&format, &format2, sizeof(format)), 0); |
| } |
| |
| void test_VIDIOC_ENUM_FMT_NULL() { |
| int ret_capture, errno_capture; |
| int ret_output, errno_output; |
| int ret_video_overlay, errno_video_overlay; |
| int ret_vbi_capture, errno_vbi_capture; |
| int ret_vbi_output, errno_vbi_output; |
| int ret_sliced_vbi_capture, errno_sliced_vbi_capture; |
| int ret_sliced_vbi_output, errno_sliced_vbi_output; |
| int ret_video_output_overlay, errno_video_output_overlay; |
| int ret_private, errno_private; |
| int ret_null, errno_null; |
| struct v4l2_fmtdesc format; |
| |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; |
| ret_capture = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_capture = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_capture=%i, errno_capture=%i\n", |
| __FILE__, __LINE__, ret_capture, errno_capture); |
| |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; |
| ret_output = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_output = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_output=%i, errno_output=%i\n", |
| __FILE__, __LINE__, ret_output, errno_output); |
| |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; |
| ret_video_overlay = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_video_overlay = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_video_overlay=%i, errno_video_overlay=%i\n", |
| __FILE__, __LINE__, ret_video_overlay, errno_video_overlay); |
| |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = V4L2_BUF_TYPE_VBI_CAPTURE; |
| ret_vbi_capture = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_vbi_capture = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_vbi_capture=%i, errno_vbi_capture=%i\n", |
| __FILE__, __LINE__, ret_vbi_capture, errno_vbi_capture); |
| |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = V4L2_BUF_TYPE_VBI_OUTPUT; |
| ret_vbi_output = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_vbi_output = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_vbi_output=%i, errno_vbi_output=%i\n", |
| __FILE__, __LINE__, ret_vbi_output, errno_vbi_output); |
| |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE; |
| ret_sliced_vbi_capture = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_sliced_vbi_capture = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_sliced_vbi_capture=%i, errno_sliced_vbi_capture=%i\n", |
| __FILE__, __LINE__, ret_sliced_vbi_capture, errno_sliced_vbi_capture); |
| |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = V4L2_BUF_TYPE_SLICED_VBI_OUTPUT; |
| ret_sliced_vbi_output = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_sliced_vbi_output = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_sliced_vbi_output=%i, errno_sliced_vbi_output=%i\n", |
| __FILE__, __LINE__, ret_sliced_vbi_output, errno_sliced_vbi_output); |
| |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY; |
| ret_video_output_overlay = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_video_output_overlay = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_video_output_overlay=%i, errno_video_output_overlay=%i\n", |
| __FILE__, __LINE__, ret_video_output_overlay, errno_video_output_overlay); |
| |
| memset(&format, 0xff, sizeof(format)); |
| format.index = 0; |
| format.type = V4L2_BUF_TYPE_PRIVATE; |
| ret_private = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, &format); |
| errno_private = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_private=%i, errno_private=%i\n", |
| __FILE__, __LINE__, ret_private, errno_private); |
| |
| ret_null = ioctl(get_video_fd(), VIDIOC_ENUM_FMT, NULL); |
| errno_null = errno; |
| |
| dprintf("\t%s:%u: VIDIOC_ENUM_FMT, ret_null=%i, errno_null=%i\n", |
| __FILE__, __LINE__, ret_null, errno_null); |
| |
| if (ret_capture == 0 || ret_output == 0 || |
| ret_video_overlay == 0 || ret_vbi_capture == 0 || |
| ret_vbi_output == 0 || ret_sliced_vbi_capture == 0 || |
| ret_sliced_vbi_output == 0 || ret_video_output_overlay == 0 || |
| ret_private == 0) { |
| CU_ASSERT_EQUAL(ret_null, -1); |
| CU_ASSERT_EQUAL(errno_null, EFAULT); |
| } else { |
| CU_ASSERT_EQUAL(ret_capture, -1); |
| CU_ASSERT_EQUAL(errno_null, EINVAL); |
| CU_ASSERT_EQUAL(ret_output, -1); |
| CU_ASSERT_EQUAL(errno_output, EINVAL); |
| CU_ASSERT_EQUAL(ret_video_overlay, -1); |
| CU_ASSERT_EQUAL(errno_video_overlay, EINVAL); |
| CU_ASSERT_EQUAL(ret_vbi_capture, -1); |
| CU_ASSERT_EQUAL(errno_vbi_capture, EINVAL); |
| CU_ASSERT_EQUAL(ret_vbi_output, -1); |
| CU_ASSERT_EQUAL(errno_vbi_output, EINVAL); |
| CU_ASSERT_EQUAL(ret_sliced_vbi_capture, -1); |
| CU_ASSERT_EQUAL(errno_sliced_vbi_capture, EINVAL); |
| CU_ASSERT_EQUAL(ret_sliced_vbi_output, -1); |
| CU_ASSERT_EQUAL(errno_sliced_vbi_output, EINVAL); |
| CU_ASSERT_EQUAL(ret_video_output_overlay, -1); |
| CU_ASSERT_EQUAL(errno_video_output_overlay, EINVAL); |
| CU_ASSERT_EQUAL(ret_private, -1); |
| CU_ASSERT_EQUAL(errno_private, EINVAL); |
| CU_ASSERT_EQUAL(ret_null, -1); |
| CU_ASSERT_EQUAL(errno_null, EINVAL); |
| } |
| |
| } |