1 /*
2 * Copyright (c) 2015-2016 Dmitry V. Levin <ldv@strace.io>
3 * Copyright (c) 2016-2021 The strace developers.
4 * All rights reserved.
5 *
6 * SPDX-License-Identifier: GPL-2.0-or-later
7 */
8
9 #include "tests.h"
10 #include <errno.h>
11 #include <stdint.h>
12 #include <stdio.h>
13 #include <string.h>
14 #include <sys/ioctl.h>
15 #include "kernel_v4l2_types.h"
16
17 #define cc0(arg) ((unsigned int) (unsigned char) (arg))
18 #define cc1(arg) ((unsigned int) (unsigned char) ((unsigned int) (arg) >> 8))
19 #define cc2(arg) ((unsigned int) (unsigned char) ((unsigned int) (arg) >> 16))
20 #define cc3(arg) ((unsigned int) (unsigned char) ((unsigned int) (arg) >> 24))
21 #define fourcc(a0, a1, a2, a3) \
22 ((unsigned int)(a0) | \
23 ((unsigned int)(a1) << 8) | \
24 ((unsigned int)(a2) << 16) | \
25 ((unsigned int)(a3) << 24))
26
27 static const unsigned int magic = 0xdeadbeef;
28 static const unsigned int mf_magic = fourcc('V', 'I', 'V', 'D');
29 static const unsigned int pf_magic = fourcc('S', '5', '0', '8');
30 static const unsigned int sf_magic = fourcc('R', 'U', '1', '2');
31
32 static void
33 init_v4l2_format(struct v4l2_format *const f,
34 const unsigned int buf_type)
35 {
36 memset(f, -1, sizeof(*f));
37 f->type = buf_type;
38 switch (buf_type) {
39 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
40 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
41 f->fmt.pix.width = 0x657b8160;
42 f->fmt.pix.height = 0x951c0047;
43 if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
44 f->fmt.pix.pixelformat = magic;
45 else
46 f->fmt.pix.pixelformat = pf_magic;
47 f->fmt.pix.field = V4L2_FIELD_NONE;
48 f->fmt.pix.bytesperline = 0xdf20d185;
49 f->fmt.pix.sizeimage = 0x0cf7be41;
50 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
51 break;
52 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
53 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: {
54 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
55 f->fmt.pix_mp.width = 0x1f3b774b;
56 f->fmt.pix_mp.height = 0xab96a8d6;
57 if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
58 f->fmt.pix_mp.pixelformat = magic;
59 else
60 f->fmt.pix_mp.pixelformat = pf_magic;
61 f->fmt.pix_mp.field = V4L2_FIELD_NONE;
62 f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_JPEG;
63 struct v4l2_plane_pix_format *cur_pix =
64 f->fmt.pix_mp.plane_fmt;
65 for (unsigned int i = 0;
66 i < ARRAY_SIZE(f->fmt.pix_mp.plane_fmt);
67 i++) {
68 cur_pix[i].sizeimage = 0x1e3c531c | i;
69 if (sizeof(cur_pix[i].bytesperline) ==
70 sizeof(uint32_t)) {
71 cur_pix[i].bytesperline = 0xa983d721 | i;
72 } else {
73 #ifdef WORDS_BIGENDIAN
74 cur_pix[i].bytesperline = 0xa983;
75 cur_pix[i].reserved[0] = 0xd721 | i;
76 #else
77 cur_pix[i].bytesperline = 0xd721 | i;
78 cur_pix[i].reserved[0] = 0xa983;
79 #endif
80 }
81 }
82 if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
83 f->fmt.pix_mp.num_planes = 1;
84 break;
85 }
86 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
87 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
88 f->fmt.win.w.left = 0xe8373662;
89 f->fmt.win.w.top = 0x0336d283;
90 f->fmt.win.w.width = 0x9235fe72;
91 f->fmt.win.w.height = 0xbbd886c8;
92 f->fmt.win.field = V4L2_FIELD_ANY;
93 f->fmt.win.chromakey = 0xdb1f991f;
94 f->fmt.win.clipcount =
95 buf_type == V4L2_BUF_TYPE_VIDEO_OVERLAY ? 3 : 2;
96 f->fmt.win.clips =
97 tail_alloc(sizeof(*f->fmt.win.clips) * 2);
98 f->fmt.win.clips[0].c.left = 0x3313d36e;
99 f->fmt.win.clips[0].c.top = 0xcdffe510;
100 f->fmt.win.clips[0].c.width = 0x2064f3a8;
101 f->fmt.win.clips[0].c.height = 0xd06d314a;
102 f->fmt.win.clips[1].c.left = 0xd8c8a83f;
103 f->fmt.win.clips[1].c.top = 0x336e87ba;
104 f->fmt.win.clips[1].c.width = 0x9e3a6fb3;
105 f->fmt.win.clips[1].c.height = 0x05617b76;
106
107 f->fmt.win.bitmap = (void *) -2UL;
108 f->fmt.win.global_alpha = 0xce;
109 break;
110 case V4L2_BUF_TYPE_VBI_CAPTURE:
111 case V4L2_BUF_TYPE_VBI_OUTPUT:
112 f->fmt.vbi.sampling_rate = 0x3d9b5b79;
113 f->fmt.vbi.offset = 0x055b3a09;
114 f->fmt.vbi.samples_per_line = 0xf176d436;
115 if (buf_type == V4L2_BUF_TYPE_VBI_CAPTURE)
116 f->fmt.vbi.sample_format = magic;
117 else
118 f->fmt.vbi.sample_format = pf_magic;
119 f->fmt.vbi.start[0] = 0x9858e2eb;
120 f->fmt.vbi.start[1] = 0x8a4dc8c1;
121 f->fmt.vbi.count[0] = 0x4bcf36a3;
122 f->fmt.vbi.count[1] = 0x97dff65f;
123 f->fmt.vbi.flags = V4L2_VBI_INTERLACED;
124 break;
125 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
126 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: {
127 f->fmt.sliced.service_set = V4L2_SLICED_VPS;
128 f->fmt.sliced.io_size = 0xd897925a;
129 for (unsigned int i = 0;
130 i < ARRAY_SIZE(f->fmt.sliced.service_lines[0]);
131 i++) {
132 f->fmt.sliced.service_lines[0][i] = 0xc38e | i;
133 f->fmt.sliced.service_lines[1][i] = 0x3abb | i;
134 }
135 break;
136 }
137 case V4L2_BUF_TYPE_SDR_OUTPUT:
138 f->fmt.sdr.pixelformat = sf_magic;
139 if (sizeof(f->fmt.sdr.buffersize == sizeof(uint32_t)))
140 f->fmt.sdr.buffersize = 0x25afabfb;
141 else
142 ((uint32_t *) &f->fmt.sdr)[1] = 0x25afabfb;
143 break;
144 case V4L2_BUF_TYPE_SDR_CAPTURE:
145 f->fmt.sdr.pixelformat = magic;
146 f->fmt.sdr.buffersize = 0x25afabfb;
147 break;
148 case V4L2_BUF_TYPE_META_OUTPUT:
149 f->fmt.meta.dataformat = magic;
150 f->fmt.meta.buffersize = 0xbadc0ded;
151 break;
152 case V4L2_BUF_TYPE_META_CAPTURE:
153 f->fmt.meta.dataformat = mf_magic;
154 f->fmt.meta.buffersize = 0xbadc0ded;
155 break;
156 }
157 }
158
159 static void
160 dprint_ioctl_v4l2(struct v4l2_format *const f,
161 XLAT_SEL(unsigned reqval, const char *reqstr),
162 const unsigned int buf_type, const char *buf_type_string)
163 {
164 int saved_errno;
165
166 switch (buf_type) {
167 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
168 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
169 saved_errno = errno;
170 printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT
171 ", fmt.pix={width=%u, height=%u, pixelformat=",
172 XLAT_SEL(reqval, reqstr),
173 XLAT_SEL(buf_type, buf_type_string),
174 f->fmt.pix.width, f->fmt.pix.height);
175
176 #if XLAT_RAW
177 printf("%#x", buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE
178 ? magic : pf_magic);
179 #else /* !XLAT_RAW */
180 if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
181 printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')",
182 cc0(magic), cc1(magic), cc2(magic), cc3(magic));
183 else
184 printf("v4l2_fourcc('%c', '%c', '%c', '%c') "
185 "/* V4L2_PIX_FMT_SPCA508 */",
186 cc0(pf_magic), cc1(pf_magic), cc2(pf_magic),
187 cc3(pf_magic));
188 #endif /* XLAT_RAW */
189
190 errno = saved_errno;
191 printf(", field=" XLAT_FMT ", bytesperline=%u, sizeimage=%u"
192 ", colorspace=" XLAT_FMT "}}) = -1 EBADF (%m)\n",
193 XLAT_ARGS(V4L2_FIELD_NONE),
194 f->fmt.pix.bytesperline,
195 f->fmt.pix.sizeimage,
196 XLAT_ARGS(V4L2_COLORSPACE_JPEG));
197 break;
198 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
199 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: {
200 saved_errno = errno;
201 printf("ioctl(-1, " XLAT_FMT
202 ", {type=" XLAT_FMT
203 ", fmt.pix_mp={width=%u, height=%u, pixelformat=",
204 XLAT_SEL(reqval, reqstr),
205 XLAT_SEL(buf_type, buf_type_string),
206 f->fmt.pix_mp.width, f->fmt.pix_mp.height);
207
208 #if XLAT_RAW
209 printf("%#x", buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
210 ? magic : pf_magic);
211 #else /* !XLAT_RAW */
212 if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
213 printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')",
214 cc0(magic), cc1(magic), cc2(magic), cc3(magic));
215 else
216 printf("v4l2_fourcc('%c', '%c', '%c', '%c') "
217 "/* V4L2_PIX_FMT_SPCA508 */",
218 cc0(pf_magic), cc1(pf_magic), cc2(pf_magic),
219 cc3(pf_magic));
220 #endif /* XLAT_RAW */
221
222 printf(", field=" XLAT_FMT ", colorspace=" XLAT_FMT
223 ", plane_fmt=[",
224 XLAT_ARGS(V4L2_FIELD_NONE),
225 XLAT_ARGS(V4L2_COLORSPACE_JPEG));
226 for (unsigned int i = 0;
227 i < (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
228 ? 1 : ARRAY_SIZE(f->fmt.pix_mp.plane_fmt));
229 ++i) {
230 if (i)
231 printf(", ");
232 printf("{sizeimage=%u, bytesperline=%u}",
233 f->fmt.pix_mp.plane_fmt[i].sizeimage,
234 sizeof(f->fmt.pix_mp.plane_fmt[i].bytesperline) ==
235 sizeof(uint32_t)
236 ? f->fmt.pix_mp.plane_fmt[i].bytesperline :
237 #ifdef WORDS_BIGENDIAN
238 (f->fmt.pix_mp.plane_fmt[i].bytesperline << 16) |
239 f->fmt.pix_mp.plane_fmt[i].reserved[0]
240 #else
241 f->fmt.pix_mp.plane_fmt[i].bytesperline |
242 (f->fmt.pix_mp.plane_fmt[i].reserved[0] << 16)
243 #endif
244 );
245 }
246 errno = saved_errno;
247 printf("], num_planes=%u}}) = -1 EBADF (%m)\n",
248 f->fmt.pix_mp.num_planes);
249 break;
250 }
251 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
252 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
253 saved_errno = errno;
254 printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT
255 ", fmt.win={w={left=%d, top=%d, width=%u, height=%u}"
256 ", field=" XLAT_FMT ", chromakey=%#x, clips="
257 "[{c={left=%d, top=%d, width=%u, height=%u}}, "
258 "{c={left=%d, top=%d, width=%u, height=%u}}",
259 XLAT_SEL(reqval, reqstr),
260 XLAT_SEL(buf_type, buf_type_string),
261 f->fmt.win.w.left, f->fmt.win.w.top,
262 f->fmt.win.w.width, f->fmt.win.w.height,
263 XLAT_ARGS(V4L2_FIELD_ANY),
264 f->fmt.win.chromakey,
265 f->fmt.win.clips[0].c.left,
266 f->fmt.win.clips[0].c.top,
267 f->fmt.win.clips[0].c.width,
268 f->fmt.win.clips[0].c.height,
269 f->fmt.win.clips[1].c.left,
270 f->fmt.win.clips[1].c.top,
271 f->fmt.win.clips[1].c.width,
272 f->fmt.win.clips[1].c.height);
273 if (f->fmt.win.clipcount > 2)
274 printf(", ... /* %p */", f->fmt.win.clips + 2);
275 errno = saved_errno;
276 printf("], clipcount=%u, bitmap=%p"
277 ", global_alpha=%#x"
278 "}}) = -1 EBADF (%m)\n",
279 f->fmt.win.clipcount, f->fmt.win.bitmap,
280 f->fmt.win.global_alpha
281 );
282 break;
283 case V4L2_BUF_TYPE_VBI_CAPTURE:
284 case V4L2_BUF_TYPE_VBI_OUTPUT:
285 saved_errno = errno;
286 printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT
287 ", fmt.vbi={sampling_rate=%u, offset=%u"
288 ", samples_per_line=%u, sample_format=",
289 XLAT_SEL(reqval, reqstr),
290 XLAT_SEL(buf_type, buf_type_string),
291 f->fmt.vbi.sampling_rate, f->fmt.vbi.offset,
292 f->fmt.vbi.samples_per_line);
293
294 #if XLAT_RAW
295 printf("%#x", buf_type == V4L2_BUF_TYPE_VBI_CAPTURE
296 ? magic : pf_magic);
297 #else /* !XLAT_RAW */
298 if (buf_type == V4L2_BUF_TYPE_VBI_CAPTURE)
299 printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')",
300 cc0(magic), cc1(magic), cc2(magic), cc3(magic));
301 else
302 printf("v4l2_fourcc('%c', '%c', '%c', '%c') "
303 "/* V4L2_PIX_FMT_SPCA508 */",
304 cc0(pf_magic), cc1(pf_magic), cc2(pf_magic),
305 cc3(pf_magic));
306 #endif /* XLAT_RAW */
307
308 errno = saved_errno;
309 printf(", start=[%d, %d], count=[%u, %u]"
310 ", flags=" XLAT_FMT "}})"
311 " = -1 EBADF (%m)\n",
312 f->fmt.vbi.start[0], f->fmt.vbi.start[1],
313 f->fmt.vbi.count[0], f->fmt.vbi.count[1],
314 XLAT_ARGS(V4L2_VBI_INTERLACED));
315 break;
316 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
317 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: {
318 saved_errno = errno;
319 printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT
320 ", fmt.sliced={service_set=" XLAT_FMT
321 ", service_lines=[",
322 XLAT_SEL(reqval, reqstr),
323 XLAT_SEL(buf_type, buf_type_string),
324 XLAT_ARGS(V4L2_SLICED_VPS));
325 for (unsigned int i = 0;
326 i < ARRAY_SIZE(f->fmt.sliced.service_lines);
327 ++i) {
328 if (i > 0)
329 printf(", ");
330 printf("[");
331 for (unsigned int j = 0;
332 j < ARRAY_SIZE(f->fmt.sliced.service_lines[0]);
333 ++j) {
334 if (j > 0)
335 printf(", ");
336 printf("%#x",
337 f->fmt.sliced.service_lines[i][j]);
338 }
339 printf("]");
340 }
341 errno = saved_errno;
342 printf("], io_size=%u}}) = -1 EBADF (%m)\n",
343 f->fmt.sliced.io_size);
344 break;
345 }
346 case V4L2_BUF_TYPE_SDR_OUTPUT:
347 case V4L2_BUF_TYPE_SDR_CAPTURE:
348 saved_errno = errno;
349 printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT
350 ", fmt.sdr={pixelformat=",
351 XLAT_SEL(reqval, reqstr),
352 XLAT_SEL(buf_type, buf_type_string));
353
354 #if XLAT_RAW
355 if (buf_type == V4L2_BUF_TYPE_SDR_CAPTURE)
356 printf("%#x", magic);
357 else
358 printf("%#x", sf_magic);
359 #else /* !XLAT_RAW */
360 if (buf_type == V4L2_BUF_TYPE_SDR_CAPTURE)
361 printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')",
362 cc0(magic), cc1(magic), cc2(magic), cc3(magic));
363 else
364 printf("v4l2_fourcc('%c', '%c', '%c', '%c') "
365 "/* V4L2_SDR_FMT_RU12LE */",
366 cc0(sf_magic), cc1(sf_magic), cc2(sf_magic),
367 cc3(sf_magic));
368 #endif /* XLAT_RAW */
369
370 errno = saved_errno;
371 printf(", buffersize=%u}}) = -1 EBADF (%m)\n"
372 , sizeof(f->fmt.sdr.buffersize == sizeof(uint32_t))
373 ? f->fmt.sdr.buffersize : ((uint32_t *) &f->fmt.sdr)[1]
374 );
375 break;
376
377 case V4L2_BUF_TYPE_META_OUTPUT:
378 case V4L2_BUF_TYPE_META_CAPTURE:
379 saved_errno = errno;
380 printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT
381 ", fmt.meta={dataformat=",
382 XLAT_SEL(reqval, reqstr),
383 XLAT_SEL(buf_type, buf_type_string));
384
385 #if XLAT_RAW
386 printf("%#x", buf_type == V4L2_BUF_TYPE_META_CAPTURE
387 ? mf_magic : magic);
388 #else /* !XLAT_RAW */
389 if (buf_type == V4L2_BUF_TYPE_META_CAPTURE)
390 printf("v4l2_fourcc('%c', '%c', '%c', '%c') "
391 "/* V4L2_META_FMT_VIVID */",
392 cc0(mf_magic), cc1(mf_magic), cc2(mf_magic),
393 cc3(mf_magic));
394 else
395 printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')",
396 cc0(magic), cc1(magic), cc2(magic), cc3(magic));
397 #endif /* XLAT_RAW */
398
399 errno = saved_errno;
400 printf(", buffersize=%u}}) = -1 EBADF (%m)\n",
401 f->fmt.meta.buffersize);
402 break;
403 }
404 }
405 #define print_ioctl_v4l2(v4l2_format, request, buf_type) \
406 dprint_ioctl_v4l2((v4l2_format), XLAT_SEL(request, #request), \
407 (buf_type), #buf_type)
408
409 int
410 main(void)
411 {
412 const unsigned int size = get_page_size();
413 void *const page = tail_alloc(size);
414 void *const page_end = page + size;
415 fill_memory(page, size);
416
417 unsigned char cc[sizeof(int)] = { 'A', '\'', '\\', '\xfa' };
418
419 /* Unknown */
420 static const struct {
421 uint32_t flags;
422 const char *str;
423 } cmd_flags[] = {
424 { ARG_STR(_IOC_NONE) },
425 { ARG_STR(_IOC_READ) },
426 { ARG_STR(_IOC_WRITE) },
427 { ARG_STR(_IOC_READ|_IOC_WRITE) },
428 };
429 static const uint8_t unknown_cmds[] = {
430 1, 3, 6 /* VIDIOC_G_MPEGCOMP */, 7 /* VIDIOC_S_MPEGCOMP */,
431 12, 13, 20, 31, 32, 35, 42, 43, 44, 45, 51, 52, 53,
432 81 /* VIDIOC_G_CHIP_IDENT_OLD */,
433 83 /* VIDIOC_ENUM_DV_PRESETS */, 84 /* VIDIOC_S_DV_PRESET */,
434 85 /* VIDIOC_G_DV_PRESET */, 86 /* VIDIOC_QUERY_DV_PRESET */,
435 104 /* 103 is the last existing */, 255
436 };
437
438 for (size_t i = 0; i < ARRAY_SIZE(unknown_cmds); i++) {
439 /* Trying to hit common argument sizes */
440 for (size_t j = 0; j < 256; j += 4) {
441 for (size_t k = 0; k < ARRAY_SIZE(cmd_flags); k++) {
442 uint32_t ioc = _IOC(cmd_flags[k].flags, 'V',
443 unknown_cmds[i], j);
444 /*
445 * Conflicts with VT* and VBG* ioctls
446 * that happen to also use 'V' command type.
447 */
448 switch (ioc) {
449 /* VT_GETMODE */
450 case _IOC(_IOC_NONE, 'V', 1, 0):
451 /* VT_GETSTATE */
452 case _IOC(_IOC_NONE, 'V', 3, 0):
453 /* VBG_IOCTL_VMMDEV_REQUEST_BIG */
454 case _IOC(_IOC_READ|_IOC_WRITE, 'V', 3, 0):
455 /* VT_ACTIVATE */
456 case _IOC(_IOC_NONE, 'V', 6, 0):
457 /* VT_WAITACTIVE */
458 case _IOC(_IOC_NONE, 'V', 7, 0):
459 /* VT_UNLOCKSWITCH */
460 case _IOC(_IOC_NONE, 'V', 12, 0):
461 /* VBG_IOCTL_CHANGE_FILTER_MASK */
462 case _IOC(_IOC_READ|_IOC_WRITE, 'V', 12, 32):
463 /* VT_GETHIFONTMASK */
464 case _IOC(_IOC_NONE, 'V', 13, 0):
465 continue;
466 /* VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES */
467 case _IOC(_IOC_READ|_IOC_WRITE, 'V', 13, 36):
468 continue;
469 }
470
471 ioctl(-1, ioc, 0);
472 printf("ioctl(-1, " NABBR("%#x") VERB(" /* ")
473 NRAW("_IOC(%s, 0x56, %#x, %#zx)")
474 VERB(" */") ", 0) = -1 EBADF (%m)\n"
475 #if XLAT_RAW || XLAT_VERBOSE
476 , ioc
477 #endif
478 #if !XLAT_RAW
479 , cmd_flags[k].str, unknown_cmds[i], j
480 #endif
481 );
482
483 ioctl(-1, ioc,
484 (unsigned long) 0xbadc0deddeadc0deULL);
485 printf("ioctl(-1, " NABBR("%#x") VERB(" /* ")
486 NRAW("_IOC(%s, 0x56, %#x, %#zx)")
487 VERB(" */") ", %#lx) = -1 EBADF (%m)\n",
488 #if XLAT_RAW || XLAT_VERBOSE
489 ioc,
490 #endif
491 #if !XLAT_RAW
492 cmd_flags[k].str, unknown_cmds[i], j,
493 #endif
494 (unsigned long) 0xbadc0deddeadc0deULL);
495 }
496 }
497 }
498
499 /* Decoding is not supported */
500 static const struct {
501 uint32_t cmd;
502 const char *str;
503 } unsupp_cmds[] = {
504 { ARG_STR(VIDIOC_OVERLAY) },
505 { ARG_STR(VIDIOC_EXPBUF) },
506 { ARG_STR(VIDIOC_G_AUDIO) },
507 { ARG_STR(VIDIOC_S_AUDIO) },
508 { ARG_STR(VIDIOC_QUERYMENU) },
509 { ARG_STR(VIDIOC_G_EDID) },
510 { ARG_STR(VIDIOC_S_EDID) },
511 { ARG_STR(VIDIOC_G_OUTPUT) },
512 { ARG_STR(VIDIOC_S_OUTPUT) },
513 { ARG_STR(VIDIOC_ENUMOUTPUT) },
514 { ARG_STR(VIDIOC_G_AUDOUT) },
515 { ARG_STR(VIDIOC_S_AUDOUT) },
516 { ARG_STR(VIDIOC_G_MODULATOR) },
517 { ARG_STR(VIDIOC_S_MODULATOR) },
518 { ARG_STR(VIDIOC_G_FREQUENCY) },
519 { ARG_STR(VIDIOC_S_FREQUENCY) },
520 { ARG_STR(VIDIOC_G_JPEGCOMP) },
521 { ARG_STR(VIDIOC_S_JPEGCOMP) },
522 { ARG_STR(VIDIOC_QUERYSTD) },
523 { ARG_STR(VIDIOC_ENUMAUDIO) },
524 { ARG_STR(VIDIOC_ENUMAUDOUT) },
525 { ARG_STR(VIDIOC_G_PRIORITY) },
526 { ARG_STR(VIDIOC_S_PRIORITY) },
527 { ARG_STR(VIDIOC_G_SLICED_VBI_CAP) },
528 { ARG_STR(VIDIOC_LOG_STATUS) },
529 { ARG_STR(VIDIOC_G_ENC_INDEX) },
530 { ARG_STR(VIDIOC_ENCODER_CMD) },
531 { ARG_STR(VIDIOC_TRY_ENCODER_CMD) },
532 { ARG_STR(VIDIOC_DBG_S_REGISTER) },
533 { ARG_STR(VIDIOC_DBG_G_REGISTER) },
534 { ARG_STR(VIDIOC_S_HW_FREQ_SEEK) },
535 { ARG_STR(VIDIOC_S_DV_TIMINGS) },
536 { ARG_STR(VIDIOC_G_DV_TIMINGS) },
537 { ARG_STR(VIDIOC_DQEVENT) },
538 { ARG_STR(VIDIOC_SUBSCRIBE_EVENT) },
539 { ARG_STR(VIDIOC_UNSUBSCRIBE_EVENT) },
540 { ARG_STR(VIDIOC_PREPARE_BUF) },
541 { ARG_STR(VIDIOC_G_SELECTION) },
542 { ARG_STR(VIDIOC_S_SELECTION) },
543 { ARG_STR(VIDIOC_DECODER_CMD) },
544 { ARG_STR(VIDIOC_TRY_DECODER_CMD) },
545 { ARG_STR(VIDIOC_ENUM_DV_TIMINGS) },
546 { ARG_STR(VIDIOC_QUERY_DV_TIMINGS) },
547 { ARG_STR(VIDIOC_DV_TIMINGS_CAP) },
548 { ARG_STR(VIDIOC_ENUM_FREQ_BANDS) },
549 { ARG_STR(VIDIOC_DBG_G_CHIP_INFO) },
550 #if 0
551 /* <linux/v4l2-subdev.h> */
552 { ARG_STR(VIDIOC_SUBDEV_ENUM_MBUS_CODE) },
553 { ARG_STR(VIDIOC_SUBDEV_G_FMT) },
554 { ARG_STR(VIDIOC_SUBDEV_S_FMT) },
555 { ARG_STR(VIDIOC_SUBDEV_G_FRAME_INTERVAL) },
556 { ARG_STR(VIDIOC_SUBDEV_S_FRAME_INTERVAL) },
557 { ARG_STR(VIDIOC_SUBDEV_G_CROP) },
558 { ARG_STR(VIDIOC_SUBDEV_S_CROP) },
559 { ARG_STR(VIDIOC_SUBDEV_G_SELECTION) },
560 { ARG_STR(VIDIOC_SUBDEV_S_SELECTION) },
561 { ARG_STR(VIDIOC_SUBDEV_ENUM_FRAME_SIZE) },
562 { ARG_STR(VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL) },
563 #endif
564 };
565
566 for (size_t i = 0; i < ARRAY_SIZE(unsupp_cmds); i++) {
567 ioctl(-1, unsupp_cmds[i].cmd, 0);
568 printf("ioctl(-1, " XLAT_FMT ", 0) = -1 EBADF (%m)\n",
569 XLAT_SEL(unsupp_cmds[i].cmd, unsupp_cmds[i].str));
570
571 ioctl(-1, unsupp_cmds[i].cmd,
572 (unsigned long) 0xbadc0deddeadc0deULL);
573 printf("ioctl(-1, " XLAT_FMT ", %#lx) = -1 EBADF (%m)\n",
574 XLAT_SEL(unsupp_cmds[i].cmd, unsupp_cmds[i].str),
575 (unsigned long) 0xbadc0deddeadc0deULL);
576 }
577
578 /* VIDIOC_QUERYCAP */
579 ioctl(-1, VIDIOC_QUERYCAP, 0);
580 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
581 XLAT_STR(VIDIOC_QUERYCAP));
582
583 ioctl(-1, VIDIOC_QUERYCAP, page);
584 printf("ioctl(-1, %s, %p) = -1 EBADF (%m)\n",
585 XLAT_STR(VIDIOC_QUERYCAP), page);
586
587 /* VIDIOC_ENUM_FMT */
588 ioctl(-1, VIDIOC_ENUM_FMT, 0);
589 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
590 XLAT_STR(VIDIOC_ENUM_FMT));
591
592 TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_fmtdesc, p_fmtdesc);
593 p_fmtdesc->index = magic;
594 p_fmtdesc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
595 ioctl(-1, VIDIOC_ENUM_FMT, p_fmtdesc);
596 printf("ioctl(-1, %s, {index=%u, type=" XLAT_FMT
597 "}) = -1 EBADF (%m)\n",
598 XLAT_STR(VIDIOC_ENUM_FMT), p_fmtdesc->index,
599 XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_CAPTURE));
600
601 /* VIDIOC_G_FMT */
602 ioctl(-1, VIDIOC_G_FMT, 0);
603 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
604 XLAT_STR(VIDIOC_G_FMT));
605
606 TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_format, p_format);
607
608 p_format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
609 ioctl(-1, VIDIOC_G_FMT, p_format);
610 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
611 XLAT_STR(VIDIOC_G_FMT),
612 XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_CAPTURE));
613 p_format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
614 ioctl(-1, VIDIOC_G_FMT, p_format);
615 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
616 XLAT_STR(VIDIOC_G_FMT),
617 XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE));
618 p_format->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY;
619 ioctl(-1, VIDIOC_G_FMT, p_format);
620 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
621 XLAT_STR(VIDIOC_G_FMT),
622 XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY));
623 p_format->type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
624 ioctl(-1, VIDIOC_G_FMT, p_format);
625 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
626 XLAT_STR(VIDIOC_G_FMT),
627 XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_OVERLAY));
628
629 p_format->type = V4L2_BUF_TYPE_VBI_CAPTURE;
630 ioctl(-1, VIDIOC_G_FMT, p_format);
631 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
632 XLAT_STR(VIDIOC_G_FMT),
633 XLAT_ARGS(V4L2_BUF_TYPE_VBI_CAPTURE));
634 p_format->type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
635 ioctl(-1, VIDIOC_G_FMT, p_format);
636 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
637 XLAT_STR(VIDIOC_G_FMT),
638 XLAT_ARGS(V4L2_BUF_TYPE_SLICED_VBI_CAPTURE));
639 p_format->type = V4L2_BUF_TYPE_SDR_CAPTURE;
640 ioctl(-1, VIDIOC_G_FMT, p_format);
641 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
642 XLAT_STR(VIDIOC_G_FMT),
643 XLAT_ARGS(V4L2_BUF_TYPE_SDR_CAPTURE));
644 p_format->type = V4L2_BUF_TYPE_SDR_OUTPUT;
645 ioctl(-1, VIDIOC_G_FMT, p_format);
646 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
647 XLAT_STR(VIDIOC_G_FMT),
648 XLAT_ARGS(V4L2_BUF_TYPE_SDR_OUTPUT));
649 p_format->type = V4L2_BUF_TYPE_META_CAPTURE;
650 ioctl(-1, VIDIOC_G_FMT, p_format);
651 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
652 XLAT_STR(VIDIOC_G_FMT),
653 XLAT_ARGS(V4L2_BUF_TYPE_META_CAPTURE));
654 p_format->type = V4L2_BUF_TYPE_META_OUTPUT;
655 ioctl(-1, VIDIOC_G_FMT, p_format);
656 printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n",
657 XLAT_STR(VIDIOC_G_FMT),
658 XLAT_ARGS(V4L2_BUF_TYPE_META_OUTPUT));
659 /* VIDIOC_S_FMT */
660 ioctl(-1, VIDIOC_S_FMT, 0);
661 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
662 XLAT_STR(VIDIOC_S_FMT));
663
664 init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OUTPUT);
665 ioctl(-1, VIDIOC_S_FMT, p_format);
666 print_ioctl_v4l2(p_format, VIDIOC_S_FMT,
667 V4L2_BUF_TYPE_VIDEO_OUTPUT);
668 init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
669 ioctl(-1, VIDIOC_S_FMT, p_format);
670 print_ioctl_v4l2(p_format, VIDIOC_S_FMT,
671 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
672 init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY);
673 ioctl(-1, VIDIOC_S_FMT, p_format);
674 print_ioctl_v4l2(p_format, VIDIOC_S_FMT,
675 V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY);
676 init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OVERLAY);
677 ioctl(-1, VIDIOC_S_FMT, p_format);
678 print_ioctl_v4l2(p_format, VIDIOC_S_FMT,
679 V4L2_BUF_TYPE_VIDEO_OVERLAY);
680
681 init_v4l2_format(p_format, V4L2_BUF_TYPE_VBI_CAPTURE);
682 ioctl(-1, VIDIOC_S_FMT, p_format);
683 print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_VBI_CAPTURE);
684 init_v4l2_format(p_format, V4L2_BUF_TYPE_SLICED_VBI_CAPTURE);
685 ioctl(-1, VIDIOC_S_FMT, p_format);
686 print_ioctl_v4l2(p_format, VIDIOC_S_FMT,
687 V4L2_BUF_TYPE_SLICED_VBI_CAPTURE);
688 init_v4l2_format(p_format, V4L2_BUF_TYPE_SDR_CAPTURE);
689 ioctl(-1, VIDIOC_S_FMT, p_format);
690 print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_SDR_CAPTURE);
691 init_v4l2_format(p_format, V4L2_BUF_TYPE_SDR_OUTPUT);
692 ioctl(-1, VIDIOC_S_FMT, p_format);
693 print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_SDR_OUTPUT);
694 init_v4l2_format(p_format, V4L2_BUF_TYPE_META_CAPTURE);
695 ioctl(-1, VIDIOC_S_FMT, p_format);
696 print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_META_CAPTURE);
697 init_v4l2_format(p_format, V4L2_BUF_TYPE_META_OUTPUT);
698 ioctl(-1, VIDIOC_S_FMT, p_format);
699 print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_META_OUTPUT);
700 /* VIDIOC_TRY_FMT */
701 ioctl(-1, VIDIOC_TRY_FMT, 0);
702 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
703 XLAT_STR(VIDIOC_TRY_FMT));
704
705 init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OUTPUT);
706 ioctl(-1, VIDIOC_TRY_FMT, p_format);
707 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT,
708 V4L2_BUF_TYPE_VIDEO_OUTPUT);
709 init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
710 ioctl(-1, VIDIOC_TRY_FMT, p_format);
711 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT,
712 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
713 init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY);
714 ioctl(-1, VIDIOC_TRY_FMT, p_format);
715 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT,
716 V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY);
717 init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OVERLAY);
718 ioctl(-1, VIDIOC_TRY_FMT, p_format);
719 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT,
720 V4L2_BUF_TYPE_VIDEO_OVERLAY);
721
722 init_v4l2_format(p_format, V4L2_BUF_TYPE_VBI_CAPTURE);
723 ioctl(-1, VIDIOC_TRY_FMT, p_format);
724 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_VBI_CAPTURE);
725 init_v4l2_format(p_format, V4L2_BUF_TYPE_SLICED_VBI_CAPTURE);
726 ioctl(-1, VIDIOC_TRY_FMT, p_format);
727 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT,
728 V4L2_BUF_TYPE_SLICED_VBI_CAPTURE);
729 init_v4l2_format(p_format, V4L2_BUF_TYPE_SDR_CAPTURE);
730 ioctl(-1, VIDIOC_TRY_FMT, p_format);
731 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_SDR_CAPTURE);
732 init_v4l2_format(p_format, V4L2_BUF_TYPE_SDR_OUTPUT);
733 ioctl(-1, VIDIOC_TRY_FMT, p_format);
734 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_SDR_OUTPUT);
735 init_v4l2_format(p_format, V4L2_BUF_TYPE_META_CAPTURE);
736 ioctl(-1, VIDIOC_TRY_FMT, p_format);
737 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_META_CAPTURE);
738 init_v4l2_format(p_format, V4L2_BUF_TYPE_META_OUTPUT);
739 ioctl(-1, VIDIOC_TRY_FMT, p_format);
740 print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_META_OUTPUT);
741 struct v4l2_format *const p_v4l2_format =
742 page_end - sizeof(*p_v4l2_format);
743 ioctl(-1, VIDIOC_TRY_FMT, p_v4l2_format);
744 printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})"
745 " = -1 EBADF (%m)\n",
746 XLAT_STR(VIDIOC_TRY_FMT), p_v4l2_format->type);
747
748 /* VIDIOC_REQBUFS */
749 ioctl(-1, VIDIOC_REQBUFS, 0);
750 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
751 XLAT_STR(VIDIOC_REQBUFS));
752
753 struct v4l2_requestbuffers *const p_v4l2_requestbuffers =
754 page_end - sizeof(*p_v4l2_requestbuffers);
755 ioctl(-1, VIDIOC_REQBUFS, p_v4l2_requestbuffers);
756 printf("ioctl(-1, %s, {type=%#x"
757 NRAW(" /* V4L2_BUF_TYPE_??? */")
758 ", memory=%#x" NRAW(" /* V4L2_MEMORY_??? */") ", count=%u})"
759 " = -1 EBADF (%m)\n",
760 XLAT_STR(VIDIOC_REQBUFS),
761 p_v4l2_requestbuffers->type,
762 p_v4l2_requestbuffers->memory,
763 p_v4l2_requestbuffers->count);
764
765 /* VIDIOC_QUERYBUF */
766 ioctl(-1, VIDIOC_QUERYBUF, 0);
767 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
768 XLAT_STR(VIDIOC_QUERYBUF));
769
770 kernel_v4l2_buffer_t *const p_v4l2_buffer =
771 page_end - sizeof(*p_v4l2_buffer);
772 ioctl(-1, VIDIOC_QUERYBUF, p_v4l2_buffer);
773 printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */")
774 ", index=%u}) = -1 EBADF (%m)\n",
775 XLAT_STR(VIDIOC_QUERYBUF),
776 p_v4l2_buffer->type, p_v4l2_buffer->index);
777
778 /* VIDIOC_QBUF */
779 ioctl(-1, VIDIOC_QBUF, 0);
780 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
781 XLAT_STR(VIDIOC_QBUF));
782
783 ioctl(-1, VIDIOC_QBUF, p_v4l2_buffer);
784 printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */")
785 ", index=%u}) = -1 EBADF (%m)\n",
786 XLAT_STR(VIDIOC_QBUF),
787 p_v4l2_buffer->type, p_v4l2_buffer->index);
788
789 /* VIDIOC_DQBUF */
790 ioctl(-1, VIDIOC_DQBUF, 0);
791 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
792 XLAT_STR(VIDIOC_DQBUF));
793
794 ioctl(-1, VIDIOC_DQBUF, p_v4l2_buffer);
795 printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */")
796 "}) = -1 EBADF (%m)\n",
797 XLAT_STR(VIDIOC_DQBUF), p_v4l2_buffer->type);
798
799 /* VIDIOC_G_FBUF */
800 ioctl(-1, VIDIOC_G_FBUF, 0);
801 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
802 XLAT_STR(VIDIOC_G_FBUF));
803
804 ioctl(-1, VIDIOC_G_FBUF, page);
805 printf("ioctl(-1, %s, %p) = -1 EBADF (%m)\n",
806 XLAT_STR(VIDIOC_G_FBUF), page);
807
808 /* VIDIOC_S_FBUF */
809 ioctl(-1, VIDIOC_S_FBUF, 0);
810 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
811 XLAT_STR(VIDIOC_S_FBUF));
812
813 struct v4l2_framebuffer *const p_v4l2_framebuffer =
814 page_end - sizeof(*p_v4l2_framebuffer);
815 ioctl(-1, VIDIOC_S_FBUF, p_v4l2_framebuffer);
816 printf("ioctl(-1, %s, {capability=%#x"
817 ", flags=%#x, base=%p}) = -1 EBADF (%m)\n",
818 XLAT_STR(VIDIOC_S_FBUF),
819 p_v4l2_framebuffer->capability,
820 p_v4l2_framebuffer->flags,
821 p_v4l2_framebuffer->base);
822
823 /* VIDIOC_STREAMON */
824 ioctl(-1, VIDIOC_STREAMON, 0);
825 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
826 XLAT_STR(VIDIOC_STREAMON));
827
828 int *const p_int = page_end - sizeof(int);
829 ioctl(-1, VIDIOC_STREAMON, p_int);
830 printf("ioctl(-1, %s, [%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "])"
831 " = -1 EBADF (%m)\n",
832 XLAT_STR(VIDIOC_STREAMON), *p_int);
833
834 /* VIDIOC_STREAMOFF */
835 ioctl(-1, VIDIOC_STREAMOFF, 0);
836 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
837 XLAT_STR(VIDIOC_STREAMOFF));
838
839 ioctl(-1, VIDIOC_STREAMOFF, p_int);
840 printf("ioctl(-1, %s, [%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "])"
841 " = -1 EBADF (%m)\n",
842 XLAT_STR(VIDIOC_STREAMOFF), *p_int);
843
844 /* VIDIOC_G_PARM */
845 ioctl(-1, VIDIOC_G_PARM, 0);
846 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
847 XLAT_STR(VIDIOC_G_PARM));
848
849 struct v4l2_streamparm *const p_v4l2_streamparm =
850 page_end - sizeof(*p_v4l2_streamparm);
851 ioctl(-1, VIDIOC_G_PARM, p_v4l2_streamparm);
852 printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})"
853 " = -1 EBADF (%m)\n",
854 XLAT_STR(VIDIOC_G_PARM), p_v4l2_streamparm->type);
855
856 /* VIDIOC_S_PARM */
857 ioctl(-1, VIDIOC_S_PARM, 0);
858 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
859 XLAT_STR(VIDIOC_S_PARM));
860
861 ioctl(-1, VIDIOC_S_PARM, p_v4l2_streamparm);
862 printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})"
863 " = -1 EBADF (%m)\n",
864 XLAT_STR(VIDIOC_S_PARM), p_v4l2_streamparm->type);
865
866 TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_streamparm, p_streamparm);
867 p_streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
868 p_streamparm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
869 p_streamparm->parm.capture.capturemode = V4L2_MODE_HIGHQUALITY;
870 p_streamparm->parm.capture.timeperframe.numerator = 0xdeadbeef;
871 p_streamparm->parm.capture.timeperframe.denominator = 0xbadc0ded;
872 ioctl(-1, VIDIOC_S_PARM, p_streamparm);
873 printf("ioctl(-1, %s, {type=" XLAT_FMT
874 ", parm.capture={capability=" XLAT_FMT
875 ", capturemode=" XLAT_FMT ", timeperframe=%u/%u"
876 ", extendedmode=%#x, readbuffers=%u}}) = -1 EBADF (%m)\n",
877 XLAT_STR(VIDIOC_S_PARM), XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_CAPTURE),
878 XLAT_ARGS(V4L2_CAP_TIMEPERFRAME), XLAT_ARGS(V4L2_MODE_HIGHQUALITY),
879 p_streamparm->parm.capture.timeperframe.numerator,
880 p_streamparm->parm.capture.timeperframe.denominator, -1U, -1U);
881
882 p_streamparm->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
883 p_streamparm->parm.output.outputmode = 0;
884 ioctl(-1, VIDIOC_S_PARM, p_streamparm);
885 printf("ioctl(-1, %s, {type=" XLAT_FMT
886 ", parm.output={capability=" XLAT_FMT
887 ", outputmode=0, timeperframe=%u/%u"
888 ", extendedmode=%#x, writebuffers=%u}}) = -1 EBADF (%m)\n",
889 XLAT_STR(VIDIOC_S_PARM), XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_OUTPUT),
890 XLAT_ARGS(V4L2_CAP_TIMEPERFRAME),
891 p_streamparm->parm.output.timeperframe.numerator,
892 p_streamparm->parm.output.timeperframe.denominator, -1U, -1U);
893
894 /* VIDIOC_G_STD */
895 ioctl(-1, VIDIOC_G_STD, 0);
896 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
897 XLAT_STR(VIDIOC_G_STD));
898
899 ioctl(-1, VIDIOC_G_STD, page);
900 printf("ioctl(-1, %s, %p) = -1 EBADF (%m)\n",
901 XLAT_STR(VIDIOC_G_STD), page);
902
903 /* VIDIOC_S_STD */
904 ioctl(-1, VIDIOC_S_STD, 0);
905 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
906 XLAT_STR(VIDIOC_S_STD));
907
908 long long *const p_longlong = page_end - sizeof(*p_longlong);
909 ioctl(-1, VIDIOC_S_STD, p_longlong);
910 printf("ioctl(-1, %s, [%#llx]) = -1 EBADF (%m)\n",
911 XLAT_STR(VIDIOC_S_STD), *p_longlong);
912
913 /* VIDIOC_ENUMSTD */
914 ioctl(-1, VIDIOC_ENUMSTD, 0);
915 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
916 XLAT_STR(VIDIOC_ENUMSTD));
917
918 struct v4l2_standard *const p_v4l2_standard =
919 page_end - sizeof(*p_v4l2_standard);
920 ioctl(-1, VIDIOC_ENUMSTD, p_v4l2_standard);
921 printf("ioctl(-1, %s, {index=%u}) = -1 EBADF (%m)\n",
922 XLAT_STR(VIDIOC_ENUMSTD), p_v4l2_standard->index);
923
924 /* VIDIOC_ENUMINPUT */
925 ioctl(-1, VIDIOC_ENUMINPUT, 0);
926 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
927 XLAT_STR(VIDIOC_ENUMINPUT));
928
929 struct v4l2_input *const p_v4l2_input =
930 page_end - sizeof(*p_v4l2_input);
931 ioctl(-1, VIDIOC_ENUMINPUT, p_v4l2_input);
932 printf("ioctl(-1, %s, {index=%u}) = -1 EBADF (%m)\n",
933 XLAT_STR(VIDIOC_ENUMINPUT), p_v4l2_input->index);
934
935 /* VIDIOC_G_CTRL */
936 ioctl(-1, VIDIOC_G_CTRL, 0);
937 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
938 XLAT_STR(VIDIOC_G_CTRL));
939
940 static const struct v4l2_control v4l2_control_vals[] = {
941 { .id = 0, .value = 3141592653U },
942 { .id = 0x97abcd, .value = 1234567890U },
943 { .id = V4L2_CTRL_CLASS_USER, .value = 0 },
944 { .id = 0x990a64, .value = 42 },
945 { .id = 0xa31234, .value = 1 },
946 { .id = 0xa60000, .value = -1 },
947 };
948 static const char *id_strs[] = {
949 "0" NRAW(" /* V4L2_CID_??? */"),
950 "0x97abcd" NRAW(" /* V4L2_CID_??? */"),
951 XLAT_KNOWN(0x980000, "V4L2_CTRL_CLASS_USER+0"),
952 XLAT_KNOWN(0x990a64, "V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE"),
953 XLAT_KNOWN(0xa31234, "V4L2_CTRL_CLASS_DETECT+0x1234"),
954 "0xa60000" NRAW(" /* V4L2_CID_??? */"),
955 };
956
957 struct v4l2_control *const p_v4l2_control =
958 page_end - sizeof(*p_v4l2_control);
959 ioctl(-1, VIDIOC_G_CTRL, p_v4l2_control);
960 printf("ioctl(-1, %s, {id=%#x" NRAW(" /* V4L2_CID_??? */")
961 "}) = -1 EBADF (%m)\n",
962 XLAT_STR(VIDIOC_G_CTRL), p_v4l2_control->id);
963
964 /* VIDIOC_S_CTRL */
965 ioctl(-1, VIDIOC_S_CTRL, 0);
966 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
967 XLAT_STR(VIDIOC_S_CTRL));
968
969 ioctl(-1, VIDIOC_S_CTRL, p_v4l2_control);
970 printf("ioctl(-1, %s, {id=%#x" NRAW(" /* V4L2_CID_??? */")
971 ", value=%d}) = -1 EBADF (%m)\n",
972 XLAT_STR(VIDIOC_S_CTRL),
973 p_v4l2_control->id, p_v4l2_control->value);
974
975 for (size_t i = 0; i < ARRAY_SIZE(id_strs); i++) {
976 struct v4l2_control v4l2_c = v4l2_control_vals[i];
977
978 ioctl(-1, VIDIOC_G_CTRL, &v4l2_c);
979 printf("ioctl(-1, %s, {id=%s}) = -1 EBADF (%m)\n",
980 XLAT_STR(VIDIOC_G_CTRL), id_strs[i]);
981
982 ioctl(-1, VIDIOC_S_CTRL, &v4l2_c);
983 printf("ioctl(-1, %s, {id=%s, value=%d}) = -1 EBADF (%m)\n",
984 XLAT_STR(VIDIOC_S_CTRL), id_strs[i], v4l2_c.value);
985 }
986
987 /* VIDIOC_G_TUNER */
988 ioctl(-1, VIDIOC_G_TUNER, 0);
989 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
990 XLAT_STR(VIDIOC_G_TUNER));
991
992 struct v4l2_tuner *const p_v4l2_tuner =
993 page_end - sizeof(*p_v4l2_tuner);
994 ioctl(-1, VIDIOC_G_TUNER, p_v4l2_tuner);
995 printf("ioctl(-1, %s, {index=%u}) = -1 EBADF (%m)\n",
996 XLAT_STR(VIDIOC_G_TUNER), p_v4l2_tuner->index);
997
998 /* VIDIOC_S_TUNER */
999 ioctl(-1, VIDIOC_S_TUNER, 0);
1000 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1001 XLAT_STR(VIDIOC_S_TUNER));
1002
1003 TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_tuner, p_tuner);
1004 p_tuner->index = 0x4fb6df39;
1005 strcpy((char *) p_tuner->name, "cum tacent clamant");
1006 p_tuner->type = V4L2_TUNER_RADIO;
1007 p_tuner->capability = V4L2_TUNER_CAP_LOW;
1008 p_tuner->rangelow = 0xa673bc29;
1009 p_tuner->rangehigh = 0xbaf16d12;
1010 p_tuner->rxsubchans = V4L2_TUNER_SUB_MONO;
1011 p_tuner->audmode = V4L2_TUNER_MODE_MONO;
1012 p_tuner->signal = 0x10bf92c8;
1013 p_tuner->afc = 0x3bf7e18b;
1014 ioctl(-1, VIDIOC_S_TUNER, p_tuner);
1015 printf("ioctl(-1, %s, {index=%u, name=\"cum tacent clamant\""
1016 ", type=" XLAT_FMT ", capability=" XLAT_FMT
1017 ", rangelow=%u, rangehigh=%u"
1018 ", rxsubchans=" XLAT_FMT ", audmode=" XLAT_FMT
1019 ", signal=%d, afc=%d}) = -1 EBADF (%m)\n",
1020 XLAT_STR(VIDIOC_S_TUNER), p_tuner->index,
1021 XLAT_ARGS(V4L2_TUNER_RADIO), XLAT_ARGS(V4L2_TUNER_CAP_LOW),
1022 p_tuner->rangelow, p_tuner->rangehigh,
1023 XLAT_ARGS(V4L2_TUNER_SUB_MONO), XLAT_ARGS(V4L2_TUNER_MODE_MONO),
1024 p_tuner->signal, p_tuner->afc);
1025
1026 /* VIDIOC_QUERYCTRL */
1027 ioctl(-1, VIDIOC_QUERYCTRL, 0);
1028 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1029 XLAT_STR(VIDIOC_QUERYCTRL));
1030
1031 struct v4l2_queryctrl *const p_v4l2_queryctrl =
1032 page_end - sizeof(*p_v4l2_queryctrl);
1033 ioctl(-1, VIDIOC_QUERYCTRL, p_v4l2_queryctrl);
1034 printf("ioctl(-1, %s, {id="
1035 #if XLAT_RAW
1036 "%#x"
1037 #else
1038 XLAT_FMT "|%#x /* V4L2_CID_??? */"
1039 #endif
1040 "}) = -1 EBADF (%m)\n",
1041 XLAT_STR(VIDIOC_QUERYCTRL),
1042 #if XLAT_RAW
1043 p_v4l2_queryctrl->id
1044 #else
1045 XLAT_ARGS(V4L2_CTRL_FLAG_NEXT_CTRL),
1046 p_v4l2_queryctrl->id & ~V4L2_CTRL_FLAG_NEXT_CTRL
1047 #endif
1048 );
1049
1050 TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_queryctrl, p_queryctrl);
1051 p_queryctrl->id = V4L2_CID_SATURATION;
1052 ioctl(-1, VIDIOC_QUERYCTRL, p_queryctrl);
1053 printf("ioctl(-1, %s, {id=" XLAT_FMT "}) = -1 EBADF (%m)\n",
1054 XLAT_STR(VIDIOC_QUERYCTRL), XLAT_ARGS(V4L2_CID_SATURATION));
1055
1056 /* VIDIOC_G_INPUT */
1057 ioctl(-1, VIDIOC_G_INPUT, 0);
1058 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1059 XLAT_STR(VIDIOC_G_INPUT));
1060
1061 ioctl(-1, VIDIOC_G_INPUT, page);
1062 printf("ioctl(-1, %s, %p) = -1 EBADF (%m)\n",
1063 XLAT_STR(VIDIOC_G_INPUT), page);
1064
1065 /* VIDIOC_S_INPUT */
1066 ioctl(-1, VIDIOC_S_INPUT, 0);
1067 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1068 XLAT_STR(VIDIOC_S_INPUT));
1069
1070 ioctl(-1, VIDIOC_S_INPUT, p_int);
1071 printf("ioctl(-1, %s, [%u]) = -1 EBADF (%m)\n",
1072 XLAT_STR(VIDIOC_S_INPUT), *p_int);
1073
1074 /* VIDIOC_CROPCAP */
1075 ioctl(-1, VIDIOC_CROPCAP, 0);
1076 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1077 XLAT_STR(VIDIOC_CROPCAP));
1078
1079 struct v4l2_cropcap *const p_v4l2_cropcap =
1080 page_end - sizeof(*p_v4l2_cropcap);
1081 ioctl(-1, VIDIOC_CROPCAP, p_v4l2_cropcap);
1082 printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})"
1083 " = -1 EBADF (%m)\n",
1084 XLAT_STR(VIDIOC_CROPCAP), p_v4l2_cropcap->type);
1085
1086 /* VIDIOC_G_CROP */
1087 ioctl(-1, VIDIOC_G_CROP, 0);
1088 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1089 XLAT_STR(VIDIOC_G_CROP));
1090
1091 struct v4l2_crop *const p_v4l2_crop =
1092 page_end - sizeof(*p_v4l2_crop);
1093 ioctl(-1, VIDIOC_G_CROP, p_v4l2_crop);
1094 printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})"
1095 " = -1 EBADF (%m)\n",
1096 XLAT_STR(VIDIOC_G_CROP), p_v4l2_crop->type);
1097
1098 /* VIDIOC_S_CROP */
1099 ioctl(-1, VIDIOC_S_CROP, 0);
1100 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1101 XLAT_STR(VIDIOC_S_CROP));
1102
1103 ioctl(-1, VIDIOC_S_CROP, p_v4l2_crop);
1104 printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */")
1105 ", c={left=%d, top=%d, width=%u, height=%u}}) = -1 EBADF (%m)\n",
1106 XLAT_STR(VIDIOC_S_CROP),
1107 p_v4l2_crop->type,
1108 p_v4l2_crop->c.left,
1109 p_v4l2_crop->c.top,
1110 p_v4l2_crop->c.width,
1111 p_v4l2_crop->c.height);
1112
1113 /* VIDIOC_S_EXT_CTRLS */
1114 ioctl(-1, VIDIOC_S_EXT_CTRLS, 0);
1115 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1116 XLAT_STR(VIDIOC_S_EXT_CTRLS));
1117
1118 TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_ext_controls, p_ext_controls);
1119 p_ext_controls->ctrl_class = V4L2_CTRL_CLASS_USER;
1120 p_ext_controls->count = 0;
1121 p_ext_controls->controls = (void *) -2UL;
1122 ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls);
1123 printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u})"
1124 " = -1 EBADF (%m)\n",
1125 XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_USER),
1126 p_ext_controls->count);
1127
1128 p_ext_controls->ctrl_class = 0x00a30000;
1129 p_ext_controls->count = magic;
1130 ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls);
1131 printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT
1132 ", count=%u, controls=%p}) = -1 EBADF (%m)\n",
1133 XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_DETECT),
1134 p_ext_controls->count, p_ext_controls->controls);
1135
1136 p_ext_controls->ctrl_class = 0x00160000;
1137 p_ext_controls->count = magic;
1138 ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls);
1139 printf("ioctl(-1, %s"
1140 ", {ctrl_class=0x160000" NRAW(" /* V4L2_CTRL_CLASS_??? */")
1141 ", count=%u, controls=%p}) = -1 EBADF (%m)\n",
1142 XLAT_STR(VIDIOC_S_EXT_CTRLS),
1143 p_ext_controls->count, p_ext_controls->controls);
1144
1145 p_ext_controls->ctrl_class = V4L2_CTRL_CLASS_CODEC;
1146 p_ext_controls->count = magic;
1147 ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls);
1148 printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT
1149 ", count=%u, controls=%p}) = -1 EBADF (%m)\n",
1150 XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_CODEC),
1151 p_ext_controls->count, p_ext_controls->controls);
1152
1153 p_ext_controls->count = 2;
1154 p_ext_controls->controls =
1155 tail_alloc(sizeof(*p_ext_controls->controls) * p_ext_controls->count);
1156 p_ext_controls->controls[0].id = V4L2_CID_BRIGHTNESS;
1157 p_ext_controls->controls[0].size = 0;
1158 p_ext_controls->controls[0].value64 = 0xfacefeeddeadbeefULL;
1159 p_ext_controls->controls[1].id = V4L2_CID_CONTRAST;
1160 p_ext_controls->controls[1].size = 2;
1161 p_ext_controls->controls[1].string =
1162 tail_alloc(p_ext_controls->controls[1].size);
1163
1164 ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls);
1165 printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls="
1166 "[{id=" XLAT_FMT ", size=0, value=%d, value64=%lld}"
1167 ", {id=" XLAT_FMT ", size=2, string=\"\\377\\377\"}"
1168 "]} => {controls="
1169 "[{id=" XLAT_FMT ", size=0, value=%d, value64=%lld}"
1170 ", {id=" XLAT_FMT ", size=2, string=\"\\377\\377\"}"
1171 "], error_idx=%u}) = -1 EBADF (%m)\n",
1172 XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_CODEC),
1173 p_ext_controls->count, XLAT_ARGS(V4L2_CID_BRIGHTNESS),
1174 p_ext_controls->controls[0].value,
1175 (long long) p_ext_controls->controls[0].value64,
1176 XLAT_ARGS(V4L2_CID_CONTRAST), XLAT_ARGS(V4L2_CID_BRIGHTNESS),
1177 p_ext_controls->controls[0].value,
1178 (long long) p_ext_controls->controls[0].value64,
1179 XLAT_ARGS(V4L2_CID_CONTRAST), p_ext_controls->error_idx);
1180
1181 ++p_ext_controls->count;
1182 ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls);
1183 printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls="
1184 "[{id=" XLAT_FMT ", size=0, value=%d, value64=%lld}"
1185 ", {id=" XLAT_FMT ", size=2, string=\"\\377\\377\"}"
1186 ", ... /* %p */]}) = -1 EBADF (%m)\n",
1187 XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_CODEC),
1188 p_ext_controls->count, XLAT_ARGS(V4L2_CID_BRIGHTNESS),
1189 p_ext_controls->controls[0].value,
1190 (long long) p_ext_controls->controls[0].value64,
1191 XLAT_ARGS(V4L2_CID_CONTRAST), p_ext_controls->controls + 2);
1192
1193 /* VIDIOC_TRY_EXT_CTRLS */
1194 ioctl(-1, VIDIOC_TRY_EXT_CTRLS, 0);
1195 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1196 XLAT_STR(VIDIOC_TRY_EXT_CTRLS));
1197
1198 p_ext_controls->ctrl_class = V4L2_CTRL_CLASS_USER;
1199 p_ext_controls->count = magic;
1200 p_ext_controls->controls = (void *) -2UL;
1201 ioctl(-1, VIDIOC_TRY_EXT_CTRLS, p_ext_controls);
1202 printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls=%p})"
1203 " = -1 EBADF (%m)\n",
1204 XLAT_STR(VIDIOC_TRY_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_USER),
1205 p_ext_controls->count, p_ext_controls->controls);
1206
1207 /* VIDIOC_G_EXT_CTRLS */
1208 ioctl(-1, VIDIOC_G_EXT_CTRLS, 0);
1209 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1210 XLAT_STR(VIDIOC_G_EXT_CTRLS));
1211
1212 ioctl(-1, VIDIOC_G_EXT_CTRLS, p_ext_controls);
1213 printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls=%p"
1214 ", error_idx=%u}) = -1 EBADF (%m)\n",
1215 XLAT_STR(VIDIOC_G_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_USER),
1216 p_ext_controls->count, p_ext_controls->controls,
1217 p_ext_controls->error_idx);
1218
1219 ioctl(-1, VIDIOC_ENUM_FRAMESIZES, 0);
1220 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1221 XLAT_STR(VIDIOC_ENUM_FRAMESIZES));
1222
1223 TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_frmsizeenum, p_frmsizeenum);
1224 p_frmsizeenum->index = magic;
1225 p_frmsizeenum->pixel_format = fourcc(cc[0], cc[1], cc[2], cc[3]);
1226
1227 ioctl(-1, VIDIOC_ENUM_FRAMESIZES, p_frmsizeenum);
1228 printf("ioctl(-1, %s, {index=%u, pixel_format="
1229 #if XLAT_RAW
1230 "0x%hhx%hhx%hhx%hhx"
1231 #else /* !XLAT_RAW */
1232 "v4l2_fourcc('%c', '\\%c', '\\%c', '\\x%x')"
1233 #endif /* XLAT_RAW */
1234 "}) = -1 EBADF (%m)\n",
1235 XLAT_STR(VIDIOC_ENUM_FRAMESIZES), p_frmsizeenum->index,
1236 #if XLAT_RAW
1237 cc[3], cc[2], cc[1], cc[0]
1238 #else /* !XLAT_RAW */
1239 cc[0], cc[1], cc[2], cc[3]
1240 #endif /* XLAT_RAW */
1241 );
1242
1243 ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, 0);
1244 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1245 XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS));
1246
1247 struct v4l2_frmivalenum *const p_v4l2_frmivalenum =
1248 page_end - sizeof(*p_v4l2_frmivalenum);
1249 ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, p_v4l2_frmivalenum);
1250 printf("ioctl(-1, %s, {index=%u, pixel_format="
1251 #if XLAT_RAW
1252 "%#x"
1253 #else /* !XLAT_RAW */
1254 "v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')"
1255 #endif /* XLAT_RAW */
1256 ", width=%u, height=%u}) = -1 EBADF (%m)\n",
1257 XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS), p_v4l2_frmivalenum->index,
1258 #if XLAT_RAW
1259 p_v4l2_frmivalenum->pixel_format,
1260 #else /* !XLAT_RAW */
1261 cc0(p_v4l2_frmivalenum->pixel_format),
1262 cc1(p_v4l2_frmivalenum->pixel_format),
1263 cc2(p_v4l2_frmivalenum->pixel_format),
1264 cc3(p_v4l2_frmivalenum->pixel_format),
1265 #endif /* XLAT_RAW */
1266 p_v4l2_frmivalenum->width,
1267 p_v4l2_frmivalenum->height);
1268
1269 ioctl(-1, VIDIOC_CREATE_BUFS, 0);
1270 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1271 XLAT_STR(VIDIOC_CREATE_BUFS));
1272
1273 struct v4l2_create_buffers *const p_v4l2_create_buffers =
1274 page_end - sizeof(*p_v4l2_create_buffers);
1275 ioctl(-1, VIDIOC_CREATE_BUFS, p_v4l2_create_buffers);
1276 printf("ioctl(-1, %s, {count=%u, memory=%#x"
1277 NRAW(" /* V4L2_MEMORY_??? */") ", format={type=%#x"
1278 NRAW(" /* V4L2_BUF_TYPE_??? */") "}}) = -1 EBADF (%m)\n",
1279 XLAT_STR(VIDIOC_CREATE_BUFS),
1280 p_v4l2_create_buffers->count,
1281 p_v4l2_create_buffers->memory,
1282 p_v4l2_create_buffers->format.type);
1283
1284 ioctl(-1, VIDIOC_QUERY_EXT_CTRL, 0);
1285 printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n",
1286 XLAT_STR(VIDIOC_QUERY_EXT_CTRL));
1287
1288 struct v4l2_query_ext_ctrl *const p_v4l2_query_ext_ctrl =
1289 page_end - sizeof(*p_v4l2_query_ext_ctrl);
1290 ioctl(-1, VIDIOC_QUERY_EXT_CTRL, p_v4l2_query_ext_ctrl);
1291 printf("ioctl(-1, %s, {id="
1292 #ifdef WORDS_BIGENDIAN
1293 RAW("0x98999a9b") VERB("0x80000000 /* ")
1294 NRAW("V4L2_CTRL_FLAG_NEXT_CTRL") VERB(" */")
1295 NRAW("|0x18999a9b /* V4L2_CID_??? */")
1296 #else
1297 RAW("0x9b9a9998") VERB("0x80000000 /* ")
1298 NRAW("V4L2_CTRL_FLAG_NEXT_CTRL") VERB(" */")
1299 NRAW("|0x1b9a9998 /* V4L2_CID_??? */")
1300 #endif
1301 "}) = -1 EBADF (%m)\n",
1302 XLAT_STR(VIDIOC_QUERY_EXT_CTRL));
1303
1304 puts("+++ exited with 0 +++");
1305 return 0;
1306 }