static void init_device(void)
{
struct v4l2_capability cap;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format fmt;
unsigned int min;
if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n", dev_name);
exit(EXIT_FAILURE);
} else {
errno_exit("VIDIOC_QUERYCAP");
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n", dev_name);
exit(EXIT_FAILURE);
}
switch (io) {
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf(stderr, "%s does not support read i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf(stderr, "%s does not support streaming i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
}
/* Select video input, video standard and tune here. */
CLEAR(cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
/* Cropping not supported. */
break;
default:
/* Errors ignored. */
break;
}
}
} else {
/* Errors ignored. */
}
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = 800;
fmt.fmt.pix.height = 600;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
errno_exit("VIDIOC_S_FMT");
/* Note VIDIOC_S_FMT may change width and height. */
/* Buggy driver paranoia. */
min = fmt.fmt.pix.width * 2;
if (fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if (fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;
switch (io) {
case IO_METHOD_READ:
init_read(fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap();
break;
case IO_METHOD_USERPTR:
init_userp(fmt.fmt.pix.sizeimage);
break;
}
}
static bool init_device(int fd, const char* dev_name, int io, buffer** buffers, size_t n_buffers, struct v4l2_format& fmt)
{
struct v4l2_capability cap;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
unsigned int min;
if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n",
dev_name);
return false;
} else {
return false;
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n",
dev_name);
return false;
}
switch (io) {
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf(stderr, "%s does not support read i/o\n",
dev_name);
return false;
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf(stderr, "%s does not support streaming i/o\n",
dev_name);
return false;
}
break;
}
/* Select video input, video standard and tune here. */
CLEAR(cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
/* Cropping not supported. */
break;
default:
/* Errors ignored. */
break;
}
}
} else {
/* Errors ignored. */
}
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0) {
CLEAR(fmt);
fmt.fmt.pix.width = 640;
fmt.fmt.pix.height = 480;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
{
cerr << "Error initializing device (VIDIOC_S_FMT)" << endl;
return false;
}
/* Note VIDIOC_S_FMT may change width and height. */
} else {
/* Preserve original settings as set by v4l2-ctl for example */
if (-1 == xioctl(fd, VIDIOC_G_FMT, &fmt))
{
cerr << "Error initializing device (VIDIOC_G_FMT)" << endl;
return false;
}
}
/* Buggy driver paranoia. */
min = fmt.fmt.pix.width * 2;
if (fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if (fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;
switch (io) {
case IO_METHOD_READ:
return init_read(buffers, fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap(fd, buffers, n_buffers, fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_USERPTR:
return init_userp(fd, buffers, n_buffers, fmt.fmt.pix.sizeimage);
break;
}
return true;
}
static void init_device(int w, int h)
{
struct v4l2_capability cap;
int ret;
int sizeimage;
if (xioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n",
dev_name);
exit(EXIT_FAILURE);
} else {
errno_exit("VIDIOC_QUERYCAP");
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n",
dev_name);
exit(EXIT_FAILURE);
}
switch (io) {
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf(stderr, "%s does not support read i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
case V4L2_MEMORY_MMAP:
case V4L2_MEMORY_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf(stderr,
"%s does not support streaming i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
}
// if (xioctl(fd, VIDIOC_G_FMT, &fmt) < 0)
// perror("get fmt");
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = w;
fmt.fmt.pix.height = h;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
#ifdef WITH_V4L2_LIB
v4lconvert_data = v4lconvert_create(fd);
if (v4lconvert_data == NULL)
errno_exit("v4lconvert_create");
if (v4lconvert_try_format(v4lconvert_data, &fmt, &src_fmt) != 0)
errno_exit("v4lconvert_try_format");
ret = xioctl(fd, VIDIOC_S_FMT, &src_fmt);
sizeimage = src_fmt.fmt.pix.sizeimage;
dst_buf = malloc(fmt.fmt.pix.sizeimage);
printf("raw pixfmt: %c%c%c%c %dx%d\n",
src_fmt.fmt.pix.pixelformat & 0xff,
(src_fmt.fmt.pix.pixelformat >> 8) & 0xff,
(src_fmt.fmt.pix.pixelformat >> 16) & 0xff,
(src_fmt.fmt.pix.pixelformat >> 24) & 0xff,
src_fmt.fmt.pix.width, src_fmt.fmt.pix.height);
#else
ret = xioctl(fd, VIDIOC_S_FMT, &fmt);
sizeimage = fmt.fmt.pix.sizeimage;
#endif
if (ret < 0)
errno_exit("VIDIOC_S_FMT");
//
// /* Note VIDIOC_S_FMT may change width and height. */
//
printf("pixfmt: %c%c%c%c %dx%d\n",
fmt.fmt.pix.pixelformat & 0xff,
(fmt.fmt.pix.pixelformat >> 8) & 0xff,
(fmt.fmt.pix.pixelformat >> 16) & 0xff,
(fmt.fmt.pix.pixelformat >> 24) & 0xff,
fmt.fmt.pix.width, fmt.fmt.pix.height);
switch (io) {
case IO_METHOD_READ:
init_read(sizeimage);
break;
case V4L2_MEMORY_MMAP:
init_mmap();
break;
case V4L2_MEMORY_USERPTR:
init_userp(sizeimage);
break;
}
}
static void init_device (void) {
struct v4l2_capability cap;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format fmt;
unsigned int min;
if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
fprintf (stderr, "%s is no V4L2 device\n",
dev_name);
exit (EXIT_FAILURE);
} else {
errno_exit ("VIDIOC_QUERYCAP");
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf (stderr, "%s is no video capture device\n",
dev_name);
exit (EXIT_FAILURE);
}
fprintf(stderr, "Card: %s\n", cap.card);
switch (io) {
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf (stderr, "%s does not support read i/o\n",
dev_name);
exit (EXIT_FAILURE);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf (stderr, "%s does not support streaming i/o\n",
dev_name);
exit (EXIT_FAILURE);
}
break;
}
/* Select video input, video standard and tune here. */
{
struct v4l2_input input;
__u32 current;
if (-1 == ioctl (fd, VIDIOC_G_INPUT, ¤t)) {
perror ("VIDIOC_G_INPUT");
}
memset (&input, 0, sizeof (input));
input.index = current;
if (-1 == ioctl (fd, VIDIOC_ENUMINPUT, &input)) {
perror ("VIDIOC_ENUMINPUT");
} else {
fprintf (stderr, "Current input: %s\n", input.name);
if (input.status & V4L2_IN_ST_NO_H_LOCK)
fprintf (stderr, "Warning: no video lock detected\n");
}
}
CLEAR (cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
/* Cropping not supported. */
break;
default:
/* Errors ignored. */
break;
}
}
} else {
/* Errors ignored. */
}
CLEAR (fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
switch (G_size) {
case 0:
fmt.fmt.pix.width = G_pal ? 704 : 640;
fmt.fmt.pix.height = G_pal ? 576 : 480;
break;
case 1:
fmt.fmt.pix.width = G_pal ? 352 : 320;
fmt.fmt.pix.height = G_pal ? 288 : 240;
break;
case 2:
fmt.fmt.pix.width = G_width;
fmt.fmt.pix.height = G_height;
break;
}
switch (type) {
case TYPE_JPEG:
case TYPE_MJPEG:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
break;
case TYPE_MPEG1:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
break;
case TYPE_H264:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_H264;
break;
case TYPE_YUYV:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
break;
case TYPE_UYVY:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
break;
case TYPE_Y8:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_GREY;
break;
case TYPE_NV12:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12;
break;
case TYPE_BGR24:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_BGR24;
break;
case TYPE_RGB565:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;
break;
case TYPE_MP42:
//fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MP42;
break;
case TYPE_MPEGTS:
case TYPE_MPEGPS:
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
break;
}
fmt.fmt.pix.field = G_field;
if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
errno_exit ("VIDIOC_S_FMT");
/* Note VIDIOC_S_FMT may change width and height. */
/* Buggy driver paranoia. */
min = fmt.fmt.pix.width * 2;
if (fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if (fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;
/* optional MPEG parameters */
if(type == TYPE_MPEG4 ||
type == TYPE_H264 ||
type == TYPE_MP42 ||
type == TYPE_MPEGTS ||
type == TYPE_MPEGPS ||
type == TYPE_MPEG2) {
struct v4l2_ext_control ctrl[12] = {};
struct v4l2_ext_controls ctrls = {
.ctrl_class = V4L2_CTRL_CLASS_MPEG,
.count = 0,
.controls = &ctrl[0],
};
if (type == TYPE_MPEGTS)
add_ctrl(&ctrls, V4L2_CID_MPEG_STREAM_TYPE, V4L2_MPEG_STREAM_TYPE_MPEG2_TS);
else if (type == TYPE_MPEGPS) {
add_ctrl(&ctrls, V4L2_CID_MPEG_STREAM_TYPE, V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
// add_ctrl(&ctrls, V4L2_CID_MPEG_AUDIO_ENCODING, V4L2_MPEG_AUDIO_ENCODING_PCM);
} else if (type != TYPE_MP42)
mux_type = type;
if (mux_type == TYPE_MPEG1)
add_ctrl(&ctrls, V4L2_CID_MPEG_VIDEO_ENCODING, V4L2_MPEG_VIDEO_ENCODING_MPEG_1);
else if (mux_type == TYPE_MPEG2)
add_ctrl(&ctrls, V4L2_CID_MPEG_VIDEO_ENCODING, V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
else if (mux_type == TYPE_H264)
add_ctrl(&ctrls, V4L2_CID_MPEG_VIDEO_ENCODING, V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC);
if (G_br != -1)
add_ctrl(&ctrls, V4L2_CID_MPEG_VIDEO_BITRATE, G_br);
if (G_abr != -1)
add_ctrl(&ctrls, V4L2_CID_MPEG_AUDIO_AAC_BITRATE, G_abr);
if (G_ach != -1)
add_ctrl(&ctrls, V4L2_CID_MPEG_AUDIO_MODE, G_ach);
if (G_gop != -1)
add_ctrl(&ctrls, V4L2_CID_MPEG_VIDEO_GOP_SIZE, G_gop);
if (G_idr != -1)
add_ctrl(&ctrls, V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, G_idr);
#if defined(V4L2_CID_MPEG_VIDEO_H264_PROFILE) && defined(V4L2_CID_MPEG_VIDEO_H264_LEVEL)
if (G_profile != -1)
add_ctrl(&ctrls, V4L2_CID_MPEG_VIDEO_H264_PROFILE, G_profile);
if (G_level != -1)
add_ctrl(&ctrls, V4L2_CID_MPEG_VIDEO_H264_LEVEL, G_level);
#endif
#if defined(V4L2_CID_MPEG_STREAM_VBI_FMT)
if (G_cc != -1) {
add_ctrl(&ctrls, V4L2_CID_MPEG_STREAM_VBI_FMT, G_cc ?
V4L2_MPEG_STREAM_VBI_FMT_IVTV :
V4L2_MPEG_STREAM_VBI_FMT_NONE);
}
#endif
} else if (type == TYPE_MJPEG || type == TYPE_JPEG) {
if (-1 == ioctl (fd, VIDIOC_S_JPEGCOMP, &G_jc))
perror ("VIDIOC_S_JPEGCOMP");
}
switch (io) {
case IO_METHOD_READ:
init_read (fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap ();
break;
case IO_METHOD_USERPTR:
init_userp (fmt.fmt.pix.sizeimage);
break;
}
}
static void init_device(void)
{
struct v4l2_capability cap;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
unsigned int min;
if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap))
{
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n",
dev_name);
exit(EXIT_FAILURE);
}
else
{
errno_exit("VIDIOC_QUERYCAP");
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
{
fprintf(stderr, "%s is no video capture device\n",
dev_name);
exit(EXIT_FAILURE);
}
switch (io)
{
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE))
{
fprintf(stderr, "%s does not support read i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING))
{
fprintf(stderr, "%s does not support streaming i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
}
/* Select video input, video standard and tune here. */
CLEAR(cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap))
{
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop))
{
switch (errno)
{
case EINVAL:
/* Cropping not supported. */
break;
default:
/* Errors ignored. */
break;
}
}
}
else
{
/* Errors ignored. */
}
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (force_format)
{
printf("FORCING FORMAT\n");
fmt.fmt.pix.width = HRES;
fmt.fmt.pix.height = VRES;
// Specify the Pixel Coding Formate here
// This one work for Logitech C200
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
//fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
//fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_VYUY;
// Would be nice if camera supported
//fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_GREY;
//fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
//fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
fmt.fmt.pix.field = V4L2_FIELD_NONE;
if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
errno_exit("VIDIOC_S_FMT");
/* Note VIDIOC_S_FMT may change width and height. */
}
else
{
printf("ASSUMING FORMAT\n");
/* Preserve original settings as set by v4l2-ctl for example */
if (-1 == xioctl(fd, VIDIOC_G_FMT, &fmt))
errno_exit("VIDIOC_G_FMT");
}
/* Buggy driver paranoia. */
min = fmt.fmt.pix.width * 2;
if (fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if (fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;
switch (io)
{
case IO_METHOD_READ:
init_read(fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap();
break;
case IO_METHOD_USERPTR:
init_userp(fmt.fmt.pix.sizeimage);
break;
}
}
static void init_device(Priv *priv)
{
struct v4l2_capability cap;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format fmt;
if (-1 == xioctl(priv->fd, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n",
priv->dev_name);
exit(EXIT_FAILURE);
} else {
errno_exit("VIDIOC_QUERYCAP");
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n",
priv->dev_name);
exit(EXIT_FAILURE);
}
switch (priv->io) {
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf(stderr, "%s does not support read i/o\n",
priv->dev_name);
exit(EXIT_FAILURE);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf(stderr, "%s does not support streaming i/o\n",
priv->dev_name);
exit(EXIT_FAILURE);
}
break;
}
/* Select video input, video standard and tune here. */
CLEAR(cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl(priv->fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl(priv->fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
/* Cropping not supported. */
break;
default:
/* Errors ignored. */
break;
}
}
} else {
/* Errors ignored. */
}
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (priv->force_format) {
fmt.fmt.pix.width = priv->w;
fmt.fmt.pix.height = priv->h;
//fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
if (-1 == xioctl(priv->fd, VIDIOC_S_FMT, &fmt))
errno_exit("VIDIOC_S_FMT");
/* Note VIDIOC_S_FMT may change width and height. */
} else {
/* Preserve original settings as set by v4l2-ctl for example */
if (-1 == xioctl(priv->fd, VIDIOC_G_FMT, &fmt))
errno_exit("VIDIOC_G_FMT");
}
switch (priv->io) {
case IO_METHOD_READ:
init_read(priv, fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap(priv);
break;
case IO_METHOD_USERPTR:
init_userp(priv, fmt.fmt.pix.sizeimage);
break;
}
}
void Camera::Init() {
struct v4l2_capability cap;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format fmt;
unsigned int min;
if(-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n",name);
exit(1);
} else {
errno_exit("VIDIOC_QUERYCAP");
}
}
if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n", name);
exit(1);
}
switch(io) {
case IO_METHOD_READ:
if(!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf(stderr, "%s does not support read i/o\n", name);
exit (1);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if(!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf (stderr, "%s does not support streaming i/o\n", name);
exit(1);
}
break;
}
CLEAR (cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if(0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if(-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
/* Cropping not supported. */
break;
default:
/* Errors ignored. */
break;
}
}
} else {
/* Errors ignored. */
}
CLEAR (fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = width;
fmt.fmt.pix.height = height;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
if(-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
errno_exit ("VIDIOC_S_FMT");
/*
struct v4l2_standard s;
s.name[0]='A';
s.frameperiod.numerator=1;
s.frameperiod.denominator=fps;
if(-1==xioctl(fd, VIDIOC_S_STD, &s))
errno_exit("VIDIOC_S_STD");
*/
struct v4l2_streamparm p;
p.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
//p.parm.capture.capability=V4L2_CAP_TIMEPERFRAME;
//p.parm.capture.capturemode=V4L2_MODE_HIGHQUALITY;
p.parm.capture.timeperframe.numerator=1;
p.parm.capture.timeperframe.denominator=fps;
p.parm.output.timeperframe.numerator=1;
p.parm.output.timeperframe.denominator=fps;
//p.parm.output.outputmode=V4L2_MODE_HIGHQUALITY;
//p.parm.capture.extendedmode=0;
//p.parm.capture.readbuffers=n_buffers;
if(-1==xioctl(fd, VIDIOC_S_PARM, &p))
errno_exit("VIDIOC_S_PARM");
//default values, mins and maxes
struct v4l2_queryctrl queryctrl;
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_BRIGHTNESS;
if(-1 == xioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if(errno != EINVAL) {
//perror ("VIDIOC_QUERYCTRL");
//exit(EXIT_FAILURE);
printf("brightness error\n");
} else {
printf("brightness is not supported\n");
}
} else if(queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
printf ("brightness is not supported\n");
}
mb=queryctrl.minimum;
Mb=queryctrl.maximum;
db=queryctrl.default_value;
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_CONTRAST;
if(-1 == xioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if(errno != EINVAL) {
//perror ("VIDIOC_QUERYCTRL");
//exit(EXIT_FAILURE);
printf("contrast error\n");
} else {
printf("contrast is not supported\n");
}
} else if(queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
printf ("contrast is not supported\n");
}
mc=queryctrl.minimum;
Mc=queryctrl.maximum;
dc=queryctrl.default_value;
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_SATURATION;
if(-1 == xioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if(errno != EINVAL) {
//perror ("VIDIOC_QUERYCTRL");
//exit(EXIT_FAILURE);
printf("saturation error\n");
} else {
printf("saturation is not supported\n");
}
} else if(queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
printf ("saturation is not supported\n");
}
ms=queryctrl.minimum;
Ms=queryctrl.maximum;
ds=queryctrl.default_value;
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_HUE;
if(-1 == xioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if(errno != EINVAL) {
//perror ("VIDIOC_QUERYCTRL");
//exit(EXIT_FAILURE);
printf("hue error\n");
} else {
printf("hue is not supported\n");
}
} else if(queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
printf ("hue is not supported\n");
}
mh=queryctrl.minimum;
Mh=queryctrl.maximum;
dh=queryctrl.default_value;
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_HUE_AUTO;
if(-1 == xioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if(errno != EINVAL) {
//perror ("VIDIOC_QUERYCTRL");
//exit(EXIT_FAILURE);
printf("hueauto error\n");
} else {
printf("hueauto is not supported\n");
}
} else if(queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
printf ("hueauto is not supported\n");
}
ha=queryctrl.default_value;
memset(&queryctrl, 0, sizeof(queryctrl));
queryctrl.id = V4L2_CID_SHARPNESS;
if(-1 == xioctl (fd, VIDIOC_QUERYCTRL, &queryctrl)) {
if(errno != EINVAL) {
//perror ("VIDIOC_QUERYCTRL");
//exit(EXIT_FAILURE);
printf("sharpness error\n");
} else {
printf("sharpness is not supported\n");
}
} else if(queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
printf ("sharpness is not supported\n");
}
msh=queryctrl.minimum;
Msh=queryctrl.maximum;
dsh=queryctrl.default_value;
//TODO: TO ADD SETTINGS
//here should go custom calls to xioctl
//END TO ADD SETTINGS
/* Note VIDIOC_S_FMT may change width and height. */
/* Buggy driver paranoia. */
min = fmt.fmt.pix.width * 2;
if(fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if(fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;
switch(io) {
case IO_METHOD_READ:
init_read(fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap();
break;
case IO_METHOD_USERPTR:
init_userp(fmt.fmt.pix.sizeimage);
break;
}
}
static void init_device(void)
{
struct v4l2_capability cap;
//struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format fmt;
unsigned int min;
/**************
struct v4l2_cropcap cropcap;
struct v4l2_format format;
reset_cropping_parameters ();
// Scale down to 1/4 size of full picture.
memset (&format, 0, sizeof (format)); // defaults
format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
format.fmt.pix.width = cropcap.defrect.width >> 1;
format.fmt.pix.height = cropcap.defrect.height >> 1;
format.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
if (-1 == ioctl (fd, VIDIOC_S_FMT, &format)) {
perror ("VIDIOC_S_FORMAT");
exit (EXIT_FAILURE);
}
****************/
if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n",
dev_name);
exit(EXIT_FAILURE);
} else {
errno_exit("VIDIOC_QUERYCAP");
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n",
dev_name);
exit(EXIT_FAILURE);
}
switch (io) {
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf(stderr, "%s does not support read i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf(stderr, "%s does not support streaming i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
}
/* Select video input, video standard and tune here. */
/*
CLEAR(cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; // reset to default
if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
// Cropping not supported.
break;
default:
printf("Error in VIDIOC_S_CROP\n");
break;
}
}
} else
printf("Error in VIDIOC_CROPCAP\n");
*/
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = 1280;
fmt.fmt.pix.height = 720;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
errno_exit("VIDIOC_S_FMT");
/* Note VIDIOC_S_FMT may change width and height. */
image_size = fmt.fmt.pix.width * fmt.fmt.pix.height * 2;
/* Buggy driver paranoia. */
min = fmt.fmt.pix.width * 2;
if (fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if (fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;
switch (io) {
case IO_METHOD_READ:
init_read(fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap();
break;
case IO_METHOD_USERPTR:
printf("capture: fmt.fmt.pix.sizeimage = %d\n",
fmt.fmt.pix.sizeimage);
init_userp(fmt.fmt.pix.sizeimage);
break;
}
}
static void init_device(void) {
struct v4l2_capability cap;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format fmt;
struct v4l2_streamparm frameint;
unsigned int min;
if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n",
dev_name);
exit(EXIT_FAILURE);
} else {
errno_exit("VIDIOC_QUERYCAP");
}
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n",
dev_name);
exit(EXIT_FAILURE);
}
switch (io) {
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf(stderr, "%s does not support read i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf(stderr, "%s does not support streaming i/o\n",
dev_name);
exit(EXIT_FAILURE);
}
break;
}
/* Select video input, video standard and tune here. */
CLEAR(cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
/* Cropping not supported. */
break;
default:
/* Errors ignored. */
break;
}
}
} else {
/* Errors ignored. */
}
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (set_format) {
fmt.fmt.pix.width = width;
fmt.fmt.pix.height = height;
fmt.fmt.pix.pixelformat = pixel_format;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
errno_exit("VIDIOC_S_FMT");
if (fmt.fmt.pix.pixelformat != pixel_format) {
fprintf(stderr,"Libv4l didn't accept pixel format. Can't proceed.\n");
exit(EXIT_FAILURE);
}
/* Note VIDIOC_S_FMT may change width and height. */
} else {
/* Preserve original settings as set by v4l2-ctl for example */
if (-1 == xioctl(fd, VIDIOC_G_FMT, &fmt))
errno_exit("VIDIOC_G_FMT");
}
CLEAR(frameint);
/* Attempt to set the frame interval. */
frameint.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
frameint.parm.capture.timeperframe.numerator = 1;
frameint.parm.capture.timeperframe.denominator = fps;
if (-1 == xioctl(fd, VIDIOC_S_PARM, &frameint))
fprintf(stderr, "Unable to set frame interval.\n");
/* Buggy driver paranoia. */
min = fmt.fmt.pix.width * 2;
if (fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if (fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;
switch (io) {
case IO_METHOD_READ:
init_read(fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap();
break;
case IO_METHOD_USERPTR:
init_userp(fmt.fmt.pix.sizeimage);
break;
}
}
//***********************************************************************************
static void init_device (void)
{
struct v4l2_capability cap;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format fmt;
unsigned int min;
if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
if (EINVAL == errno) {
fprintf (stderr, "%s is no V4L2 device\n", dev_name);
exit (EXIT_FAILURE);
} else {
errno_exit ("VIDIOC_QUERYCAP");
}
}
else {
printf ("Caps returns: 0x%x\n", cap.capabilities);
}
if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf (stderr, "%s is no video capture device\n", dev_name);
exit (EXIT_FAILURE);
}
switch (io) {
case IO_METHOD_READ:
if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
fprintf (stderr, "%s does not support read i/o\n", dev_name);
//exit (EXIT_FAILURE);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
fprintf (stderr, "%s does not support streaming i/o\n", dev_name);
exit (EXIT_FAILURE);
}
break;
case IO_METHOD_SETEXPOSURE:
puts("I am in expo");
init_exposure();
break;
case IO_METHOD_SETGAIN :
puts("I am in gain");
init_gain();
break;
}
/* Select video input, video standard and tune here. */
CLEAR (cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
/* Cropping not supported. */
fprintf(stderr, " Cropping not supported\n");
break;
default:
/* Errors ignored. */
break;
}
}
} else {
/* Errors ignored. */
}
CLEAR (fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = TARGETWIDTH;
fmt.fmt.pix.height = TARGETHEIGHT;
fmt.fmt.pix.pixelformat = PIXELFMT; // defined at the top of the file
printf("capture: size: W - %d H - %d, format: 0x%x\n",
fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.pixelformat);
fmt.fmt.pix.field = V4L2_FIELD_NONE;
#if 1
if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt)) {
printf("xioctl(VIDIOC_S_FMT) failed--->It's doesn't matter. Continue...");
}
else {
printf("VIDIOC_S_FMT returned success\n");
printf(" returned: pix.width: %d pix.height: %d\n", fmt.fmt.pix.width, fmt.fmt.pix.height);
}
//;jr;$* exit for now
// printf("EXIT APPLICATION for now......\n");
// exit(0);
#endif
/* Note VIDIOC_S_FMT may change width and height. */
/* Buggy driver paranoia. */
min = fmt.fmt.pix.width * 2;
if (fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
if (fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;
switch (io) {
case IO_METHOD_READ:
init_read (fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap ();
break;
case IO_METHOD_USERPTR:
init_userp (fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_SETEXPOSURE:
break;
}
}
int filter_pe_fastq_bz2(FLT_OPTS *opts){
int left1=0,left2=0;
int stat_single1 = 0;
int stat_single2 = 0;
int stat_paired = 0;
int index=1;
char fn[128];
char outfile[128];
SEQ_QUAL item1=init_read();
SEQ_QUAL item2=init_read();
BZFILE *fp1=bzopen_report(opts->r1,"r");
BZFILE *fp2=bzopen_report(opts->r2,"r");
file_name(outfile,opt->r1);
sprintf(fn,"%s/%s.flt",opts->output,outfile);
FILE *fo1=fopen_report(fn,"w+");
if(!fo1) return -1;
file_name(outfile,opts->r2);
sprintf(fn,"%s/%s.flt",opts->output,outfile);
FILE *fo2=fopen_report(fn,"w+");
if(!fo2) return -1;
sprintf(fn,"%s/%s.flt.s",opts->output,outfile);
FILE *fos=fopen_report(fn,"w+");
if(!fos) return -1;
while(read_fastq_bz2(fp1,&item1,index) >= 0 && read_fastq_bz2(fp2,&item2,index) >= 0)
{
left1=filter_all(&item1, opts);
left2=filter_all(&item2, opts);
if(left1 == 1 && left2 == 1){
output_fastq(fo1, &item1);
output_fastq(fo2, &item2);
stat_single1++;
stat_single2++;
stat_paired++;
}else{
if(left1 == 1){
output_fastq(fos, &item1);
stat_single1++;
}
if(left2 == 1){
output_fastq(fos, &item2);
stat_single2++;
}
}
index++;
}
printf("Totally %d reads were processed\n",(index-1)*2);
printf(" file [ %s ]: %d reads were left (%.2f%)\n",opts->r1,stat_paired+stat_single1,(float) (stat_paired+stat_single1)*100/(index-1));
printf(" file [ %s ]: %d reads were left (%.2f%)\n",opts->r2,stat_paired+stat_single2,(float) (stat_paired+stat_single2)*100/(index-1));
printf("After filtering %d reads are paired in each file (%.2f%)\n",stat_paired,(float) stat_paired*100/(index-1));
printf(" file [ %s ]: %d reads were left as single end\n",opts->r1,stat_single1);
printf(" file [ %s ]: %d reads were left as single end\n",opts->r2,stat_single2);
free_read(&item1);
free_read(&item2);
BZ2_bzclose(fp1);
BZ2_bzclose(fp2);
fclose(fo1);
fclose(fo2);
fclose(fos);
return 0;
}
static void init_device(capture * cap)
{
struct v4l2_capability capb;
struct v4l2_cropcap cropcap;
struct v4l2_crop crop;
struct v4l2_format fmt;
unsigned int min;
if (-1 == xioctl(cap->fd, VIDIOC_QUERYCAP, &capb)) {
if (EINVAL == errno) {
fprintf(stderr, "%s is no V4L2 device\n", cap->dev_name);
exit(EXIT_FAILURE);
} else {
errno_exit("VIDIOC_QUERYCAP");
}
}
if (!(capb.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
fprintf(stderr, "%s is no video capture device\n", cap->dev_name);
exit(EXIT_FAILURE);
}
switch (cap->io) {
case IO_METHOD_READ:
if (!(capb.capabilities & V4L2_CAP_READWRITE)) {
fprintf(stderr, "%s does not support read i/o\n", cap->dev_name);
exit(EXIT_FAILURE);
}
break;
case IO_METHOD_MMAP:
case IO_METHOD_USERPTR:
if (!(capb.capabilities & V4L2_CAP_STREAMING)) {
fprintf(stderr, "%s does not support streaming i/o\n", cap->dev_name);
exit(EXIT_FAILURE);
}
break;
}
/* Select video input, video standard and tune here. */
CLEAR(cropcap);
cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 == xioctl(cap->fd, VIDIOC_CROPCAP, &cropcap)) {
crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c = cropcap.defrect; /* reset to default */
if (-1 == xioctl(cap->fd, VIDIOC_S_CROP, &crop)) {
switch (errno) {
case EINVAL:
/* Cropping not supported. */
break;
default:
/* Errors ignored. */
break;
}
}
} else {
/* Errors ignored. */
}
CLEAR(fmt);
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = cap->width;
fmt.fmt.pix.height = cap->height;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12;
fmt.fmt.pix.field = V4L2_FIELD_ANY;
if (-1 == xioctl(cap->fd, VIDIOC_S_FMT, &fmt)) {
errno_exit("VIDIOC_S_FMT");
}
cap->pixel_format = fmt.fmt.pix.pixelformat;
/* Note VIDIOC_S_FMT may change width and height. */
cap->width = fmt.fmt.pix.width;
cap->height = fmt.fmt.pix.height;
switch (cap->io) {
case IO_METHOD_READ:
init_read(cap, fmt.fmt.pix.sizeimage);
break;
case IO_METHOD_MMAP:
init_mmap(cap);
break;
case IO_METHOD_USERPTR:
init_userp(cap, fmt.fmt.pix.sizeimage);
break;
}
}
