static void find_controls(int fd)
{
struct v4l2_queryctrl qctrl;
int id;
memset(&qctrl, 0, sizeof(qctrl));
qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;
while (test_ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0) {
if (qctrl.type != V4L2_CTRL_TYPE_CTRL_CLASS &&
!(qctrl.flags & V4L2_CTRL_FLAG_DISABLED)) {
ctrl_str2q[name2var(qctrl.name)] = qctrl;
ctrl_id2str[qctrl.id] = name2var(qctrl.name);
}
qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
}
if (qctrl.id != V4L2_CTRL_FLAG_NEXT_CTRL)
return;
for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
qctrl.id = id;
if (test_ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0 &&
!(qctrl.flags & V4L2_CTRL_FLAG_DISABLED)) {
ctrl_str2q[name2var(qctrl.name)] = qctrl;
ctrl_id2str[qctrl.id] = name2var(qctrl.name);
}
}
for (qctrl.id = V4L2_CID_PRIVATE_BASE;
test_ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0; qctrl.id++) {
if (!(qctrl.flags & V4L2_CTRL_FLAG_DISABLED)) {
ctrl_str2q[name2var(qctrl.name)] = qctrl;
ctrl_id2str[qctrl.id] = name2var(qctrl.name);
}
}
}
static int do_handle_out(int fd, buffers &b, FILE *fin,
unsigned &count, unsigned &last, struct timeval &tv_last)
{
struct v4l2_plane planes[VIDEO_MAX_PLANES];
struct v4l2_buffer buf;
int ret;
memset(&buf, 0, sizeof(buf));
memset(planes, 0, sizeof(planes));
buf.type = b.type;
buf.memory = b.memory;
if (b.is_mplane) {
buf.m.planes = planes;
buf.length = VIDEO_MAX_PLANES;
}
ret = test_ioctl(fd, VIDIOC_DQBUF, &buf);
if (ret < 0 && errno == EAGAIN)
return 0;
if (ret < 0) {
fprintf(stderr, "%s: failed: %s\n", "VIDIOC_DQBUF", strerror(errno));
return -1;
}
if (fin && !fill_buffer_from_file(b, buf.index, fin))
return -1;
if (b.is_mplane) {
for (unsigned j = 0; j < buf.length; j++)
buf.m.planes[j].bytesused = buf.m.planes[j].length;
} else {
buf.bytesused = buf.length;
}
if (test_ioctl(fd, VIDIOC_QBUF, &buf))
return -1;
fprintf(stderr, ">");
fflush(stderr);
if (count == 0) {
gettimeofday(&tv_last, NULL);
} else {
struct timeval tv_cur, res;
gettimeofday(&tv_cur, NULL);
timersub(&tv_cur, &tv_last, &res);
if (res.tv_sec) {
unsigned fps = (100 * (count - last)) /
(res.tv_sec * 100 + res.tv_usec / 10000);
last = count;
tv_last = tv_cur;
fprintf(stderr, " %d fps\n", fps);
}
}
count++;
if (stream_count == 0)
return 0;
if (--stream_count == 0)
return -1;
return 0;
}
static void print_video_fields(int fd)
{
struct v4l2_format fmt;
struct v4l2_format tmp;
memset(&fmt, 0, sizeof(fmt));
fmt.fmt.pix.priv = priv_magic;
fmt.type = vidcap_buftype;
if (test_ioctl(fd, VIDIOC_G_FMT, &fmt) < 0)
return;
printf("Supported Video Fields:\n");
for (__u32 f = V4L2_FIELD_NONE; f <= V4L2_FIELD_INTERLACED_BT; f++) {
bool ok;
tmp = fmt;
if (is_multiplanar)
tmp.fmt.pix_mp.field = f;
else
tmp.fmt.pix.field = f;
if (test_ioctl(fd, VIDIOC_TRY_FMT, &tmp) < 0)
continue;
if (is_multiplanar)
ok = tmp.fmt.pix_mp.field == f;
else
ok = tmp.fmt.pix.field == f;
if (ok)
printf("\t%s\n", field2s(f).c_str());
}
}
void vidcap_list(int fd)
{
if (options[OptListFormats]) {
printf("ioctl: VIDIOC_ENUM_FMT\n");
print_video_formats(fd, vidcap_buftype);
}
if (options[OptListFormatsExt]) {
printf("ioctl: VIDIOC_ENUM_FMT\n");
print_video_formats_ext(fd, vidcap_buftype);
}
if (options[OptListFields]) {
print_video_fields(fd);
}
if (options[OptListFrameSizes]) {
printf("ioctl: VIDIOC_ENUM_FRAMESIZES\n");
frmsize.index = 0;
while (test_ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize) >= 0) {
print_frmsize(frmsize, "");
frmsize.index++;
}
}
if (options[OptListFrameIntervals]) {
printf("ioctl: VIDIOC_ENUM_FRAMEINTERVALS\n");
frmival.index = 0;
while (test_ioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival) >= 0) {
print_frmival(frmival, "");
frmival.index++;
}
}
}
static int print_control(int fd, struct v4l2_query_ext_ctrl &qctrl, int show_menus)
{
struct v4l2_control ctrl;
struct v4l2_ext_control ext_ctrl;
struct v4l2_ext_controls ctrls;
memset(&ctrl, 0, sizeof(ctrl));
memset(&ext_ctrl, 0, sizeof(ext_ctrl));
memset(&ctrls, 0, sizeof(ctrls));
if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
return 1;
if (qctrl.type == V4L2_CTRL_TYPE_CTRL_CLASS) {
printf("\n%s\n\n", qctrl.name);
return 1;
}
ext_ctrl.id = qctrl.id;
if ((qctrl.flags & V4L2_CTRL_FLAG_WRITE_ONLY) ||
qctrl.type == V4L2_CTRL_TYPE_BUTTON) {
print_qctrl(fd, &qctrl, &ext_ctrl, show_menus);
return 1;
}
if (qctrl.type >= V4L2_CTRL_COMPOUND_TYPES) {
print_qctrl(fd, &qctrl, NULL, show_menus);
return 1;
}
ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(qctrl.id);
ctrls.count = 1;
ctrls.controls = &ext_ctrl;
if (qctrl.type == V4L2_CTRL_TYPE_INTEGER64 ||
qctrl.type == V4L2_CTRL_TYPE_STRING ||
(V4L2_CTRL_ID2CLASS(qctrl.id) != V4L2_CTRL_CLASS_USER &&
qctrl.id < V4L2_CID_PRIVATE_BASE)) {
if (qctrl.type == V4L2_CTRL_TYPE_STRING) {
ext_ctrl.size = qctrl.maximum + 1;
ext_ctrl.string = (char *)malloc(ext_ctrl.size);
ext_ctrl.string[0] = 0;
}
if (test_ioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls)) {
printf("error %d getting ext_ctrl %s\n",
errno, qctrl.name);
return 0;
}
}
else {
ctrl.id = qctrl.id;
if (test_ioctl(fd, VIDIOC_G_CTRL, &ctrl)) {
printf("error %d getting ctrl %s\n",
errno, qctrl.name);
return 0;
}
ext_ctrl.value = ctrl.value;
}
print_qctrl(fd, &qctrl, &ext_ctrl, show_menus);
if (qctrl.type == V4L2_CTRL_TYPE_STRING)
free(ext_ctrl.string);
return 1;
}
void stds_set(int fd)
{
if (options[OptSetStandard]) {
if (standard & (1ULL << 63)) {
struct v4l2_standard vs;
vs.index = standard & 0xffff;
if (test_ioctl(fd, VIDIOC_ENUMSTD, &vs) >= 0) {
standard = vs.id;
}
}
if (doioctl(fd, VIDIOC_S_STD, &standard) == 0)
printf("Standard set to %08llx\n", (unsigned long long)standard);
}
if (options[OptSetDvBtTimings]) {
struct v4l2_enum_dv_timings et;
if (query_and_set_dv_timings)
doioctl(fd, VIDIOC_QUERY_DV_TIMINGS, &dv_timings);
if (enum_and_set_dv_timings >= 0) {
memset(&et, 0, sizeof(et));
et.index = enum_and_set_dv_timings;
doioctl(fd, VIDIOC_ENUM_DV_TIMINGS, &et);
dv_timings = et.timings;
}
if (doioctl(fd, VIDIOC_S_DV_TIMINGS, &dv_timings) >= 0) {
printf("BT timings set\n");
}
}
}
static void list_buffers(int fd, unsigned buftype)
{
int i;
for (i = 0; i < VIDEO_MAX_FRAME; i++) {
struct v4l2_plane planes[VIDEO_MAX_PLANES];
struct v4l2_buffer buf;
memset(&buf, 0, sizeof(buf));
buf.type = buftype;
buf.index = i;
buf.reserved = 0;
if (buftype == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ||
buftype == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
buf.m.planes = planes;
buf.length = VIDEO_MAX_PLANES;
memset(planes, 0, sizeof(planes));
}
if (test_ioctl(fd, VIDIOC_QUERYBUF, &buf))
break;
if (i == 0)
printf("VIDIOC_QUERYBUF:\n");
print_buffer(stdout, buf);
}
}
void io_set(int fd)
{
if (options[OptSetInput]) {
if (doioctl(fd, VIDIOC_S_INPUT, &input) == 0) {
struct v4l2_input vin;
printf("Video input set to %d", input);
vin.index = input;
if (test_ioctl(fd, VIDIOC_ENUMINPUT, &vin) >= 0)
printf(" (%s: %s)", vin.name, status2s(vin.status).c_str());
printf("\n");
}
}
if (options[OptSetOutput]) {
if (doioctl(fd, VIDIOC_S_OUTPUT, &output) == 0)
printf("Output set to %d\n", output);
}
if (options[OptSetAudioInput]) {
if (doioctl(fd, VIDIOC_S_AUDIO, &vaudio) == 0)
printf("Audio input set to %d\n", vaudio.index);
}
if (options[OptSetAudioOutput]) {
if (doioctl(fd, VIDIOC_S_AUDOUT, &vaudout) == 0)
printf("Audio output set to %d\n", vaudout.index);
}
}
void stds_list(int fd)
{
if (options[OptListStandards]) {
struct v4l2_standard vs;
printf("ioctl: VIDIOC_ENUMSTD\n");
vs.index = 0;
while (test_ioctl(fd, VIDIOC_ENUMSTD, &vs) >= 0) {
if (options[OptConcise]) {
printf("\t%2d: 0x%016llX %s\n", vs.index,
(unsigned long long)vs.id, vs.name);
} else {
if (vs.index)
printf("\n");
printf("\tIndex : %d\n", vs.index);
printf("\tID : 0x%016llX\n", (unsigned long long)vs.id);
printf("\tName : %s\n", vs.name);
printf("\tFrame period: %d/%d\n",
vs.frameperiod.numerator,
vs.frameperiod.denominator);
printf("\tFrame lines : %d\n", vs.framelines);
}
vs.index++;
}
}
if (options[OptListDvTimings]) {
struct v4l2_enum_dv_timings dv_enum_timings;
dv_enum_timings.index = 0;
printf("ioctl: VIDIOC_ENUM_DV_TIMINGS\n");
while (test_ioctl(fd, VIDIOC_ENUM_DV_TIMINGS, &dv_enum_timings) >= 0) {
if (options[OptConcise]) {
printf("\t%d:", dv_enum_timings.index);
} else {
if (dv_enum_timings.index)
printf("\n");
printf("\tIndex: %d\n", dv_enum_timings.index);
}
print_dv_timings(&dv_enum_timings.timings);
dv_enum_timings.index++;
}
}
}
static int query_ext_ctrl_ioctl(int fd, struct v4l2_query_ext_ctrl &qctrl)
{
struct v4l2_queryctrl qc;
int rc;
if (have_query_ext_ctrl) {
rc = test_ioctl(fd, VIDIOC_QUERY_EXT_CTRL, &qctrl);
if (errno != ENOTTY)
return rc;
}
qc.id = qctrl.id;
rc = test_ioctl(fd, VIDIOC_QUERYCTRL, &qc);
if (rc == 0) {
qctrl.type = qc.type;
memcpy(qctrl.name, qc.name, sizeof(qctrl.name));
qctrl.minimum = qc.minimum;
qctrl.maximum = qc.maximum;
qctrl.step = qc.step;
qctrl.default_value = qc.default_value;
qctrl.flags = qc.flags;
qctrl.elems = 1;
qctrl.nr_of_dims = 0;
memset(qctrl.dims, 0, sizeof(qctrl.dims));
switch (qctrl.type) {
case V4L2_CTRL_TYPE_INTEGER64:
qctrl.elem_size = sizeof(__s64);
break;
case V4L2_CTRL_TYPE_STRING:
qctrl.elem_size = qc.maximum + 1;
break;
default:
qctrl.elem_size = sizeof(__s32);
break;
}
memset(qctrl.reserved, 0, sizeof(qctrl.reserved));
}
qctrl.id = qc.id;
return rc;
}
static void list_controls(int fd, int show_menus)
{
struct v4l2_queryctrl qctrl;
int id;
memset(&qctrl, 0, sizeof(qctrl));
qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;
while (test_ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0) {
print_control(fd, qctrl, show_menus);
qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
}
if (qctrl.id != V4L2_CTRL_FLAG_NEXT_CTRL)
return;
for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
qctrl.id = id;
if (test_ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0)
print_control(fd, qctrl, show_menus);
}
for (qctrl.id = V4L2_CID_PRIVATE_BASE;
test_ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0; qctrl.id++) {
print_control(fd, qctrl, show_menus);
}
}
int doioctl_name(int fd, unsigned long int request, void *parm, const char *name)
{
int retval = test_ioctl(fd, request, parm);
if (retval < 0)
app_result = -1;
if (options[OptSilent]) return retval;
if (retval < 0)
printf("%s: failed: %s\n", name, strerror(errno));
else if (verbose)
printf("%s: ok\n", name);
return retval;
}
void io_get(int fd)
{
if (options[OptGetInput]) {
if (doioctl(fd, VIDIOC_G_INPUT, &input) == 0) {
struct v4l2_input vin;
printf("Video input : %d", input);
vin.index = input;
if (test_ioctl(fd, VIDIOC_ENUMINPUT, &vin) >= 0)
printf(" (%s: %s)", vin.name, status2s(vin.status).c_str());
printf("\n");
}
}
if (options[OptGetOutput]) {
if (doioctl(fd, VIDIOC_G_OUTPUT, &output) == 0) {
struct v4l2_output vout;
printf("Video output: %d", output);
vout.index = output;
if (test_ioctl(fd, VIDIOC_ENUMOUTPUT, &vout) >= 0) {
printf(" (%s)", vout.name);
}
printf("\n");
}
}
if (options[OptGetAudioInput]) {
if (doioctl(fd, VIDIOC_G_AUDIO, &vaudio) == 0)
printf("Audio input : %d (%s)\n", vaudio.index, vaudio.name);
}
if (options[OptGetAudioOutput]) {
if (doioctl(fd, VIDIOC_G_AUDOUT, &vaudout) == 0)
printf("Audio output: %d (%s)\n", vaudout.index, vaudout.name);
}
}
static void print_video_formats_ext(int fd, __u32 type)
{
struct v4l2_fmtdesc fmt;
struct v4l2_frmsizeenum frmsize;
struct v4l2_frmivalenum frmival;
fmt.index = 0;
fmt.type = type;
while (test_ioctl(fd, VIDIOC_ENUM_FMT, &fmt) >= 0) {
printf("\tIndex : %d\n", fmt.index);
printf("\tType : %s\n", buftype2s(type).c_str());
printf("\tPixel Format: '%s'", fcc2s(fmt.pixelformat).c_str());
if (fmt.flags)
printf(" (%s)", fmtdesc2s(fmt.flags).c_str());
printf("\n");
printf("\tName : %s\n", fmt.description);
frmsize.pixel_format = fmt.pixelformat;
frmsize.index = 0;
while (test_ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize) >= 0) {
print_frmsize(frmsize, "\t");
if (frmsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
frmival.index = 0;
frmival.pixel_format = fmt.pixelformat;
frmival.width = frmsize.discrete.width;
frmival.height = frmsize.discrete.height;
while (test_ioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival) >= 0) {
print_frmival(frmival, "\t\t");
frmival.index++;
}
}
frmsize.index++;
}
printf("\n");
fmt.index++;
}
}
int doioctl_name(struct node *node, unsigned long int request, void *parm, const char *name)
{
int retval;
int e;
errno = 0;
retval = test_ioctl(node->fd, request, parm);
e = errno;
if (options[OptTrace])
printf("\t\t%s returned %d (%s)\n", name, retval, strerror(e));
if (retval == 0)
return 0;
if (retval != -1) {
fail("%s returned %d instead of 0 or -1\n", name, retval);
return -1;
}
return e;
}
void print_video_formats(int fd, __u32 type)
{
struct v4l2_fmtdesc fmt;
memset(&fmt, 0, sizeof(fmt));
fmt.type = type;
while (test_ioctl(fd, VIDIOC_ENUM_FMT, &fmt) >= 0) {
printf("\tIndex : %d\n", fmt.index);
printf("\tType : %s\n", buftype2s(type).c_str());
printf("\tPixel Format: '%s'", fcc2s(fmt.pixelformat).c_str());
if (fmt.flags)
printf(" (%s)", fmtdesc2s(fmt.flags).c_str());
printf("\n");
printf("\tName : %s\n", fmt.description);
printf("\n");
fmt.index++;
}
}
int
main(int argc, char *argv[])
{
strcpy(temp_dir, "/tmp/fifo_misc.XXXXXXXXXXX");
if (mkdtemp(temp_dir) == NULL)
err(-1, "mkdtemp");
atexit(atexit_temp_dir);
if (chdir(temp_dir) < 0)
err(-1, "chdir %s", temp_dir);
test_lseek();
test_truncate();
test_ioctl();
return (0);
}
void common_process_controls(int fd)
{
struct v4l2_query_ext_ctrl qc = {
V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND
};
int rc;
rc = test_ioctl(fd, VIDIOC_QUERY_EXT_CTRL, &qc);
have_query_ext_ctrl = rc == 0;
find_controls(fd);
for (ctrl_get_list::iterator iter = get_ctrls.begin(); iter != get_ctrls.end(); ++iter) {
if (ctrl_str2q.find(*iter) == ctrl_str2q.end()) {
fprintf(stderr, "unknown control '%s'\n", iter->c_str());
exit(1);
}
}
for (ctrl_set_map::iterator iter = set_ctrls.begin(); iter != set_ctrls.end(); ++iter) {
if (ctrl_str2q.find(iter->first) == ctrl_str2q.end()) {
fprintf(stderr, "unknown control '%s'\n", iter->first.c_str());
exit(1);
}
}
}
static void print_qctrl(int fd, struct v4l2_query_ext_ctrl *queryctrl,
struct v4l2_ext_control *ctrl, int show_menus)
{
struct v4l2_querymenu qmenu;
std::string s = name2var(queryctrl->name);
unsigned i;
memset(&qmenu, 0, sizeof(qmenu));
qmenu.id = queryctrl->id;
switch (queryctrl->type) {
case V4L2_CTRL_TYPE_INTEGER:
printf("%31s (int) : min=%lld max=%lld step=%lld default=%lld",
s.c_str(),
queryctrl->minimum, queryctrl->maximum,
queryctrl->step, queryctrl->default_value);
break;
case V4L2_CTRL_TYPE_INTEGER64:
printf("%31s (int64) : min=%lld max=%lld step=%lld default=%lld",
s.c_str(),
queryctrl->minimum, queryctrl->maximum,
queryctrl->step, queryctrl->default_value);
break;
case V4L2_CTRL_TYPE_STRING:
printf("%31s (str) : min=%lld max=%lld step=%lld",
s.c_str(),
queryctrl->minimum, queryctrl->maximum,
queryctrl->step);
break;
case V4L2_CTRL_TYPE_BOOLEAN:
printf("%31s (bool) : default=%lld",
s.c_str(), queryctrl->default_value);
break;
case V4L2_CTRL_TYPE_MENU:
printf("%31s (menu) : min=%lld max=%lld default=%lld",
s.c_str(),
queryctrl->minimum, queryctrl->maximum,
queryctrl->default_value);
break;
case V4L2_CTRL_TYPE_INTEGER_MENU:
printf("%31s (intmenu): min=%lld max=%lld default=%lld",
s.c_str(),
queryctrl->minimum, queryctrl->maximum,
queryctrl->default_value);
break;
case V4L2_CTRL_TYPE_BUTTON:
printf("%31s (button) :", s.c_str());
break;
case V4L2_CTRL_TYPE_BITMASK:
printf("%31s (bitmask): max=0x%08llx default=0x%08llx",
s.c_str(), queryctrl->maximum,
queryctrl->default_value);
break;
case V4L2_CTRL_TYPE_U8:
printf("%31s (u8) : min=%lld max=%lld step=%lld default=%lld",
s.c_str(),
queryctrl->minimum, queryctrl->maximum,
queryctrl->step, queryctrl->default_value);
break;
case V4L2_CTRL_TYPE_U16:
printf("%31s (u16) : min=%lld max=%lld step=%lld default=%lld",
s.c_str(),
queryctrl->minimum, queryctrl->maximum,
queryctrl->step, queryctrl->default_value);
break;
case V4L2_CTRL_TYPE_U32:
printf("%31s (u32) : min=%lld max=%lld step=%lld default=%lld",
s.c_str(),
queryctrl->minimum, queryctrl->maximum,
queryctrl->step, queryctrl->default_value);
break;
default:
printf("%31s (unknown): type=%x", s.c_str(), queryctrl->type);
break;
}
if (queryctrl->nr_of_dims == 0) {
switch (queryctrl->type) {
case V4L2_CTRL_TYPE_INTEGER:
case V4L2_CTRL_TYPE_BOOLEAN:
case V4L2_CTRL_TYPE_MENU:
case V4L2_CTRL_TYPE_INTEGER_MENU:
printf(" value=%d", ctrl->value);
break;
case V4L2_CTRL_TYPE_BITMASK:
printf(" value=0x%08x", ctrl->value);
break;
case V4L2_CTRL_TYPE_INTEGER64:
printf(" value=%lld", ctrl->value64);
break;
case V4L2_CTRL_TYPE_STRING:
printf(" value='%s'", safename(ctrl->string).c_str());
break;
default:
break;
}
}
if (queryctrl->nr_of_dims) {
printf(" ");
for (i = 0; i < queryctrl->nr_of_dims; i++)
printf("[%u]", queryctrl->dims[i]);
}
if (queryctrl->flags)
printf(" flags=%s", ctrlflags2s(queryctrl->flags).c_str());
printf("\n");
if ((queryctrl->type == V4L2_CTRL_TYPE_MENU ||
queryctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU) && show_menus) {
for (i = queryctrl->minimum; i <= queryctrl->maximum; i++) {
qmenu.index = i;
if (test_ioctl(fd, VIDIOC_QUERYMENU, &qmenu))
continue;
if (queryctrl->type == V4L2_CTRL_TYPE_MENU)
printf("\t\t\t\t%d: %s\n", i, qmenu.name);
else
printf("\t\t\t\t%d: %lld (0x%llx)\n", i, qmenu.value, qmenu.value);
}
}
}
void io_list(int fd)
{
if (options[OptListInputs]) {
struct v4l2_input vin;
vin.index = 0;
printf("ioctl: VIDIOC_ENUMINPUT\n");
while (test_ioctl(fd, VIDIOC_ENUMINPUT, &vin) >= 0) {
if (vin.index)
printf("\n");
printf("\tInput : %d\n", vin.index);
printf("\tName : %s\n", vin.name);
printf("\tType : 0x%08X\n", vin.type);
printf("\tAudioset : 0x%08X\n", vin.audioset);
printf("\tTuner : 0x%08X\n", vin.tuner);
printf("\tStandard : 0x%016llX (%s)\n", (unsigned long long)vin.std,
std2s(vin.std).c_str());
printf("\tStatus : 0x%08X (%s)\n", vin.status, status2s(vin.status).c_str());
printf("\tCapabilities: 0x%08X (%s)\n", vin.capabilities, input_cap2s(vin.capabilities).c_str());
vin.index++;
}
}
if (options[OptListOutputs]) {
struct v4l2_output vout;
vout.index = 0;
printf("ioctl: VIDIOC_ENUMOUTPUT\n");
while (test_ioctl(fd, VIDIOC_ENUMOUTPUT, &vout) >= 0) {
if (vout.index)
printf("\n");
printf("\tOutput : %d\n", vout.index);
printf("\tName : %s\n", vout.name);
printf("\tType : 0x%08X\n", vout.type);
printf("\tAudioset : 0x%08X\n", vout.audioset);
printf("\tStandard : 0x%016llX (%s)\n", (unsigned long long)vout.std,
std2s(vout.std).c_str());
printf("\tCapabilities: 0x%08X (%s)\n", vout.capabilities, output_cap2s(vout.capabilities).c_str());
vout.index++;
}
}
if (options[OptListAudioInputs]) {
struct v4l2_audio vaudio; /* list audio inputs */
vaudio.index = 0;
printf("ioctl: VIDIOC_ENUMAUDIO\n");
while (test_ioctl(fd, VIDIOC_ENUMAUDIO, &vaudio) >= 0) {
if (vaudio.index)
printf("\n");
printf("\tInput : %d\n", vaudio.index);
printf("\tName : %s\n", vaudio.name);
vaudio.index++;
}
}
if (options[OptListAudioOutputs]) {
struct v4l2_audioout vaudio; /* list audio outputs */
vaudio.index = 0;
printf("ioctl: VIDIOC_ENUMAUDOUT\n");
while (test_ioctl(fd, VIDIOC_ENUMAUDOUT, &vaudio) >= 0) {
if (vaudio.index)
printf("\n");
printf("\tOutput : %d\n", vaudio.index);
printf("\tName : %s\n", vaudio.name);
vaudio.index++;
}
}
}
static int do_handle_cap(int fd, buffers &b, FILE *fout,
unsigned &count, unsigned &last, struct timeval &tv_last)
{
char ch = '<';
int ret;
struct v4l2_plane planes[VIDEO_MAX_PLANES];
struct v4l2_buffer buf;
bool ignore_count_skip = false;
memset(&buf, 0, sizeof(buf));
memset(planes, 0, sizeof(planes));
/*
* The stream_count and stream_skip does not apply to capture path of
* M2M devices.
*/
if ((capabilities & V4L2_CAP_VIDEO_M2M) ||
(capabilities & V4L2_CAP_VIDEO_M2M_MPLANE))
ignore_count_skip = true;
buf.type = b.type;
buf.memory = b.memory;
if (b.is_mplane) {
buf.m.planes = planes;
buf.length = VIDEO_MAX_PLANES;
}
ret = test_ioctl(fd, VIDIOC_DQBUF, &buf);
if (ret < 0 && errno == EAGAIN)
return 0;
if (ret < 0) {
fprintf(stderr, "%s: failed: %s\n", "VIDIOC_DQBUF", strerror(errno));
return -1;
}
if (fout && (!stream_skip || ignore_count_skip)) {
for (unsigned j = 0; j < b.num_planes; j++) {
unsigned used = b.is_mplane ? planes[j].bytesused : buf.bytesused;
unsigned offset = b.is_mplane ? planes[j].data_offset : 0;
unsigned sz;
if (offset > used) {
// Should never happen
fprintf(stderr, "offset %d > used %d!\n",
offset, used);
offset = 0;
}
used -= offset;
sz = fwrite((char *)b.bufs[buf.index][j] + offset, 1, used, fout);
if (sz != used)
fprintf(stderr, "%u != %u\n", sz, used);
}
}
if (buf.flags & V4L2_BUF_FLAG_KEYFRAME)
ch = 'K';
else if (buf.flags & V4L2_BUF_FLAG_PFRAME)
ch = 'P';
else if (buf.flags & V4L2_BUF_FLAG_BFRAME)
ch = 'B';
if (verbose)
print_buffer(stderr, buf);
if (test_ioctl(fd, VIDIOC_QBUF, &buf))
return -1;
if (!verbose) {
fprintf(stderr, "%c", ch);
fflush(stderr);
}
if (count == 0) {
gettimeofday(&tv_last, NULL);
} else {
struct timeval tv_cur, res;
gettimeofday(&tv_cur, NULL);
timersub(&tv_cur, &tv_last, &res);
if (res.tv_sec) {
unsigned fps = (100 * (count - last)) /
(res.tv_sec * 100 + res.tv_usec / 10000);
last = count;
tv_last = tv_cur;
fprintf(stderr, " %d fps\n", fps);
}
}
count++;
if (ignore_count_skip)
return 0;
if (stream_skip) {
stream_skip--;
return 0;
}
if (stream_count == 0)
return 0;
if (--stream_count == 0)
return -1;
return 0;
}
