1 /*
2 * Copyright (c) 2018-2023 The strace developers.
3 * All rights reserved.
4 *
5 * SPDX-License-Identifier: GPL-2.0-or-later
6 */
7
8 #include "tests.h"
9
10 #include <stdint.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <sys/ioctl.h>
15 #include "kernel_v4l2_types.h"
16
17 static bool
18 fill_fmt(struct v4l2_format *f)
19 {
20 static struct v4l2_clip *clips;
21
22 switch (f->type) {
23 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
24 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
25 f->fmt.pix.width = 0xdeadc0de;
26 f->fmt.pix.height = 0xfeedbeef;
27 f->fmt.pix.pixelformat = 0xb5315258; /* forurcc_be("XR15") */
28 f->fmt.pix.field = f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE
29 ? V4L2_FIELD_ALTERNATE : 0xdec0ded1;
30 f->fmt.pix.bytesperline = 0xbadc0ded;
31 f->fmt.pix.sizeimage = 0xface1e55;
32 f->fmt.pix.colorspace = V4L2_COLORSPACE_REC709;
33 break;
34
35 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
36 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
37 f->fmt.win.w.left = 0xa0a1a2a3;
38 f->fmt.win.w.top = 0xb0b1b2b3;
39 f->fmt.win.w.width = 0xc0c1c2c3;
40 f->fmt.win.w.height = 0xd0d1d2d3;
41 f->fmt.win.field = f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
42 ? V4L2_FIELD_ANY : 10;
43 f->fmt.win.chromakey = 0xbeefface;
44
45 if (!clips)
46 clips = tail_alloc(sizeof(*clips) * 3);
47 f->fmt.win.clips = clips;
48
49 f->fmt.win.clips[0].c.left = 0xa4a5a6a7;
50 f->fmt.win.clips[0].c.top = 0xb4b5b6b7;
51 f->fmt.win.clips[0].c.width = 0xc4c5c6c7;
52 f->fmt.win.clips[0].c.height = 0xd4d5d6d7;
53 f->fmt.win.clips[0].next = clips;
54
55 f->fmt.win.clips[1].c.left = 0xa8a9aaab;
56 f->fmt.win.clips[1].c.top = 0xb8b9babb;
57 f->fmt.win.clips[1].c.width = 0xc8c9cacb;
58 f->fmt.win.clips[1].c.height = 0xd8d9dadb;
59
60 f->fmt.win.clips[2].c.left = 0xacadaeaf;
61 f->fmt.win.clips[2].c.top = 0xbcbdbebf;
62 f->fmt.win.clips[2].c.width = 0xcccdcecf;
63 f->fmt.win.clips[2].c.height = 0xdcdddedf;
64 f->fmt.win.clips[2].next = clips + 1;
65
66 f->fmt.win.clipcount = f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
67 ? 4 : 0;
68 f->fmt.win.bitmap = f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
69 ? NULL : clips;
70 break;
71
72 case V4L2_BUF_TYPE_VBI_CAPTURE:
73 case V4L2_BUF_TYPE_VBI_OUTPUT:
74 f->fmt.vbi.sampling_rate = 0xdecaffed;
75 f->fmt.vbi.offset = 0xcafefeed;
76 f->fmt.vbi.samples_per_line = 0xbeefaced;
77 f->fmt.vbi.sample_format = V4L2_PIX_FMT_RGB555X;
78
79 f->fmt.vbi.start[0] = 0xdec0ded0;
80 f->fmt.vbi.start[1] = 0xdec0ded1;
81 f->fmt.vbi.count[0] = 0xacceded2;
82 f->fmt.vbi.count[1] = 0xacceded3;
83
84 f->fmt.vbi.flags = f->type == V4L2_BUF_TYPE_VBI_CAPTURE
85 ? 0x3 : 0x1ce50d1c;
86 break;
87
88 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
89 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
90 f->fmt.pix_mp.width = 0xdeaffade;
91 f->fmt.pix_mp.height = 0xfadeb1a5;
92 f->fmt.pix_mp.pixelformat = 0x36314454;
93 f->fmt.pix_mp.field = V4L2_FIELD_NONE;
94 f->fmt.pix_mp.colorspace = 13;
95
96 for (size_t i = 0; i < VIDEO_MAX_PLANES; i++) {
97 f->fmt.pix_mp.plane_fmt[i].sizeimage = 0xd0decad0 ^ i;
98 if (sizeof(f->fmt.pix_mp.plane_fmt[i].bytesperline) ==
99 sizeof(uint32_t)) {
100 f->fmt.pix_mp.plane_fmt[i].bytesperline
101 = 0xd0decad1 ^ i;
102 } else {
103 #ifdef WORDS_BIGENDIAN
104 f->fmt.pix_mp.plane_fmt[i].bytesperline
105 = 0xd0de;
106 f->fmt.pix_mp.plane_fmt[i].reserved[0]
107 = 0xcad1 ^ i;
108 #else
109 f->fmt.pix_mp.plane_fmt[i].bytesperline
110 = 0xcad1 ^ i;
111 f->fmt.pix_mp.plane_fmt[i].reserved[0]
112 = 0xd0de;
113 #endif
114 }
115 }
116
117 f->fmt.pix_mp.num_planes = f->type ==
118 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ? 0xd5 : 0;
119 break;
120 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
121 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
122 f->fmt.sliced.service_set = 0xfeed;
123 for (size_t i = 0; i < 2; i++) {
124 for (size_t j = 0; j < 24; j++) {
125 f->fmt.sliced.service_lines[i][j] =
126 0xdead ^ (i << 8) ^ j;
127 }
128 }
129 f->fmt.sliced.io_size = 0xdefaceed;
130 break;
131 case V4L2_BUF_TYPE_SDR_CAPTURE:
132 case V4L2_BUF_TYPE_SDR_OUTPUT:
133 f->fmt.sdr.pixelformat = V4L2_SDR_FMT_CU8;
134 if (sizeof(f->fmt.sdr.buffersize == sizeof(uint32_t)))
135 f->fmt.sdr.buffersize = 0xbadc0ded;
136 else
137 ((uint32_t *) &f->fmt.sdr)[1] = 0xbadc0ded;
138 break;
139 case V4L2_BUF_TYPE_META_CAPTURE:
140 case V4L2_BUF_TYPE_META_OUTPUT:
141 f->fmt.meta.dataformat = V4L2_META_FMT_VSP1_HGO;
142 f->fmt.meta.buffersize = 0xbadc0ded;
143 break;
144 default:
145 return false;
146 }
147
148 return true;
149 }
150
151 static void
152 print_fmt(const char *pfx, struct v4l2_format *f)
153 {
154 switch (f->type) {
155 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
156 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
157 printf("%sfmt.pix={width=3735929054, height=4276993775"
158 ", pixelformat=" RAW("0xb5315258")
159 NRAW("v4l2_fourcc('X', 'R', '1', '\\xb5')"
160 " /* V4L2_PIX_FMT_XRGB555X */")
161 ", field=%s, bytesperline=3134983661"
162 ", sizeimage=4207812181, colorspace="
163 XLAT_KNOWN(0x3, "V4L2_COLORSPACE_REC709") "}",
164 pfx, f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE
165 ? XLAT_STR(V4L2_FIELD_ALTERNATE)
166 : XLAT_UNKNOWN(0xdec0ded1, "V4L2_FIELD_???"));
167 break;
168
169 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
170 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
171 printf("%sfmt.win={w={left=-1600019805, top=-1330531661"
172 ", width=3233923779, height=3503411923}, field=%s"
173 ", chromakey=0xbeefface, clips=[",
174 pfx, f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
175 ? XLAT_STR(V4L2_FIELD_ANY)
176 : XLAT_UNKNOWN(0xa, "V4L2_FIELD_???"));
177 if (f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY) {
178 printf("{c={left=-1532647769, top=-1263159625"
179 ", width=3301295815, height=3570783959}}, "
180 "{c={left=-1465275733, top=-1195787589"
181 ", width=3368667851, height=3638155995}}, "
182 "{c={left=-1397903697, top=-1128415553"
183 ", width=3436039887, height=3705528031}}, "
184 "... /* %p */", f->fmt.win.clips + 3);
185 }
186 printf("], clipcount=%d, bitmap=",
187 f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY ? 4 : 0);
188
189 if (f->type == V4L2_BUF_TYPE_VIDEO_OVERLAY)
190 printf("NULL");
191 else
192 printf("%p", f->fmt.win.bitmap);
193
194 printf(", global_alpha=%#hhx}", f->fmt.win.global_alpha);
195 break;
196
197 case V4L2_BUF_TYPE_VBI_CAPTURE:
198 case V4L2_BUF_TYPE_VBI_OUTPUT:
199 printf("%sfmt.vbi={sampling_rate=3737845741, offset=3405709037"
200 ", samples_per_line=3203378413, sample_format="
201 RAW("0x51424752") NRAW("v4l2_fourcc('R', 'G', 'B', 'Q')"
202 " /* V4L2_PIX_FMT_RGB555X */")
203 ", start=[-557785392, -557785391]"
204 ", count=[2899238610, 2899238611], flags=%s}",
205 pfx, f->type == V4L2_BUF_TYPE_VBI_CAPTURE
206 ? XLAT_KNOWN(0x3, "V4L2_VBI_UNSYNC|V4L2_VBI_INTERLACED")
207 : XLAT_UNKNOWN(0x1ce50d1c, "V4L2_VBI_???"));
208 break;
209
210 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
211 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
212 printf("%sfmt.pix_mp={width=3736074974, height=4208898469"
213 ", pixelformat=" RAW("0x36314454")
214 NRAW("v4l2_fourcc('T', 'D', '1', '6')")
215 ", field=%s, colorspace=0xd"
216 NRAW(" /* V4L2_COLORSPACE_??? */") ", plane_fmt=[",
217 pfx, XLAT_STR(V4L2_FIELD_NONE));
218 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
219 printf("{sizeimage=3504261840, bytesperline=3504261841}"
220 ", "
221 "{sizeimage=3504261841, bytesperline=3504261840}"
222 ", "
223 "{sizeimage=3504261842, bytesperline=3504261843}"
224 ", "
225 "{sizeimage=3504261843, bytesperline=3504261842}"
226 ", "
227 "{sizeimage=3504261844, bytesperline=3504261845}"
228 ", "
229 "{sizeimage=3504261845, bytesperline=3504261844}"
230 ", "
231 "{sizeimage=3504261846, bytesperline=3504261847}"
232 ", "
233 "{sizeimage=3504261847, bytesperline=3504261846}"
234 "], num_planes=213}");
235 } else {
236 printf("], num_planes=0}");
237 }
238 break;
239 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
240 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
241 printf("%sfmt.sliced={service_set="
242 XLAT_KNOWN(0xfeed, "V4L2_SLICED_VBI_625"
243 "|V4L2_SLICED_CAPTION_525|0xaaec")
244 ", service_lines=[[0xdead, 0xdeac, 0xdeaf, 0xdeae"
245 ", 0xdea9, 0xdea8, 0xdeab, 0xdeaa, 0xdea5, 0xdea4"
246 ", 0xdea7, 0xdea6, 0xdea1, 0xdea0, 0xdea3, 0xdea2"
247 ", 0xdebd, 0xdebc, 0xdebf, 0xdebe, 0xdeb9, 0xdeb8"
248 ", 0xdebb, 0xdeba], [0xdfad, 0xdfac, 0xdfaf, 0xdfae"
249 ", 0xdfa9, 0xdfa8, 0xdfab, 0xdfaa, 0xdfa5, 0xdfa4"
250 ", 0xdfa7, 0xdfa6, 0xdfa1, 0xdfa0, 0xdfa3, 0xdfa2"
251 ", 0xdfbd, 0xdfbc, 0xdfbf, 0xdfbe, 0xdfb9, 0xdfb8"
252 ", 0xdfbb, 0xdfba]], io_size=3740978925}",
253 pfx);
254 break;
255 case V4L2_BUF_TYPE_SDR_CAPTURE:
256 case V4L2_BUF_TYPE_SDR_OUTPUT:
257 printf("%sfmt.sdr={pixelformat=" RAW("0x38305543")
258 NRAW("v4l2_fourcc('C', 'U', '0', '8')"
259 " /* V4L2_SDR_FMT_CU8 */")
260 ", buffersize=3134983661}",
261 pfx);
262 break;
263
264 case V4L2_BUF_TYPE_META_CAPTURE:
265 case V4L2_BUF_TYPE_META_OUTPUT:
266 printf("%sfmt.meta={dataformat=" RAW("0x48505356")
267 NRAW("v4l2_fourcc('V', 'S', 'P', 'H')"
268 " /* V4L2_META_FMT_VSP1_HGO */")
269 ", buffersize=3134983661}",
270 pfx);
271 break;
272 }
273 }
274
275 int
276 main(int argc, char **argv)
277 {
278 unsigned long num_skip;
279 long inject_retval;
280 bool locked = false;
281
282 if (argc == 1)
283 return 0;
284
285 if (argc < 3)
286 error_msg_and_fail("Usage: %s NUM_SKIP INJECT_RETVAL", argv[0]);
287
288 num_skip = strtoul(argv[1], NULL, 0);
289 inject_retval = strtol(argv[2], NULL, 0);
290
291 if (inject_retval < 0)
292 error_msg_and_fail("Expected non-negative INJECT_RETVAL, "
293 "but got %ld", inject_retval);
294
295 for (unsigned int i = 0; i < num_skip; i++) {
296 long rc = ioctl(-1, VIDIOC_QUERYCAP, NULL);
297 printf("ioctl(-1, %s, NULL) = %s%s\n",
298 XLAT_STR(VIDIOC_QUERYCAP), sprintrc(rc),
299 rc == inject_retval ? " (INJECTED)" : "");
300
301 if (rc != inject_retval)
302 continue;
303
304 locked = true;
305 break;
306 }
307
308 if (!locked)
309 error_msg_and_fail("Hasn't locked on ioctl(-1"
310 ", VIDIOC_QUERYCAP, NULL) returning %lu",
311 inject_retval);
312
313
314 /* VIDIOC_QUERYCAP */
315 struct v4l2_capability *caps = tail_alloc(sizeof(*caps));
316
317 fill_memory(caps, sizeof(*caps));
318 caps->capabilities = 0xdeadbeef;
319 caps->device_caps = 0xfacefeed;
320
321 ioctl(-1, VIDIOC_QUERYCAP, 0);
322 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
323 XLAT_STR(VIDIOC_QUERYCAP), inject_retval);
324
325 ioctl(-1, VIDIOC_QUERYCAP, (char *) caps + 1);
326 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
327 XLAT_STR(VIDIOC_QUERYCAP), (char *) caps + 1, inject_retval);
328
329 ioctl(-1, VIDIOC_QUERYCAP, caps);
330 printf("ioctl(-1, %s, {driver=", XLAT_STR(VIDIOC_QUERYCAP));
331 print_quoted_cstring((char *) caps->driver, sizeof(caps->driver));
332 printf(", card=");
333 print_quoted_cstring((char *) caps->card, sizeof(caps->card));
334 printf(", bus_info=");
335 print_quoted_cstring((char *) caps->bus_info, sizeof(caps->bus_info));
336 printf(", version="
337 #ifdef WORDS_BIGENDIAN
338 XLAT_KNOWN(0xd0d1d2d3, "KERNEL_VERSION(53457, 210, 211)")
339 #else
340 XLAT_KNOWN(0xd3d2d1d0, "KERNEL_VERSION(54226, 209, 208)")
341 #endif
342 ", capabilities=" XLAT_KNOWN(0xdeadbeef,
343 "V4L2_CAP_VIDEO_CAPTURE|V4L2_CAP_VIDEO_OUTPUT"
344 "|V4L2_CAP_VIDEO_OVERLAY|V4L2_CAP_VBI_OUTPUT"
345 "|V4L2_CAP_SLICED_VBI_CAPTURE|V4L2_CAP_SLICED_VBI_OUTPUT"
346 "|V4L2_CAP_VIDEO_OUTPUT_OVERLAY|V4L2_CAP_HW_FREQ_SEEK"
347 "|V4L2_CAP_RDS_OUTPUT|V4L2_CAP_VIDEO_CAPTURE_MPLANE"
348 "|V4L2_CAP_VIDEO_OUTPUT_MPLANE|V4L2_CAP_VIDEO_M2M"
349 "|V4L2_CAP_TUNER|V4L2_CAP_RADIO|V4L2_CAP_MODULATOR"
350 "|V4L2_CAP_EXT_PIX_FORMAT|V4L2_CAP_META_CAPTURE|V4L2_CAP_ASYNCIO"
351 "|V4L2_CAP_STREAMING|V4L2_CAP_META_OUTPUT|V4L2_CAP_TOUCH"
352 "|V4L2_CAP_DEVICE_CAPS|0x40000008"));
353 printf(", device_caps=" XLAT_KNOWN(0xfacefeed,
354 "V4L2_CAP_VIDEO_CAPTURE|V4L2_CAP_VIDEO_OVERLAY"
355 "|V4L2_CAP_VBI_OUTPUT|V4L2_CAP_SLICED_VBI_CAPTURE"
356 "|V4L2_CAP_SLICED_VBI_OUTPUT|V4L2_CAP_VIDEO_OUTPUT_OVERLAY"
357 "|V4L2_CAP_HW_FREQ_SEEK|V4L2_CAP_RDS_OUTPUT"
358 "|V4L2_CAP_VIDEO_CAPTURE_MPLANE|V4L2_CAP_VIDEO_OUTPUT_MPLANE"
359 "|V4L2_CAP_VIDEO_M2M_MPLANE|V4L2_CAP_VIDEO_M2M|V4L2_CAP_AUDIO"
360 "|V4L2_CAP_RADIO|V4L2_CAP_MODULATOR|V4L2_CAP_SDR_OUTPUT"
361 "|V4L2_CAP_META_CAPTURE|V4L2_CAP_ASYNCIO|V4L2_CAP_META_OUTPUT"
362 "|V4L2_CAP_TOUCH|V4L2_CAP_DEVICE_CAPS|0x60000008"));
363 printf("}) = %ld (INJECTED)\n", inject_retval);
364
365
366 /* VIDIOC_ENUM_FMT */
367 static const struct strval32 buf_types[] = {
368 { ARG_XLAT_UNKNOWN(0, "V4L2_BUF_TYPE_???") },
369 { ARG_XLAT_KNOWN(0x1, "V4L2_BUF_TYPE_VIDEO_CAPTURE") },
370 { ARG_XLAT_KNOWN(0x2, "V4L2_BUF_TYPE_VIDEO_OUTPUT") },
371 { ARG_XLAT_KNOWN(0x3, "V4L2_BUF_TYPE_VIDEO_OVERLAY") },
372 { ARG_XLAT_KNOWN(0x4, "V4L2_BUF_TYPE_VBI_CAPTURE") },
373 { ARG_XLAT_KNOWN(0x5, "V4L2_BUF_TYPE_VBI_OUTPUT") },
374 { ARG_XLAT_KNOWN(0x6, "V4L2_BUF_TYPE_SLICED_VBI_CAPTURE") },
375 { ARG_XLAT_KNOWN(0x7, "V4L2_BUF_TYPE_SLICED_VBI_OUTPUT") },
376 { ARG_XLAT_KNOWN(0x8, "V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY") },
377 { ARG_XLAT_KNOWN(0x9, "V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE") },
378 { ARG_XLAT_KNOWN(0xa, "V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE") },
379 { ARG_XLAT_KNOWN(0xb, "V4L2_BUF_TYPE_SDR_CAPTURE") },
380 { ARG_XLAT_KNOWN(0xc, "V4L2_BUF_TYPE_SDR_OUTPUT") },
381 { ARG_XLAT_KNOWN(0xd, "V4L2_BUF_TYPE_META_CAPTURE") },
382 { ARG_XLAT_KNOWN(0xe, "V4L2_BUF_TYPE_META_OUTPUT") },
383 { ARG_XLAT_UNKNOWN(0xf, "V4L2_BUF_TYPE_???") },
384 { ARG_XLAT_UNKNOWN(0x80, "V4L2_BUF_TYPE_???") },
385 { ARG_XLAT_UNKNOWN(0xbadc0ded, "V4L2_BUF_TYPE_???") },
386 };
387 static const struct strval32 fmtdesc_flags[] = {
388 { ARG_STR(0) },
389 { ARG_XLAT_KNOWN(0x1, "V4L2_FMT_FLAG_COMPRESSED") },
390 { ARG_XLAT_KNOWN(0x3fe, "V4L2_FMT_FLAG_EMULATED"
391 "|V4L2_FMT_FLAG_CONTINUOUS_BYTESTREAM"
392 "|V4L2_FMT_FLAG_DYN_RESOLUTION"
393 "|V4L2_FMT_FLAG_ENC_CAP_FRAME_INTERVAL"
394 "|V4L2_FMT_FLAG_CSC_COLORSPACE"
395 "|V4L2_FMT_FLAG_CSC_XFER_FUNC"
396 "|V4L2_FMT_FLAG_CSC_YCBCR_ENC"
397 "|V4L2_FMT_FLAG_CSC_QUANTIZATION"
398 "|0x200") },
399 { ARG_XLAT_UNKNOWN(0xdead0000, "V4L2_FMT_FLAG_???") },
400 };
401 static const struct strval32 fmtdesc_fmts[] = {
402 { 0x4c47504a, RAW("0x4c47504a")
403 NRAW("v4l2_fourcc('J', 'P', 'G', 'L')"
404 " /* V4L2_PIX_FMT_JPGL */") },
405 { 0xbadc0ded, RAW("0xbadc0ded")
406 NRAW("v4l2_fourcc('\\xed', '\\x0d', '\\xdc',"
407 " '\\xba')") },
408 };
409 struct v4l2_fmtdesc *fmtdesc = tail_alloc(sizeof(*fmtdesc));
410
411 fill_memory(fmtdesc, sizeof(*fmtdesc));
412 fmtdesc->index = 0xdeac0de;
413
414 ioctl(-1, VIDIOC_ENUM_FMT, 0);
415 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
416 XLAT_STR(VIDIOC_ENUM_FMT), inject_retval);
417
418 ioctl(-1, VIDIOC_ENUM_FMT, (char *) fmtdesc + 1);
419 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
420 XLAT_STR(VIDIOC_ENUM_FMT), (char *) fmtdesc + 1, inject_retval);
421
422 for (size_t i = 0; i < ARRAY_SIZE(buf_types); i++) {
423 for (size_t j = 0; j < ARRAY_SIZE(fmtdesc_flags); j++) {
424 for (size_t k = 0; k < ARRAY_SIZE(fmtdesc_fmts); k++) {
425 fmtdesc->type = buf_types[i].val;
426 fmtdesc->flags = fmtdesc_flags[j].val;
427 fmtdesc->pixelformat = fmtdesc_fmts[k].val;
428
429 ioctl(-1, VIDIOC_ENUM_FMT, fmtdesc);
430 printf("ioctl(-1, %s, {index=233488606, type=%s"
431 ", flags=%s, description=",
432 XLAT_STR(VIDIOC_ENUM_FMT),
433 buf_types[i].str,
434 fmtdesc_flags[j].str);
435 print_quoted_cstring((char *) fmtdesc->description,
436 sizeof(fmtdesc->description));
437 printf(", pixelformat=%s}) = %ld (INJECTED)\n",
438 fmtdesc_fmts[k].str, inject_retval);
439
440 fill_memory_ex(fmtdesc->description,
441 sizeof(fmtdesc->description),
442 (i * 9 + j) * 7 + k,
443 (k * 3 + j) * 11 + i + 5);
444 }
445 }
446 }
447
448
449 /* VIDIOC_REQBUFS */
450 static const struct strval32 reqb_mems[] = {
451 { ARG_XLAT_UNKNOWN(0, "V4L2_MEMORY_???") },
452 { ARG_XLAT_KNOWN(0x1, "V4L2_MEMORY_MMAP") },
453 { ARG_XLAT_KNOWN(0x4, "V4L2_MEMORY_DMABUF") },
454 { ARG_XLAT_UNKNOWN(0x5, "V4L2_MEMORY_???") },
455 { ARG_XLAT_UNKNOWN(0xbadc0ded, "V4L2_MEMORY_???") },
456 };
457 struct v4l2_requestbuffers *reqb = tail_alloc(sizeof(*reqb));
458
459 fill_memory(reqb, sizeof(*reqb));
460 reqb->count = 0xfeedface;
461
462 ioctl(-1, VIDIOC_REQBUFS, 0);
463 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
464 XLAT_STR(VIDIOC_REQBUFS), inject_retval);
465
466 ioctl(-1, VIDIOC_REQBUFS, (char *) reqb + 1);
467 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
468 XLAT_STR(VIDIOC_REQBUFS), (char *) reqb + 1, inject_retval);
469
470 for (size_t i = 0; i < MAX(ARRAY_SIZE(buf_types),
471 ARRAY_SIZE(reqb_mems)); i++) {
472 reqb->type = buf_types[i % ARRAY_SIZE(buf_types)].val;
473 reqb->memory = reqb_mems[i % ARRAY_SIZE(reqb_mems)].val;
474
475 ioctl(-1, VIDIOC_REQBUFS, reqb);
476 printf("ioctl(-1, %s, {type=%s, memory=%s"
477 ", count=4277009102 => 4277009102}) = %ld (INJECTED)\n",
478 XLAT_STR(VIDIOC_REQBUFS),
479 buf_types[i % ARRAY_SIZE(buf_types)].str,
480 reqb_mems[i % ARRAY_SIZE(reqb_mems)].str,
481 inject_retval);
482 }
483
484
485 /* VIDIOC_G_FMT, VIDIOC_S_FMT, VIDIOC_TRY_FMT */
486 static const struct strval32 fmt_cmds[] = {
487 { ARG_STR(VIDIOC_G_FMT) },
488 { ARG_STR(VIDIOC_S_FMT) },
489 { ARG_STR(VIDIOC_TRY_FMT) },
490 };
491
492 struct v4l2_format *fmt = tail_alloc(sizeof(*fmt));
493
494 for (size_t i = 0; i < ARRAY_SIZE(fmt_cmds); i++) {
495 ioctl(-1, fmt_cmds[i].val, 0);
496 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
497 sprintxlat(fmt_cmds[i].str, fmt_cmds[i].val, NULL),
498 inject_retval);
499
500 ioctl(-1, fmt_cmds[i].val, (char *) fmt + 1);
501 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
502 sprintxlat(fmt_cmds[i].str, fmt_cmds[i].val, NULL),
503 (char *) fmt + 1, inject_retval);
504
505 for (size_t j = 0; j < ARRAY_SIZE(buf_types); j++) {
506 fill_memory(fmt, sizeof(*fmt));
507
508 fmt->type = buf_types[j].val;
509 if (!fill_fmt(fmt))
510 continue;
511
512 ioctl(-1, fmt_cmds[i].val, fmt);
513 printf("ioctl(-1, %s, {type=%s",
514 sprintxlat(fmt_cmds[i].str, fmt_cmds[i].val,
515 NULL),
516 buf_types[j].str);
517 print_fmt(", ", fmt);
518 if (fmt_cmds[i].val != VIDIOC_G_FMT &&
519 buf_types[j].val != V4L2_BUF_TYPE_VIDEO_OVERLAY &&
520 buf_types[j].val != 8)
521 print_fmt("} => {", fmt);
522 printf("}) = %ld (INJECTED)\n", inject_retval);
523 }
524 }
525
526
527 /* VIDIOC_QUERYBUF, VIDIOC_QBUF, VIDIOC_DQBUF */
528 static const struct strval32 buf_cmds[] = {
529 { ARG_STR(VIDIOC_QUERYBUF) },
530 { ARG_STR(VIDIOC_QBUF) },
531 { ARG_STR(VIDIOC_DQBUF) },
532 };
533
534 kernel_v4l2_buffer_t *buf = tail_alloc(sizeof(*buf));
535
536 for (size_t i = 0; i < ARRAY_SIZE(buf_cmds); i++) {
537 ioctl(-1, buf_cmds[i].val, 0);
538 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
539 sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
540 inject_retval);
541
542 ioctl(-1, buf_cmds[i].val, (char *) buf + 1);
543 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
544 sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
545 (char *) buf + 1, inject_retval);
546
547 fill_memory(buf, sizeof(*buf));
548 buf->index = 0xdeadc0de;
549 buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
550 buf->bytesused = 0xdecaffee;
551 buf->flags = 0x1ff; /* TODO: update */
552 buf->field = V4L2_FIELD_TOP;
553
554 buf->timestamp.tv_sec = 0x1e55c0de;
555 buf->timestamp.tv_usec = 999999;
556
557 buf->timecode.type = V4L2_TC_TYPE_24FPS;
558 buf->timecode.flags = 0xbeefdeaf;
559
560 buf->memory = V4L2_MEMORY_MMAP;
561 buf->m.offset = 0xfacefeed;
562 buf->length = 0xcafebed5;
563 buf->reserved = 0xdeefaced;
564
565 ioctl(-1, buf_cmds[i].val, buf);
566 printf("ioctl(-1, %s, {type="
567 XLAT_KNOWN(0x1, "V4L2_BUF_TYPE_VIDEO_CAPTURE")
568 ", index=3735929054, memory="
569 XLAT_KNOWN(0x1, "V4L2_MEMORY_MMAP")
570 ", m.offset=0xfacefeed, length=3405692629"
571 ", bytesused=3737845742, flags=" RAW("0x1ff")
572 #if !XLAT_RAW
573 XLAT_KNOWN(0x1ff, "V4L2_BUF_FLAG_MAPPED"
574 "|V4L2_BUF_FLAG_QUEUED|V4L2_BUF_FLAG_DONE"
575 "|V4L2_BUF_FLAG_KEYFRAME|V4L2_BUF_FLAG_PFRAME"
576 "|V4L2_BUF_FLAG_BFRAME|V4L2_BUF_FLAG_ERROR"
577 "|V4L2_BUF_FLAG_IN_REQUEST|V4L2_BUF_FLAG_TIMECODE") "|"
578 XLAT_KNOWN(0, "V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN") "|"
579 XLAT_KNOWN(0, "V4L2_BUF_FLAG_TSTAMP_SRC_EOF")
580 #endif
581 "%s, ...}) = %ld (INJECTED)\n",
582 sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
583 buf_cmds[i].val == VIDIOC_DQBUF
584 ? ", timestamp={tv_sec=508936414, tv_usec=999999}" : "",
585 inject_retval);
586
587 buf->type = V4L2_BUF_TYPE_VBI_CAPTURE;
588 buf->flags = 0x268040;
589 buf->field = 0xb;
590 buf->memory = V4L2_MEMORY_USERPTR;
591 buf->m.userptr = (long) 0xdefaced0dec0ded1LL;
592
593 ioctl(-1, buf_cmds[i].val, buf);
594 printf("ioctl(-1, %s, {type="
595 XLAT_KNOWN(0x4, "V4L2_BUF_TYPE_VBI_CAPTURE")
596 ", index=3735929054, memory="
597 XLAT_KNOWN(0x2, "V4L2_MEMORY_USERPTR")
598 ", m.userptr=%p, length=3405692629"
599 ", bytesused=3737845742, flags=" RAW("0x268040")
600 #if !XLAT_RAW
601 XLAT_KNOWN(0x200040, "V4L2_BUF_FLAG_ERROR|0x200000") "|"
602 XLAT_UNKNOWN(0x8000, "V4L2_BUF_FLAG_TIMESTAMP_???") "|"
603 XLAT_UNKNOWN(0x60000, "V4L2_BUF_FLAG_TSTAMP_SRC_???")
604 #endif
605 "%s, ...}) = %ld (INJECTED)\n",
606 sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
607 (void *) (intptr_t) 0xdefaced0dec0ded1LL,
608 buf_cmds[i].val == VIDIOC_DQBUF
609 ? ", timestamp={tv_sec=508936414, tv_usec=999999}" : "",
610 inject_retval);
611
612 buf->type = 0x9;
613 buf->flags = 0;
614
615 ioctl(-1, buf_cmds[i].val, buf);
616 printf("ioctl(-1, %s, {type="
617 XLAT_KNOWN(0x9, "V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE")
618 ", index=3735929054, memory="
619 XLAT_KNOWN(0x2, "V4L2_MEMORY_USERPTR")
620 ", m.userptr=%p, length=3405692629"
621 ", bytesused=3737845742, flags=" RAW("0")
622 #if !XLAT_RAW
623 XLAT_KNOWN(0, "V4L2_BUF_FLAG_TIMESTAMP_UNKNOWN") "|"
624 XLAT_KNOWN(0, "V4L2_BUF_FLAG_TSTAMP_SRC_EOF")
625 #endif
626 "%s, ...}) = %ld (INJECTED)\n",
627 sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
628 (void *) (intptr_t) 0xdefaced0dec0ded1LL,
629 buf_cmds[i].val == VIDIOC_DQBUF
630 ? ", timestamp={tv_sec=508936414, tv_usec=999999}" : "",
631 inject_retval);
632
633 buf->type = 0xa;
634 buf->memory = V4L2_MEMORY_OVERLAY;
635 buf->flags = 0x2000;
636
637 ioctl(-1, buf_cmds[i].val, buf);
638 printf("ioctl(-1, %s, {type="
639 XLAT_KNOWN(0xa, "V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE")
640 ", index=3735929054, memory="
641 XLAT_KNOWN(0x3, "V4L2_MEMORY_OVERLAY")
642 ", length=3405692629, bytesused=3737845742"
643 ", flags=" RAW("0x2000")
644 #if !XLAT_RAW
645 XLAT_KNOWN(0x2000, "V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC")
646 "|" XLAT_KNOWN(0, "V4L2_BUF_FLAG_TSTAMP_SRC_EOF")
647 #endif
648 "%s, ...}) = %ld (INJECTED)\n",
649 sprintxlat(buf_cmds[i].str, buf_cmds[i].val, NULL),
650 buf_cmds[i].val == VIDIOC_DQBUF
651 ? ", timestamp={tv_sec=508936414, tv_usec=999999}" : "",
652 inject_retval);
653 }
654
655
656 /* VIDIOC_G_FBUF, VIDIOC_S_FBUF */
657 static const struct strval32 fbuf_cmds[] = {
658 { ARG_STR(VIDIOC_G_FBUF) },
659 { ARG_STR(VIDIOC_S_FBUF) },
660 };
661
662 struct v4l2_framebuffer *fbuf = tail_alloc(sizeof(*fbuf));
663
664 for (size_t i = 0; i < ARRAY_SIZE(fbuf_cmds); i++) {
665 ioctl(-1, fbuf_cmds[i].val, 0);
666 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
667 sprintxlat(fbuf_cmds[i].str, fbuf_cmds[i].val, NULL),
668 inject_retval);
669
670 ioctl(-1, fbuf_cmds[i].val, (char *) fbuf + 1);
671 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
672 sprintxlat(fbuf_cmds[i].str, fbuf_cmds[i].val, NULL),
673 (char *) fbuf + 1, inject_retval);
674
675 fill_memory32(fbuf, sizeof(*fbuf));
676 fbuf->base = NULL;
677
678 ioctl(-1, fbuf_cmds[i].val, fbuf);
679 printf("ioctl(-1, %s, {capability=0x80a0c0e0, flags=0x80a0c0e1"
680 ", base=NULL}) = %ld (INJECTED)\n",
681 sprintxlat(fbuf_cmds[i].str, fbuf_cmds[i].val, NULL),
682 inject_retval);
683 }
684
685
686 /* VIDIOC_G_PARM, VIDIOC_S_PARM */
687 static const struct strval32 sparm_cmds[] = {
688 { ARG_STR(VIDIOC_G_PARM) },
689 { ARG_STR(VIDIOC_S_PARM) },
690 };
691
692 struct v4l2_streamparm *sparm = tail_alloc(sizeof(*sparm));
693
694 for (size_t i = 0; i < ARRAY_SIZE(sparm_cmds); i++) {
695 ioctl(-1, sparm_cmds[i].val, 0);
696 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
697 sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
698 inject_retval);
699
700 ioctl(-1, sparm_cmds[i].val, (char *) sparm + 1);
701 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
702 sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
703 (char *) sparm + 1, inject_retval);
704
705 fill_memory32(sparm, sizeof(*sparm));
706
707 ioctl(-1, sparm_cmds[i].val, sparm);
708 printf("ioctl(-1, %s, {type="
709 XLAT_UNKNOWN(0x80a0c0e0, "V4L2_BUF_TYPE_???")
710 "}) = %ld (INJECTED)\n",
711 sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
712 inject_retval);
713
714 sparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
715
716 static const char *parm_str1 = "parm.capture={capability="
717 XLAT_UNKNOWN(0x80a0c0e1, "V4L2_CAP_???")
718 ", capturemode="
719 XLAT_UNKNOWN(0x80a0c0e2, "V4L2_MODE_???")
720 ", timeperframe=2158018787/2158018788"
721 ", extendedmode=0x80a0c0e5, readbuffers=2158018790}";
722
723 ioctl(-1, sparm_cmds[i].val, sparm);
724 printf("ioctl(-1, %s, {type="
725 XLAT_KNOWN(0x1, "V4L2_BUF_TYPE_VIDEO_CAPTURE")
726 ", %s}%s%s%s) = %ld (INJECTED)\n",
727 sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
728 parm_str1,
729 sparm_cmds[i].val == VIDIOC_S_PARM ? " => {" : "",
730 sparm_cmds[i].val == VIDIOC_S_PARM ? parm_str1 : "",
731 sparm_cmds[i].val == VIDIOC_S_PARM ? "}" : "",
732 inject_retval);
733
734 sparm->parm.capture.capability = 0x1000;
735 sparm->parm.capture.capturemode = 0x1;
736
737 static const char *parm_str2 = "parm.capture={capability="
738 XLAT_KNOWN(0x1000, "V4L2_CAP_TIMEPERFRAME")
739 ", capturemode="
740 XLAT_KNOWN(0x1, "V4L2_MODE_HIGHQUALITY")
741 ", timeperframe=2158018787/2158018788"
742 ", extendedmode=0x80a0c0e5, readbuffers=2158018790}";
743
744 ioctl(-1, sparm_cmds[i].val, sparm);
745 printf("ioctl(-1, %s, {type="
746 XLAT_KNOWN(0x1, "V4L2_BUF_TYPE_VIDEO_CAPTURE")
747 ", %s}%s%s%s) = %ld (INJECTED)\n",
748 sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
749 parm_str2,
750 sparm_cmds[i].val == VIDIOC_S_PARM ? " => {" : "",
751 sparm_cmds[i].val == VIDIOC_S_PARM ? parm_str2 : "",
752 sparm_cmds[i].val == VIDIOC_S_PARM ? "}" : "",
753 inject_retval);
754
755 sparm->type = 0x9;
756 sparm->parm.capture.capability = 0xdeadbeef;
757 sparm->parm.capture.capturemode = 0xadec0ded;
758
759 ioctl(-1, sparm_cmds[i].val, sparm);
760 printf("ioctl(-1, %s, {type="
761 XLAT_KNOWN(0x9, "V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE")
762 "}) = %ld (INJECTED)\n",
763 sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
764 inject_retval);
765
766 fill_memory32(sparm, sizeof(*sparm));
767 sparm->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
768
769 static const char *parm_str3 = "parm.output={capability="
770 XLAT_UNKNOWN(0x80a0c0e1, "V4L2_CAP_???")
771 ", outputmode="
772 XLAT_UNKNOWN(0x80a0c0e2, "V4L2_MODE_???")
773 ", timeperframe=2158018787/2158018788"
774 ", extendedmode=0x80a0c0e5, writebuffers=2158018790}";
775
776 ioctl(-1, sparm_cmds[i].val, sparm);
777 printf("ioctl(-1, %s, {type="
778 XLAT_KNOWN(0x2, "V4L2_BUF_TYPE_VIDEO_OUTPUT")
779 ", %s}%s%s%s) = %ld (INJECTED)\n",
780 sprintxlat(sparm_cmds[i].str, sparm_cmds[i].val, NULL),
781 parm_str3,
782 sparm_cmds[i].val == VIDIOC_S_PARM ? " => {" : "",
783 sparm_cmds[i].val == VIDIOC_S_PARM ? parm_str3 : "",
784 sparm_cmds[i].val == VIDIOC_S_PARM ? "}" : "",
785 inject_retval);
786
787 }
788
789
790 /* VIDIOC_G_STD, VIDIOC_S_STD */
791 static const struct strval32 stdid_cmds[] = {
792 { ARG_STR(VIDIOC_G_STD) },
793 { ARG_STR(VIDIOC_S_STD) },
794 };
795 static const struct strval64 stdids[] = {
796 { ARG_STR(0) },
797 { ARG_STR(0x1) },
798 { ARG_STR(0xb000) },
799 { ARG_STR(0x3ffffff) },
800 { ARG_STR(0xffffffff) },
801 { ARG_ULL_STR(0xbadc0deddeadface) },
802 };
803
804 v4l2_std_id *stdid = tail_alloc(sizeof(*stdid));
805
806 for (size_t i = 0; i < ARRAY_SIZE(stdid_cmds); i++) {
807 ioctl(-1, stdid_cmds[i].val, 0);
808 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
809 sprintxlat(stdid_cmds[i].str, stdid_cmds[i].val, NULL),
810 inject_retval);
811
812 ioctl(-1, stdid_cmds[i].val, (char *) stdid + 1);
813 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
814 sprintxlat(stdid_cmds[i].str, stdid_cmds[i].val, NULL),
815 (char *) stdid + 1, inject_retval);
816
817 for (size_t j = 0; j < ARRAY_SIZE(stdids); j++) {
818 *stdid = stdids[j].val;
819
820 ioctl(-1, stdid_cmds[i].val, stdid);
821 printf("ioctl(-1, %s, [%s]) = %ld (INJECTED)\n",
822 sprintxlat(stdid_cmds[i].str, stdid_cmds[i].val, NULL),
823 stdids[j].str, inject_retval);
824
825 }
826 }
827
828
829 /* VIDIOC_ENUMSTD */
830 struct v4l2_standard *std = tail_alloc(sizeof(*std));
831
832 ioctl(-1, VIDIOC_ENUMSTD, 0);
833 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
834 XLAT_STR(VIDIOC_ENUMSTD), inject_retval);
835
836 ioctl(-1, VIDIOC_ENUMSTD, (char *) std + 1);
837 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
838 XLAT_STR(VIDIOC_ENUMSTD), (char *) std + 1, inject_retval);
839
840 for (size_t i = 0; i < ARRAY_SIZE(stdids); i++) {
841 fill_memory32(&std->frameperiod, sizeof(*std) -
842 offsetof(struct v4l2_standard, frameperiod));
843 fill_memory_ex(std->name, sizeof(std->name), i * 47 + 1, 255);
844 std->index = 0xdeadface;
845 std->id = stdids[i].val;
846
847 ioctl(-1, VIDIOC_ENUMSTD, std);
848 printf("ioctl(-1, %s, {index=3735943886, name=",
849 XLAT_STR(VIDIOC_ENUMSTD));
850 print_quoted_cstring((char *) std->name, sizeof(std->name));
851 printf(", frameperiod=2158018784/2158018785"
852 ", framelines=2158018786}) = %ld (INJECTED)\n",
853 inject_retval);
854 }
855
856
857 /* VIDIOC_ENUMINPUT */
858 static const struct strval32 input_types[] = {
859 { ARG_XLAT_UNKNOWN(0, "V4L2_INPUT_TYPE_???") },
860 { V4L2_INPUT_TYPE_TUNER,
861 XLAT_KNOWN(0x1, "V4L2_INPUT_TYPE_TUNER") },
862 { V4L2_INPUT_TYPE_CAMERA,
863 XLAT_KNOWN(0x2, "V4L2_INPUT_TYPE_CAMERA") },
864 { ARG_XLAT_UNKNOWN(0x4, "V4L2_INPUT_TYPE_???") },
865 { ARG_XLAT_UNKNOWN(0xdeadc0de, "V4L2_INPUT_TYPE_???") },
866 };
867
868 static const struct strval32 input_std[] = {
869 { V4L2_STD_PAL_I,
870 XLAT_KNOWN(0x10, "V4L2_STD_PAL_I") },
871 { V4L2_STD_SECAM_L,
872 XLAT_KNOWN(0x400000, "V4L2_STD_SECAM_L") },
873 { V4L2_STD_PAL_B | V4L2_STD_PAL_G,
874 XLAT_KNOWN(0x5, "V4L2_STD_PAL_B|V4L2_STD_PAL_G") },
875 { ARG_XLAT_UNKNOWN(0x80000000, "V4L2_STD_???") },
876 };
877
878 static const struct strval32 input_status[] = {
879 { V4L2_IN_ST_NO_SIGNAL,
880 XLAT_KNOWN(0x2, "V4L2_IN_ST_NO_SIGNAL") },
881 { V4L2_IN_ST_NO_STD_LOCK,
882 XLAT_KNOWN(0x800, "V4L2_IN_ST_NO_STD_LOCK") },
883 { V4L2_IN_ST_NO_CARRIER | V4L2_IN_ST_NO_ACCESS,
884 XLAT_KNOWN(0x2040000, "V4L2_IN_ST_NO_CARRIER|V4L2_IN_ST_NO_ACCESS") },
885 { ARG_XLAT_UNKNOWN(0x80000000, "V4L2_IN_ST_???") },
886 };
887
888 static const struct strval32 input_caps[] = {
889 { V4L2_IN_CAP_DV_TIMINGS,
890 XLAT_KNOWN(0x2, "V4L2_IN_CAP_DV_TIMINGS") },
891 { V4L2_IN_CAP_NATIVE_SIZE,
892 XLAT_KNOWN(0x8, "V4L2_IN_CAP_NATIVE_SIZE") },
893 { V4L2_IN_CAP_STD | V4L2_IN_CAP_NATIVE_SIZE,
894 XLAT_KNOWN(0xc, "V4L2_IN_CAP_STD|V4L2_IN_CAP_NATIVE_SIZE") },
895 { ARG_XLAT_UNKNOWN(0x80000000, "V4L2_IN_CAP_???") },
896 };
897
898 struct v4l2_input *input = tail_alloc(sizeof(*input));
899
900 ioctl(-1, VIDIOC_ENUMINPUT, 0);
901 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
902 XLAT_STR(VIDIOC_ENUMINPUT), inject_retval);
903
904 ioctl(-1, VIDIOC_ENUMINPUT, (char *) input + 1);
905 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
906 XLAT_STR(VIDIOC_ENUMINPUT), (char *) input + 1, inject_retval);
907
908 for (size_t i = 0; i < ARRAY_SIZE(stdids); i++) {
909 for (size_t j = 0; j < ARRAY_SIZE(input_types); j++) {
910 for (size_t k = 0; k < ARRAY_SIZE(input_std); k++) {
911 for (size_t l = 0; l < ARRAY_SIZE(input_status); l++) {
912 for (size_t m = 0; m < ARRAY_SIZE(input_caps); m++) {
913 fill_memory32(input, sizeof(*input));
914 fill_memory_ex(input->name, sizeof(input->name),
915 i * 47 + 13, 255);
916 input->type = input_types[j].val;
917 input->std = stdids[i].val;
918 input->audioset = 0;
919 input->tuner = 0;
920 input->std = input_std[k].val;
921 input->status = input_status[l].val;
922 input->capabilities = input_caps[m].val;
923
924 ioctl(-1, VIDIOC_ENUMINPUT, input);
925 printf("ioctl(-1, %s, {index=2158018784, name=",
926 XLAT_STR(VIDIOC_ENUMINPUT));
927 print_quoted_cstring((char *) input->name,
928 sizeof(input->name));
929 printf(", type=%s", input_types[j].str);
930 printf(", audioset=0, tuner=0");
931 printf(", std=%s", input_std[k].str);
932 printf(", status=%s", input_status[l].str);
933 printf(", capabilities=%s}) = %ld (INJECTED)\n",
934 input_caps[m].str, inject_retval);
935 }
936 }
937 }
938 }
939 }
940
941
942 /* VIDIOC_G_CTRL, VIDIOC_S_CTRL */
943 static const struct strval32 ctrl_cmds[] = {
944 { ARG_STR(VIDIOC_G_CTRL) },
945 { ARG_STR(VIDIOC_S_CTRL) },
946 };
947
948 struct v4l2_control *ctrl = tail_alloc(sizeof(*ctrl));
949
950 for (size_t i = 0; i < ARRAY_SIZE(ctrl_cmds); i++) {
951 ioctl(-1, ctrl_cmds[i].val, 0);
952 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
953 sprintxlat(ctrl_cmds[i].str, ctrl_cmds[i].val, NULL),
954 inject_retval);
955
956 ioctl(-1, ctrl_cmds[i].val, (char *) ctrl + 1);
957 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
958 sprintxlat(ctrl_cmds[i].str, ctrl_cmds[i].val, NULL),
959 (char *) ctrl + 1, inject_retval);
960
961 /* NB: cid printing is mostly tested in ioctl_v4l2.c */
962 fill_memory32(ctrl, sizeof(*ctrl));
963 ioctl(-1, ctrl_cmds[i].val, ctrl);
964 printf("ioctl(-1, %s, {id=0x80a0c0e0"
965 NRAW(" /* V4L2_CID_??? */")
966 ", value=-2136948511%s}) = %ld (INJECTED)\n",
967 sprintxlat(ctrl_cmds[i].str, ctrl_cmds[i].val, NULL),
968 ctrl_cmds[i].val == VIDIOC_S_CTRL
969 ? " => -2136948511" : "",
970 inject_retval);
971 }
972
973
974 /* VIDIOC_G_TUNER, VIDIOC_S_TUNER */
975 static const struct strval32 tuner_cmds[] = {
976 { ARG_STR(VIDIOC_G_TUNER) },
977 { ARG_STR(VIDIOC_S_TUNER) },
978 };
979 static const struct strval32 tuner_types[] = {
980 { ARG_XLAT_UNKNOWN(0, "V4L2_TUNER_???") },
981 { ARG_XLAT_KNOWN(0x1, "V4L2_TUNER_RADIO") },
982 { ARG_XLAT_KNOWN(0x5, "V4L2_TUNER_RF") },
983 { ARG_XLAT_UNKNOWN(0x6, "V4L2_TUNER_???") },
984 { ARG_XLAT_UNKNOWN(0xdeadc0de, "V4L2_TUNER_???") },
985 };
986 static const struct strval32 tuner_caps[] = {
987 { ARG_STR(0) },
988 { ARG_XLAT_KNOWN(0x1fff, "V4L2_TUNER_CAP_LOW"
989 "|V4L2_TUNER_CAP_NORM"
990 "|V4L2_TUNER_CAP_HWSEEK_BOUNDED"
991 "|V4L2_TUNER_CAP_HWSEEK_WRAP"
992 "|V4L2_TUNER_CAP_STEREO|V4L2_TUNER_CAP_LANG2"
993 "|V4L2_TUNER_CAP_LANG1|V4L2_TUNER_CAP_RDS"
994 "|V4L2_TUNER_CAP_RDS_BLOCK_IO"
995 "|V4L2_TUNER_CAP_RDS_CONTROLS"
996 "|V4L2_TUNER_CAP_FREQ_BANDS"
997 "|V4L2_TUNER_CAP_HWSEEK_PROG_LIM"
998 "|V4L2_TUNER_CAP_1HZ") },
999 { ARG_XLAT_KNOWN(0xdeadc0de, "V4L2_TUNER_CAP_NORM"
1000 "|V4L2_TUNER_CAP_HWSEEK_BOUNDED"
1001 "|V4L2_TUNER_CAP_HWSEEK_WRAP"
1002 "|V4L2_TUNER_CAP_STEREO|V4L2_TUNER_CAP_LANG1"
1003 "|V4L2_TUNER_CAP_RDS|0xdeadc000") },
1004 { ARG_XLAT_UNKNOWN(0xffffe000, "V4L2_TUNER_CAP_???") },
1005 };
1006 static const struct strval32 tuner_rxsc[] = {
1007 { ARG_STR(0) },
1008 { ARG_XLAT_KNOWN(0x1f, "V4L2_TUNER_SUB_MONO"
1009 "|V4L2_TUNER_SUB_STEREO|V4L2_TUNER_SUB_LANG2"
1010 "|V4L2_TUNER_SUB_LANG1|V4L2_TUNER_SUB_RDS") },
1011 { ARG_XLAT_KNOWN(0xbeefface, "V4L2_TUNER_SUB_STEREO"
1012 "|V4L2_TUNER_SUB_LANG2|V4L2_TUNER_SUB_LANG1"
1013 "|0xbeeffac0") },
1014 { ARG_XLAT_UNKNOWN(0xffffffe0, "V4L2_TUNER_SUB_???") },
1015
1016 };
1017 static const struct strval32 tuner_amodes[] = {
1018 { ARG_XLAT_KNOWN(0, "V4L2_TUNER_MODE_MONO") },
1019 { ARG_XLAT_KNOWN(0x2, "V4L2_TUNER_MODE_LANG2") },
1020 { ARG_XLAT_KNOWN(0x4, "V4L2_TUNER_MODE_LANG1_LANG2") },
1021 { ARG_XLAT_UNKNOWN(0x5, "V4L2_TUNER_MODE_???") },
1022 { ARG_XLAT_UNKNOWN(0xcaffeeed, "V4L2_TUNER_MODE_???") },
1023 };
1024 static const size_t tuner_iters = MAX(MAX(MAX(ARRAY_SIZE(tuner_types),
1025 ARRAY_SIZE(tuner_caps)),
1026 ARRAY_SIZE(tuner_rxsc)),
1027 ARRAY_SIZE(tuner_amodes));
1028
1029 struct v4l2_tuner *tuner = tail_alloc(sizeof(*tuner));
1030
1031 for (size_t i = 0; i < ARRAY_SIZE(tuner_cmds); i++) {
1032 ioctl(-1, tuner_cmds[i].val, 0);
1033 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1034 sprintxlat(tuner_cmds[i].str, tuner_cmds[i].val, NULL),
1035 inject_retval);
1036
1037 ioctl(-1, tuner_cmds[i].val, (char *) tuner + 1);
1038 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1039 sprintxlat(tuner_cmds[i].str, tuner_cmds[i].val, NULL),
1040 (char *) tuner + 1, inject_retval);
1041
1042 for (size_t j = 0; j < tuner_iters; j++) {
1043 fill_memory32(tuner, sizeof(*tuner));
1044 fill_memory_ex(tuner->name, sizeof(tuner->name),
1045 j * 47 + 7, 255);
1046 tuner->type =
1047 tuner_types[j % ARRAY_SIZE(tuner_types)].val;
1048 tuner->capability =
1049 tuner_caps[j % ARRAY_SIZE(tuner_caps)].val;
1050 tuner->rxsubchans =
1051 tuner_rxsc[j % ARRAY_SIZE(tuner_rxsc)].val;
1052 tuner->audmode =
1053 tuner_amodes[j % ARRAY_SIZE(tuner_amodes)].val;
1054
1055 ioctl(-1, tuner_cmds[i].val, tuner);
1056 printf("ioctl(-1, %s, {index=2158018784",
1057 sprintxlat(tuner_cmds[i].str,
1058 tuner_cmds[i].val, NULL));
1059 for (size_t k = 0;
1060 k < (tuner_cmds[i].val == VIDIOC_S_TUNER ? 2 : 1);
1061 k++) {
1062 printf("%sname=", k ? "} => {" : ", ");
1063 print_quoted_cstring((char *) tuner->name,
1064 sizeof(tuner->name));
1065 printf(", type=%s, capability=%s"
1066 ", rangelow=2158018795"
1067 ", rangehigh=2158018796, rxsubchans=%s"
1068 ", audmode=%s, signal=-2136948497"
1069 ", afc=-2136948496",
1070 tuner_types[j %
1071 ARRAY_SIZE(tuner_types)].str,
1072 tuner_caps[j %
1073 ARRAY_SIZE(tuner_caps)].str,
1074 tuner_rxsc[j %
1075 ARRAY_SIZE(tuner_rxsc)].str,
1076 tuner_amodes[j %
1077 ARRAY_SIZE(tuner_amodes)].str);
1078 }
1079 printf("}) = %ld (INJECTED)\n", inject_retval);
1080 }
1081 }
1082
1083
1084 /* VIDIOC_QUERYCTRL */
1085 static const struct strval32 cids[] = {
1086 { ARG_XLAT_UNKNOWN(0, "V4L2_CID_???") },
1087 { ARG_XLAT_UNKNOWN(0x97abcd, "V4L2_CID_???") },
1088 { ARG_XLAT_KNOWN(0x980000, "V4L2_CTRL_CLASS_USER+0") },
1089 { ARG_XLAT_KNOWN(0x990a64,
1090 "V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE") },
1091 { ARG_XLAT_KNOWN(0xa31234, "V4L2_CTRL_CLASS_DETECT+0x1234") },
1092 { ARG_XLAT_UNKNOWN(0xa60000, "V4L2_CID_???") },
1093 { 0xdeadc0de,
1094 #if XLAT_RAW
1095 "0xdeadc0de"
1096 #else
1097 XLAT_KNOWN(0xc0000000, "V4L2_CTRL_FLAG_NEXT_CTRL"
1098 "|V4L2_CTRL_FLAG_NEXT_COMPOUND")
1099 "|0x1eadc0de /* V4L2_CID_??? */"
1100 #endif
1101 },
1102 };
1103 static const struct strval32 ctrl_types[] = {
1104 { ARG_XLAT_UNKNOWN(0, "V4L2_CTRL_TYPE_???") },
1105 { ARG_XLAT_KNOWN(0x1, "V4L2_CTRL_TYPE_INTEGER") },
1106 { ARG_XLAT_KNOWN(0x2, "V4L2_CTRL_TYPE_BOOLEAN") },
1107 { ARG_XLAT_KNOWN(0x3, "V4L2_CTRL_TYPE_MENU") },
1108 { ARG_XLAT_KNOWN(0x4, "V4L2_CTRL_TYPE_BUTTON") },
1109 { ARG_XLAT_KNOWN(0x5, "V4L2_CTRL_TYPE_INTEGER64") },
1110 { ARG_XLAT_KNOWN(0x6, "V4L2_CTRL_TYPE_CTRL_CLASS") },
1111 { ARG_XLAT_KNOWN(0x7, "V4L2_CTRL_TYPE_STRING") },
1112 { ARG_XLAT_KNOWN(0x8, "V4L2_CTRL_TYPE_BITMASK") },
1113 { ARG_XLAT_KNOWN(0x9, "V4L2_CTRL_TYPE_INTEGER_MENU") },
1114 { ARG_XLAT_UNKNOWN(0xa, "V4L2_CTRL_TYPE_???") },
1115 { ARG_XLAT_UNKNOWN(0xff, "V4L2_CTRL_TYPE_???") },
1116 { ARG_XLAT_KNOWN(0x100, "V4L2_CTRL_TYPE_U8") },
1117 { ARG_XLAT_KNOWN(0x101, "V4L2_CTRL_TYPE_U16") },
1118 { ARG_XLAT_KNOWN(0x102, "V4L2_CTRL_TYPE_U32") },
1119 { ARG_XLAT_UNKNOWN(0x103, "V4L2_CTRL_TYPE_???") },
1120 { ARG_XLAT_UNKNOWN(0x104, "V4L2_CTRL_TYPE_???") },
1121 { ARG_XLAT_UNKNOWN(0x105, "V4L2_CTRL_TYPE_???") },
1122 { ARG_XLAT_KNOWN(0x106, "V4L2_CTRL_TYPE_AREA") },
1123 { ARG_XLAT_UNKNOWN(0x107, "V4L2_CTRL_TYPE_???") },
1124 { ARG_XLAT_UNKNOWN(0xdeadc0de, "V4L2_CTRL_TYPE_???") },
1125 };
1126 static const struct strval32 ctrl_flags[] = {
1127 { ARG_STR(0) },
1128 { ARG_XLAT_KNOWN(0xfff, "V4L2_CTRL_FLAG_DISABLED"
1129 "|V4L2_CTRL_FLAG_GRABBED"
1130 "|V4L2_CTRL_FLAG_READ_ONLY"
1131 "|V4L2_CTRL_FLAG_UPDATE"
1132 "|V4L2_CTRL_FLAG_INACTIVE"
1133 "|V4L2_CTRL_FLAG_SLIDER"
1134 "|V4L2_CTRL_FLAG_WRITE_ONLY"
1135 "|V4L2_CTRL_FLAG_VOLATILE"
1136 "|V4L2_CTRL_FLAG_HAS_PAYLOAD"
1137 "|V4L2_CTRL_FLAG_EXECUTE_ON_WRITE"
1138 "|V4L2_CTRL_FLAG_MODIFY_LAYOUT"
1139 "|V4L2_CTRL_FLAG_DYNAMIC_ARRAY") },
1140 { ARG_XLAT_KNOWN(0xbeefface, "V4L2_CTRL_FLAG_GRABBED"
1141 "|V4L2_CTRL_FLAG_READ_ONLY"
1142 "|V4L2_CTRL_FLAG_UPDATE"
1143 "|V4L2_CTRL_FLAG_WRITE_ONLY"
1144 "|V4L2_CTRL_FLAG_VOLATILE"
1145 "|V4L2_CTRL_FLAG_EXECUTE_ON_WRITE"
1146 "|V4L2_CTRL_FLAG_DYNAMIC_ARRAY"
1147 "|0xbeeff000") },
1148 { ARG_XLAT_UNKNOWN(0xfffff000, "V4L2_CTRL_FLAG_???") },
1149 };
1150 static const size_t qctrl_iters = MAX(MAX(ARRAY_SIZE(cids),
1151 ARRAY_SIZE(ctrl_types)),
1152 ARRAY_SIZE(ctrl_flags));
1153
1154 struct v4l2_queryctrl *qctrl = tail_alloc(sizeof(*qctrl));
1155
1156 ioctl(-1, VIDIOC_QUERYCTRL, 0);
1157 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1158 XLAT_STR(VIDIOC_QUERYCTRL), inject_retval);
1159
1160 ioctl(-1, VIDIOC_QUERYCTRL, (char *) qctrl + 1);
1161 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1162 XLAT_STR(VIDIOC_QUERYCTRL), (char *) qctrl + 1, inject_retval);
1163
1164 for (size_t i = 0; i < qctrl_iters; i++) {
1165 fill_memory32(qctrl, sizeof(*qctrl));
1166 fill_memory_ex(qctrl->name, sizeof(qctrl->name),
1167 i * 47 + 5, 255);
1168 qctrl->id = cids[i % ARRAY_SIZE(cids)].val;
1169 qctrl->type = ctrl_types[i % ARRAY_SIZE(ctrl_types)].val;
1170 qctrl->flags = ctrl_flags[i % ARRAY_SIZE(ctrl_flags)].val;
1171
1172 if (i % 2)
1173 memset(qctrl->reserved, 0, sizeof(qctrl->reserved));
1174
1175 ioctl(-1, VIDIOC_QUERYCTRL, qctrl);
1176 printf("ioctl(-1, %s, {id=%s, type=%s, name=",
1177 XLAT_STR(VIDIOC_QUERYCTRL),
1178 cids[i % ARRAY_SIZE(cids)].str,
1179 ctrl_types[i % ARRAY_SIZE(ctrl_types)].str);
1180 print_quoted_cstring((char *) qctrl->name, sizeof(qctrl->name));
1181 #if VERBOSE
1182 printf(", minimum=-2136948502, maximum=-2136948501"
1183 ", step=-2136948500, default_value=-2136948499"
1184 ", flags=%s%s",
1185 ctrl_flags[i % ARRAY_SIZE(ctrl_flags)].str,
1186 i % 2 ? "" : ", reserved=[0x80a0c0ef, 0x80a0c0f0]");
1187 #else
1188 printf(", ...");
1189 #endif
1190 printf("}) = %ld (INJECTED)\n", inject_retval);
1191 }
1192
1193
1194 /* VIDIOC_G_INPUT, VIDIOC_S_INPUT */
1195 static const struct strval32 input_cmds[] = {
1196 { ARG_STR(VIDIOC_G_INPUT) },
1197 { ARG_STR(VIDIOC_S_INPUT) },
1198 };
1199 static const struct strval32 inputids[] = {
1200 { ARG_STR(0) },
1201 { ARG_STR(1) },
1202 { ARG_STR(1578221295) },
1203 { ARG_STR(31415926) },
1204 { ARG_STR(4294967295) },
1205 };
1206
1207 int *inputid = tail_alloc(sizeof(*inputid));
1208
1209 for (size_t i = 0; i < ARRAY_SIZE(input_cmds); i++) {
1210 ioctl(-1, input_cmds[i].val, 0);
1211 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1212 sprintxlat(input_cmds[i].str, input_cmds[i].val, NULL),
1213 inject_retval);
1214
1215 ioctl(-1, input_cmds[i].val, (char *) inputid + 1);
1216 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1217 sprintxlat(input_cmds[i].str, input_cmds[i].val, NULL),
1218 (char *) inputid + 1, inject_retval);
1219
1220 for (size_t j = 0; j < ARRAY_SIZE(inputids); j++) {
1221 *inputid = inputids[j].val;
1222
1223 ioctl(-1, input_cmds[i].val, inputid);
1224 printf("ioctl(-1, %s, [%s]) = %ld (INJECTED)\n",
1225 sprintxlat(input_cmds[i].str, input_cmds[i].val,
1226 NULL),
1227 inputids[j].str, inject_retval);
1228
1229 }
1230 }
1231
1232
1233 /* VIDIOC_CROPCAP */
1234 struct v4l2_cropcap *ccap = tail_alloc(sizeof(*ccap));
1235
1236 fill_memory32(ccap, sizeof(*ccap));
1237
1238 ioctl(-1, VIDIOC_CROPCAP, 0);
1239 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1240 XLAT_STR(VIDIOC_CROPCAP), inject_retval);
1241
1242 ioctl(-1, VIDIOC_CROPCAP, (char *) ccap + 1);
1243 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1244 XLAT_STR(VIDIOC_CROPCAP), (char *) ccap + 1, inject_retval);
1245
1246 for (size_t i = 0; i < ARRAY_SIZE(buf_types); i++) {
1247 ccap->type = buf_types[i].val;
1248
1249 ioctl(-1, VIDIOC_CROPCAP, ccap);
1250 printf("ioctl(-1, %s, {type=%s"
1251 ", bounds={left=-2136948511, top=-2136948510"
1252 ", width=2158018787, height=2158018788}"
1253 ", defrect={left=-2136948507, top=-2136948506"
1254 ", width=2158018791, height=2158018792}"
1255 ", pixelaspect=2158018793/2158018794})"
1256 " = %ld (INJECTED)\n",
1257 XLAT_STR(VIDIOC_CROPCAP),
1258 buf_types[i].str, inject_retval);
1259 }
1260
1261
1262 /* VIDIOC_G_CROP, VIDIOC_S_CROP */
1263 static const struct strval32 crop_cmds[] = {
1264 { ARG_STR(VIDIOC_G_CROP) },
1265 { ARG_STR(VIDIOC_S_CROP) },
1266 };
1267 struct v4l2_crop *crop = tail_alloc(sizeof(*crop));
1268
1269 for (size_t i = 0; i < ARRAY_SIZE(crop_cmds); i++) {
1270 fill_memory32(crop, sizeof(*crop));
1271
1272 ioctl(-1, crop_cmds[i].val, 0);
1273 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1274 sprintxlat(crop_cmds[i].str, crop_cmds[i].val, NULL),
1275 inject_retval);
1276
1277 ioctl(-1, crop_cmds[i].val, (char *) crop + 1);
1278 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1279 sprintxlat(crop_cmds[i].str, crop_cmds[i].val, NULL),
1280 (char *) crop + 1, inject_retval);
1281
1282 for (size_t j = 0; j < ARRAY_SIZE(buf_types); j++) {
1283 crop->type = buf_types[j].val;
1284
1285 ioctl(-1, crop_cmds[i].val, crop);
1286 printf("ioctl(-1, %s, {type=%s, c={left=-2136948511"
1287 ", top=-2136948510, width=2158018787"
1288 ", height=2158018788}}) = %ld (INJECTED)\n",
1289 sprintxlat(crop_cmds[i].str, crop_cmds[i].val,
1290 NULL),
1291 buf_types[j].str, inject_retval);
1292 }
1293 }
1294
1295
1296 /* VIDIOC_S_EXT_CTRLS, VIDIOC_TRY_EXT_CTRLS, VIDIOC_G_EXT_CTRLS */
1297 static const struct strval32 ectrl_cmds[] = {
1298 { ARG_STR(VIDIOC_S_EXT_CTRLS) },
1299 { ARG_STR(VIDIOC_TRY_EXT_CTRLS) },
1300 { ARG_STR(VIDIOC_G_EXT_CTRLS) },
1301 };
1302 /* static const struct strval32 ectrl_which = {
1303 }; */
1304
1305 struct v4l2_ext_controls *ectrls = tail_alloc(sizeof(*ectrls));
1306 /* struct v4l2_ext_control *ectrl = tail_alloc(sizeof(*ectrl) * 2); */
1307
1308 for (size_t i = 0; i < ARRAY_SIZE(ectrl_cmds); i++) {
1309 fill_memory32(ectrls, sizeof(*ectrls));
1310
1311 ioctl(-1, ectrl_cmds[i].val, 0);
1312 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1313 sprintxlat(ectrl_cmds[i].str, ectrl_cmds[i].val, NULL),
1314 inject_retval);
1315
1316 ioctl(-1, ectrl_cmds[i].val, (char *) ectrls + 1);
1317 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1318 sprintxlat(ectrl_cmds[i].str, ectrl_cmds[i].val, NULL),
1319 (char *) ectrls + 1, inject_retval);
1320 }
1321
1322
1323 /* VIDIOC_ENUM_FRAMESIZES */
1324 static const struct strval32 frmsz_simple_types[] = {
1325 { ARG_XLAT_UNKNOWN(0, "V4L2_FRMSIZE_TYPE_???") },
1326 { ARG_XLAT_KNOWN(0x2, "V4L2_FRMSIZE_TYPE_CONTINUOUS") },
1327 { ARG_XLAT_UNKNOWN(0x4, "V4L2_FRMSIZE_TYPE_???") },
1328 { ARG_XLAT_UNKNOWN(0xdeadf157, "V4L2_FRMSIZE_TYPE_???") },
1329 };
1330
1331 struct v4l2_frmsizeenum *fse = tail_alloc(sizeof(*fse));
1332
1333 ioctl(-1, VIDIOC_ENUM_FRAMESIZES, 0);
1334 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1335 XLAT_STR(VIDIOC_ENUM_FRAMESIZES), inject_retval);
1336
1337 ioctl(-1, VIDIOC_ENUM_FRAMESIZES, (char *) fse + 1);
1338 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1339 XLAT_STR(VIDIOC_ENUM_FRAMESIZES), (char *) fse + 1,
1340 inject_retval);
1341
1342 fill_memory32(fse, sizeof(*fse));
1343 fse->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1344
1345 ioctl(-1, VIDIOC_ENUM_FRAMESIZES, fse);
1346 printf("ioctl(-1, %s, {index=2158018784, pixel_format="
1347 RAW("0x80a0c0e1")
1348 NRAW("v4l2_fourcc('\\xe1', '\\xc0', '\\xa0', '\\x80')")
1349 ", type=" XLAT_KNOWN(0x1, "V4L2_FRMSIZE_TYPE_DISCRETE")
1350 ", discrete={width=2158018787, height=2158018788}"
1351 "}) = %ld (INJECTED)\n",
1352 XLAT_STR(VIDIOC_ENUM_FRAMESIZES), inject_retval);
1353
1354 fse->pixel_format = 0x5c22270d;
1355 fse->type = V4L2_FRMSIZE_TYPE_STEPWISE;
1356
1357 ioctl(-1, VIDIOC_ENUM_FRAMESIZES, fse);
1358 printf("ioctl(-1, %s, {index=2158018784, pixel_format="
1359 RAW("0x5c22270d")
1360 NRAW("v4l2_fourcc('\\x0d', '\\\'', '\"', '\\\\')")
1361 ", type=" XLAT_KNOWN(0x3, "V4L2_FRMSIZE_TYPE_STEPWISE")
1362 ", stepwise={min_width=2158018787, max_width=2158018788"
1363 ", step_width=2158018789, min_height=2158018790"
1364 ", max_height=2158018791, step_height=2158018792}"
1365 "}) = %ld (INJECTED)\n",
1366 XLAT_STR(VIDIOC_ENUM_FRAMESIZES), inject_retval);
1367
1368 for (size_t i = 0; i < ARRAY_SIZE(frmsz_simple_types); i++) {
1369 fill_memory32(fse, sizeof(*fse));
1370 fse->type = frmsz_simple_types[i].val;
1371
1372 ioctl(-1, VIDIOC_ENUM_FRAMESIZES, fse);
1373 printf("ioctl(-1, %s, {index=2158018784, pixel_format="
1374 RAW("0x80a0c0e1")
1375 NRAW("v4l2_fourcc('\\xe1', '\\xc0', '\\xa0', '\\x80')")
1376 ", type=%s}) = %ld (INJECTED)\n",
1377 XLAT_STR(VIDIOC_ENUM_FRAMESIZES),
1378 frmsz_simple_types[i].str, inject_retval);
1379
1380 }
1381
1382
1383 /* VIDIOC_ENUM_FRAMEINTERVALS */
1384 static const struct strval32 frmival_simple_types[] = {
1385 { ARG_XLAT_UNKNOWN(0, "V4L2_FRMIVAL_TYPE_???") },
1386 { ARG_XLAT_UNKNOWN(0x4, "V4L2_FRMIVAL_TYPE_???") },
1387 { ARG_XLAT_UNKNOWN(0xdeadf157, "V4L2_FRMIVAL_TYPE_???") },
1388 };
1389 static const struct strval32 frmival_step_types[] = {
1390 { ARG_XLAT_KNOWN(0x2, "V4L2_FRMIVAL_TYPE_CONTINUOUS") },
1391 { ARG_XLAT_KNOWN(0x3, "V4L2_FRMIVAL_TYPE_STEPWISE") },
1392 };
1393
1394 struct v4l2_frmivalenum *fie = tail_alloc(sizeof(*fie));
1395
1396 ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, 0);
1397 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1398 XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS), inject_retval);
1399
1400 ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, (char *) fie + 1);
1401 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1402 XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS), (char *) fie + 1,
1403 inject_retval);
1404
1405 fill_memory32(fie, sizeof(*fie));
1406 fie->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1407
1408 ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, fie);
1409 printf("ioctl(-1, %s, {index=2158018784, pixel_format="
1410 RAW("0x80a0c0e1")
1411 NRAW("v4l2_fourcc('\\xe1', '\\xc0', '\\xa0', '\\x80')")
1412 ", width=2158018786, height=2158018787"
1413 ", type=" XLAT_KNOWN(0x1, "V4L2_FRMIVAL_TYPE_DISCRETE")
1414 ", discrete=2158018789/2158018790}) = %ld (INJECTED)\n",
1415 XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS), inject_retval);
1416
1417 fie->pixel_format = 0x5c22270d;
1418
1419 for (size_t i = 0; i < ARRAY_SIZE(frmival_step_types); i++) {
1420 fie->type = frmival_step_types[i].val;
1421
1422 ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, fie);
1423 printf("ioctl(-1, %s, {index=2158018784, pixel_format="
1424 RAW("0x5c22270d")
1425 NRAW("v4l2_fourcc('\\x0d', '\\\'', '\"', '\\\\')")
1426 ", width=2158018786, height=2158018787, type=%s"
1427 ", stepwise={min=2158018789/2158018790"
1428 ", max=2158018791/2158018792"
1429 ", step=2158018793/2158018794}}) = %ld (INJECTED)\n",
1430 XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS),
1431 frmival_step_types[i].str, inject_retval);
1432 }
1433
1434 for (size_t i = 0; i < ARRAY_SIZE(frmival_simple_types); i++) {
1435 fill_memory32(fie, sizeof(*fie));
1436 fie->type = frmival_simple_types[i].val;
1437
1438 ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, fie);
1439 printf("ioctl(-1, %s, {index=2158018784, pixel_format="
1440 RAW("0x80a0c0e1")
1441 NRAW("v4l2_fourcc('\\xe1', '\\xc0', '\\xa0', '\\x80')")
1442 ", width=2158018786, height=2158018787, type=%s})"
1443 " = %ld (INJECTED)\n",
1444 XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS),
1445 frmival_simple_types[i].str, inject_retval);
1446
1447 }
1448
1449
1450 /* VIDIOC_CREATE_BUFS */
1451 struct v4l2_create_buffers *cbuf = tail_alloc(sizeof(*cbuf));
1452
1453 fill_memory32(cbuf, sizeof(*cbuf));
1454
1455 ioctl(-1, VIDIOC_CREATE_BUFS, 0);
1456 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1457 XLAT_STR(VIDIOC_CREATE_BUFS), inject_retval);
1458
1459 ioctl(-1, VIDIOC_CREATE_BUFS, (char *) cbuf + 1);
1460 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1461 XLAT_STR(VIDIOC_CREATE_BUFS), (char *) cbuf + 1, inject_retval);
1462
1463 for (size_t i = 0; i < MAX(ARRAY_SIZE(buf_types),
1464 ARRAY_SIZE(reqb_mems)); i++) {
1465 cbuf->memory = reqb_mems[i % ARRAY_SIZE(reqb_mems)].val;
1466 cbuf->format.type = buf_types[i % ARRAY_SIZE(buf_types)].val;
1467 if (!fill_fmt(&cbuf->format))
1468 continue;
1469
1470 ioctl(-1, VIDIOC_CREATE_BUFS, cbuf);
1471 printf("ioctl(-1, %s, {count=2158018785, memory=%s"
1472 ", format={type=%s",
1473 XLAT_STR(VIDIOC_CREATE_BUFS),
1474 reqb_mems[i % ARRAY_SIZE(reqb_mems)].str,
1475 buf_types[i % ARRAY_SIZE(buf_types)].str);
1476 print_fmt(", ", &cbuf->format);
1477 printf("}}) = %ld ({index=2158018784, count=2158018785})"
1478 " (INJECTED)\n", inject_retval);
1479 }
1480
1481 /* VIDIOC_QUERY_EXT_CTRL */
1482 static const struct strval32 qextc_nrdims[] = {
1483 { ARG_STR(0) },
1484 { ARG_STR(3) },
1485 { ARG_STR(4) },
1486 { ARG_STR(5) },
1487 { ARG_STR(3141592653) },
1488 };
1489
1490 static const size_t qextc_iters = MAX(MAX(MAX(ARRAY_SIZE(cids),
1491 ARRAY_SIZE(ctrl_types)),
1492 ARRAY_SIZE(ctrl_flags)),
1493 ARRAY_SIZE(qextc_nrdims));
1494
1495 struct v4l2_query_ext_ctrl *qextc = tail_alloc(sizeof(*qextc));
1496
1497 fill_memory32(qextc, sizeof(*qextc));
1498
1499 ioctl(-1, VIDIOC_QUERY_EXT_CTRL, 0);
1500 printf("ioctl(-1, %s, NULL) = %ld (INJECTED)\n",
1501 XLAT_STR(VIDIOC_QUERY_EXT_CTRL), inject_retval);
1502
1503 ioctl(-1, VIDIOC_QUERY_EXT_CTRL, (char *) qextc + 1);
1504 printf("ioctl(-1, %s, %p) = %ld (INJECTED)\n",
1505 XLAT_STR(VIDIOC_QUERY_EXT_CTRL),
1506 (char *) qextc + 1, inject_retval);
1507
1508 for (size_t i = 0; i < qextc_iters; i++) {
1509 fill_memory32(qextc, sizeof(*qextc));
1510 fill_memory_ex(qextc->name, sizeof(qextc->name),
1511 i * 49 + 23, 255);
1512 qextc->id = cids[i % ARRAY_SIZE(cids)].val;
1513 qextc->type = ctrl_types[i % ARRAY_SIZE(ctrl_types)].val;
1514 qextc->flags = ctrl_flags[i % ARRAY_SIZE(ctrl_flags)].val;
1515 qextc->nr_of_dims =
1516 qextc_nrdims[ i % ARRAY_SIZE(qextc_nrdims)].val;
1517
1518 qextc->minimum = 0xbadc0deddeadfaceULL;
1519 qextc->maximum = 0xdecaffedbeeff00dULL;
1520 qextc->step = 0xbeaded1dea5a51deULL;
1521 qextc->default_value = 0xca5efade1cedbeefULL;
1522
1523 for (size_t j = 0; j < 2; j++) {
1524 ioctl(-1, VIDIOC_QUERY_EXT_CTRL, qextc);
1525 printf("ioctl(-1, %s, {id=%s, type=%s, name=",
1526 XLAT_STR(VIDIOC_QUERY_EXT_CTRL),
1527 cids[i % ARRAY_SIZE(cids)].str,
1528 ctrl_types[i % ARRAY_SIZE(ctrl_types)].str);
1529 print_quoted_cstring((char *) qextc->name,
1530 sizeof(qextc->name));
1531 #if VERBOSE
1532 printf(", minimum=-4982091772484257074"
1533 ", maximum=-2392818855418269683"
1534 ", step=13739898750918873566"
1535 ", default_value=-3864375598362280209, flags=%s"
1536 ", elem_size=2158018803, elems=2158018804"
1537 ", nr_of_dims=%s, dims=[%s%s]%s",
1538 ctrl_flags[i % ARRAY_SIZE(ctrl_flags)].str,
1539 qextc_nrdims[i % ARRAY_SIZE(qextc_nrdims)].str,
1540 qextc_nrdims[i % ARRAY_SIZE(qextc_nrdims)].val
1541 ? "2158018806, 2158018807, 2158018808" : "",
1542 qextc_nrdims[i % ARRAY_SIZE(qextc_nrdims)].val >
1543 3 ? ", 2158018809" : "",
1544 j ? "" : ", reserved=[0x80a0c0fa"
1545 ", 0x80a0c0fb, 0x80a0c0fc, 0x80a0c0fd"
1546 ", 0x80a0c0fe, 0x80a0c0ff, 0x80a0c100"
1547 ", 0x80a0c101, 0x80a0c102, 0x80a0c103"
1548 ", 0x80a0c104, 0x80a0c105, 0x80a0c106"
1549 ", 0x80a0c107, 0x80a0c108, 0x80a0c109"
1550 ", 0x80a0c10a, 0x80a0c10b, 0x80a0c10c"
1551 ", 0x80a0c10d, 0x80a0c10e, 0x80a0c10f"
1552 ", 0x80a0c110, 0x80a0c111, 0x80a0c112"
1553 ", 0x80a0c113, 0x80a0c114, 0x80a0c115"
1554 ", 0x80a0c116, 0x80a0c117, 0x80a0c118"
1555 ", 0x80a0c119]"
1556 );
1557 #else
1558 printf(", ...");
1559 #endif
1560 printf("}) = %ld (INJECTED)\n", inject_retval);
1561
1562 memset(qextc->reserved, 0, sizeof(qextc->reserved));
1563 }
1564 }
1565
1566 puts("+++ exited with 0 +++");
1567
1568 return 0;
1569 }