1 /*
2 * v4l-test: Test environment for Video For Linux Two API
3 *
4 * 20 Apr 2009 0.7 Added string content validation
5 * 18 Apr 2009 0.6 More strict check for strings
6 * 29 Mar 2009 0.5 Clean up test case for NULL parameter
7 * 22 Mar 2009 0.4 Cleaned up dprintf() messages
8 * 9 Feb 2009 0.3 Typo corrected; added some debug messages
9 * 7 Feb 2009 0.2 Test case test_VIDIOC_G_AUDOUT_ignore_index added
10 * 3 Feb 2009 0.1 First release
11 *
12 * Written by M�rton N�meth <nm127@freemail.hu>
13 * Released under GPL
14 *
15 */
16
17 #include <stdio.h>
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #include <fcntl.h>
21 #include <unistd.h>
22 #include <sys/ioctl.h>
23 #include <errno.h>
24 #include <string.h>
25
26 #include <linux/videodev2.h>
27 #include <linux/errno.h>
28
29 #include <CUnit/CUnit.h>
30
31 #include "v4l2_test.h"
32 #include "dev_video.h"
33 #include "video_limits.h"
34 #include "v4l2_validator.h"
35
36 #include "test_VIDIOC_AUDOUT.h"
37
valid_audioout_mode(__u32 mode)38 int valid_audioout_mode(__u32 mode)
39 {
40 int valid = 0;
41
42 if ((mode & ~(V4L2_AUDMODE_AVL))
43 == 0) {
44 valid = 1;
45 } else {
46 valid = 0;
47 }
48 return valid;
49 }
50
test_VIDIOC_G_AUDOUT()51 void test_VIDIOC_G_AUDOUT()
52 {
53 int ret_get, errno_get;
54 struct v4l2_audioout audioout;
55 struct v4l2_audioout audioout2;
56
57 memset(&audioout, 0xff, sizeof(audioout));
58 ret_get = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout);
59 errno_get = errno;
60
61 dprintf("\tVIDIOC_AUDIOOUT, ret_get=%i, errno_get=%i\n", ret_get,
62 errno_get);
63
64 if (ret_get == 0) {
65 CU_ASSERT_EQUAL(ret_get, 0);
66
67 //CU_ASSERT_EQUAL(audioout.index, ?);
68
69 CU_ASSERT(0 < strlen((char *)audioout.name));
70 CU_ASSERT(valid_string
71 ((char *)audioout.name, sizeof(audioout.name)));
72
73 CU_ASSERT_EQUAL(audioout.capability, 0);
74 CU_ASSERT_EQUAL(audioout.mode, 0);
75
76 CU_ASSERT_EQUAL(audioout.reserved[0], 0);
77 CU_ASSERT_EQUAL(audioout.reserved[1], 0);
78
79 /* Check if the unused bytes of the name string is also filled
80 * with zeros. Also check if there is any padding byte between
81 * any two fields then this padding byte is also filled with zeros.
82 */
83 memset(&audioout2, 0, sizeof(audioout2));
84 audioout2.index = audioout.index;
85 strncpy((char *)audioout2.name, (char *)audioout.name,
86 sizeof(audioout2.name));
87 audioout2.capability = audioout.capability;
88 audioout2.mode = audioout.mode;
89 CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)),
90 0);
91
92 dprintf("\taudioout = {.index=%u, .name=\"%s\", "
93 ".capability=0x%X, .mode=0x%X, "
94 ".reserved[]={ 0x%X, 0x%X } }\n",
95 audioout.index,
96 audioout.name,
97 audioout.capability,
98 audioout.mode,
99 audioout.reserved[0], audioout.reserved[1]
100 );
101
102 } else {
103 CU_ASSERT_EQUAL(ret_get, -1);
104 CU_ASSERT_EQUAL(errno_get, EINVAL);
105
106 /* check if the audioout structure is untouched */
107 memset(&audioout2, 0xff, sizeof(audioout2));
108 CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)),
109 0);
110
111 }
112
113 }
114
test_VIDIOC_G_AUDOUT_ignore_index()115 void test_VIDIOC_G_AUDOUT_ignore_index()
116 {
117 int reg_get1, errno1;
118 int reg_get2, errno2;
119 struct v4l2_audioout audioout;
120 struct v4l2_audioout audioout2;
121
122 /* check whether the "index" field is ignored by VIDIOC_G_AUDOUT */
123
124 memset(&audioout, 0, sizeof(audioout));
125 reg_get1 = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout);
126 errno1 = errno;
127
128 dprintf("\tVIDIOC_G_AUDOUT, reg_get1=%i, errno1=%i\n", reg_get1,
129 errno1);
130
131 memset(&audioout2, 0, sizeof(audioout2));
132 audioout2.index = U32_MAX;
133 reg_get2 = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout2);
134 errno2 = errno;
135
136 dprintf("\tVIDIOC_G_AUDOUT, reg_get2=%i, errno2=%i\n", reg_get2,
137 errno2);
138
139 if (reg_get1 == 0) {
140 CU_ASSERT_EQUAL(reg_get2, 0);
141 CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)),
142 0);
143 } else {
144 CU_ASSERT_EQUAL(reg_get1, -1);
145 CU_ASSERT_EQUAL(errno1, EINVAL);
146 CU_ASSERT_EQUAL(reg_get2, -1);
147 CU_ASSERT_EQUAL(errno2, EINVAL);
148 }
149
150 }
151
test_VIDIOC_G_AUDOUT_NULL()152 void test_VIDIOC_G_AUDOUT_NULL()
153 {
154 int ret_get, errno_get;
155 int ret_null, errno_null;
156 struct v4l2_audioout audioout;
157
158 memset(&audioout, 0xff, sizeof(audioout));
159 ret_get = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout);
160 errno_get = errno;
161
162 dprintf("\t%s:%u: VIDIOC_AUDIOOUT, ret_get=%i, errno_get=%i\n",
163 __FILE__, __LINE__, ret_get, errno_get);
164
165 ret_null = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, NULL);
166 errno_null = errno;
167
168 dprintf("\t%s:%u: VIDIOC_AUDIOOUT, ret_null=%i, errno_null=%i\n",
169 __FILE__, __LINE__, ret_null, errno_null);
170
171 /* check if VIDIOC_G_AUDOUT is supported at all or not */
172 if (ret_get == 0) {
173 /* VIDIOC_G_AUDOUT is supported, the parameter should be checked */
174 CU_ASSERT_EQUAL(ret_null, -1);
175 CU_ASSERT_EQUAL(errno_null, EFAULT);
176 } else {
177 /* VIDIOC_G_AUDOUT not supported at all, the parameter should not be evaluated */
178 CU_ASSERT_EQUAL(ret_null, -1);
179 CU_ASSERT_EQUAL(errno_null, EINVAL);
180 }
181
182 }
183
184 /* TODO: - try with all possible outputs (VIDIOC_ENUMOUTPUT)
185 * - try with STREAM_ON
186 */
187
test_VIDIOC_S_AUDOUT()188 void test_VIDIOC_S_AUDOUT()
189 {
190 int ret_orig, errno_orig;
191 int ret_enum, errno_enum;
192 int ret_set, errno_set;
193 __u32 index;
194 __u32 i;
195 struct v4l2_audioout audioout_orig;
196 struct v4l2_audioout audioout_enum;
197 struct v4l2_audioout audioout_set;
198
199 /* This testcase tries to find out the relations between the following
200 * commands:
201 * - VIDIOC_ENUMAUDOUT
202 * - VIDIOC_G_AUDOUT
203 * - VIDIOC_S_AUDOUT
204 */
205
206 /* remember the original settings */
207 memset(&audioout_orig, 0, sizeof(audioout_orig));
208 ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout_orig);
209 errno_orig = errno;
210
211 dprintf("\tVIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig,
212 errno_orig);
213
214 if (ret_orig == 0) {
215 CU_ASSERT_EQUAL(ret_orig, 0);
216 } else {
217 CU_ASSERT_EQUAL(ret_orig, -1);
218 CU_ASSERT_EQUAL(errno_orig, EINVAL);
219 }
220
221 /* try to continue even if VIDIOC_G_AUDOUT seems to be not supported */
222
223 index = 0;
224 do {
225 memset(&audioout_enum, 0, sizeof(audioout_enum));
226 audioout_enum.index = index;
227 ret_enum =
228 ioctl(get_video_fd(), VIDIOC_ENUMAUDOUT, &audioout_enum);
229 errno_enum = errno;
230
231 if (ret_enum == 0) {
232 memset(&audioout_set, 0xff, sizeof(audioout_set));
233 audioout_set.index = index;
234 ret_set =
235 ioctl(get_video_fd(), VIDIOC_S_AUDOUT,
236 &audioout_set);
237 errno_set = errno;
238
239 /* It shall be always possible to set the audio output to the
240 * enumerated values.
241 */
242 CU_ASSERT_EQUAL(ret_set, 0);
243
244 index++;
245 }
246
247 } while (ret_enum == 0);
248 CU_ASSERT_EQUAL(ret_enum, -1);
249 CU_ASSERT_EQUAL(errno_enum, EINVAL);
250
251 /* try to set audio output to beyond the enumerated values */
252 for (i = 0; i <= 32; i++) {
253 memset(&audioout_set, 0xff, sizeof(audioout_set));
254 audioout_set.index = index;
255 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
256 errno_set = errno;
257
258 CU_ASSERT_EQUAL(ret_set, -1);
259 CU_ASSERT_EQUAL(errno_set, EINVAL);
260
261 index++;
262 }
263
264 /* restore the original audio output settings */
265 memset(&audioout_set, 0, sizeof(audioout_set));
266 audioout_set.index = audioout_orig.index;
267 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
268 errno_set = errno;
269
270 if (ret_orig == 0) {
271 /* If it was possible at the beginning to get the audio output then
272 * it shall be possible to set it again.
273 */
274 CU_ASSERT_EQUAL(ret_set, 0);
275 } else {
276 /* In case we could not fetch the audio output value at the start
277 * of this test case: the VIDIOC_S_AUDOUT shall also fail.
278 */
279 CU_ASSERT_EQUAL(ret_set, -1);
280 CU_ASSERT_EQUAL(errno_set, EINVAL);
281 }
282
283 }
284
test_VIDIOC_S_AUDOUT_S32_MAX()285 void test_VIDIOC_S_AUDOUT_S32_MAX()
286 {
287 int ret_orig, errno_orig;
288 int ret_set, errno_set;
289 struct v4l2_audioout audioout;
290 struct v4l2_audioout audioout2;
291 struct v4l2_audioout audioout_orig;
292 struct v4l2_audioout audioout_set;
293
294 /* remember the original settings */
295 memset(&audioout_orig, 0, sizeof(audioout_orig));
296 ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout_orig);
297 errno_orig = errno;
298
299 dprintf("\tVIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig,
300 errno_orig);
301
302 /* test invalid index */
303 memset(&audioout, 0xff, sizeof(audioout));
304 audioout.index = (__u32) S32_MAX;
305 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout);
306 errno_set = errno;
307
308 CU_ASSERT_EQUAL(ret_set, -1);
309 CU_ASSERT_EQUAL(errno_set, EINVAL);
310
311 /* Check whether the original audioout struct is untouched */
312 memset(&audioout2, 0xff, sizeof(audioout2));
313 audioout2.index = (__u32) S32_MAX;
314 CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)), 0);
315
316 /* restore the original audio output settings */
317 memset(&audioout_set, 0, sizeof(audioout_set));
318 audioout_set.index = audioout_orig.index;
319 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
320 errno_set = errno;
321
322 dprintf("\tVIDIOC_S_AUDOUT, ret_set=%i, errno_set=%i\n", ret_set,
323 errno_set);
324
325 if (ret_orig == 0) {
326 /* If it was possible at the beginning to get the audio output then
327 * it shall be possible to set it again.
328 */
329 CU_ASSERT_EQUAL(ret_set, 0);
330 } else {
331 /* In case we could not fetch the audio output value at the start
332 * of this test case: the VIDIOC_S_AUDOUT shall also fail.
333 */
334 CU_ASSERT_EQUAL(ret_set, -1);
335 CU_ASSERT_EQUAL(errno_set, EINVAL);
336 }
337 }
338
test_VIDIOC_S_AUDOUT_S32_MAX_1()339 void test_VIDIOC_S_AUDOUT_S32_MAX_1()
340 {
341 int ret_orig, errno_orig;
342 int ret_set, errno_set;
343 struct v4l2_audioout audioout;
344 struct v4l2_audioout audioout2;
345 struct v4l2_audioout audioout_orig;
346 struct v4l2_audioout audioout_set;
347
348 /* remember the original settings */
349 memset(&audioout_orig, 0, sizeof(audioout_orig));
350 ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout_orig);
351 errno_orig = errno;
352
353 dprintf("\tVIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig,
354 errno_orig);
355
356 /* test invalid index */
357 memset(&audioout, 0xff, sizeof(audioout));
358 audioout.index = ((__u32) S32_MAX) + 1;
359 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout);
360 errno_set = errno;
361
362 CU_ASSERT_EQUAL(ret_set, -1);
363 CU_ASSERT_EQUAL(errno_set, EINVAL);
364
365 /* Check whether the original audioout struct is untouched */
366 memset(&audioout2, 0xff, sizeof(audioout2));
367 audioout2.index = ((__u32) S32_MAX) + 1;
368 CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)), 0);
369
370 /* restore the original audio output settings */
371 memset(&audioout_set, 0, sizeof(audioout_set));
372 audioout_set.index = audioout_orig.index;
373 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
374 errno_set = errno;
375
376 dprintf("\tVIDIOC_S_AUDOUT, ret_set=%i, errno_set=%i\n", ret_set,
377 errno_set);
378
379 if (ret_orig == 0) {
380 /* If it was possible at the beginning to get the audio output then
381 * it shall be possible to set it again.
382 */
383 CU_ASSERT_EQUAL(ret_set, 0);
384 } else {
385 /* In case we could not fetch the audio output value at the start
386 * of this test case: the VIDIOC_S_AUDOUT shall also fail.
387 */
388 CU_ASSERT_EQUAL(ret_set, -1);
389 CU_ASSERT_EQUAL(errno_set, EINVAL);
390 }
391 }
392
test_VIDIOC_S_AUDOUT_U32_MAX()393 void test_VIDIOC_S_AUDOUT_U32_MAX()
394 {
395 int ret_orig, errno_orig;
396 int ret_set, errno_set;
397 struct v4l2_audioout audioout;
398 struct v4l2_audioout audioout2;
399 struct v4l2_audioout audioout_orig;
400 struct v4l2_audioout audioout_set;
401
402 /* remember the original settings */
403 memset(&audioout_orig, 0, sizeof(audioout_orig));
404 ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audioout_orig);
405 errno_orig = errno;
406
407 dprintf("\tVIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig,
408 errno_orig);
409 /* test invalid index */
410 memset(&audioout, 0xff, sizeof(audioout));
411 audioout.index = U32_MAX;
412 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout);
413 errno_set = errno;
414
415 CU_ASSERT_EQUAL(ret_set, -1);
416 CU_ASSERT_EQUAL(errno_set, EINVAL);
417
418 /* Check whether the original audioout struct is untouched */
419 memset(&audioout2, 0xff, sizeof(audioout2));
420 audioout2.index = U32_MAX;
421 CU_ASSERT_EQUAL(memcmp(&audioout, &audioout2, sizeof(audioout)), 0);
422
423 /* restore the original audio output settings */
424 memset(&audioout_set, 0, sizeof(audioout_set));
425 audioout_set.index = audioout_orig.index;
426 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audioout_set);
427 errno_set = errno;
428
429 dprintf("\tVIDIOC_S_AUDOUT, ret_set=%i, errno_set=%i\n", ret_set,
430 errno_set);
431
432 if (ret_orig == 0) {
433 /* If it was possible at the beginning to get the audio output then
434 * it shall be possible to set it again.
435 */
436 CU_ASSERT_EQUAL(ret_set, 0);
437 } else {
438 /* In case we could not fetch the audio output value at the start
439 * of this test case: the VIDIOC_S_AUDOUT shall also fail.
440 */
441 CU_ASSERT_EQUAL(ret_set, -1);
442 CU_ASSERT_EQUAL(errno_set, EINVAL);
443 }
444 }
445
test_VIDIOC_S_AUDOUT_NULL()446 void test_VIDIOC_S_AUDOUT_NULL()
447 {
448 int ret_orig, errno_orig;
449 int ret_set, errno_set;
450 int ret_get, errno_get;
451 struct v4l2_audio audio_orig;
452 struct v4l2_audio audio_set;
453
454 /* remember the original settings */
455 memset(&audio_orig, 0, sizeof(audio_orig));
456 ret_orig = ioctl(get_video_fd(), VIDIOC_G_AUDOUT, &audio_orig);
457 errno_orig = errno;
458
459 dprintf("\tVIDIOC_G_AUDOUT, ret_orig=%i, errno_orig=%i\n", ret_orig,
460 errno_orig);
461
462 memset(&audio_set, 0, sizeof(audio_set));
463 ret_get = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audio_set);
464 errno_get = errno;
465
466 dprintf("\tVIDIOC_S_AUDOUT, ret_get=%i, errno_get=%i\n", ret_get,
467 errno_get);
468
469 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, NULL);
470 errno_set = errno;
471
472 dprintf("\tVIDIOC_S_AUDOUT, ret_set=%i, errno_set=%i\n", ret_set,
473 errno_set);
474
475 if (ret_get == 0) {
476 CU_ASSERT_EQUAL(ret_get, 0);
477 CU_ASSERT_EQUAL(ret_set, -1);
478 CU_ASSERT_EQUAL(errno_set, EFAULT);
479 } else {
480 CU_ASSERT_EQUAL(ret_get, -1);
481 CU_ASSERT_EQUAL(errno_get, EINVAL);
482 CU_ASSERT_EQUAL(ret_set, -1);
483 CU_ASSERT_EQUAL(errno_set, EINVAL);
484 }
485
486 /* restore the original audio input settings */
487 memset(&audio_set, 0, sizeof(audio_set));
488 audio_set.index = audio_orig.index;
489 ret_set = ioctl(get_video_fd(), VIDIOC_S_AUDOUT, &audio_set);
490 errno_set = errno;
491
492 dprintf("\tVIDIOC_S_AUDOUT, ret_set=%i, errno_set=%i\n", ret_set,
493 errno_set);
494
495 if (ret_orig == 0) {
496 /* If it was possible at the beginning to get the audio input then
497 * it shall be possible to set it again.
498 */
499 CU_ASSERT_EQUAL(ret_orig, 0);
500 CU_ASSERT_EQUAL(ret_set, 0);
501 } else {
502 /* In case we could not fetch the audio input value at the start
503 * of this test case: the VIDIOC_S_AUDOUT shall also fail.
504 */
505 CU_ASSERT_EQUAL(ret_orig, -1);
506 CU_ASSERT_EQUAL(errno_orig, EINVAL);
507 CU_ASSERT_EQUAL(ret_set, -1);
508 CU_ASSERT_EQUAL(errno_set, EINVAL);
509 }
510 }
511