void ApplicationWindow::addTabs()
{
struct v4l2_queryctrl qctrl;
unsigned ctrl_class;
unsigned i;
int id;
memset(&qctrl, 0, sizeof(qctrl));
qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;
while (::ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0) {
if ((qctrl.flags & V4L2_CTRL_FLAG_DISABLED) == 0) {
ctrlMap[qctrl.id] = qctrl;
if (qctrl.type != V4L2_CTRL_TYPE_CTRL_CLASS)
classMap[V4L2_CTRL_ID2CLASS(qctrl.id)].push_back(qctrl.id);
}
qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
}
if (qctrl.id == V4L2_CTRL_FLAG_NEXT_CTRL) {
strcpy((char *)qctrl.name, "User Controls");
qctrl.id = V4L2_CTRL_CLASS_USER | 1;
qctrl.type = V4L2_CTRL_TYPE_CTRL_CLASS;
ctrlMap[qctrl.id] = qctrl;
for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
qctrl.id = id;
if (::ioctl(fd, VIDIOC_QUERYCTRL, &qctrl))
continue;
if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
continue;
ctrlMap[qctrl.id] = qctrl;
classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
}
for (qctrl.id = V4L2_CID_PRIVATE_BASE;
::ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0; qctrl.id++) {
if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
continue;
ctrlMap[qctrl.id] = qctrl;
classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
}
}
for (ClassMap::iterator iter = classMap.begin(); iter != classMap.end(); ++iter) {
ctrl_class = V4L2_CTRL_ID2CLASS(iter->second[0]);
id = ctrl_class | 1;
const struct v4l2_queryctrl &qctrl = ctrlMap[id];
QVBox *vbox = new QVBox(tabs);
QGrid *grid = new QGrid(4, vbox);
grid->setSpacing(3);
tabs->addTab(vbox, (char *)qctrl.name);
for (i = 0; i < iter->second.size(); i++) {
if (i & 1)
id = iter->second[(1+iter->second.size()) / 2 + i / 2];
else
id = iter->second[i / 2];
addCtrl(grid, ctrlMap[id]);
}
finishGrid(vbox, grid, ctrl_class, i & 1);
}
}
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;
}
int v4l2_hls_model(int fd, char *model)
{
struct v4l2_queryctrl query;
struct v4l2_ext_controls ctrls;
struct v4l2_ext_control ctrl;
int ret;
memset(&query, 0, sizeof(query));
memset(&ctrls, 0, sizeof(ctrls));
memset(&ctrl, 0, sizeof(ctrl));
query.id = V4L2_CID_XILINX_HLS_MODEL;
ret = ioctl(fd, VIDIOC_QUERYCTRL, &query);
ASSERT(ret < 0, "VIDIOC_QUERYCTRL failed: %s\n", ERRSTR);
ASSERT(query.type != V4L2_CTRL_TYPE_STRING, "Incorrect control type, string expected\n");
ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(query.id);
ctrls.count = 1;
ctrls.controls = &ctrl;
ctrl.id = query.id;
ctrl.size = query.maximum + 1;
ctrl.string = model;
ret = ioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls);
ASSERT(ret < 0, "VIDIOC_G_EXT_CTRLS failed: %s\n", ERRSTR);
return VLIB_SUCCESS;
}
static int empress_querymenu(struct file *file, void *priv,
struct v4l2_querymenu *c)
{
struct saa7134_dev *dev = file->private_data;
if (V4L2_CTRL_ID2CLASS(c->id) != V4L2_CTRL_CLASS_MPEG)
return -EINVAL;
return saa_call_empress(dev, core, querymenu, c);
}
void ApplicationWindow::updateCtrl(unsigned id)
{
unsigned ctrl_class = V4L2_CTRL_ID2CLASS(id);
if (ctrl_class == V4L2_CID_PRIVATE_BASE)
ctrl_class = V4L2_CTRL_CLASS_USER;
if (m_ctrlMap[id].flags & CTRL_FLAG_DISABLED)
return;
if (!m_haveExtendedUserCtrls && ctrl_class == V4L2_CTRL_CLASS_USER) {
struct v4l2_control c;
c.id = id;
c.value = getVal(id);
if (ioctl(VIDIOC_S_CTRL, &c)) {
errorCtrl(id, errno, c.value);
}
else if (m_ctrlMap[id].flags & V4L2_CTRL_FLAG_UPDATE)
refresh(ctrl_class);
return;
}
struct v4l2_ext_control c;
struct v4l2_ext_controls ctrls;
memset(&c, 0, sizeof(c));
memset(&ctrls, 0, sizeof(ctrls));
c.id = id;
if (m_ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
c.value64 = getVal64(id);
else if (m_ctrlMap[id].type == V4L2_CTRL_TYPE_STRING) {
c.size = m_ctrlMap[id].maximum + 1;
c.string = (char *)malloc(c.size);
strcpy(c.string, getString(id).toLatin1());
}
else
c.value = getVal(id);
ctrls.count = 1;
ctrls.ctrl_class = ctrl_class;
ctrls.controls = &c;
if (ioctl(VIDIOC_S_EXT_CTRLS, &ctrls)) {
errorCtrl(id, errno, c.value);
}
else if (m_ctrlMap[id].flags & V4L2_CTRL_FLAG_UPDATE)
refresh(ctrl_class);
else {
if (m_ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
setVal64(id, c.value64);
else if (m_ctrlMap[id].type == V4L2_CTRL_TYPE_STRING) {
setString(id, c.string);
free(c.string);
}
else
setVal(id, c.value);
}
}
void ApplicationWindow::updateCtrl(unsigned id)
{
unsigned ctrl_class = V4L2_CTRL_ID2CLASS(id);
if (ctrl_class == V4L2_CID_PRIVATE_BASE)
ctrl_class = V4L2_CTRL_CLASS_USER;
if (ctrlMap[id].flags & (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE))
return;
if (ctrl_class == V4L2_CTRL_CLASS_USER) {
struct v4l2_control c;
c.id = id;
c.value = getVal(id);
if (::ioctl(fd, VIDIOC_S_CTRL, &c)) {
int err = errno;
char buf[200];
sprintf(buf, "Error %08x (%s): %s", id,
ctrlMap[id].name, strerror(err));
statusBar()->message(buf, 10000);
}
return;
}
struct v4l2_ext_control c;
struct v4l2_ext_controls ctrls;
memset(&c, 0, sizeof(c));
memset(&ctrls, 0, sizeof(ctrls));
c.id = id;
if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
c.value64 = getVal64(id);
else
c.value = getVal(id);
ctrls.count = 1;
ctrls.ctrl_class = ctrl_class;
ctrls.controls = &c;
if (::ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls)) {
int err = errno;
char buf[200];
sprintf(buf, "Error %08x (%s): %s", id,
ctrlMap[id].name, strerror(err));
statusBar()->message(buf, 10000);
}
else if (ctrlMap[id].flags & V4L2_CTRL_FLAG_UPDATE)
refresh(ctrl_class);
else {
if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
setVal64(id, c.value64);
else
setVal(id, c.value);
}
}
/* ctrl_classes points to an array of u32 pointers, the last element is
a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
Each array must be sorted low to high and belong to the same control
class. The array of u32 pointers must also be sorted, from low class IDs
to high class IDs.
This function returns the first ID that follows after the given ID.
When no more controls are available 0 is returned. */
u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
{
u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
const u32 *pctrl;
if (ctrl_classes == NULL)
return 0;
/* if no query is desired, then check if the ID is part of ctrl_classes */
if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
/* find class */
while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
ctrl_classes++;
if (*ctrl_classes == NULL)
return 0;
pctrl = *ctrl_classes;
/* find control ID */
while (*pctrl && *pctrl != id) pctrl++;
return *pctrl ? id : 0;
}
id &= V4L2_CTRL_ID_MASK;
id++; /* select next control */
/* find first class that matches (or is greater than) the class of
the ID */
while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
ctrl_classes++;
/* no more classes */
if (*ctrl_classes == NULL)
return 0;
pctrl = *ctrl_classes;
/* find first ctrl within the class that is >= ID */
while (*pctrl && *pctrl < id) pctrl++;
if (*pctrl)
return *pctrl;
/* we are at the end of the controls of the current class. */
/* continue with next class if available */
ctrl_classes++;
if (*ctrl_classes == NULL)
return 0;
return **ctrl_classes;
}
u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
{
u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
const u32 *pctrl;
if (ctrl_classes == NULL)
return 0;
if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
ctrl_classes++;
if (*ctrl_classes == NULL)
return 0;
pctrl = *ctrl_classes;
while (*pctrl && *pctrl != id) pctrl++;
return *pctrl ? id : 0;
}
id &= V4L2_CTRL_ID_MASK;
id++;
while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
ctrl_classes++;
if (*ctrl_classes == NULL)
return 0;
pctrl = *ctrl_classes;
while (*pctrl && *pctrl < id) pctrl++;
if (*pctrl)
return *pctrl;
ctrl_classes++;
if (*ctrl_classes == NULL)
return 0;
return **ctrl_classes;
}
static int empress_queryctrl(struct file *file, void *priv,
struct v4l2_queryctrl *c)
{
/* Must be sorted from low to high control ID! */
static const u32 user_ctrls[] = {
V4L2_CID_USER_CLASS,
V4L2_CID_BRIGHTNESS,
V4L2_CID_CONTRAST,
V4L2_CID_SATURATION,
V4L2_CID_HUE,
V4L2_CID_AUDIO_VOLUME,
V4L2_CID_AUDIO_MUTE,
V4L2_CID_HFLIP,
0
};
/* Must be sorted from low to high control ID! */
static const u32 mpeg_ctrls[] = {
V4L2_CID_MPEG_CLASS,
V4L2_CID_MPEG_STREAM_TYPE,
V4L2_CID_MPEG_STREAM_PID_PMT,
V4L2_CID_MPEG_STREAM_PID_AUDIO,
V4L2_CID_MPEG_STREAM_PID_VIDEO,
V4L2_CID_MPEG_STREAM_PID_PCR,
V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
V4L2_CID_MPEG_AUDIO_ENCODING,
V4L2_CID_MPEG_AUDIO_L2_BITRATE,
V4L2_CID_MPEG_VIDEO_ENCODING,
V4L2_CID_MPEG_VIDEO_ASPECT,
V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
V4L2_CID_MPEG_VIDEO_BITRATE,
V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
0
};
static const u32 *ctrl_classes[] = {
user_ctrls,
mpeg_ctrls,
NULL
};
struct saa7134_dev *dev = file->private_data;
c->id = v4l2_ctrl_next(ctrl_classes, c->id);
if (c->id == 0)
return -EINVAL;
if (c->id == V4L2_CID_USER_CLASS || c->id == V4L2_CID_MPEG_CLASS)
return v4l2_ctrl_query_fill(c, 0, 0, 0, 0);
if (V4L2_CTRL_ID2CLASS(c->id) != V4L2_CTRL_CLASS_MPEG)
return saa7134_queryctrl(file, priv, c);
return saa_call_empress(dev, core, queryctrl, c);
}
static int print_control(int fd, struct v4l2_queryctrl &qctrl, int show_menus)
{
struct v4l2_control ctrl = { 0 };
struct v4l2_ext_control ext_ctrl = { 0 };
struct v4l2_ext_controls ctrls = { 0 };
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;
ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(qctrl.id);
ctrls.count = 1;
ctrls.controls = &ext_ctrl;
if (V4L2_CTRL_ID2CLASS(qctrl.id) != V4L2_CTRL_CLASS_USER &&
qctrl.id < V4L2_CID_PRIVATE_BASE) {
if (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 (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);
return 1;
}
void test_VIDIOC_QUERYCTRL_flag_NEXT_CTRL() {
int ret_query, errno_query;
char count_controls1[V4L2_CID_LASTP1-V4L2_CID_BASE];
char count_controls2[V4L2_CID_LASTP1-V4L2_CID_BASE];
struct v4l2_queryctrl controls[V4L2_CID_LASTP1-V4L2_CID_BASE];
struct v4l2_queryctrl queryctrl;
__u32 i;
/* find out all the possible user controls */
memset(count_controls1, 0, sizeof(count_controls1));
memset(controls, 0, sizeof(controls));
for (i = V4L2_CID_BASE; i < V4L2_CID_LASTP1; i++) {
memset(&queryctrl, 0xff, sizeof(queryctrl));
queryctrl.id = i;
ret_query = ioctl(get_video_fd(), VIDIOC_QUERYCTRL, &queryctrl);
errno_query = errno;
if (ret_query == 0) {
CU_ASSERT_EQUAL(ret_query, 0);
CU_ASSERT_EQUAL(queryctrl.id, i);
count_controls1[i-V4L2_CID_BASE]++;
controls[i-V4L2_CID_BASE] = queryctrl;
dprintf("\tqueryctrl = {.id=%u, .type=%i, .name=\"%s\", "
".minimum=%i, .maximum=%i, .step=%i, "
".default_value=%i, "
".flags=0x%X, "
".reserved[]={ 0x%X, 0x%X } }\n",
queryctrl.id,
queryctrl.type,
queryctrl.name,
queryctrl.minimum,
queryctrl.maximum,
queryctrl.step,
queryctrl.default_value,
queryctrl.flags,
queryctrl.reserved[0],
queryctrl.reserved[1]
);
} else {
CU_ASSERT_EQUAL(ret_query, -1);
CU_ASSERT_EQUAL(errno_query, EINVAL);
}
}
/* enumerate the controls with V4L2_CTRL_FLAG_NEXT_CTRL */
dprintf1("\tStarting enumeration with V4L2_CTRL_FLAG_NEXT_CTRL\n");
memset(count_controls2, 0, sizeof(count_controls2));
/* As described at V4L2 Chapter 1.9.3. Enumerating Extended Controls */
i = 0;
memset(&queryctrl, 0xff, sizeof(queryctrl));
queryctrl.id = i | V4L2_CTRL_FLAG_NEXT_CTRL;
dprintf("\tasking for id=%i=V4L2_CID_BASE+%i | V4L2_CTRL_FLAG_NEXT_CTRL\n", i, i-V4L2_CID_BASE);
ret_query = ioctl(get_video_fd(), VIDIOC_QUERYCTRL, &queryctrl);
errno_query = errno;
dprintf("\tret_query=%i\n", ret_query);
if (ret_query == 0) {
do {
/* protect the count_controls2[] from overindexing */
if ((V4L2_CID_BASE <= queryctrl.id) && (queryctrl.id < V4L2_CID_LASTP1)) {
count_controls2[queryctrl.id-V4L2_CID_BASE]++;
CU_ASSERT_EQUAL(memcmp(&queryctrl, &controls[queryctrl.id-V4L2_CID_BASE], sizeof(queryctrl)), 0);
}
/* "The VIDIOC_QUERYCTRL ioctl will return the first
* control with a higher ID than the specified one."
*/
CU_ASSERT(i < queryctrl.id);
CU_ASSERT(V4L2_CID_BASE <= queryctrl.id);
CU_ASSERT(queryctrl.id < V4L2_CID_LASTP1);
dprintf("\tqueryctrl = {.id=%u, .type=%i, .name=\"%s\", "
".minimum=%i, .maximum=%i, .step=%i, "
".default_value=%i, "
".flags=0x%X, "
".reserved[]={ 0x%X, 0x%X } }\n",
queryctrl.id,
queryctrl.type,
queryctrl.name,
queryctrl.minimum,
queryctrl.maximum,
queryctrl.step,
queryctrl.default_value,
queryctrl.flags,
queryctrl.reserved[0],
queryctrl.reserved[1]
);
i = queryctrl.id;
memset(&queryctrl, 0xff, sizeof(queryctrl));
queryctrl.id = i | V4L2_CTRL_FLAG_NEXT_CTRL;
dprintf("\tasking for id=%i=V4L2_CID_BASE+%i | V4L2_CTRL_FLAG_NEXT_CTRL\n", i, i-V4L2_CID_BASE);
ret_query = ioctl(get_video_fd(), VIDIOC_QUERYCTRL, &queryctrl);
errno_query = errno;
dprintf("\tret_query=%i\n", ret_query);
} while (ret_query == 0 && V4L2_CTRL_ID2CLASS(queryctrl.id) == V4L2_CTRL_CLASS_USER);
if (ret_query == 0) {
/* some other controls also exists, stop for now. */
} else {
CU_ASSERT_EQUAL(ret_query, -1);
CU_ASSERT_EQUAL(errno_query, EINVAL);
}
/* Check whether the same controls are reported if using
* V4L2_CTRL_FLAG_NEXT_CTRL and without using it.
* This also checks if one control is not reported twice.
*/
CU_ASSERT_EQUAL(memcmp(count_controls1, count_controls2, sizeof(count_controls1)), 0);
dprintf1("count_controls1 = { ");
for (i=0; i<sizeof(count_controls1)/sizeof(*count_controls1); i++) {
dprintf("%i ", count_controls1[i]);
}
dprintf1("}\n");
dprintf1("count_controls2 = { ");
for (i=0; i<sizeof(count_controls2)/sizeof(*count_controls2); i++) {
dprintf("%i ", count_controls2[i]);
}
dprintf1("}\n");
} else {
dprintf1("V4L2_CTRL_FLAG_NEXT_CTRL is not supported or no control is available\n");
/* The flag V4L2_CTRL_FLAG_NEXT_CTRL is not supported
* or no control is avaliable at all. Do not continue the
* enumeration.
*/
CU_ASSERT_EQUAL(ret_query, -1);
CU_ASSERT_EQUAL(errno_query, EINVAL);
}
}
int testExtendedControls(struct node *node)
{
qctrl_list::iterator iter;
struct v4l2_ext_controls ctrls;
std::vector<struct v4l2_ext_control> total_vec;
std::vector<struct v4l2_ext_control> class_vec;
struct v4l2_ext_control ctrl;
__u32 ctrl_class = 0;
bool multiple_classes = false;
int ret;
memset(&ctrls, 0, sizeof(ctrls));
ret = doioctl(node, VIDIOC_G_EXT_CTRLS, &ctrls);
if (ret == ENOTTY && node->controls.empty())
return ret;
if (ret)
return fail("g_ext_ctrls does not support count == 0\n");
if (node->controls.empty())
return fail("g_ext_ctrls worked even when no controls are present\n");
if (ctrls.ctrl_class)
return fail("field ctrl_class changed\n");
if (ctrls.count)
return fail("field count changed\n");
if (check_0(ctrls.reserved, sizeof(ctrls.reserved)))
return fail("reserved not zeroed\n");
memset(&ctrls, 0, sizeof(ctrls));
ret = doioctl(node, VIDIOC_TRY_EXT_CTRLS, &ctrls);
if (ret == ENOTTY && node->controls.empty())
return ret;
if (ret)
return fail("try_ext_ctrls does not support count == 0\n");
if (node->controls.empty())
return fail("try_ext_ctrls worked even when no controls are present\n");
if (ctrls.ctrl_class)
return fail("field ctrl_class changed\n");
if (ctrls.count)
return fail("field count changed\n");
if (check_0(ctrls.reserved, sizeof(ctrls.reserved)))
return fail("reserved not zeroed\n");
for (iter = node->controls.begin(); iter != node->controls.end(); ++iter) {
info("checking extended control '%s' (0x%08x)\n", iter->name, iter->id);
ctrl.id = iter->id;
ctrl.size = 0;
ctrl.reserved2[0] = 0;
ctrls.count = 1;
// Either should work, so try both semi-randomly
ctrls.ctrl_class = (ctrl.id & 1) ? 0 : V4L2_CTRL_ID2CLASS(ctrl.id);
ctrls.controls = &ctrl;
// Get the current value
ret = doioctl(node, VIDIOC_G_EXT_CTRLS, &ctrls);
if ((iter->flags & V4L2_CTRL_FLAG_WRITE_ONLY)) {
if (ret != EACCES)
return fail("g_ext_ctrls did not check the write-only flag\n");
if (ctrls.error_idx != ctrls.count)
return fail("invalid error index write only control\n");
ctrl.id = iter->id;
ctrl.value = iter->default_value;
} else {
if (ret != ENOSPC && iter->type == V4L2_CTRL_TYPE_STRING)
return fail("did not check against size\n");
if (ret == ENOSPC && iter->type == V4L2_CTRL_TYPE_STRING) {
if (ctrls.error_idx != 0)
return fail("invalid error index string control\n");
ctrl.string = new char[iter->maximum + 1];
ctrl.size = iter->maximum + 1;
ret = doioctl(node, VIDIOC_G_EXT_CTRLS, &ctrls);
}
if (ret == EIO) {
warn("g_ext_ctrls returned EIO\n");
ret = 0;
}
if (ret)
return fail("g_ext_ctrls returned an error (%d)\n", ret);
if (checkExtendedCtrl(ctrl, *iter))
return fail("invalid control %08x\n", iter->id);
}
// Try the current value (or the default value for write only controls)
ret = doioctl(node, VIDIOC_TRY_EXT_CTRLS, &ctrls);
if (iter->flags & V4L2_CTRL_FLAG_READ_ONLY) {
if (ret != EACCES)
return fail("try_ext_ctrls did not check the read-only flag\n");
if (ctrls.error_idx != 0)
return fail("invalid error index read only control\n");
} else if (ret) {
return fail("try_ext_ctrls returned an error\n");
}
// Try to set the current value (or the default value for write only controls)
ret = doioctl(node, VIDIOC_S_EXT_CTRLS, &ctrls);
if (iter->flags & V4L2_CTRL_FLAG_READ_ONLY) {
if (ret != EACCES)
return fail("s_ext_ctrls did not check the read-only flag\n");
if (ctrls.error_idx != ctrls.count)
return fail("invalid error index\n");
} else {
if (ret == EIO) {
warn("s_ext_ctrls returned EIO\n");
ret = 0;
}
if (ret)
return fail("s_ext_ctrls returned an error\n");
if (checkExtendedCtrl(ctrl, *iter))
return fail("s_ext_ctrls returned invalid control contents (%08x)\n", iter->id);
}
if (iter->type == V4L2_CTRL_TYPE_STRING)
delete [] ctrl.string;
ctrl.string = NULL;
}
ctrls.ctrl_class = 0;
ctrl.id = 0;
ctrl.size = 0;
ret = doioctl(node, VIDIOC_G_EXT_CTRLS, &ctrls);
if (ret != EINVAL)
return fail("g_ext_ctrls accepted invalid control ID\n");
if (ctrls.error_idx != ctrls.count)
return fail("g_ext_ctrls(0) invalid error_idx\n");
ctrl.id = 0;
ctrl.size = 0;
ctrl.value = 0;
ret = doioctl(node, VIDIOC_TRY_EXT_CTRLS, &ctrls);
if (ret != EINVAL)
return fail("try_ext_ctrls accepted invalid control ID\n");
if (ctrls.error_idx != 0)
return fail("try_ext_ctrls(0) invalid error_idx\n");
ret = doioctl(node, VIDIOC_S_EXT_CTRLS, &ctrls);
if (ret != EINVAL)
return fail("s_ext_ctrls accepted invalid control ID\n");
if (ctrls.error_idx != ctrls.count)
return fail("s_ext_ctrls(0) invalid error_idx\n");
for (iter = node->controls.begin(); iter != node->controls.end(); ++iter) {
struct v4l2_ext_control ctrl;
if (iter->flags & (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY))
continue;
ctrl.id = iter->id;
ctrl.size = 0;
if (iter->type == V4L2_CTRL_TYPE_STRING) {
ctrl.size = iter->maximum + 1;
ctrl.string = new char[ctrl.size];
}
ctrl.reserved2[0] = 0;
if (!ctrl_class)
ctrl_class = V4L2_CTRL_ID2CLASS(ctrl.id);
else if (ctrl_class != V4L2_CTRL_ID2CLASS(ctrl.id))
multiple_classes = true;
total_vec.push_back(ctrl);
}
ctrls.count = total_vec.size();
ctrls.controls = &total_vec[0];
ret = doioctl(node, VIDIOC_G_EXT_CTRLS, &ctrls);
if (ret)
return fail("could not get all controls\n");
ret = doioctl(node, VIDIOC_TRY_EXT_CTRLS, &ctrls);
if (ret)
return fail("could not try all controls\n");
ret = doioctl(node, VIDIOC_S_EXT_CTRLS, &ctrls);
if (ret == EIO) {
warn("s_ext_ctrls returned EIO\n");
ret = 0;
}
if (ret)
return fail("could not set all controls\n");
ctrls.ctrl_class = ctrl_class;
ret = doioctl(node, VIDIOC_G_EXT_CTRLS, &ctrls);
if (ret && !multiple_classes)
return fail("could not get all controls of a specific class\n");
if (ret != EINVAL && multiple_classes)
return fail("should get EINVAL when getting mixed-class controls\n");
if (multiple_classes && ctrls.error_idx != ctrls.count)
return fail("error_idx should be equal to count\n");
ret = doioctl(node, VIDIOC_TRY_EXT_CTRLS, &ctrls);
if (ret && !multiple_classes)
return fail("could not try all controls of a specific class\n");
if (ret != EINVAL && multiple_classes)
return fail("should get EINVAL when trying mixed-class controls\n");
if (multiple_classes && ctrls.error_idx >= ctrls.count)
return fail("error_idx should be < count\n");
ret = doioctl(node, VIDIOC_S_EXT_CTRLS, &ctrls);
if (ret == EIO) {
warn("s_ext_ctrls returned EIO\n");
ret = 0;
}
if (ret && !multiple_classes)
return fail("could not set all controls of a specific class\n");
if (ret != EINVAL && multiple_classes)
return fail("should get EINVAL when setting mixed-class controls\n");
if (multiple_classes && ctrls.error_idx != ctrls.count)
return fail("error_idx should be equal to count\n");
return 0;
}
int testQueryControls(struct node *node)
{
struct test_queryctrl qctrl;
__u32 id = 0;
int ret;
__u32 ctrl_class = 0;
bool found_ctrl_class = false;
unsigned user_controls = 0;
unsigned priv_user_controls = 0;
unsigned user_controls_check = 0;
unsigned priv_user_controls_check = 0;
unsigned class_count = 0;
for (;;) {
memset(&qctrl, 0xff, sizeof(qctrl));
qctrl.id = id | V4L2_CTRL_FLAG_NEXT_CTRL;
ret = doioctl(node, VIDIOC_QUERYCTRL, &qctrl);
if (ret == ENOTTY)
return ret;
if (ret && ret != EINVAL)
return fail("invalid queryctrl return code\n");
if (ret)
break;
if (checkQCtrl(node, qctrl))
return fail("invalid control %08x\n", qctrl.id);
if (qctrl.id <= id)
return fail("id did not increase!\n");
id = qctrl.id;
if (id >= V4L2_CID_PRIVATE_BASE)
return fail("no V4L2_CID_PRIVATE_BASE allowed\n");
if (V4L2_CTRL_ID2CLASS(id) != ctrl_class) {
if (ctrl_class && !found_ctrl_class)
return fail("missing control class for class %08x\n", ctrl_class);
if (ctrl_class && !class_count)
return fail("no controls in class %08x\n", ctrl_class);
ctrl_class = V4L2_CTRL_ID2CLASS(id);
found_ctrl_class = false;
class_count = 0;
}
if (qctrl.type == V4L2_CTRL_TYPE_CTRL_CLASS) {
found_ctrl_class = true;
} else {
class_count++;
}
if (ctrl_class == V4L2_CTRL_CLASS_USER &&
qctrl.type != V4L2_CTRL_TYPE_INTEGER64 &&
qctrl.type != V4L2_CTRL_TYPE_STRING &&
qctrl.type != V4L2_CTRL_TYPE_CTRL_CLASS) {
if (V4L2_CTRL_DRIVER_PRIV(id))
priv_user_controls_check++;
else if (id < V4L2_CID_LASTP1)
user_controls_check++;
}
if (V4L2_CTRL_DRIVER_PRIV(id))
node->priv_controls++;
else
node->std_controls++;
node->controls.push_back(qctrl);
}
if (ctrl_class && !found_ctrl_class)
return fail("missing control class for class %08x\n", ctrl_class);
if (ctrl_class && !class_count)
return fail("no controls in class %08x\n", ctrl_class);
for (id = V4L2_CID_BASE; id < V4L2_CID_LASTP1; id++) {
memset(&qctrl, 0xff, sizeof(qctrl));
qctrl.id = id;
ret = doioctl(node, VIDIOC_QUERYCTRL, &qctrl);
if (ret && ret != EINVAL)
return fail("invalid queryctrl return code\n");
if (ret)
continue;
if (qctrl.id != id)
return fail("qctrl.id (%08x) != id (%08x)\n",
qctrl.id, id);
if (checkQCtrl(node, qctrl))
return fail("invalid control %08x\n", qctrl.id);
user_controls++;
}
for (id = V4L2_CID_PRIVATE_BASE; ; id++) {
memset(&qctrl, 0xff, sizeof(qctrl));
qctrl.id = id;
ret = doioctl(node, VIDIOC_QUERYCTRL, &qctrl);
if (ret && ret != EINVAL)
return fail("invalid queryctrl return code\n");
if (ret)
break;
if (qctrl.id != id)
return fail("qctrl.id (%08x) != id (%08x)\n",
qctrl.id, id);
if (checkQCtrl(node, qctrl))
return fail("invalid control %08x\n", qctrl.id);
priv_user_controls++;
}
if (priv_user_controls + user_controls && node->controls.empty())
return fail("does not support V4L2_CTRL_FLAG_NEXT_CTRL\n");
if (user_controls != user_controls_check)
return fail("expected %d user controls, got %d\n",
user_controls_check, user_controls);
if (priv_user_controls != priv_user_controls_check)
return fail("expected %d private controls, got %d\n",
priv_user_controls_check, priv_user_controls);
return 0;
}
int main(int argc, char **argv)
{
char *value, *subs;
int i;
int fd = -1;
/* command args */
int ch;
const char *device = "/dev/video0"; /* -d device */
struct v4l2_capability vcap; /* list_cap */
char short_options[26 * 2 * 2 + 1];
int idx = 0;
if (argc == 1) {
usage();
return 0;
}
for (i = 0; long_options[i].name; i++) {
if (!isalpha(long_options[i].val))
continue;
short_options[idx++] = long_options[i].val;
if (long_options[i].has_arg == required_argument)
short_options[idx++] = ':';
}
while (1) {
int option_index = 0;
short_options[idx] = 0;
ch = getopt_long(argc, argv, short_options,
long_options, &option_index);
if (ch == -1)
break;
options[(int)ch] = 1;
switch (ch) {
case OptHelp:
usage();
return 0;
case OptSetDevice:
device = optarg;
if (device[0] >= '0' && device[0] <= '9' && device[1] == 0) {
static char newdev[20];
char dev = device[0];
sprintf(newdev, "/dev/video%c", dev);
device = newdev;
}
break;
case OptGetCtrl:
subs = optarg;
while (*subs != '\0') {
parse_next_subopt(&subs, &value);
if (strchr(value, '=')) {
usage();
exit(1);
}
else {
get_ctrls.push_back(value);
}
}
break;
case OptSetCtrl:
subs = optarg;
while (*subs != '\0') {
parse_next_subopt(&subs, &value);
if (const char *equal = strchr(value, '=')) {
set_ctrls[std::string(value, (equal - value))] = equal + 1;
}
else {
fprintf(stderr, "control '%s' without '='\n", value);
exit(1);
}
}
break;
case ':':
fprintf(stderr, "Option `%s' requires a value\n",
argv[optind]);
usage();
return 1;
case '?':
fprintf(stderr, "Unknown argument `%s'\n",
argv[optind]);
usage();
return 1;
}
}
if (optind < argc) {
printf("unknown arguments: ");
while (optind < argc)
printf("%s ", argv[optind++]);
printf("\n");
usage();
return 1;
}
if ((fd = open(device, O_RDWR)) < 0) {
fprintf(stderr, "Failed to open %s: %s\n", device,
strerror(errno));
exit(1);
}
doioctl(fd, VIDIOC_QUERYCAP, &vcap, "VIDIOC_QUERYCAP");
capabilities = vcap.capabilities;
find_controls(fd);
for (ctrl_get_list::iterator iter = get_ctrls.begin(); iter != get_ctrls.end(); ++iter) {
if (ctrl_str2id.find(*iter) == ctrl_str2id.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_str2id.find(iter->first) == ctrl_str2id.end()) {
fprintf(stderr, "unknown control '%s'\n", iter->first.c_str());
exit(1);
}
}
/* Information Opts */
if (options[OptSetCtrl] && !set_ctrls.empty()) {
struct v4l2_ext_controls ctrls = { 0 };
for (ctrl_set_map::iterator iter = set_ctrls.begin();
iter != set_ctrls.end(); ++iter) {
struct v4l2_ext_control ctrl = { 0 };
ctrl.id = ctrl_str2id[iter->first];
ctrl.value = strtol(iter->second.c_str(), NULL, 0);
if (V4L2_CTRL_ID2CLASS(ctrl.id) == V4L2_CTRL_CLASS_MPEG)
mpeg_ctrls.push_back(ctrl);
else
user_ctrls.push_back(ctrl);
}
for (unsigned i = 0; i < user_ctrls.size(); i++) {
struct v4l2_control ctrl;
ctrl.id = user_ctrls[i].id;
ctrl.value = user_ctrls[i].value;
if (doioctl(fd, VIDIOC_S_CTRL, &ctrl, "VIDIOC_S_CTRL")) {
fprintf(stderr, "%s: %s\n",
ctrl_id2str[ctrl.id].c_str(),
strerror(errno));
}
}
if (mpeg_ctrls.size()) {
ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
ctrls.count = mpeg_ctrls.size();
ctrls.controls = &mpeg_ctrls[0];
if (doioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls, "VIDIOC_S_EXT_CTRLS")) {
if (ctrls.error_idx >= ctrls.count) {
fprintf(stderr, "Error setting MPEG controls: %s\n",
strerror(errno));
}
else {
fprintf(stderr, "%s: %s\n",
ctrl_id2str[mpeg_ctrls[ctrls.error_idx].id].c_str(),
strerror(errno));
}
}
}
}
/* Get options */
if (options[OptGetCtrl] && !get_ctrls.empty()) {
struct v4l2_ext_controls ctrls = { 0 };
mpeg_ctrls.clear();
user_ctrls.clear();
for (ctrl_get_list::iterator iter = get_ctrls.begin();
iter != get_ctrls.end(); ++iter) {
struct v4l2_ext_control ctrl = { 0 };
ctrl.id = ctrl_str2id[*iter];
if (V4L2_CTRL_ID2CLASS(ctrl.id) == V4L2_CTRL_CLASS_MPEG)
mpeg_ctrls.push_back(ctrl);
else
user_ctrls.push_back(ctrl);
}
for (unsigned i = 0; i < user_ctrls.size(); i++) {
struct v4l2_control ctrl;
ctrl.id = user_ctrls[i].id;
doioctl(fd, VIDIOC_G_CTRL, &ctrl, "VIDIOC_G_CTRL");
printf("%s: %d\n", ctrl_id2str[ctrl.id].c_str(), ctrl.value);
}
if (mpeg_ctrls.size()) {
ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
ctrls.count = mpeg_ctrls.size();
ctrls.controls = &mpeg_ctrls[0];
doioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls, "VIDIOC_G_EXT_CTRLS");
for (unsigned i = 0; i < mpeg_ctrls.size(); i++) {
struct v4l2_ext_control ctrl = mpeg_ctrls[i];
printf("%s: %d\n", ctrl_id2str[ctrl.id].c_str(), ctrl.value);
}
}
}
if (options[OptListCtrlsMenus]) {
list_controls(fd, 1);
}
if (options[OptListCtrls]) {
list_controls(fd, 0);
}
close(fd);
exit(app_result);
}
void common_get(int fd)
{
if (options[OptGetCtrl] && !get_ctrls.empty()) {
struct v4l2_ext_controls ctrls;
class2ctrls_map class2ctrls;
bool use_ext_ctrls = false;
memset(&ctrls, 0, sizeof(ctrls));
for (ctrl_get_list::iterator iter = get_ctrls.begin();
iter != get_ctrls.end(); ++iter) {
struct v4l2_ext_control ctrl;
memset(&ctrl, 0, sizeof(ctrl));
ctrl.id = ctrl_str2q[*iter].id;
if (ctrl_str2q[*iter].type == V4L2_CTRL_TYPE_INTEGER64)
use_ext_ctrls = true;
if (ctrl_str2q[*iter].type == V4L2_CTRL_TYPE_STRING) {
use_ext_ctrls = true;
ctrl.size = ctrl_str2q[*iter].maximum + 1;
ctrl.string = (char *)malloc(ctrl.size);
ctrl.string[0] = 0;
}
if (V4L2_CTRL_DRIVER_PRIV(ctrl.id))
use_ext_ctrls = true;
class2ctrls[V4L2_CTRL_ID2CLASS(ctrl.id)].push_back(ctrl);
}
for (class2ctrls_map::iterator iter = class2ctrls.begin();
iter != class2ctrls.end(); ++iter) {
if (!use_ext_ctrls &&
(iter->first == V4L2_CTRL_CLASS_USER ||
iter->first == V4L2_CID_PRIVATE_BASE)) {
for (unsigned i = 0; i < iter->second.size(); i++) {
struct v4l2_control ctrl;
ctrl.id = iter->second[i].id;
doioctl(fd, VIDIOC_G_CTRL, &ctrl);
printf("%s: %d\n", ctrl_id2str[ctrl.id].c_str(), ctrl.value);
}
continue;
}
if (iter->second.size()) {
ctrls.ctrl_class = iter->first;
ctrls.count = iter->second.size();
ctrls.controls = &iter->second[0];
doioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls);
for (unsigned i = 0; i < iter->second.size(); i++) {
struct v4l2_ext_control ctrl = iter->second[i];
if (ctrl_str2q[ctrl_id2str[ctrl.id]].type == V4L2_CTRL_TYPE_STRING)
printf("%s: '%s'\n", ctrl_id2str[ctrl.id].c_str(),
safename(ctrl.string).c_str());
else
printf("%s: %d\n", ctrl_id2str[ctrl.id].c_str(), ctrl.value);
}
}
}
}
if (options[OptGetPriority]) {
if (doioctl(fd, VIDIOC_G_PRIORITY, &prio) == 0)
printf("Priority: %d\n", prio);
}
if (options[OptLogStatus]) {
static char buf[40960];
int len = -1;
if (doioctl(fd, VIDIOC_LOG_STATUS, NULL) == 0) {
printf("\nStatus Log:\n\n");
#ifdef HAVE_KLOGCTL
len = klogctl(3, buf, sizeof(buf) - 1);
#endif
if (len >= 0) {
char *p = buf;
char *q;
buf[len] = 0;
while ((q = strstr(p, "START STATUS"))) {
p = q + 1;
}
if (p) {
while (p > buf && *p != '<') p--;
q = p;
while ((q = strstr(q, "<6>"))) {
memcpy(q, " ", 3);
}
printf("%s", p);
}
}
}
}
}
void ApplicationWindow::addTabs()
{
v4l2_queryctrl qctrl;
unsigned ctrl_class;
unsigned i;
int id;
memset(&qctrl, 0, sizeof(qctrl));
qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;
while (queryctrl(qctrl)) {
if (is_valid_type(qctrl.type) &&
(qctrl.flags & V4L2_CTRL_FLAG_DISABLED) == 0) {
m_ctrlMap[qctrl.id] = qctrl;
if (qctrl.type != V4L2_CTRL_TYPE_CTRL_CLASS)
m_classMap[V4L2_CTRL_ID2CLASS(qctrl.id)].push_back(qctrl.id);
}
qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
}
if (qctrl.id == V4L2_CTRL_FLAG_NEXT_CTRL) {
strcpy((char *)qctrl.name, "User Controls");
qctrl.id = V4L2_CTRL_CLASS_USER | 1;
qctrl.type = V4L2_CTRL_TYPE_CTRL_CLASS;
m_ctrlMap[qctrl.id] = qctrl;
for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
qctrl.id = id;
if (!queryctrl(qctrl))
continue;
if (!is_valid_type(qctrl.type))
continue;
if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
continue;
m_ctrlMap[qctrl.id] = qctrl;
m_classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
}
for (qctrl.id = V4L2_CID_PRIVATE_BASE;
queryctrl(qctrl); qctrl.id++) {
if (!is_valid_type(qctrl.type))
continue;
if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
continue;
m_ctrlMap[qctrl.id] = qctrl;
m_classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
}
}
m_haveExtendedUserCtrls = false;
for (unsigned i = 0; i < m_classMap[V4L2_CTRL_CLASS_USER].size(); i++) {
unsigned id = m_classMap[V4L2_CTRL_CLASS_USER][i];
if (m_ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64 ||
m_ctrlMap[id].type == V4L2_CTRL_TYPE_STRING ||
V4L2_CTRL_DRIVER_PRIV(id)) {
m_haveExtendedUserCtrls = true;
break;
}
}
for (ClassMap::iterator iter = m_classMap.begin(); iter != m_classMap.end(); ++iter) {
if (iter->second.size() == 0)
continue;
ctrl_class = V4L2_CTRL_ID2CLASS(iter->second[0]);
id = ctrl_class | 1;
m_col = m_row = 0;
m_cols = 4;
const v4l2_queryctrl &qctrl = m_ctrlMap[id];
QWidget *t = new QWidget(m_tabs);
QVBoxLayout *vbox = new QVBoxLayout(t);
QWidget *w = new QWidget(t);
vbox->addWidget(w);
QGridLayout *grid = new QGridLayout(w);
grid->setSpacing(3);
m_tabs->addTab(t, (char *)qctrl.name);
for (i = 0; i < iter->second.size(); i++) {
if (i & 1)
id = iter->second[(1+iter->second.size()) / 2 + i / 2];
else
id = iter->second[i / 2];
addCtrl(grid, m_ctrlMap[id]);
}
grid->addWidget(new QWidget(w), grid->rowCount(), 0, 1, m_cols);
grid->setRowStretch(grid->rowCount() - 1, 1);
w = new QWidget(t);
vbox->addWidget(w);
grid = new QGridLayout(w);
finishGrid(grid, ctrl_class);
}
}
void common_set(int fd)
{
if (options[OptSetPriority]) {
if (doioctl(fd, VIDIOC_S_PRIORITY, &prio) >= 0) {
printf("Priority set: %d\n", prio);
}
}
if (options[OptSetCtrl] && !set_ctrls.empty()) {
struct v4l2_ext_controls ctrls;
class2ctrls_map class2ctrls;
bool use_ext_ctrls = false;
memset(&ctrls, 0, sizeof(ctrls));
for (ctrl_set_map::iterator iter = set_ctrls.begin();
iter != set_ctrls.end(); ++iter) {
struct v4l2_ext_control ctrl;
memset(&ctrl, 0, sizeof(ctrl));
ctrl.id = ctrl_str2q[iter->first].id;
if (ctrl_str2q[iter->first].type == V4L2_CTRL_TYPE_INTEGER64)
use_ext_ctrls = true;
if (ctrl_str2q[iter->first].type == V4L2_CTRL_TYPE_STRING) {
unsigned len = iter->second.length();
unsigned maxlen = ctrl_str2q[iter->first].maximum;
use_ext_ctrls = true;
ctrl.size = maxlen + 1;
ctrl.string = (char *)malloc(ctrl.size);
if (len > maxlen) {
memcpy(ctrl.string, iter->second.c_str(), maxlen);
ctrl.string[maxlen] = 0;
}
else {
strcpy(ctrl.string, iter->second.c_str());
}
} else {
if (V4L2_CTRL_DRIVER_PRIV(ctrl.id))
use_ext_ctrls = true;
ctrl.value = strtol(iter->second.c_str(), NULL, 0);
}
class2ctrls[V4L2_CTRL_ID2CLASS(ctrl.id)].push_back(ctrl);
}
for (class2ctrls_map::iterator iter = class2ctrls.begin();
iter != class2ctrls.end(); ++iter) {
if (!use_ext_ctrls &&
(iter->first == V4L2_CTRL_CLASS_USER ||
iter->first == V4L2_CID_PRIVATE_BASE)) {
for (unsigned i = 0; i < iter->second.size(); i++) {
struct v4l2_control ctrl;
ctrl.id = iter->second[i].id;
ctrl.value = iter->second[i].value;
if (doioctl(fd, VIDIOC_S_CTRL, &ctrl)) {
fprintf(stderr, "%s: %s\n",
ctrl_id2str[ctrl.id].c_str(),
strerror(errno));
}
}
continue;
}
if (iter->second.size()) {
ctrls.ctrl_class = iter->first;
ctrls.count = iter->second.size();
ctrls.controls = &iter->second[0];
if (doioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls)) {
if (ctrls.error_idx >= ctrls.count) {
fprintf(stderr, "Error setting MPEG controls: %s\n",
strerror(errno));
}
else {
fprintf(stderr, "%s: %s\n",
ctrl_id2str[iter->second[ctrls.error_idx].id].c_str(),
strerror(errno));
}
}
}
}
}
}
void ApplicationWindow::ctrlAction(int id)
{
unsigned ctrl_class = V4L2_CTRL_ID2CLASS(id);
if (ctrl_class == V4L2_CID_PRIVATE_BASE)
ctrl_class = V4L2_CTRL_CLASS_USER;
unsigned ctrl = id & 0xffff;
QCheckBox *cbox = static_cast<QCheckBox *>(widgetMap[ctrl_class | CTRL_UPDATE_ON_CHANGE]);
bool update = cbox->isChecked();
bool all = (ctrl == CTRL_UPDATE || (update && ctrl == CTRL_UPDATE_ON_CHANGE));
if (ctrl == CTRL_DEFAULTS) {
setDefaults(ctrl_class);
return;
}
if (ctrl == CTRL_REFRESH) {
refresh(ctrl_class);
return;
}
if (!update && !all && ctrlMap[id].type != V4L2_CTRL_TYPE_BUTTON)
return;
if (ctrl_class == V4L2_CTRL_CLASS_USER) {
if (!all) {
updateCtrl(id);
return;
}
for (unsigned i = 0; i < classMap[ctrl_class].size(); i++) {
updateCtrl(classMap[ctrl_class][i]);
}
return;
}
if (!all) {
updateCtrl(id);
return;
}
unsigned count = classMap[ctrl_class].size();
struct v4l2_ext_control *c = new v4l2_ext_control[count];
struct v4l2_ext_controls ctrls;
int idx = 0;
for (unsigned i = 0; i < count; i++) {
unsigned id = classMap[ctrl_class][i];
if (ctrlMap[id].flags & (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE))
continue;
c[idx].id = id;
if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
c[idx].value64 = getVal64(id);
else
c[idx].value = getVal(id);
idx++;
}
memset(&ctrls, 0, sizeof(ctrls));
ctrls.count = idx;
ctrls.ctrl_class = ctrl_class;
ctrls.controls = c;
if (::ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls)) {
int err = errno;
if (ctrls.error_idx >= ctrls.count) {
printf("error: %s\n", strerror(err));
}
else {
id = c[ctrls.error_idx].id;
printf("error %08x (%s): %s\n", id,
ctrlMap[id].name, strerror(err));
}
}
delete [] c;
refresh(ctrl_class);
}
void ApplicationWindow::ctrlAction(int id)
{
unsigned ctrl_class = V4L2_CTRL_ID2CLASS(id);
if (ctrl_class == V4L2_CID_PRIVATE_BASE)
ctrl_class = V4L2_CTRL_CLASS_USER;
unsigned ctrl = id & 0xffff;
QCheckBox *cbox = static_cast<QCheckBox *>(m_widgetMap[ctrl_class | CTRL_UPDATE_ON_CHANGE]);
bool update = cbox->isChecked();
bool all = (ctrl == CTRL_UPDATE || (update && ctrl == CTRL_UPDATE_ON_CHANGE));
if (ctrl == CTRL_DEFAULTS) {
setDefaults(ctrl_class);
return;
}
if (ctrl == CTRL_REFRESH) {
refresh(ctrl_class);
return;
}
if (m_ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER &&
(m_ctrlMap[id].flags & V4L2_CTRL_FLAG_SLIDER)) {
QWidget *w = m_widgetMap[id];
int v = static_cast<QSlider *>(w)->value();
info(QString("Value: %1").arg(v));
}
if (!update && !all && m_ctrlMap[id].type != V4L2_CTRL_TYPE_BUTTON)
return;
if (!m_haveExtendedUserCtrls && ctrl_class == V4L2_CTRL_CLASS_USER) {
if (!all) {
updateCtrl(id);
return;
}
for (unsigned i = 0; i < m_classMap[ctrl_class].size(); i++) {
updateCtrl(m_classMap[ctrl_class][i]);
}
return;
}
if (!all) {
updateCtrl(id);
return;
}
unsigned count = m_classMap[ctrl_class].size();
struct v4l2_ext_control *c = new v4l2_ext_control[count];
struct v4l2_ext_controls ctrls;
int idx = 0;
for (unsigned i = 0; i < count; i++) {
unsigned id = m_classMap[ctrl_class][i];
if (m_ctrlMap[id].flags & CTRL_FLAG_DISABLED)
continue;
c[idx].id = id;
c[idx].size = 0;
if (m_ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
c[idx].value64 = getVal64(id);
else if (m_ctrlMap[id].type == V4L2_CTRL_TYPE_STRING) {
c[idx].size = m_ctrlMap[id].maximum + 1;
c[idx].string = (char *)malloc(c[idx].size);
strcpy(c[idx].string, getString(id).toLatin1());
}
else
c[idx].value = getVal(id);
idx++;
}
memset(&ctrls, 0, sizeof(ctrls));
ctrls.count = idx;
ctrls.ctrl_class = ctrl_class;
ctrls.controls = c;
if (ioctl(VIDIOC_S_EXT_CTRLS, &ctrls)) {
if (ctrls.error_idx >= ctrls.count) {
error(errno);
}
else {
errorCtrl(c[ctrls.error_idx].id, errno);
}
}
for (unsigned i = 0; i < ctrls.count; i++) {
if (c[i].size)
free(c[i].string);
}
delete [] c;
refresh(ctrl_class);
}
void common_get(int fd)
{
if (options[OptGetCtrl] && !get_ctrls.empty()) {
struct v4l2_ext_controls ctrls;
class2ctrls_map class2ctrls;
bool use_ext_ctrls = false;
memset(&ctrls, 0, sizeof(ctrls));
for (ctrl_get_list::iterator iter = get_ctrls.begin();
iter != get_ctrls.end(); ++iter) {
struct v4l2_ext_control ctrl;
struct v4l2_query_ext_ctrl &qc = ctrl_str2q[*iter];
memset(&ctrl, 0, sizeof(ctrl));
ctrl.id = qc.id;
if (qc.type == V4L2_CTRL_TYPE_INTEGER64)
use_ext_ctrls = true;
if (qc.flags & V4L2_CTRL_FLAG_HAS_PAYLOAD) {
use_ext_ctrls = true;
ctrl.size = qc.elems * qc.elem_size;
ctrl.ptr = calloc(1, ctrl.size);
}
if (V4L2_CTRL_DRIVER_PRIV(ctrl.id))
use_ext_ctrls = true;
class2ctrls[V4L2_CTRL_ID2CLASS(ctrl.id)].push_back(ctrl);
}
for (class2ctrls_map::iterator iter = class2ctrls.begin();
iter != class2ctrls.end(); ++iter) {
if (!use_ext_ctrls &&
(iter->first == V4L2_CTRL_CLASS_USER ||
iter->first == V4L2_CID_PRIVATE_BASE)) {
for (unsigned i = 0; i < iter->second.size(); i++) {
struct v4l2_control ctrl;
ctrl.id = iter->second[i].id;
doioctl(fd, VIDIOC_G_CTRL, &ctrl);
printf("%s: %d\n", ctrl_id2str[ctrl.id].c_str(), ctrl.value);
}
continue;
}
if (iter->second.size()) {
ctrls.ctrl_class = iter->first;
ctrls.count = iter->second.size();
ctrls.controls = &iter->second[0];
doioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls);
for (unsigned i = 0; i < iter->second.size(); i++) {
struct v4l2_ext_control ctrl = iter->second[i];
std::string &name = ctrl_id2str[ctrl.id];
struct v4l2_query_ext_ctrl &qc = ctrl_str2q[name];
if (qc.flags & V4L2_CTRL_FLAG_HAS_PAYLOAD) {
switch (qc.type) {
case V4L2_CTRL_TYPE_U8:
case V4L2_CTRL_TYPE_U16:
case V4L2_CTRL_TYPE_U32:
print_array(qc, ctrl.ptr);
break;
case V4L2_CTRL_TYPE_STRING:
printf("%s: '%s'\n", name.c_str(),
safename(ctrl.string).c_str());
break;
default:
fprintf(stderr, "%s: unsupported payload type\n",
qc.name);
break;
}
} else
printf("%s: %d\n", name.c_str(), ctrl.value);
}
}
}
}
if (options[OptGetPriority]) {
if (doioctl(fd, VIDIOC_G_PRIORITY, &prio) == 0)
printf("Priority: %d\n", prio);
}
if (options[OptLogStatus]) {
static char buf[40960];
int len = -1;
if (doioctl(fd, VIDIOC_LOG_STATUS, NULL) == 0) {
printf("\nStatus Log:\n\n");
#ifdef HAVE_KLOGCTL
len = klogctl(3, buf, sizeof(buf) - 1);
#endif
if (len >= 0) {
char *p = buf;
char *q;
buf[len] = 0;
while ((q = strstr(p, "START STATUS"))) {
p = q + 1;
}
if (p) {
while (p > buf && *p != '<') p--;
q = p;
while ((q = strstr(q, "<6>"))) {
memcpy(q, " ", 3);
}
printf("%s", p);
}
}
}
}
}
void common_set(int fd)
{
if (options[OptSetPriority]) {
if (doioctl(fd, VIDIOC_S_PRIORITY, &prio) >= 0) {
printf("Priority set: %d\n", prio);
}
}
if (options[OptSetCtrl] && !set_ctrls.empty()) {
struct v4l2_ext_controls ctrls;
class2ctrls_map class2ctrls;
bool use_ext_ctrls = false;
memset(&ctrls, 0, sizeof(ctrls));
for (ctrl_set_map::iterator iter = set_ctrls.begin();
iter != set_ctrls.end(); ++iter) {
struct v4l2_ext_control ctrl;
struct v4l2_query_ext_ctrl &qc = ctrl_str2q[iter->first];
memset(&ctrl, 0, sizeof(ctrl));
ctrl.id = qc.id;
if (qc.type == V4L2_CTRL_TYPE_INTEGER64)
use_ext_ctrls = true;
if (qc.flags & V4L2_CTRL_FLAG_HAS_PAYLOAD) {
struct v4l2_ext_controls ctrls = { 0, 1 };
unsigned divide[V4L2_CTRL_MAX_DIMS] = { 0 };
ctrl_subset subset;
long long v;
unsigned d, i;
use_ext_ctrls = true;
ctrl.size = qc.elems * qc.elem_size;
ctrl.ptr = malloc(ctrl.size);
ctrls.controls = &ctrl;
ioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls);
if (fill_subset(qc, subset))
return;
divide[qc.nr_of_dims - 1] = 1;
for (d = 0; d < qc.nr_of_dims - 1; d++) {
divide[d] = qc.dims[d + 1];
for (i = 0; i < d; i++)
divide[i] *= divide[d];
}
switch (qc.type) {
case V4L2_CTRL_TYPE_U8:
v = strtoul(iter->second.c_str(), NULL, 0);
for (i = 0; i < qc.elems; i++)
if (idx_in_subset(qc, subset, divide, i))
ctrl.p_u8[i] = v;
break;
case V4L2_CTRL_TYPE_U16:
v = strtoul(iter->second.c_str(), NULL, 0);
for (i = 0; i < qc.elems; i++)
if (idx_in_subset(qc, subset, divide, i))
ctrl.p_u16[i] = v;
break;
case V4L2_CTRL_TYPE_U32:
v = strtoul(iter->second.c_str(), NULL, 0);
for (i = 0; i < qc.elems; i++)
if (idx_in_subset(qc, subset, divide, i))
ctrl.p_u32[i] = v;
break;
case V4L2_CTRL_TYPE_STRING:
strncpy(ctrl.string, iter->second.c_str(), qc.maximum);
ctrl.string[qc.maximum] = 0;
break;
default:
fprintf(stderr, "%s: unsupported payload type\n",
qc.name);
break;
}
} else {
if (V4L2_CTRL_DRIVER_PRIV(ctrl.id))
use_ext_ctrls = true;
ctrl.value = strtol(iter->second.c_str(), NULL, 0);
}
class2ctrls[V4L2_CTRL_ID2CLASS(ctrl.id)].push_back(ctrl);
}
for (class2ctrls_map::iterator iter = class2ctrls.begin();
iter != class2ctrls.end(); ++iter) {
if (!use_ext_ctrls &&
(iter->first == V4L2_CTRL_CLASS_USER ||
iter->first == V4L2_CID_PRIVATE_BASE)) {
for (unsigned i = 0; i < iter->second.size(); i++) {
struct v4l2_control ctrl;
ctrl.id = iter->second[i].id;
ctrl.value = iter->second[i].value;
if (doioctl(fd, VIDIOC_S_CTRL, &ctrl)) {
fprintf(stderr, "%s: %s\n",
ctrl_id2str[ctrl.id].c_str(),
strerror(errno));
}
}
continue;
}
if (iter->second.size()) {
ctrls.ctrl_class = iter->first;
ctrls.count = iter->second.size();
ctrls.controls = &iter->second[0];
if (doioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls)) {
if (ctrls.error_idx >= ctrls.count) {
fprintf(stderr, "Error setting controls: %s\n",
strerror(errno));
}
else {
fprintf(stderr, "%s: %s\n",
ctrl_id2str[iter->second[ctrls.error_idx].id].c_str(),
strerror(errno));
}
}
}
}
}
}
