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; } }