/* * Copyright (c) 2015-2016 Dmitry V. Levin * Copyright (c) 2016-2021 The strace developers. * All rights reserved. * * SPDX-License-Identifier: GPL-2.0-or-later */ #include "tests.h" #include #include #include #include #include #include "kernel_v4l2_types.h" #define cc0(arg) ((unsigned int) (unsigned char) (arg)) #define cc1(arg) ((unsigned int) (unsigned char) ((unsigned int) (arg) >> 8)) #define cc2(arg) ((unsigned int) (unsigned char) ((unsigned int) (arg) >> 16)) #define cc3(arg) ((unsigned int) (unsigned char) ((unsigned int) (arg) >> 24)) #define fourcc(a0, a1, a2, a3) \ ((unsigned int)(a0) | \ ((unsigned int)(a1) << 8) | \ ((unsigned int)(a2) << 16) | \ ((unsigned int)(a3) << 24)) static const unsigned int magic = 0xdeadbeef; static const unsigned int mf_magic = fourcc('V', 'I', 'V', 'D'); static const unsigned int pf_magic = fourcc('S', '5', '0', '8'); static const unsigned int sf_magic = fourcc('R', 'U', '1', '2'); static void init_v4l2_format(struct v4l2_format *const f, const unsigned int buf_type) { memset(f, -1, sizeof(*f)); f->type = buf_type; switch (buf_type) { case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_OUTPUT: f->fmt.pix.width = 0x657b8160; f->fmt.pix.height = 0x951c0047; if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE) f->fmt.pix.pixelformat = magic; else f->fmt.pix.pixelformat = pf_magic; f->fmt.pix.field = V4L2_FIELD_NONE; f->fmt.pix.bytesperline = 0xdf20d185; f->fmt.pix.sizeimage = 0x0cf7be41; f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG; break; case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: { f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; f->fmt.pix_mp.width = 0x1f3b774b; f->fmt.pix_mp.height = 0xab96a8d6; if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) f->fmt.pix_mp.pixelformat = magic; else f->fmt.pix_mp.pixelformat = pf_magic; f->fmt.pix_mp.field = V4L2_FIELD_NONE; f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_JPEG; struct v4l2_plane_pix_format *cur_pix = f->fmt.pix_mp.plane_fmt; for (unsigned int i = 0; i < ARRAY_SIZE(f->fmt.pix_mp.plane_fmt); i++) { cur_pix[i].sizeimage = 0x1e3c531c | i; if (sizeof(cur_pix[i].bytesperline) == sizeof(uint32_t)) { cur_pix[i].bytesperline = 0xa983d721 | i; } else { #ifdef WORDS_BIGENDIAN cur_pix[i].bytesperline = 0xa983; cur_pix[i].reserved[0] = 0xd721 | i; #else cur_pix[i].bytesperline = 0xd721 | i; cur_pix[i].reserved[0] = 0xa983; #endif } } if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) f->fmt.pix_mp.num_planes = 1; break; } case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: case V4L2_BUF_TYPE_VIDEO_OVERLAY: f->fmt.win.w.left = 0xe8373662; f->fmt.win.w.top = 0x0336d283; f->fmt.win.w.width = 0x9235fe72; f->fmt.win.w.height = 0xbbd886c8; f->fmt.win.field = V4L2_FIELD_ANY; f->fmt.win.chromakey = 0xdb1f991f; f->fmt.win.clipcount = buf_type == V4L2_BUF_TYPE_VIDEO_OVERLAY ? 3 : 2; f->fmt.win.clips = tail_alloc(sizeof(*f->fmt.win.clips) * 2); f->fmt.win.clips[0].c.left = 0x3313d36e; f->fmt.win.clips[0].c.top = 0xcdffe510; f->fmt.win.clips[0].c.width = 0x2064f3a8; f->fmt.win.clips[0].c.height = 0xd06d314a; f->fmt.win.clips[1].c.left = 0xd8c8a83f; f->fmt.win.clips[1].c.top = 0x336e87ba; f->fmt.win.clips[1].c.width = 0x9e3a6fb3; f->fmt.win.clips[1].c.height = 0x05617b76; f->fmt.win.bitmap = (void *) -2UL; f->fmt.win.global_alpha = 0xce; break; case V4L2_BUF_TYPE_VBI_CAPTURE: case V4L2_BUF_TYPE_VBI_OUTPUT: f->fmt.vbi.sampling_rate = 0x3d9b5b79; f->fmt.vbi.offset = 0x055b3a09; f->fmt.vbi.samples_per_line = 0xf176d436; if (buf_type == V4L2_BUF_TYPE_VBI_CAPTURE) f->fmt.vbi.sample_format = magic; else f->fmt.vbi.sample_format = pf_magic; f->fmt.vbi.start[0] = 0x9858e2eb; f->fmt.vbi.start[1] = 0x8a4dc8c1; f->fmt.vbi.count[0] = 0x4bcf36a3; f->fmt.vbi.count[1] = 0x97dff65f; f->fmt.vbi.flags = V4L2_VBI_INTERLACED; break; case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: { f->fmt.sliced.service_set = V4L2_SLICED_VPS; f->fmt.sliced.io_size = 0xd897925a; for (unsigned int i = 0; i < ARRAY_SIZE(f->fmt.sliced.service_lines[0]); i++) { f->fmt.sliced.service_lines[0][i] = 0xc38e | i; f->fmt.sliced.service_lines[1][i] = 0x3abb | i; } break; } case V4L2_BUF_TYPE_SDR_OUTPUT: f->fmt.sdr.pixelformat = sf_magic; if (sizeof(f->fmt.sdr.buffersize == sizeof(uint32_t))) f->fmt.sdr.buffersize = 0x25afabfb; else ((uint32_t *) &f->fmt.sdr)[1] = 0x25afabfb; break; case V4L2_BUF_TYPE_SDR_CAPTURE: f->fmt.sdr.pixelformat = magic; f->fmt.sdr.buffersize = 0x25afabfb; break; case V4L2_BUF_TYPE_META_OUTPUT: f->fmt.meta.dataformat = magic; f->fmt.meta.buffersize = 0xbadc0ded; break; case V4L2_BUF_TYPE_META_CAPTURE: f->fmt.meta.dataformat = mf_magic; f->fmt.meta.buffersize = 0xbadc0ded; break; } } static void dprint_ioctl_v4l2(struct v4l2_format *const f, XLAT_SEL(unsigned reqval, const char *reqstr), const unsigned int buf_type, const char *buf_type_string) { int saved_errno; switch (buf_type) { case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_OUTPUT: saved_errno = errno; printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT ", fmt.pix={width=%u, height=%u, pixelformat=", XLAT_SEL(reqval, reqstr), XLAT_SEL(buf_type, buf_type_string), f->fmt.pix.width, f->fmt.pix.height); #if XLAT_RAW printf("%#x", buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE ? magic : pf_magic); #else /* !XLAT_RAW */ if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE) printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')", cc0(magic), cc1(magic), cc2(magic), cc3(magic)); else printf("v4l2_fourcc('%c', '%c', '%c', '%c') " "/* V4L2_PIX_FMT_SPCA508 */", cc0(pf_magic), cc1(pf_magic), cc2(pf_magic), cc3(pf_magic)); #endif /* XLAT_RAW */ errno = saved_errno; printf(", field=" XLAT_FMT ", bytesperline=%u, sizeimage=%u" ", colorspace=" XLAT_FMT "}}) = -1 EBADF (%m)\n", XLAT_ARGS(V4L2_FIELD_NONE), f->fmt.pix.bytesperline, f->fmt.pix.sizeimage, XLAT_ARGS(V4L2_COLORSPACE_JPEG)); break; case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: { saved_errno = errno; printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT ", fmt.pix_mp={width=%u, height=%u, pixelformat=", XLAT_SEL(reqval, reqstr), XLAT_SEL(buf_type, buf_type_string), f->fmt.pix_mp.width, f->fmt.pix_mp.height); #if XLAT_RAW printf("%#x", buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ? magic : pf_magic); #else /* !XLAT_RAW */ if (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')", cc0(magic), cc1(magic), cc2(magic), cc3(magic)); else printf("v4l2_fourcc('%c', '%c', '%c', '%c') " "/* V4L2_PIX_FMT_SPCA508 */", cc0(pf_magic), cc1(pf_magic), cc2(pf_magic), cc3(pf_magic)); #endif /* XLAT_RAW */ printf(", field=" XLAT_FMT ", colorspace=" XLAT_FMT ", plane_fmt=[", XLAT_ARGS(V4L2_FIELD_NONE), XLAT_ARGS(V4L2_COLORSPACE_JPEG)); for (unsigned int i = 0; i < (buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ? 1 : ARRAY_SIZE(f->fmt.pix_mp.plane_fmt)); ++i) { if (i) printf(", "); printf("{sizeimage=%u, bytesperline=%u}", f->fmt.pix_mp.plane_fmt[i].sizeimage, sizeof(f->fmt.pix_mp.plane_fmt[i].bytesperline) == sizeof(uint32_t) ? f->fmt.pix_mp.plane_fmt[i].bytesperline : #ifdef WORDS_BIGENDIAN (f->fmt.pix_mp.plane_fmt[i].bytesperline << 16) | f->fmt.pix_mp.plane_fmt[i].reserved[0] #else f->fmt.pix_mp.plane_fmt[i].bytesperline | (f->fmt.pix_mp.plane_fmt[i].reserved[0] << 16) #endif ); } errno = saved_errno; printf("], num_planes=%u}}) = -1 EBADF (%m)\n", f->fmt.pix_mp.num_planes); break; } case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: case V4L2_BUF_TYPE_VIDEO_OVERLAY: saved_errno = errno; printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT ", fmt.win={w={left=%d, top=%d, width=%u, height=%u}" ", field=" XLAT_FMT ", chromakey=%#x, clips=" "[{c={left=%d, top=%d, width=%u, height=%u}}, " "{c={left=%d, top=%d, width=%u, height=%u}}", XLAT_SEL(reqval, reqstr), XLAT_SEL(buf_type, buf_type_string), f->fmt.win.w.left, f->fmt.win.w.top, f->fmt.win.w.width, f->fmt.win.w.height, XLAT_ARGS(V4L2_FIELD_ANY), f->fmt.win.chromakey, f->fmt.win.clips[0].c.left, f->fmt.win.clips[0].c.top, f->fmt.win.clips[0].c.width, f->fmt.win.clips[0].c.height, f->fmt.win.clips[1].c.left, f->fmt.win.clips[1].c.top, f->fmt.win.clips[1].c.width, f->fmt.win.clips[1].c.height); if (f->fmt.win.clipcount > 2) printf(", ... /* %p */", f->fmt.win.clips + 2); errno = saved_errno; printf("], clipcount=%u, bitmap=%p" ", global_alpha=%#x" "}}) = -1 EBADF (%m)\n", f->fmt.win.clipcount, f->fmt.win.bitmap, f->fmt.win.global_alpha ); break; case V4L2_BUF_TYPE_VBI_CAPTURE: case V4L2_BUF_TYPE_VBI_OUTPUT: saved_errno = errno; printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT ", fmt.vbi={sampling_rate=%u, offset=%u" ", samples_per_line=%u, sample_format=", XLAT_SEL(reqval, reqstr), XLAT_SEL(buf_type, buf_type_string), f->fmt.vbi.sampling_rate, f->fmt.vbi.offset, f->fmt.vbi.samples_per_line); #if XLAT_RAW printf("%#x", buf_type == V4L2_BUF_TYPE_VBI_CAPTURE ? magic : pf_magic); #else /* !XLAT_RAW */ if (buf_type == V4L2_BUF_TYPE_VBI_CAPTURE) printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')", cc0(magic), cc1(magic), cc2(magic), cc3(magic)); else printf("v4l2_fourcc('%c', '%c', '%c', '%c') " "/* V4L2_PIX_FMT_SPCA508 */", cc0(pf_magic), cc1(pf_magic), cc2(pf_magic), cc3(pf_magic)); #endif /* XLAT_RAW */ errno = saved_errno; printf(", start=[%d, %d], count=[%u, %u]" ", flags=" XLAT_FMT "}})" " = -1 EBADF (%m)\n", f->fmt.vbi.start[0], f->fmt.vbi.start[1], f->fmt.vbi.count[0], f->fmt.vbi.count[1], XLAT_ARGS(V4L2_VBI_INTERLACED)); break; case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: { saved_errno = errno; printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT ", fmt.sliced={service_set=" XLAT_FMT ", service_lines=[", XLAT_SEL(reqval, reqstr), XLAT_SEL(buf_type, buf_type_string), XLAT_ARGS(V4L2_SLICED_VPS)); for (unsigned int i = 0; i < ARRAY_SIZE(f->fmt.sliced.service_lines); ++i) { if (i > 0) printf(", "); printf("["); for (unsigned int j = 0; j < ARRAY_SIZE(f->fmt.sliced.service_lines[0]); ++j) { if (j > 0) printf(", "); printf("%#x", f->fmt.sliced.service_lines[i][j]); } printf("]"); } errno = saved_errno; printf("], io_size=%u}}) = -1 EBADF (%m)\n", f->fmt.sliced.io_size); break; } case V4L2_BUF_TYPE_SDR_OUTPUT: case V4L2_BUF_TYPE_SDR_CAPTURE: saved_errno = errno; printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT ", fmt.sdr={pixelformat=", XLAT_SEL(reqval, reqstr), XLAT_SEL(buf_type, buf_type_string)); #if XLAT_RAW if (buf_type == V4L2_BUF_TYPE_SDR_CAPTURE) printf("%#x", magic); else printf("%#x", sf_magic); #else /* !XLAT_RAW */ if (buf_type == V4L2_BUF_TYPE_SDR_CAPTURE) printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')", cc0(magic), cc1(magic), cc2(magic), cc3(magic)); else printf("v4l2_fourcc('%c', '%c', '%c', '%c') " "/* V4L2_SDR_FMT_RU12LE */", cc0(sf_magic), cc1(sf_magic), cc2(sf_magic), cc3(sf_magic)); #endif /* XLAT_RAW */ errno = saved_errno; printf(", buffersize=%u}}) = -1 EBADF (%m)\n" , sizeof(f->fmt.sdr.buffersize == sizeof(uint32_t)) ? f->fmt.sdr.buffersize : ((uint32_t *) &f->fmt.sdr)[1] ); break; case V4L2_BUF_TYPE_META_OUTPUT: case V4L2_BUF_TYPE_META_CAPTURE: saved_errno = errno; printf("ioctl(-1, " XLAT_FMT ", {type=" XLAT_FMT ", fmt.meta={dataformat=", XLAT_SEL(reqval, reqstr), XLAT_SEL(buf_type, buf_type_string)); #if XLAT_RAW printf("%#x", buf_type == V4L2_BUF_TYPE_META_CAPTURE ? mf_magic : magic); #else /* !XLAT_RAW */ if (buf_type == V4L2_BUF_TYPE_META_CAPTURE) printf("v4l2_fourcc('%c', '%c', '%c', '%c') " "/* V4L2_META_FMT_VIVID */", cc0(mf_magic), cc1(mf_magic), cc2(mf_magic), cc3(mf_magic)); else printf("v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')", cc0(magic), cc1(magic), cc2(magic), cc3(magic)); #endif /* XLAT_RAW */ errno = saved_errno; printf(", buffersize=%u}}) = -1 EBADF (%m)\n", f->fmt.meta.buffersize); break; } } #define print_ioctl_v4l2(v4l2_format, request, buf_type) \ dprint_ioctl_v4l2((v4l2_format), XLAT_SEL(request, #request), \ (buf_type), #buf_type) int main(void) { const unsigned int size = get_page_size(); void *const page = tail_alloc(size); void *const page_end = page + size; fill_memory(page, size); unsigned char cc[sizeof(int)] = { 'A', '\'', '\\', '\xfa' }; /* Unknown */ static const struct { uint32_t flags; const char *str; } cmd_flags[] = { { ARG_STR(_IOC_NONE) }, { ARG_STR(_IOC_READ) }, { ARG_STR(_IOC_WRITE) }, { ARG_STR(_IOC_READ|_IOC_WRITE) }, }; static const uint8_t unknown_cmds[] = { 1, 3, 6 /* VIDIOC_G_MPEGCOMP */, 7 /* VIDIOC_S_MPEGCOMP */, 12, 13, 20, 31, 32, 35, 42, 43, 44, 45, 51, 52, 53, 81 /* VIDIOC_G_CHIP_IDENT_OLD */, 83 /* VIDIOC_ENUM_DV_PRESETS */, 84 /* VIDIOC_S_DV_PRESET */, 85 /* VIDIOC_G_DV_PRESET */, 86 /* VIDIOC_QUERY_DV_PRESET */, 104 /* 103 is the last existing */, 255 }; for (size_t i = 0; i < ARRAY_SIZE(unknown_cmds); i++) { /* Trying to hit common argument sizes */ for (size_t j = 0; j < 256; j += 4) { for (size_t k = 0; k < ARRAY_SIZE(cmd_flags); k++) { uint32_t ioc = _IOC(cmd_flags[k].flags, 'V', unknown_cmds[i], j); /* * Conflicts with VT* and VBG* ioctls * that happen to also use 'V' command type. */ switch (ioc) { /* VT_GETMODE */ case _IOC(_IOC_NONE, 'V', 1, 0): /* VT_GETSTATE */ case _IOC(_IOC_NONE, 'V', 3, 0): /* VBG_IOCTL_VMMDEV_REQUEST_BIG */ case _IOC(_IOC_READ|_IOC_WRITE, 'V', 3, 0): /* VT_ACTIVATE */ case _IOC(_IOC_NONE, 'V', 6, 0): /* VT_WAITACTIVE */ case _IOC(_IOC_NONE, 'V', 7, 0): /* VT_UNLOCKSWITCH */ case _IOC(_IOC_NONE, 'V', 12, 0): /* VBG_IOCTL_CHANGE_FILTER_MASK */ case _IOC(_IOC_READ|_IOC_WRITE, 'V', 12, 32): /* VT_GETHIFONTMASK */ case _IOC(_IOC_NONE, 'V', 13, 0): continue; /* VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES */ case _IOC(_IOC_READ|_IOC_WRITE, 'V', 13, 36): continue; } ioctl(-1, ioc, 0); printf("ioctl(-1, " NABBR("%#x") VERB(" /* ") NRAW("_IOC(%s, 0x56, %#x, %#zx)") VERB(" */") ", 0) = -1 EBADF (%m)\n" #if XLAT_RAW || XLAT_VERBOSE , ioc #endif #if !XLAT_RAW , cmd_flags[k].str, unknown_cmds[i], j #endif ); ioctl(-1, ioc, (unsigned long) 0xbadc0deddeadc0deULL); printf("ioctl(-1, " NABBR("%#x") VERB(" /* ") NRAW("_IOC(%s, 0x56, %#x, %#zx)") VERB(" */") ", %#lx) = -1 EBADF (%m)\n", #if XLAT_RAW || XLAT_VERBOSE ioc, #endif #if !XLAT_RAW cmd_flags[k].str, unknown_cmds[i], j, #endif (unsigned long) 0xbadc0deddeadc0deULL); } } } /* Decoding is not supported */ static const struct { uint32_t cmd; const char *str; } unsupp_cmds[] = { { ARG_STR(VIDIOC_OVERLAY) }, { ARG_STR(VIDIOC_EXPBUF) }, { ARG_STR(VIDIOC_G_AUDIO) }, { ARG_STR(VIDIOC_S_AUDIO) }, { ARG_STR(VIDIOC_QUERYMENU) }, { ARG_STR(VIDIOC_G_EDID) }, { ARG_STR(VIDIOC_S_EDID) }, { ARG_STR(VIDIOC_G_OUTPUT) }, { ARG_STR(VIDIOC_S_OUTPUT) }, { ARG_STR(VIDIOC_ENUMOUTPUT) }, { ARG_STR(VIDIOC_G_AUDOUT) }, { ARG_STR(VIDIOC_S_AUDOUT) }, { ARG_STR(VIDIOC_G_MODULATOR) }, { ARG_STR(VIDIOC_S_MODULATOR) }, { ARG_STR(VIDIOC_G_FREQUENCY) }, { ARG_STR(VIDIOC_S_FREQUENCY) }, { ARG_STR(VIDIOC_G_JPEGCOMP) }, { ARG_STR(VIDIOC_S_JPEGCOMP) }, { ARG_STR(VIDIOC_QUERYSTD) }, { ARG_STR(VIDIOC_ENUMAUDIO) }, { ARG_STR(VIDIOC_ENUMAUDOUT) }, { ARG_STR(VIDIOC_G_PRIORITY) }, { ARG_STR(VIDIOC_S_PRIORITY) }, { ARG_STR(VIDIOC_G_SLICED_VBI_CAP) }, { ARG_STR(VIDIOC_LOG_STATUS) }, { ARG_STR(VIDIOC_G_ENC_INDEX) }, { ARG_STR(VIDIOC_ENCODER_CMD) }, { ARG_STR(VIDIOC_TRY_ENCODER_CMD) }, { ARG_STR(VIDIOC_DBG_S_REGISTER) }, { ARG_STR(VIDIOC_DBG_G_REGISTER) }, { ARG_STR(VIDIOC_S_HW_FREQ_SEEK) }, { ARG_STR(VIDIOC_S_DV_TIMINGS) }, { ARG_STR(VIDIOC_G_DV_TIMINGS) }, { ARG_STR(VIDIOC_DQEVENT) }, { ARG_STR(VIDIOC_SUBSCRIBE_EVENT) }, { ARG_STR(VIDIOC_UNSUBSCRIBE_EVENT) }, { ARG_STR(VIDIOC_PREPARE_BUF) }, { ARG_STR(VIDIOC_G_SELECTION) }, { ARG_STR(VIDIOC_S_SELECTION) }, { ARG_STR(VIDIOC_DECODER_CMD) }, { ARG_STR(VIDIOC_TRY_DECODER_CMD) }, { ARG_STR(VIDIOC_ENUM_DV_TIMINGS) }, { ARG_STR(VIDIOC_QUERY_DV_TIMINGS) }, { ARG_STR(VIDIOC_DV_TIMINGS_CAP) }, { ARG_STR(VIDIOC_ENUM_FREQ_BANDS) }, { ARG_STR(VIDIOC_DBG_G_CHIP_INFO) }, #if 0 /* */ { ARG_STR(VIDIOC_SUBDEV_ENUM_MBUS_CODE) }, { ARG_STR(VIDIOC_SUBDEV_G_FMT) }, { ARG_STR(VIDIOC_SUBDEV_S_FMT) }, { ARG_STR(VIDIOC_SUBDEV_G_FRAME_INTERVAL) }, { ARG_STR(VIDIOC_SUBDEV_S_FRAME_INTERVAL) }, { ARG_STR(VIDIOC_SUBDEV_G_CROP) }, { ARG_STR(VIDIOC_SUBDEV_S_CROP) }, { ARG_STR(VIDIOC_SUBDEV_G_SELECTION) }, { ARG_STR(VIDIOC_SUBDEV_S_SELECTION) }, { ARG_STR(VIDIOC_SUBDEV_ENUM_FRAME_SIZE) }, { ARG_STR(VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL) }, #endif }; for (size_t i = 0; i < ARRAY_SIZE(unsupp_cmds); i++) { ioctl(-1, unsupp_cmds[i].cmd, 0); printf("ioctl(-1, " XLAT_FMT ", 0) = -1 EBADF (%m)\n", XLAT_SEL(unsupp_cmds[i].cmd, unsupp_cmds[i].str)); ioctl(-1, unsupp_cmds[i].cmd, (unsigned long) 0xbadc0deddeadc0deULL); printf("ioctl(-1, " XLAT_FMT ", %#lx) = -1 EBADF (%m)\n", XLAT_SEL(unsupp_cmds[i].cmd, unsupp_cmds[i].str), (unsigned long) 0xbadc0deddeadc0deULL); } /* VIDIOC_QUERYCAP */ ioctl(-1, VIDIOC_QUERYCAP, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QUERYCAP)); ioctl(-1, VIDIOC_QUERYCAP, page); printf("ioctl(-1, %s, %p) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QUERYCAP), page); /* VIDIOC_ENUM_FMT */ ioctl(-1, VIDIOC_ENUM_FMT, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUM_FMT)); TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_fmtdesc, p_fmtdesc); p_fmtdesc->index = magic; p_fmtdesc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; ioctl(-1, VIDIOC_ENUM_FMT, p_fmtdesc); printf("ioctl(-1, %s, {index=%u, type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUM_FMT), p_fmtdesc->index, XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_CAPTURE)); /* VIDIOC_G_FMT */ ioctl(-1, VIDIOC_G_FMT, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT)); TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_format, p_format); p_format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_CAPTURE)); p_format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)); p_format->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY)); p_format->type = V4L2_BUF_TYPE_VIDEO_OVERLAY; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_OVERLAY)); p_format->type = V4L2_BUF_TYPE_VBI_CAPTURE; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_VBI_CAPTURE)); p_format->type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)); p_format->type = V4L2_BUF_TYPE_SDR_CAPTURE; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_SDR_CAPTURE)); p_format->type = V4L2_BUF_TYPE_SDR_OUTPUT; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_SDR_OUTPUT)); p_format->type = V4L2_BUF_TYPE_META_CAPTURE; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_META_CAPTURE)); p_format->type = V4L2_BUF_TYPE_META_OUTPUT; ioctl(-1, VIDIOC_G_FMT, p_format); printf("ioctl(-1, %s, {type=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FMT), XLAT_ARGS(V4L2_BUF_TYPE_META_OUTPUT)); /* VIDIOC_S_FMT */ ioctl(-1, VIDIOC_S_FMT, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_FMT)); init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OUTPUT); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_VIDEO_OUTPUT); init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY); init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OVERLAY); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_VIDEO_OVERLAY); init_v4l2_format(p_format, V4L2_BUF_TYPE_VBI_CAPTURE); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_VBI_CAPTURE); init_v4l2_format(p_format, V4L2_BUF_TYPE_SLICED_VBI_CAPTURE); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_SLICED_VBI_CAPTURE); init_v4l2_format(p_format, V4L2_BUF_TYPE_SDR_CAPTURE); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_SDR_CAPTURE); init_v4l2_format(p_format, V4L2_BUF_TYPE_SDR_OUTPUT); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_SDR_OUTPUT); init_v4l2_format(p_format, V4L2_BUF_TYPE_META_CAPTURE); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_META_CAPTURE); init_v4l2_format(p_format, V4L2_BUF_TYPE_META_OUTPUT); ioctl(-1, VIDIOC_S_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_S_FMT, V4L2_BUF_TYPE_META_OUTPUT); /* VIDIOC_TRY_FMT */ ioctl(-1, VIDIOC_TRY_FMT, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_TRY_FMT)); init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OUTPUT); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_VIDEO_OUTPUT); init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY); init_v4l2_format(p_format, V4L2_BUF_TYPE_VIDEO_OVERLAY); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_VIDEO_OVERLAY); init_v4l2_format(p_format, V4L2_BUF_TYPE_VBI_CAPTURE); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_VBI_CAPTURE); init_v4l2_format(p_format, V4L2_BUF_TYPE_SLICED_VBI_CAPTURE); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_SLICED_VBI_CAPTURE); init_v4l2_format(p_format, V4L2_BUF_TYPE_SDR_CAPTURE); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_SDR_CAPTURE); init_v4l2_format(p_format, V4L2_BUF_TYPE_SDR_OUTPUT); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_SDR_OUTPUT); init_v4l2_format(p_format, V4L2_BUF_TYPE_META_CAPTURE); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_META_CAPTURE); init_v4l2_format(p_format, V4L2_BUF_TYPE_META_OUTPUT); ioctl(-1, VIDIOC_TRY_FMT, p_format); print_ioctl_v4l2(p_format, VIDIOC_TRY_FMT, V4L2_BUF_TYPE_META_OUTPUT); struct v4l2_format *const p_v4l2_format = page_end - sizeof(*p_v4l2_format); ioctl(-1, VIDIOC_TRY_FMT, p_v4l2_format); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_TRY_FMT), p_v4l2_format->type); /* VIDIOC_REQBUFS */ ioctl(-1, VIDIOC_REQBUFS, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_REQBUFS)); struct v4l2_requestbuffers *const p_v4l2_requestbuffers = page_end - sizeof(*p_v4l2_requestbuffers); ioctl(-1, VIDIOC_REQBUFS, p_v4l2_requestbuffers); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") ", memory=%#x" NRAW(" /* V4L2_MEMORY_??? */") ", count=%u})" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_REQBUFS), p_v4l2_requestbuffers->type, p_v4l2_requestbuffers->memory, p_v4l2_requestbuffers->count); /* VIDIOC_QUERYBUF */ ioctl(-1, VIDIOC_QUERYBUF, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QUERYBUF)); kernel_v4l2_buffer_t *const p_v4l2_buffer = page_end - sizeof(*p_v4l2_buffer); ioctl(-1, VIDIOC_QUERYBUF, p_v4l2_buffer); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") ", index=%u}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QUERYBUF), p_v4l2_buffer->type, p_v4l2_buffer->index); /* VIDIOC_QBUF */ ioctl(-1, VIDIOC_QBUF, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QBUF)); ioctl(-1, VIDIOC_QBUF, p_v4l2_buffer); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") ", index=%u}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QBUF), p_v4l2_buffer->type, p_v4l2_buffer->index); /* VIDIOC_DQBUF */ ioctl(-1, VIDIOC_DQBUF, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_DQBUF)); ioctl(-1, VIDIOC_DQBUF, p_v4l2_buffer); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_DQBUF), p_v4l2_buffer->type); /* VIDIOC_G_FBUF */ ioctl(-1, VIDIOC_G_FBUF, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FBUF)); ioctl(-1, VIDIOC_G_FBUF, page); printf("ioctl(-1, %s, %p) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_FBUF), page); /* VIDIOC_S_FBUF */ ioctl(-1, VIDIOC_S_FBUF, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_FBUF)); struct v4l2_framebuffer *const p_v4l2_framebuffer = page_end - sizeof(*p_v4l2_framebuffer); ioctl(-1, VIDIOC_S_FBUF, p_v4l2_framebuffer); printf("ioctl(-1, %s, {capability=%#x" ", flags=%#x, base=%p}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_FBUF), p_v4l2_framebuffer->capability, p_v4l2_framebuffer->flags, p_v4l2_framebuffer->base); /* VIDIOC_STREAMON */ ioctl(-1, VIDIOC_STREAMON, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_STREAMON)); int *const p_int = page_end - sizeof(int); ioctl(-1, VIDIOC_STREAMON, p_int); printf("ioctl(-1, %s, [%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "])" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_STREAMON), *p_int); /* VIDIOC_STREAMOFF */ ioctl(-1, VIDIOC_STREAMOFF, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_STREAMOFF)); ioctl(-1, VIDIOC_STREAMOFF, p_int); printf("ioctl(-1, %s, [%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "])" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_STREAMOFF), *p_int); /* VIDIOC_G_PARM */ ioctl(-1, VIDIOC_G_PARM, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_PARM)); struct v4l2_streamparm *const p_v4l2_streamparm = page_end - sizeof(*p_v4l2_streamparm); ioctl(-1, VIDIOC_G_PARM, p_v4l2_streamparm); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_PARM), p_v4l2_streamparm->type); /* VIDIOC_S_PARM */ ioctl(-1, VIDIOC_S_PARM, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_PARM)); ioctl(-1, VIDIOC_S_PARM, p_v4l2_streamparm); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_PARM), p_v4l2_streamparm->type); TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_streamparm, p_streamparm); p_streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; p_streamparm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; p_streamparm->parm.capture.capturemode = V4L2_MODE_HIGHQUALITY; p_streamparm->parm.capture.timeperframe.numerator = 0xdeadbeef; p_streamparm->parm.capture.timeperframe.denominator = 0xbadc0ded; ioctl(-1, VIDIOC_S_PARM, p_streamparm); printf("ioctl(-1, %s, {type=" XLAT_FMT ", parm.capture={capability=" XLAT_FMT ", capturemode=" XLAT_FMT ", timeperframe=%u/%u" ", extendedmode=%#x, readbuffers=%u}}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_PARM), XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_CAPTURE), XLAT_ARGS(V4L2_CAP_TIMEPERFRAME), XLAT_ARGS(V4L2_MODE_HIGHQUALITY), p_streamparm->parm.capture.timeperframe.numerator, p_streamparm->parm.capture.timeperframe.denominator, -1U, -1U); p_streamparm->type = V4L2_BUF_TYPE_VIDEO_OUTPUT; p_streamparm->parm.output.outputmode = 0; ioctl(-1, VIDIOC_S_PARM, p_streamparm); printf("ioctl(-1, %s, {type=" XLAT_FMT ", parm.output={capability=" XLAT_FMT ", outputmode=0, timeperframe=%u/%u" ", extendedmode=%#x, writebuffers=%u}}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_PARM), XLAT_ARGS(V4L2_BUF_TYPE_VIDEO_OUTPUT), XLAT_ARGS(V4L2_CAP_TIMEPERFRAME), p_streamparm->parm.output.timeperframe.numerator, p_streamparm->parm.output.timeperframe.denominator, -1U, -1U); /* VIDIOC_G_STD */ ioctl(-1, VIDIOC_G_STD, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_STD)); ioctl(-1, VIDIOC_G_STD, page); printf("ioctl(-1, %s, %p) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_STD), page); /* VIDIOC_S_STD */ ioctl(-1, VIDIOC_S_STD, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_STD)); long long *const p_longlong = page_end - sizeof(*p_longlong); ioctl(-1, VIDIOC_S_STD, p_longlong); printf("ioctl(-1, %s, [%#llx]) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_STD), *p_longlong); /* VIDIOC_ENUMSTD */ ioctl(-1, VIDIOC_ENUMSTD, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUMSTD)); struct v4l2_standard *const p_v4l2_standard = page_end - sizeof(*p_v4l2_standard); ioctl(-1, VIDIOC_ENUMSTD, p_v4l2_standard); printf("ioctl(-1, %s, {index=%u}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUMSTD), p_v4l2_standard->index); /* VIDIOC_ENUMINPUT */ ioctl(-1, VIDIOC_ENUMINPUT, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUMINPUT)); struct v4l2_input *const p_v4l2_input = page_end - sizeof(*p_v4l2_input); ioctl(-1, VIDIOC_ENUMINPUT, p_v4l2_input); printf("ioctl(-1, %s, {index=%u}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUMINPUT), p_v4l2_input->index); /* VIDIOC_G_CTRL */ ioctl(-1, VIDIOC_G_CTRL, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_CTRL)); static const struct v4l2_control v4l2_control_vals[] = { { .id = 0, .value = 3141592653U }, { .id = 0x97abcd, .value = 1234567890U }, { .id = V4L2_CTRL_CLASS_USER, .value = 0 }, { .id = 0x990a64, .value = 42 }, { .id = 0xa31234, .value = 1 }, { .id = 0xa60000, .value = -1 }, }; static const char *id_strs[] = { "0" NRAW(" /* V4L2_CID_??? */"), "0x97abcd" NRAW(" /* V4L2_CID_??? */"), XLAT_KNOWN(0x980000, "V4L2_CTRL_CLASS_USER+0"), XLAT_KNOWN(0x990a64, "V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE"), XLAT_KNOWN(0xa31234, "V4L2_CTRL_CLASS_DETECT+0x1234"), "0xa60000" NRAW(" /* V4L2_CID_??? */"), }; struct v4l2_control *const p_v4l2_control = page_end - sizeof(*p_v4l2_control); ioctl(-1, VIDIOC_G_CTRL, p_v4l2_control); printf("ioctl(-1, %s, {id=%#x" NRAW(" /* V4L2_CID_??? */") "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_CTRL), p_v4l2_control->id); /* VIDIOC_S_CTRL */ ioctl(-1, VIDIOC_S_CTRL, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_CTRL)); ioctl(-1, VIDIOC_S_CTRL, p_v4l2_control); printf("ioctl(-1, %s, {id=%#x" NRAW(" /* V4L2_CID_??? */") ", value=%d}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_CTRL), p_v4l2_control->id, p_v4l2_control->value); for (size_t i = 0; i < ARRAY_SIZE(id_strs); i++) { struct v4l2_control v4l2_c = v4l2_control_vals[i]; ioctl(-1, VIDIOC_G_CTRL, &v4l2_c); printf("ioctl(-1, %s, {id=%s}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_CTRL), id_strs[i]); ioctl(-1, VIDIOC_S_CTRL, &v4l2_c); printf("ioctl(-1, %s, {id=%s, value=%d}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_CTRL), id_strs[i], v4l2_c.value); } /* VIDIOC_G_TUNER */ ioctl(-1, VIDIOC_G_TUNER, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_TUNER)); struct v4l2_tuner *const p_v4l2_tuner = page_end - sizeof(*p_v4l2_tuner); ioctl(-1, VIDIOC_G_TUNER, p_v4l2_tuner); printf("ioctl(-1, %s, {index=%u}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_TUNER), p_v4l2_tuner->index); /* VIDIOC_S_TUNER */ ioctl(-1, VIDIOC_S_TUNER, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_TUNER)); TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_tuner, p_tuner); p_tuner->index = 0x4fb6df39; strcpy((char *) p_tuner->name, "cum tacent clamant"); p_tuner->type = V4L2_TUNER_RADIO; p_tuner->capability = V4L2_TUNER_CAP_LOW; p_tuner->rangelow = 0xa673bc29; p_tuner->rangehigh = 0xbaf16d12; p_tuner->rxsubchans = V4L2_TUNER_SUB_MONO; p_tuner->audmode = V4L2_TUNER_MODE_MONO; p_tuner->signal = 0x10bf92c8; p_tuner->afc = 0x3bf7e18b; ioctl(-1, VIDIOC_S_TUNER, p_tuner); printf("ioctl(-1, %s, {index=%u, name=\"cum tacent clamant\"" ", type=" XLAT_FMT ", capability=" XLAT_FMT ", rangelow=%u, rangehigh=%u" ", rxsubchans=" XLAT_FMT ", audmode=" XLAT_FMT ", signal=%d, afc=%d}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_TUNER), p_tuner->index, XLAT_ARGS(V4L2_TUNER_RADIO), XLAT_ARGS(V4L2_TUNER_CAP_LOW), p_tuner->rangelow, p_tuner->rangehigh, XLAT_ARGS(V4L2_TUNER_SUB_MONO), XLAT_ARGS(V4L2_TUNER_MODE_MONO), p_tuner->signal, p_tuner->afc); /* VIDIOC_QUERYCTRL */ ioctl(-1, VIDIOC_QUERYCTRL, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QUERYCTRL)); struct v4l2_queryctrl *const p_v4l2_queryctrl = page_end - sizeof(*p_v4l2_queryctrl); ioctl(-1, VIDIOC_QUERYCTRL, p_v4l2_queryctrl); printf("ioctl(-1, %s, {id=" #if XLAT_RAW "%#x" #else XLAT_FMT "|%#x /* V4L2_CID_??? */" #endif "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QUERYCTRL), #if XLAT_RAW p_v4l2_queryctrl->id #else XLAT_ARGS(V4L2_CTRL_FLAG_NEXT_CTRL), p_v4l2_queryctrl->id & ~V4L2_CTRL_FLAG_NEXT_CTRL #endif ); TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_queryctrl, p_queryctrl); p_queryctrl->id = V4L2_CID_SATURATION; ioctl(-1, VIDIOC_QUERYCTRL, p_queryctrl); printf("ioctl(-1, %s, {id=" XLAT_FMT "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QUERYCTRL), XLAT_ARGS(V4L2_CID_SATURATION)); /* VIDIOC_G_INPUT */ ioctl(-1, VIDIOC_G_INPUT, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_INPUT)); ioctl(-1, VIDIOC_G_INPUT, page); printf("ioctl(-1, %s, %p) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_INPUT), page); /* VIDIOC_S_INPUT */ ioctl(-1, VIDIOC_S_INPUT, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_INPUT)); ioctl(-1, VIDIOC_S_INPUT, p_int); printf("ioctl(-1, %s, [%u]) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_INPUT), *p_int); /* VIDIOC_CROPCAP */ ioctl(-1, VIDIOC_CROPCAP, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_CROPCAP)); struct v4l2_cropcap *const p_v4l2_cropcap = page_end - sizeof(*p_v4l2_cropcap); ioctl(-1, VIDIOC_CROPCAP, p_v4l2_cropcap); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_CROPCAP), p_v4l2_cropcap->type); /* VIDIOC_G_CROP */ ioctl(-1, VIDIOC_G_CROP, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_CROP)); struct v4l2_crop *const p_v4l2_crop = page_end - sizeof(*p_v4l2_crop); ioctl(-1, VIDIOC_G_CROP, p_v4l2_crop); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "})" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_CROP), p_v4l2_crop->type); /* VIDIOC_S_CROP */ ioctl(-1, VIDIOC_S_CROP, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_CROP)); ioctl(-1, VIDIOC_S_CROP, p_v4l2_crop); printf("ioctl(-1, %s, {type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") ", c={left=%d, top=%d, width=%u, height=%u}}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_CROP), p_v4l2_crop->type, p_v4l2_crop->c.left, p_v4l2_crop->c.top, p_v4l2_crop->c.width, p_v4l2_crop->c.height); /* VIDIOC_S_EXT_CTRLS */ ioctl(-1, VIDIOC_S_EXT_CTRLS, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_EXT_CTRLS)); TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_ext_controls, p_ext_controls); p_ext_controls->ctrl_class = V4L2_CTRL_CLASS_USER; p_ext_controls->count = 0; p_ext_controls->controls = (void *) -2UL; ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls); printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u})" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_USER), p_ext_controls->count); p_ext_controls->ctrl_class = 0x00a30000; p_ext_controls->count = magic; ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls); printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls=%p}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_DETECT), p_ext_controls->count, p_ext_controls->controls); p_ext_controls->ctrl_class = 0x00160000; p_ext_controls->count = magic; ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls); printf("ioctl(-1, %s" ", {ctrl_class=0x160000" NRAW(" /* V4L2_CTRL_CLASS_??? */") ", count=%u, controls=%p}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_EXT_CTRLS), p_ext_controls->count, p_ext_controls->controls); p_ext_controls->ctrl_class = V4L2_CTRL_CLASS_CODEC; p_ext_controls->count = magic; ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls); printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls=%p}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_CODEC), p_ext_controls->count, p_ext_controls->controls); p_ext_controls->count = 2; p_ext_controls->controls = tail_alloc(sizeof(*p_ext_controls->controls) * p_ext_controls->count); p_ext_controls->controls[0].id = V4L2_CID_BRIGHTNESS; p_ext_controls->controls[0].size = 0; p_ext_controls->controls[0].value64 = 0xfacefeeddeadbeefULL; p_ext_controls->controls[1].id = V4L2_CID_CONTRAST; p_ext_controls->controls[1].size = 2; p_ext_controls->controls[1].string = tail_alloc(p_ext_controls->controls[1].size); ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls); printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls=" "[{id=" XLAT_FMT ", size=0, value=%d, value64=%lld}" ", {id=" XLAT_FMT ", size=2, string=\"\\377\\377\"}" "]} => {controls=" "[{id=" XLAT_FMT ", size=0, value=%d, value64=%lld}" ", {id=" XLAT_FMT ", size=2, string=\"\\377\\377\"}" "], error_idx=%u}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_CODEC), p_ext_controls->count, XLAT_ARGS(V4L2_CID_BRIGHTNESS), p_ext_controls->controls[0].value, (long long) p_ext_controls->controls[0].value64, XLAT_ARGS(V4L2_CID_CONTRAST), XLAT_ARGS(V4L2_CID_BRIGHTNESS), p_ext_controls->controls[0].value, (long long) p_ext_controls->controls[0].value64, XLAT_ARGS(V4L2_CID_CONTRAST), p_ext_controls->error_idx); ++p_ext_controls->count; ioctl(-1, VIDIOC_S_EXT_CTRLS, p_ext_controls); printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls=" "[{id=" XLAT_FMT ", size=0, value=%d, value64=%lld}" ", {id=" XLAT_FMT ", size=2, string=\"\\377\\377\"}" ", ... /* %p */]}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_S_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_CODEC), p_ext_controls->count, XLAT_ARGS(V4L2_CID_BRIGHTNESS), p_ext_controls->controls[0].value, (long long) p_ext_controls->controls[0].value64, XLAT_ARGS(V4L2_CID_CONTRAST), p_ext_controls->controls + 2); /* VIDIOC_TRY_EXT_CTRLS */ ioctl(-1, VIDIOC_TRY_EXT_CTRLS, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_TRY_EXT_CTRLS)); p_ext_controls->ctrl_class = V4L2_CTRL_CLASS_USER; p_ext_controls->count = magic; p_ext_controls->controls = (void *) -2UL; ioctl(-1, VIDIOC_TRY_EXT_CTRLS, p_ext_controls); printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls=%p})" " = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_TRY_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_USER), p_ext_controls->count, p_ext_controls->controls); /* VIDIOC_G_EXT_CTRLS */ ioctl(-1, VIDIOC_G_EXT_CTRLS, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_EXT_CTRLS)); ioctl(-1, VIDIOC_G_EXT_CTRLS, p_ext_controls); printf("ioctl(-1, %s, {ctrl_class=" XLAT_FMT ", count=%u, controls=%p" ", error_idx=%u}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_G_EXT_CTRLS), XLAT_ARGS(V4L2_CTRL_CLASS_USER), p_ext_controls->count, p_ext_controls->controls, p_ext_controls->error_idx); ioctl(-1, VIDIOC_ENUM_FRAMESIZES, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUM_FRAMESIZES)); TAIL_ALLOC_OBJECT_CONST_PTR(struct v4l2_frmsizeenum, p_frmsizeenum); p_frmsizeenum->index = magic; p_frmsizeenum->pixel_format = fourcc(cc[0], cc[1], cc[2], cc[3]); ioctl(-1, VIDIOC_ENUM_FRAMESIZES, p_frmsizeenum); printf("ioctl(-1, %s, {index=%u, pixel_format=" #if XLAT_RAW "0x%hhx%hhx%hhx%hhx" #else /* !XLAT_RAW */ "v4l2_fourcc('%c', '\\%c', '\\%c', '\\x%x')" #endif /* XLAT_RAW */ "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUM_FRAMESIZES), p_frmsizeenum->index, #if XLAT_RAW cc[3], cc[2], cc[1], cc[0] #else /* !XLAT_RAW */ cc[0], cc[1], cc[2], cc[3] #endif /* XLAT_RAW */ ); ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS)); struct v4l2_frmivalenum *const p_v4l2_frmivalenum = page_end - sizeof(*p_v4l2_frmivalenum); ioctl(-1, VIDIOC_ENUM_FRAMEINTERVALS, p_v4l2_frmivalenum); printf("ioctl(-1, %s, {index=%u, pixel_format=" #if XLAT_RAW "%#x" #else /* !XLAT_RAW */ "v4l2_fourcc('\\x%x', '\\x%x', '\\x%x', '\\x%x')" #endif /* XLAT_RAW */ ", width=%u, height=%u}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_ENUM_FRAMEINTERVALS), p_v4l2_frmivalenum->index, #if XLAT_RAW p_v4l2_frmivalenum->pixel_format, #else /* !XLAT_RAW */ cc0(p_v4l2_frmivalenum->pixel_format), cc1(p_v4l2_frmivalenum->pixel_format), cc2(p_v4l2_frmivalenum->pixel_format), cc3(p_v4l2_frmivalenum->pixel_format), #endif /* XLAT_RAW */ p_v4l2_frmivalenum->width, p_v4l2_frmivalenum->height); ioctl(-1, VIDIOC_CREATE_BUFS, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_CREATE_BUFS)); struct v4l2_create_buffers *const p_v4l2_create_buffers = page_end - sizeof(*p_v4l2_create_buffers); ioctl(-1, VIDIOC_CREATE_BUFS, p_v4l2_create_buffers); printf("ioctl(-1, %s, {count=%u, memory=%#x" NRAW(" /* V4L2_MEMORY_??? */") ", format={type=%#x" NRAW(" /* V4L2_BUF_TYPE_??? */") "}}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_CREATE_BUFS), p_v4l2_create_buffers->count, p_v4l2_create_buffers->memory, p_v4l2_create_buffers->format.type); ioctl(-1, VIDIOC_QUERY_EXT_CTRL, 0); printf("ioctl(-1, %s, NULL) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QUERY_EXT_CTRL)); struct v4l2_query_ext_ctrl *const p_v4l2_query_ext_ctrl = page_end - sizeof(*p_v4l2_query_ext_ctrl); ioctl(-1, VIDIOC_QUERY_EXT_CTRL, p_v4l2_query_ext_ctrl); printf("ioctl(-1, %s, {id=" #ifdef WORDS_BIGENDIAN RAW("0x98999a9b") VERB("0x80000000 /* ") NRAW("V4L2_CTRL_FLAG_NEXT_CTRL") VERB(" */") NRAW("|0x18999a9b /* V4L2_CID_??? */") #else RAW("0x9b9a9998") VERB("0x80000000 /* ") NRAW("V4L2_CTRL_FLAG_NEXT_CTRL") VERB(" */") NRAW("|0x1b9a9998 /* V4L2_CID_??? */") #endif "}) = -1 EBADF (%m)\n", XLAT_STR(VIDIOC_QUERY_EXT_CTRL)); puts("+++ exited with 0 +++"); return 0; }