int v4lconvert_enum_framesizes(struct v4lconvert_data *data,
struct v4l2_frmsizeenum *frmsize)
{
if (!v4lconvert_supported_dst_format(frmsize->pixel_format)) {
if (v4lconvert_supported_dst_fmt_only(data)) {
errno = EINVAL;
return -1;
}
return SYS_IOCTL(data->fd, VIDIOC_ENUM_FRAMESIZES, frmsize);
}
if (frmsize->index >= data->no_framesizes) {
errno = EINVAL;
return -1;
}
frmsize->type = data->framesizes[frmsize->index].type;
switch (frmsize->type) {
case V4L2_FRMSIZE_TYPE_DISCRETE:
frmsize->discrete = data->framesizes[frmsize->index].discrete;
/* Apply the same rounding algorithm as v4lconvert_try_format */
frmsize->discrete.width &= ~7;
frmsize->discrete.height &= ~1;
break;
case V4L2_FRMSIZE_TYPE_CONTINUOUS:
case V4L2_FRMSIZE_TYPE_STEPWISE:
frmsize->stepwise = data->framesizes[frmsize->index].stepwise;
break;
}
return 0;
}
int v4lconvert_enum_frameintervals(struct v4lconvert_data *data,
struct v4l2_frmivalenum *frmival)
{
int res;
struct v4l2_format src_fmt, dest_fmt;
if (!v4lconvert_supported_dst_format(frmival->pixel_format)) {
if (v4lconvert_supported_dst_fmt_only(data)) {
errno = EINVAL;
return -1;
}
res = SYS_IOCTL(data->fd, VIDIOC_ENUM_FRAMEINTERVALS, frmival);
if (res)
V4LCONVERT_ERR("%s\n", strerror(errno));
return res;
}
/* Check which format we will be using to convert to frmival->pixel_format */
memset(&dest_fmt, 0, sizeof(dest_fmt));
dest_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
dest_fmt.fmt.pix.pixelformat = frmival->pixel_format;
dest_fmt.fmt.pix.width = frmival->width;
dest_fmt.fmt.pix.height = frmival->height;
res = v4lconvert_try_format(data, &dest_fmt, &src_fmt);
if (res) {
V4LCONVERT_ERR("trying format: %s\n", strerror(errno));
return res;
}
/* Check the requested format is supported exactly as requested */
if (dest_fmt.fmt.pix.pixelformat != frmival->pixel_format ||
dest_fmt.fmt.pix.width != frmival->width ||
dest_fmt.fmt.pix.height != frmival->height) {
int frmival_pixformat = frmival->pixel_format;
int dest_pixformat = dest_fmt.fmt.pix.pixelformat;
V4LCONVERT_ERR("Could not find matching framesize for: %c%c%c%c %dx%d "
"closest match: %c%c%c%c %dx%d\n",
frmival_pixformat & 0xff,
(frmival_pixformat >> 8) & 0xff,
(frmival_pixformat >> 16) & 0xff,
frmival_pixformat >> 24,
frmival->width, frmival->height,
dest_pixformat & 0xff,
(dest_pixformat >> 8) & 0xff,
(dest_pixformat >> 16) & 0xff,
dest_pixformat >> 24,
dest_fmt.fmt.pix.width , dest_fmt.fmt.pix.height);
errno = EINVAL;
return -1;
}
/* See libv4lconvert.h for description of in / out parameters */
int v4lconvert_enum_fmt(struct v4lconvert_data *data, struct v4l2_fmtdesc *fmt)
{
int i, no_faked_fmts = 0;
unsigned int faked_fmts[ARRAY_SIZE(supported_dst_pixfmts)];
if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
(!v4lconvert_supported_dst_fmt_only(data) &&
fmt->index < data->no_formats))
return SYS_IOCTL(data->fd, VIDIOC_ENUM_FMT, fmt);
for (i = 0; i < ARRAY_SIZE(supported_dst_pixfmts); i++)
if (v4lconvert_supported_dst_fmt_only(data) ||
!(data->supported_src_formats & (1 << i))) {
faked_fmts[no_faked_fmts] = supported_dst_pixfmts[i].fmt;
no_faked_fmts++;
}
if (!v4lconvert_supported_dst_fmt_only(data))
i = fmt->index - data->no_formats;
else
i = fmt->index;
if (i >= no_faked_fmts) {
errno = EINVAL;
return -1;
}
fmt->flags = V4L2_FMT_FLAG_EMULATED;
fmt->pixelformat = faked_fmts[i];
fmt->description[0] = faked_fmts[i] & 0xff;
fmt->description[1] = (faked_fmts[i] >> 8) & 0xff;
fmt->description[2] = (faked_fmts[i] >> 16) & 0xff;
fmt->description[3] = faked_fmts[i] >> 24;
fmt->description[4] = '\0';
memset(fmt->reserved, 0, sizeof(fmt->reserved));
return 0;
}
static int v4lconvert_do_try_format(struct v4lconvert_data *data,
struct v4l2_format *dest_fmt, struct v4l2_format *src_fmt)
{
int i, size_x_diff, size_y_diff, rank, best_rank = 0;
unsigned int size_diff, closest_fmt_size_diff = -1;
unsigned int desired_pixfmt = dest_fmt->fmt.pix.pixelformat;
struct v4l2_format try_fmt, closest_fmt = { .type = 0 };
if (data->flags & V4LCONVERT_IS_UVC)
return v4lconvert_do_try_format_uvc(data, dest_fmt, src_fmt);
for (i = 0; i < ARRAY_SIZE(supported_src_pixfmts); i++) {
/* is this format supported? */
if (!(data->supported_src_formats & (1 << i)))
continue;
try_fmt = *dest_fmt;
try_fmt.fmt.pix.pixelformat = supported_src_pixfmts[i].fmt;
if (SYS_IOCTL(data->fd, VIDIOC_TRY_FMT, &try_fmt))
continue;
if (try_fmt.fmt.pix.pixelformat !=
supported_src_pixfmts[i].fmt)
continue;
/* Did we get a better match then before? */
size_x_diff = (int)try_fmt.fmt.pix.width -
(int)dest_fmt->fmt.pix.width;
size_y_diff = (int)try_fmt.fmt.pix.height -
(int)dest_fmt->fmt.pix.height;
size_diff = size_x_diff * size_x_diff +
size_y_diff * size_y_diff;
rank = v4lconvert_get_rank(data, i,
try_fmt.fmt.pix.width,
try_fmt.fmt.pix.height,
desired_pixfmt);
if (size_diff < closest_fmt_size_diff ||
(size_diff == closest_fmt_size_diff && rank < best_rank)) {
closest_fmt = try_fmt;
closest_fmt_size_diff = size_diff;
best_rank = rank;
}
}
if (closest_fmt.type == 0)
return -1;
*dest_fmt = closest_fmt;
if (closest_fmt.fmt.pix.pixelformat != desired_pixfmt)
dest_fmt->fmt.pix.pixelformat = desired_pixfmt;
*src_fmt = closest_fmt;
return 0;
}
void v4lconvert_fixup_fmt(struct v4l2_format *fmt)
{
switch (fmt->fmt.pix.pixelformat) {
case V4L2_PIX_FMT_RGB24:
case V4L2_PIX_FMT_BGR24:
fmt->fmt.pix.bytesperline = fmt->fmt.pix.width * 3;
fmt->fmt.pix.sizeimage = fmt->fmt.pix.width * fmt->fmt.pix.height * 3;
break;
case V4L2_PIX_FMT_YUV420:
case V4L2_PIX_FMT_YVU420:
fmt->fmt.pix.bytesperline = fmt->fmt.pix.width;
fmt->fmt.pix.sizeimage = fmt->fmt.pix.width * fmt->fmt.pix.height * 3 / 2;
break;
}
}
/* See libv4lconvert.h for description of in / out parameters */
int v4lconvert_try_format(struct v4lconvert_data *data,
struct v4l2_format *dest_fmt, struct v4l2_format *src_fmt)
{
int i, result;
unsigned int desired_width = dest_fmt->fmt.pix.width;
unsigned int desired_height = dest_fmt->fmt.pix.height;
struct v4l2_format try_src, try_dest, try2_src, try2_dest;
if (dest_fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
v4lconvert_supported_dst_fmt_only(data) &&
!v4lconvert_supported_dst_format(dest_fmt->fmt.pix.pixelformat))
dest_fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
try_dest = *dest_fmt;
/* Can we do conversion to the requested format & type? */
if (!v4lconvert_supported_dst_format(dest_fmt->fmt.pix.pixelformat) ||
dest_fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
v4lconvert_do_try_format(data, &try_dest, &try_src)) {
result = SYS_IOCTL(data->fd, VIDIOC_TRY_FMT, dest_fmt);
if (src_fmt)
*src_fmt = *dest_fmt;
return result;
}
/* In case of a non exact resolution match, try again with a slightly larger
resolution as some weird devices are not able to crop of the number of
extra (border) pixels most sensors have compared to standard resolutions,
which we will then just crop of in software */
if (try_dest.fmt.pix.width != desired_width ||
try_dest.fmt.pix.height != desired_height) {
try2_dest = *dest_fmt;
try2_dest.fmt.pix.width = desired_width + 7;
try2_dest.fmt.pix.height = desired_height + 1;
result = v4lconvert_do_try_format(data, &try2_dest, &try2_src);
if (result == 0 &&
try2_dest.fmt.pix.width >= desired_width &&
try2_dest.fmt.pix.width <= desired_width + 7 &&
try2_dest.fmt.pix.height >= desired_height &&
try2_dest.fmt.pix.height <= desired_height + 1) {
/* Success! */
try2_dest.fmt.pix.width = desired_width;
try2_dest.fmt.pix.height = desired_height;
try_dest = try2_dest;
try_src = try2_src;
}
}
/* In case of a non exact resolution match, see if this is a well known
resolution some apps are hardcoded too and try to give the app what it
asked for by cropping a slightly larger resolution or adding a small
black border to a slightly smaller resolution */
if (try_dest.fmt.pix.width != desired_width ||
try_dest.fmt.pix.height != desired_height) {
for (i = 0; i < ARRAY_SIZE(v4lconvert_crop_res); i++) {
if (v4lconvert_crop_res[i][0] == desired_width &&
v4lconvert_crop_res[i][1] == desired_height) {
try2_dest = *dest_fmt;
/* Note these are chosen so that cropping to vga res just works for
vv6410 sensor cams, which have 356x292 and 180x148 */
try2_dest.fmt.pix.width = desired_width * 113 / 100;
try2_dest.fmt.pix.height = desired_height * 124 / 100;
result = v4lconvert_do_try_format(data, &try2_dest, &try2_src);
if (result == 0 &&
(/* Add a small black border of max 16 pixels */
(try2_dest.fmt.pix.width >= desired_width - 16 &&
try2_dest.fmt.pix.width <= desired_width &&
try2_dest.fmt.pix.height >= desired_height - 16 &&
try2_dest.fmt.pix.height <= desired_height) ||
/* Standard cropping to max 80% of actual width / height */
(try2_dest.fmt.pix.width >= desired_width &&
try2_dest.fmt.pix.width <= desired_width * 5 / 4 &&
try2_dest.fmt.pix.height >= desired_height &&
try2_dest.fmt.pix.height <= desired_height * 5 / 4) ||
/* Downscale 2x + cropping to max 80% of actual width / height */
(try2_dest.fmt.pix.width >= desired_width * 2 &&
try2_dest.fmt.pix.width <= desired_width * 5 / 2 &&
try2_dest.fmt.pix.height >= desired_height * 2 &&
try2_dest.fmt.pix.height <= desired_height * 5 / 2))) {
/* Success! */
try2_dest.fmt.pix.width = desired_width;
try2_dest.fmt.pix.height = desired_height;
try_dest = try2_dest;
try_src = try2_src;
}
break;
}
}
}
/* Some applications / libs (*cough* gstreamer *cough*) will not work
correctly with planar YUV formats when the width is not a multiple of 8
or the height is not a multiple of 2. With RGB formats these apps require
the width to be a multiple of 4. We apply the same rounding to all
formats to not end up with 2 close but different resolutions. */
try_dest.fmt.pix.width &= ~7;
try_dest.fmt.pix.height &= ~1;
/* Are we converting / cropping ? */
if (try_src.fmt.pix.width != try_dest.fmt.pix.width ||
try_src.fmt.pix.height != try_dest.fmt.pix.height ||
try_src.fmt.pix.pixelformat != try_dest.fmt.pix.pixelformat)
v4lconvert_fixup_fmt(&try_dest);
*dest_fmt = try_dest;
if (src_fmt)
*src_fmt = try_src;
return 0;
}
int v4l2_ioctl(int fd, unsigned long int request, ...)
{
void *arg;
va_list ap;
int result, index, saved_err;
int is_capture_request = 0, stream_needs_locking = 0;
va_start(ap, request);
arg = va_arg(ap, void *);
va_end(ap);
index = v4l2_get_index(fd);
if (index == -1)
return SYS_IOCTL(fd, request, arg);
/* Appearantly the kernel and / or glibc ignore the 32 most significant bits
when long = 64 bits, and some applications pass an int holding the req to
ioctl, causing it to get sign extended, depending upon this behavior */
request = (unsigned int)request;
/* Is this a capture request and do we need to take the stream lock? */
switch (request) {
case VIDIOC_QUERYCTRL:
case VIDIOC_G_CTRL:
case VIDIOC_S_CTRL:
if (!(devices[index].flags & V4L2_DISABLE_CONVERSION))
is_capture_request = 1;
break;
case VIDIOC_QUERYCAP:
is_capture_request = 1;
break;
case VIDIOC_ENUM_FMT:
if (((struct v4l2_fmtdesc *)arg)->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
!(devices[index].flags & V4L2_DISABLE_CONVERSION))
is_capture_request = 1;
break;
case VIDIOC_ENUM_FRAMESIZES:
case VIDIOC_ENUM_FRAMEINTERVALS:
if (!(devices[index].flags & V4L2_DISABLE_CONVERSION))
is_capture_request = 1;
break;
case VIDIOC_TRY_FMT:
if (((struct v4l2_format *)arg)->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
!(devices[index].flags & V4L2_DISABLE_CONVERSION))
is_capture_request = 1;
break;
case VIDIOC_S_FMT:
case VIDIOC_G_FMT:
if (((struct v4l2_format *)arg)->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
is_capture_request = 1;
stream_needs_locking = 1;
}
break;
case VIDIOC_REQBUFS:
if (((struct v4l2_requestbuffers *)arg)->type ==
V4L2_BUF_TYPE_VIDEO_CAPTURE) {
is_capture_request = 1;
stream_needs_locking = 1;
}
break;
case VIDIOC_QUERYBUF:
case VIDIOC_QBUF:
case VIDIOC_DQBUF:
if (((struct v4l2_buffer *)arg)->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
is_capture_request = 1;
stream_needs_locking = 1;
}
break;
case VIDIOC_STREAMON:
case VIDIOC_STREAMOFF:
if (*((enum v4l2_buf_type *)arg) == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
is_capture_request = 1;
stream_needs_locking = 1;
}
}
if (!is_capture_request) {
result = SYS_IOCTL(fd, request, arg);
saved_err = errno;
v4l2_log_ioctl(request, arg, result);
errno = saved_err;
return result;
}
if (stream_needs_locking) {
pthread_mutex_lock(&devices[index].stream_lock);
/* If this is the first stream related ioctl, and we should only allow
libv4lconvert supported destination formats (so that it can do flipping,
processing, etc.) and the current destination format is not supported,
try setting the format to RGB24 (which is a supported dest. format). */
if (!(devices[index].flags & V4L2_STREAM_TOUCHED) &&
!(devices[index].flags & V4L2_DISABLE_CONVERSION) &&
v4lconvert_supported_dst_fmt_only(devices[index].convert) &&
!v4lconvert_supported_dst_format(
devices[index].dest_fmt.fmt.pix.pixelformat)) {
struct v4l2_format fmt = devices[index].dest_fmt;
V4L2_LOG("Setting pixelformat to RGB24 (supported_dst_fmt_only)");
devices[index].flags |= V4L2_STREAM_TOUCHED;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
pthread_mutex_unlock(&devices[index].stream_lock);
v4l2_ioctl(fd, VIDIOC_S_FMT, &fmt);
pthread_mutex_lock(&devices[index].stream_lock);
V4L2_LOG("Done setting pixelformat (supported_dst_fmt_only)");
}
devices[index].flags |= V4L2_STREAM_TOUCHED;
}
switch (request) {
case VIDIOC_QUERYCTRL:
result = v4lconvert_vidioc_queryctrl(devices[index].convert, arg);
break;
case VIDIOC_G_CTRL:
result = v4lconvert_vidioc_g_ctrl(devices[index].convert, arg);
break;
case VIDIOC_S_CTRL:
result = v4lconvert_vidioc_s_ctrl(devices[index].convert, arg);
break;
case VIDIOC_QUERYCAP: {
struct v4l2_capability *cap = arg;
result = SYS_IOCTL(devices[index].fd, VIDIOC_QUERYCAP, cap);
if (result == 0)
/* We always support read() as we fake it using mmap mode */
cap->capabilities |= V4L2_CAP_READWRITE;
break;
}
case VIDIOC_ENUM_FMT:
result = v4lconvert_enum_fmt(devices[index].convert, arg);
break;
case VIDIOC_ENUM_FRAMESIZES:
result = v4lconvert_enum_framesizes(devices[index].convert, arg);
break;
case VIDIOC_ENUM_FRAMEINTERVALS:
result = v4lconvert_enum_frameintervals(devices[index].convert, arg);
if (result)
V4L2_LOG("ENUM_FRAMEINTERVALS Error: %s",
v4lconvert_get_error_message(devices[index].convert));
break;
case VIDIOC_TRY_FMT:
result = v4lconvert_try_format(devices[index].convert, arg, NULL);
break;
case VIDIOC_S_FMT: {
struct v4l2_format src_fmt, *dest_fmt = arg;
struct v4l2_pix_format req_pix_fmt;
/* Don't be lazy on uvc cams, as this triggers a bug in the uvcvideo
driver in kernel <= 2.6.28 (with certain cams) */
if (!(devices[index].flags & V4L2_IS_UVC) &&
v4l2_pix_fmt_identical(&devices[index].dest_fmt, dest_fmt)) {
*dest_fmt = devices[index].dest_fmt;
result = 0;
break;
}
if (v4l2_log_file) {
int pixfmt = dest_fmt->fmt.pix.pixelformat;
fprintf(v4l2_log_file, "VIDIOC_S_FMT app requesting: %c%c%c%c\n",
pixfmt & 0xff,
(pixfmt >> 8) & 0xff,
(pixfmt >> 16) & 0xff,
pixfmt >> 24);
}
if (devices[index].flags & V4L2_DISABLE_CONVERSION) {
result = SYS_IOCTL(devices[index].fd, VIDIOC_TRY_FMT,
dest_fmt);
src_fmt = *dest_fmt;
} else {
result = v4lconvert_try_format(devices[index].convert, dest_fmt,
&src_fmt);
}
if (result) {
saved_err = errno;
V4L2_LOG("S_FMT error trying format: %s\n", strerror(errno));
errno = saved_err;
break;
}
if (src_fmt.fmt.pix.pixelformat != dest_fmt->fmt.pix.pixelformat &&
v4l2_log_file) {
int pixfmt = src_fmt.fmt.pix.pixelformat;
fprintf(v4l2_log_file, "VIDIOC_S_FMT converting from: %c%c%c%c\n",
pixfmt & 0xff,
(pixfmt >> 8) & 0xff,
(pixfmt >> 16) & 0xff,
pixfmt >> 24);
}
/* Maybe after try format has adjusted width/height etc, to whats
available nothing has changed (on the cam side) ? */
if (!(devices[index].flags & V4L2_IS_UVC) &&
v4l2_pix_fmt_identical(&devices[index].src_fmt, &src_fmt)) {
v4l2_set_src_and_dest_format(index, &devices[index].src_fmt,
dest_fmt);
result = 0;
break;
}
result = v4l2_check_buffer_change_ok(index);
if (result)
break;
req_pix_fmt = src_fmt.fmt.pix;
result = SYS_IOCTL(devices[index].fd, VIDIOC_S_FMT, &src_fmt);
if (result) {
saved_err = errno;
V4L2_LOG_ERR("setting pixformat: %s\n", strerror(errno));
/* Report to the app dest_fmt has not changed */
*dest_fmt = devices[index].dest_fmt;
errno = saved_err;
break;
}
/* See if we've gotten what try_fmt promised us
(this check should never fail) */
if (src_fmt.fmt.pix.width != req_pix_fmt.width ||
src_fmt.fmt.pix.height != req_pix_fmt.height ||
src_fmt.fmt.pix.pixelformat != req_pix_fmt.pixelformat) {
V4L2_LOG_ERR("set_fmt gave us a different result then try_fmt!\n");
/* Not what we expected / wanted, disable conversion */
*dest_fmt = src_fmt;
}
v4l2_set_src_and_dest_format(index, &src_fmt, dest_fmt);
break;
}
case VIDIOC_G_FMT: {
struct v4l2_format *fmt = arg;
*fmt = devices[index].dest_fmt;
result = 0;
break;
}
case VIDIOC_REQBUFS: {
struct v4l2_requestbuffers *req = arg;
/* IMPROVEME (maybe?) add support for userptr's? */
if (req->memory != V4L2_MEMORY_MMAP) {
errno = EINVAL;
result = -1;
break;
}
result = v4l2_check_buffer_change_ok(index);
if (result)
break;
/* No more buffers then we can manage please */
if (req->count > V4L2_MAX_NO_FRAMES)
req->count = V4L2_MAX_NO_FRAMES;
result = SYS_IOCTL(devices[index].fd, VIDIOC_REQBUFS, req);
if (result < 0)
break;
result = 0; /* some drivers return the number of buffers on success */
devices[index].no_frames = MIN(req->count, V4L2_MAX_NO_FRAMES);
devices[index].flags &= ~V4L2_BUFFERS_REQUESTED_BY_READ;
break;
}
case VIDIOC_QUERYBUF: {
struct v4l2_buffer *buf = arg;
if (devices[index].flags & V4L2_STREAM_CONTROLLED_BY_READ) {
result = v4l2_deactivate_read_stream(index);
if (result)
break;
}
/* Do a real query even when converting to let the driver fill in
things like buf->field */
result = SYS_IOCTL(devices[index].fd, VIDIOC_QUERYBUF, buf);
if (result || !v4l2_needs_conversion(index))
break;
buf->m.offset = V4L2_MMAP_OFFSET_MAGIC | buf->index;
buf->length = V4L2_FRAME_BUF_SIZE;
if (devices[index].frame_map_count[buf->index])
buf->flags |= V4L2_BUF_FLAG_MAPPED;
else
buf->flags &= ~V4L2_BUF_FLAG_MAPPED;
break;
}
case VIDIOC_QBUF:
if (devices[index].flags & V4L2_STREAM_CONTROLLED_BY_READ) {
result = v4l2_deactivate_read_stream(index);
if (result)
break;
}
/* With some drivers the buffers must be mapped before queuing */
if (v4l2_needs_conversion(index)) {
result = v4l2_map_buffers(index);
if (result)
break;
}
result = SYS_IOCTL(devices[index].fd, VIDIOC_QBUF, arg);
break;
case VIDIOC_DQBUF: {
struct v4l2_buffer *buf = arg;
if (devices[index].flags & V4L2_STREAM_CONTROLLED_BY_READ) {
result = v4l2_deactivate_read_stream(index);
if (result)
break;
}
if (!v4l2_needs_conversion(index)) {
result = SYS_IOCTL(devices[index].fd, VIDIOC_DQBUF, buf);
if (result) {
int saved_err = errno;
V4L2_LOG_ERR("dequeuing buf: %s\n", strerror(errno));
errno = saved_err;
}
break;
}
/* An application can do a DQBUF before mmap-ing in the buffer,
but we need the buffer _now_ to write our converted data
to it! */
if (devices[index].convert_mmap_buf == MAP_FAILED) {
devices[index].convert_mmap_buf = (void *)SYS_MMAP(NULL,
(size_t)(devices[index].no_frames * V4L2_FRAME_BUF_SIZE),
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE,
-1, 0);
if (devices[index].convert_mmap_buf == MAP_FAILED) {
saved_err = errno;
V4L2_LOG_ERR("allocating conversion buffer\n");
errno = saved_err;
result = -1;
break;
}
}
result = v4l2_dequeue_and_convert(index, buf, 0, V4L2_FRAME_BUF_SIZE);
if (result < 0)
break;
buf->bytesused = result;
buf->m.offset = V4L2_MMAP_OFFSET_MAGIC | buf->index;
buf->length = V4L2_FRAME_BUF_SIZE;
if (devices[index].frame_map_count[buf->index])
buf->flags |= V4L2_BUF_FLAG_MAPPED;
else
buf->flags &= ~V4L2_BUF_FLAG_MAPPED;
result = 0;
break;
}
case VIDIOC_STREAMON:
case VIDIOC_STREAMOFF:
if (devices[index].flags & V4L2_STREAM_CONTROLLED_BY_READ) {
result = v4l2_deactivate_read_stream(index);
if (result)
break;
}
if (request == VIDIOC_STREAMON)
result = v4l2_streamon(index);
else
result = v4l2_streamoff(index);
break;
default:
result = SYS_IOCTL(fd, request, arg);
break;
}
