1 /* 2 * v4l-test: Test environment for Video For Linux Two API 3 * 4 * 3 Apr 2009 0.6 Test case for with NULL parameter reworked 5 * 28 Mar 2009 0.5 Clean up ret and errno variable names and dprintf() output 6 * 7 Mar 2009 0.4 Typo corrected 7 * 9 Feb 2009 0.3 Modify test_VIDIOC_CROPCAP_enum_INPUT() to support drivers 8 * without any inputs 9 * 3 Feb 2009 0.2 Typo fixed 10 * 21 Dec 2008 0.1 First release 11 * 12 * Written by M�rton N�meth <nm127@freemail.hu> 13 * Released under GPL 14 */ 15 16 #include <stdio.h> 17 #include <sys/types.h> 18 #include <sys/stat.h> 19 #include <fcntl.h> 20 #include <unistd.h> 21 #include <sys/ioctl.h> 22 #include <errno.h> 23 #include <string.h> 24 25 #include <linux/videodev2.h> 26 #include <linux/errno.h> 27 28 #include <CUnit/CUnit.h> 29 30 #include "v4l2_test.h" 31 #include "dev_video.h" 32 #include "video_limits.h" 33 34 #include "test_VIDIOC_CROPCAP.h" 35 do_ioctl_VIDIOC_CROPCAP(enum v4l2_buf_type buf_type,int expected_ret)36 static void do_ioctl_VIDIOC_CROPCAP(enum v4l2_buf_type buf_type, 37 int expected_ret) 38 { 39 int ret_cap, errno_cap; 40 struct v4l2_cropcap cropcap; 41 struct v4l2_cropcap cropcap2; 42 43 memset(&cropcap, 0xff, sizeof(cropcap)); 44 cropcap.type = buf_type; 45 ret_cap = ioctl(get_video_fd(), VIDIOC_CROPCAP, &cropcap); 46 errno_cap = errno; 47 48 dprintf("\t%s:%u: type=%i, ret_cap=%i, errno_cap=%i, expected_ret=%i\n", 49 __FILE__, __LINE__, buf_type, ret_cap, errno_cap, expected_ret); 50 51 if (expected_ret != 0) { 52 CU_ASSERT_EQUAL(ret_cap, expected_ret); 53 } 54 if (ret_cap == 0) { 55 CU_ASSERT_EQUAL(ret_cap, 0); 56 CU_ASSERT_EQUAL(cropcap.type, buf_type); 57 58 /* | left x */ 59 /* ----+----+--------------------------------------> */ 60 /* | : */ 61 /* top + +-------- cropcap ------------+ ^ */ 62 /* | | | | */ 63 /* | | +------- defrect ---------+ | | */ 64 /* | | | | | | */ 65 /* | | | | | | */ 66 /* | | | | | | height */ 67 /* | | +-------------------------+ | | */ 68 /* | | | | */ 69 /* | | | | */ 70 /* | +-----------------------------+ v */ 71 /* | : : */ 72 /* | <---------- width ------------> */ 73 /* | */ 74 /* v y */ 75 76 /* top left corner */ 77 CU_ASSERT(cropcap.bounds.left <= cropcap.defrect.left); 78 CU_ASSERT(cropcap.bounds.top <= cropcap.defrect.top); 79 80 /* size of default cropping rectangle should be smaller or */ 81 /* equal to the cropping bounds */ 82 CU_ASSERT(cropcap.defrect.width <= cropcap.bounds.width); 83 CU_ASSERT(cropcap.defrect.height <= cropcap.bounds.height); 84 85 /* the right bottom corner should not exceed bounds */ 86 CU_ASSERT(cropcap.defrect.left + cropcap.defrect.width <= 87 cropcap.bounds.left + cropcap.bounds.width); 88 CU_ASSERT(cropcap.defrect.top + cropcap.defrect.height <= 89 cropcap.bounds.top + cropcap.bounds.height); 90 91 //CU_ASSERT_EQUAL(cropcap.pixelaspect.numerator, ?); 92 CU_ASSERT_NOT_EQUAL(cropcap.pixelaspect.numerator, 0); 93 //CU_ASSERT_EQUAL(cropcap.pixelaspect.denominator, ?); 94 CU_ASSERT_NOT_EQUAL(cropcap.pixelaspect.denominator, 0); 95 96 dprintf("\tcropcap = { .type = %i, " 97 ".bounds = { .left = %i, .top = %i, .width = %i, .height = %i }, " 98 ".defrect = { .left = %i, .top = %i, .width = %i, .height = %i }, " 99 ".pixelaspect = { .numerator = %u, .denominator = %u } " 100 "}\n", 101 cropcap.type, 102 cropcap.bounds.left, 103 cropcap.bounds.top, 104 cropcap.bounds.width, 105 cropcap.bounds.height, 106 cropcap.defrect.left, 107 cropcap.defrect.top, 108 cropcap.defrect.width, 109 cropcap.defrect.height, 110 cropcap.pixelaspect.numerator, 111 cropcap.pixelaspect.denominator); 112 113 } else { 114 CU_ASSERT_EQUAL(ret_cap, -1); 115 CU_ASSERT_EQUAL(errno_cap, EINVAL); 116 117 memset(&cropcap2, 0xff, sizeof(cropcap2)); 118 cropcap2.type = buf_type; 119 CU_ASSERT_EQUAL(memcmp(&cropcap, &cropcap2, sizeof(cropcap)), 120 0); 121 122 } 123 124 } 125 test_VIDIOC_CROPCAP()126 void test_VIDIOC_CROPCAP() 127 { 128 129 do_ioctl_VIDIOC_CROPCAP(0, -1); 130 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_VIDEO_CAPTURE, 0); 131 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_VIDEO_OUTPUT, 0); 132 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_VIDEO_OVERLAY, 0); 133 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_VBI_CAPTURE, -1); 134 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_VBI_OUTPUT, -1); 135 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_SLICED_VBI_CAPTURE, -1); 136 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_SLICED_VBI_OUTPUT, -1); 137 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY, -1); 138 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_PRIVATE - 1, -1); 139 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_PRIVATE, 0); 140 do_ioctl_VIDIOC_CROPCAP(V4L2_BUF_TYPE_PRIVATE + 1, 0); 141 do_ioctl_VIDIOC_CROPCAP(S32_MAX, -1); 142 do_ioctl_VIDIOC_CROPCAP(((__u32) S32_MAX) + 1, -1); 143 do_ioctl_VIDIOC_CROPCAP(U32_MAX - 1, -1); 144 do_ioctl_VIDIOC_CROPCAP(U32_MAX, -1); 145 146 } 147 test_VIDIOC_CROPCAP_enum_INPUT()148 void test_VIDIOC_CROPCAP_enum_INPUT() 149 { 150 int ret_get, errno_get; 151 int ret_set, errno_set; 152 int enum_ret; 153 __u32 input_index_orig; 154 struct v4l2_input input; 155 __u32 i; 156 int f; 157 158 f = get_video_fd(); 159 160 memset(&input_index_orig, 0xff, sizeof(input_index_orig)); 161 ret_get = ioctl(f, VIDIOC_G_INPUT, &input_index_orig); 162 errno_get = errno; 163 164 if (ret_get == 0) { 165 CU_ASSERT_EQUAL(ret_get, 0); 166 i = 0; 167 do { 168 memset(&input, 0xff, sizeof(input)); 169 input.index = i; 170 enum_ret = ioctl(f, VIDIOC_ENUMINPUT, &input); 171 172 dprintf 173 ("\t%s:%u: ENUMINPUT: i=%u, enum_ret=%i, errno=%i\n", 174 __FILE__, __LINE__, i, enum_ret, errno); 175 176 if (enum_ret == 0) { 177 ret_set = 178 ioctl(f, VIDIOC_S_INPUT, &input.index); 179 errno_set = errno; 180 181 dprintf 182 ("\t%s:%u: input.index=0x%X, ret_set=%i, errno_set=%i\n", 183 __FILE__, __LINE__, input.index, ret_set, 184 errno_set); 185 186 CU_ASSERT_EQUAL(ret_set, 0); 187 if (ret_set == 0) { 188 test_VIDIOC_CROPCAP(); 189 } 190 191 } 192 i++; 193 } while (enum_ret == 0 && i != 0); 194 195 /* Setting the original input_id should not fail */ 196 ret_set = ioctl(f, VIDIOC_S_INPUT, &input_index_orig); 197 errno_set = errno; 198 199 CU_ASSERT_EQUAL(ret_set, 0); 200 } else { 201 CU_ASSERT_EQUAL(ret_get, -1); 202 CU_ASSERT_EQUAL(errno_get, EINVAL); 203 } 204 } 205 test_VIDIOC_CROPCAP_NULL()206 void test_VIDIOC_CROPCAP_NULL() 207 { 208 int ret_capture, errno_capture; 209 int ret_output, errno_output; 210 int ret_overlay, errno_overlay; 211 int ret_private, errno_private; 212 int ret_private_1, errno_private_1; 213 int ret_null, errno_null; 214 struct v4l2_cropcap cropcap; 215 216 memset(&cropcap, 0xff, sizeof(cropcap)); 217 cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 218 ret_capture = ioctl(get_video_fd(), VIDIOC_CROPCAP, &cropcap); 219 errno_capture = errno; 220 221 dprintf("\t%s:%u: VIDIOC_CROPCAP, ret_capture=%i, errno_capture=%i\n", 222 __FILE__, __LINE__, ret_capture, errno_capture); 223 224 memset(&cropcap, 0xff, sizeof(cropcap)); 225 cropcap.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; 226 ret_output = ioctl(get_video_fd(), VIDIOC_CROPCAP, &cropcap); 227 errno_output = errno; 228 229 dprintf("\t%s:%u: VIDIOC_CROPCAP, ret_output=%i, errno_output=%i\n", 230 __FILE__, __LINE__, ret_output, errno_output); 231 232 memset(&cropcap, 0xff, sizeof(cropcap)); 233 cropcap.type = V4L2_BUF_TYPE_VIDEO_OVERLAY; 234 ret_overlay = ioctl(get_video_fd(), VIDIOC_CROPCAP, &cropcap); 235 errno_overlay = errno; 236 237 dprintf("\t%s:%u: VIDIOC_CROPCAP, ret_overlay=%i, errno_overlay=%i\n", 238 __FILE__, __LINE__, ret_overlay, errno_overlay); 239 240 memset(&cropcap, 0xff, sizeof(cropcap)); 241 cropcap.type = V4L2_BUF_TYPE_PRIVATE; 242 ret_private = ioctl(get_video_fd(), VIDIOC_CROPCAP, &cropcap); 243 errno_private = errno; 244 245 dprintf("\t%s:%u: VIDIOC_CROPCAP, ret_private=%i, errno_private=%i\n", 246 __FILE__, __LINE__, ret_private, errno_private); 247 248 memset(&cropcap, 0xff, sizeof(cropcap)); 249 cropcap.type = V4L2_BUF_TYPE_PRIVATE + 1; 250 ret_private_1 = ioctl(get_video_fd(), VIDIOC_CROPCAP, &cropcap); 251 errno_private_1 = errno; 252 253 dprintf 254 ("\t%s:%u: VIDIOC_CROPCAP, ret_private_1=%i, errno_private_1=%i\n", 255 __FILE__, __LINE__, ret_private_1, errno_private_1); 256 257 ret_null = ioctl(get_video_fd(), VIDIOC_CROPCAP, NULL); 258 errno_null = errno; 259 260 dprintf("\t%s:%u: VIDIOC_CROPCAP, ret_null=%i, errno_null=%i\n", 261 __FILE__, __LINE__, ret_null, errno_null); 262 263 /* Check if at least one type was supported */ 264 if (ret_capture == 0 || ret_output == 0 || ret_overlay == 0 || 265 ret_private == 0 || ret_private_1 == 0) { 266 /* the parameter shall be validated */ 267 CU_ASSERT_EQUAL(ret_null, -1); 268 CU_ASSERT_EQUAL(errno_null, EFAULT); 269 } else { 270 /* VIDIOC_CROPCAP is not supported at all, the parameter 271 * shall also not be checked. 272 */ 273 CU_ASSERT_EQUAL(ret_capture, -1); 274 CU_ASSERT_EQUAL(errno_capture, EINVAL); 275 CU_ASSERT_EQUAL(ret_output, -1); 276 CU_ASSERT_EQUAL(errno_output, EINVAL); 277 CU_ASSERT_EQUAL(ret_overlay, -1); 278 CU_ASSERT_EQUAL(errno_overlay, EINVAL); 279 CU_ASSERT_EQUAL(ret_private, -1); 280 CU_ASSERT_EQUAL(errno_private, EINVAL); 281 CU_ASSERT_EQUAL(ret_private_1, -1); 282 CU_ASSERT_EQUAL(errno_private_1, EINVAL); 283 CU_ASSERT_EQUAL(ret_null, -1); 284 CU_ASSERT_EQUAL(errno_null, EINVAL); 285 } 286 287 } 288