V4L2 + opencv3 Linux获取摄像头数据显示 程序源码

/*
* V4L2 video capture example
*
* This program can be used and distributed without restrictions.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h> /* getopt_long() */
#include <fcntl.h> /* low-level i/o */
#include <unistd.h>
#include <malloc.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm/types.h> /* for videodev2.h */
#include <linux/videodev2.h>
#include <opencv2/opencv.hpp>

#include <jpeglib.h>
#include <iostream>
#include <boost/thread/thread.hpp>
#define CLEAR(x) memset (&(x), 0, sizeof (x))

#define Img_WIDTH 1504
#define Img_HEIGHT 1504
#define YUYV    //YUYV  MJEGP
#define ShowImg false //YUYV  MJEGP
#define FrameRate 30

typedef enum {
  IO_METHOD_READ,
  IO_METHOD_MMAP,
  IO_METHOD_USERPTR,
} io_method;

struct buffer {
  void * start;
  size_t length;
};

static char * dev_name = NULL;
static io_method io = IO_METHOD_MMAP;
static int fd = -1;
struct buffer * buffers = NULL;
static unsigned int n_buffers = 0;
static void errno_exit (const char * s)
{
  fprintf (stderr, "%s error %d, %s\n",s, errno, strerror (errno));
  exit (EXIT_FAILURE);
}
static int xioctl(int fd,int request,void * arg)
{
  int r;
  do r = ioctl (fd, request, arg);// ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速等等。它的调用个数如下
  while (-1 == r && EINTR == errno);
  return r;
}
static void process_image(const void * p)
{
  fputc('.',stdout);
  fputc('.',stdout);
  fflush(stdout);
}
double t_old; 
static void process_image(const void * p,int length)
{
  // std::cout<<"length = "<<length<<std::endl;  
  double t = ((double)cv::getTickCount()-t_old)/cv::getTickFrequency();
  // std::cout<<" t = "<<t*1000<<" ms"<<std::endl;
  t_old = (double)cv::getTickCount();

#ifdef YUYV
  cv::Mat M(Img_HEIGHT,Img_WIDTH,CV_8U); 
  uchar *data = (uchar*)M.data;
  for(int i=0;i<Img_HEIGHT*Img_WIDTH;i++)
  {
      data[i] = *((uchar*)p+2*i);
  } 
  if(ShowImg)
  {
    cv::imshow("img_gray",M);
    cv::waitKey(1);
  }
#endif
#ifdef MJPEG
  cv::Mat M(Img_HEIGHT,Img_WIDTH*2,CV_8U); 
  uchar *data = (uchar*)M.data;
  for(int i=0;i<Img_HEIGHT*Img_WIDTH*2;i++)
  {
    data[i] = *((uchar*)p+i);
  } 
  cv::Mat A = cv::imdecode(M,cv::IMREAD_GRAYSCALE);
  cv::imshow("img_gray",A);
  cv::waitKey(1);
  if(ShowImg)
  {
    cv::imshow("img_gray",M);
    cv::waitKey(1);
  }
#endif
}

static int read_frame(void)
{
  struct v4l2_buffer buf;
  unsigned int i;
  switch (io) {
    case IO_METHOD_READ:
      if (-1 == read (fd, buffers[0].start, buffers[0].length)) {
        switch (errno) 
        {
          case EAGAIN:
            return 0;
          case EIO:
          /* Could ignore EIO, see spec. */
          /* fall through */
          default:
            errno_exit ("read");
        }
      }
      process_image (buffers[0].start,buffers[0].length);
      break;
    case IO_METHOD_MMAP:
      CLEAR (buf);
      buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      buf.memory = V4L2_MEMORY_MMAP;
      if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
        switch (errno) {
          case EAGAIN:
            return 0;
          case EIO:
          /* Could ignore EIO, see spec. */
          /* fall through */
          default:
          errno_exit ("VIDIOC_DQBUF");
        }
      }
      assert (buf.index < n_buffers);
      process_image (buffers[buf.index].start,buffers[buf.index].length);
      {
        FILE *fp = NULL;
        // fp = fopen("/home/huajun/hj/test.jpg", "w");
        if (fp != NULL)
        {
                // fwrite(buffers[buf.index].start, 1, buffers[buf.index].length, fp);
                sync();
                // fclose(fp);
        }
      }

      if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
        errno_exit ("VIDIOC_QBUF");
      break;
    case IO_METHOD_USERPTR:
      CLEAR (buf);
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_USERPTR;
    if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
      switch (errno) {
        case EAGAIN:
          return 0;
        case EIO:
        /* Could ignore EIO, see spec. */
        /* fall through */
        default:
          errno_exit ("VIDIOC_DQBUF");
      }
    }
    for (i = 0; i < n_buffers; ++i)
      if (buf.m.userptr == (unsigned long) buffers[i].start && buf.length == buffers[i].length)
        break;
    assert (i < n_buffers);
    process_image ((void *) buf.m.userptr);
    if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
      errno_exit ("VIDIOC_QBUF");
      break;
  }
  return 1;
}

static void mainloop(void)
{
  unsigned int count;
  count = 100;
  while (1) {
    for (;;) {
      fd_set fds;
      struct timeval tv;
      int r;
      FD_ZERO (&fds); //将指定的文件描述符集清空，在对文件描述符集合进行设置前，必须对其进行初始化，如果不清空，由于在系统分配内存空间后，通常并不作清空处理，所以结果是不可知的。
      FD_SET (fd, &fds); //用于在文件描述符集合中增加一个新的文件描述符。 

      // std::cout<<" fd = "<<fd<<std::endl;
      /* Timeout. */
      tv.tv_sec = 4;
      tv.tv_usec = 0;
      // t_old = (double)cv::getTickCount();
      r = select (fd + 1, &fds, NULL, NULL, &tv); //用于在非阻塞中，当一个套接字或一组套接字有信号时通知你，系统提供select函数来实现多路复用输入/输出模型
      // double t = ((double)cv::getTickCount()-t_old)/cv::getTickFrequency();
      // std::cout<<" t = "<<t*1000<<" ms"<<std::endl;
      if(-1 == r) {
        if (EINTR == errno)
          continue;
        errno_exit ("select");
      }
      if(0 == r) {
        fprintf (stderr, "select timeout\n");
        exit (EXIT_FAILURE);
      }
      if(read_frame())
      {
        break;
      }
        /* EAGAIN - continue select loop. */
    }
  }
}
static void stop_capturing(void)
{
  enum v4l2_buf_type type;
  switch (io) {
    case IO_METHOD_READ:
    /* Nothing to do. */
      break;
    case IO_METHOD_MMAP:
    case IO_METHOD_USERPTR:
      type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type))
      errno_exit ("VIDIOC_STREAMOFF");
      break;
  }
}
static void start_capturing(void)
{
  unsigned int i;
  enum v4l2_buf_type type;
  switch (io) {
    case IO_METHOD_READ:
      /* Nothing to do. */
      break;
    case IO_METHOD_MMAP:
      for (i = 0; i < n_buffers; ++i) {
        struct v4l2_buffer buf;
        CLEAR (buf);
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = i;
        if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
          errno_exit ("VIDIOC_QBUF");
      }
      type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
        errno_exit ("VIDIOC_STREAMON");
      break;
    case IO_METHOD_USERPTR:
      for (i = 0; i < n_buffers; ++i) {
        struct v4l2_buffer buf;
        CLEAR (buf);
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_USERPTR;
        buf.m.userptr = (unsigned long) buffers[i].start;
        buf.length = buffers[i].length;
        if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
          errno_exit ("VIDIOC_QBUF");
      }
      type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
      if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
      errno_exit ("VIDIOC_STREAMON");
      break;
  }
}

static void uninit_device (void)
{
  unsigned int i;
  switch (io) {
    case IO_METHOD_READ:
      free (buffers[0].start);
      break;
    case IO_METHOD_MMAP:
      for (i = 0; i < n_buffers; ++i)
        if(-1 == munmap (buffers[i].start, buffers[i].length))
          errno_exit ("munmap");
      break;
    case IO_METHOD_USERPTR:
      for (i = 0; i < n_buffers; ++i)
        free (buffers[i].start);
    break;
  }
  free (buffers);
}

static void init_read(unsigned int buffer_size)
{
  buffers = (buffer*)calloc (1, sizeof (*buffers));//内存的动态存储区中分配n个长度为size的连续空间，函数返回一个指向分配起始地址的指针
  if (!buffers) {
    fprintf (stderr, "Out of memory\n");
    exit (EXIT_FAILURE);
  }
  buffers[0].length = buffer_size;
  buffers[0].start = malloc (buffer_size); //malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型
  if (!buffers[0].start) {
    fprintf (stderr, "Out of memory\n");
    exit (EXIT_FAILURE);
  }
}

static void init_mmap(void)
{
  struct v4l2_requestbuffers req;
  CLEAR (req);
  req.count = 4;
  req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  req.memory = V4L2_MEMORY_MMAP;
  if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) { //申请若干个帧缓冲区
    if (EINVAL == errno) {
      fprintf (stderr, "%s does not support "
      "memory mapping\n", dev_name);
      exit (EXIT_FAILURE);
    } 
    else {
      errno_exit ("VIDIOC_REQBUFS");
    }
  }
  if(req.count < 2) {
    fprintf (stderr, "Insufficient buffer memory on %s\n",dev_name);
    exit (EXIT_FAILURE);
  }
  buffers = (buffer*)calloc(req.count, sizeof (*buffers));
  if (!buffers) {
    fprintf (stderr, "Out of memory\n");
    exit (EXIT_FAILURE);
  }
  for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
    struct v4l2_buffer buf;
    CLEAR (buf);
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    buf.index = n_buffers;
    if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))   //查询帧缓冲区在内核中的偏移量和长度
    errno_exit ("VIDIOC_QUERYBUF");
    buffers[n_buffers].length = buf.length;
    buffers[n_buffers].start = mmap (NULL , buf.length,PROT_READ | PROT_WRITE , MAP_SHARED , fd, buf.m.offset);
    if (MAP_FAILED == buffers[n_buffers].start)
    errno_exit ("mmap");
  }
}

static void init_userp(unsigned int buffer_size)
{
  struct v4l2_requestbuffers req;
  CLEAR (req);
  req.count = 4;
  req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  req.memory = V4L2_MEMORY_USERPTR;
  if(-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
    if (EINVAL == errno) {
      fprintf (stderr, "%s does not support "
      "user pointer i/o\n", dev_name);
      exit (EXIT_FAILURE);
    } 
    else {
      errno_exit ("VIDIOC_REQBUFS");
    }
  }
  buffers = (buffer*)calloc (4, sizeof (*buffers));
  if (!buffers) {
    fprintf (stderr, "Out of memory\n");
    exit (EXIT_FAILURE);
  }
  for (n_buffers = 0; n_buffers < 4; ++n_buffers) {
    buffers[n_buffers].length = buffer_size;
    buffers[n_buffers].start = malloc (buffer_size);
    if (!buffers[n_buffers].start) {
    fprintf (stderr, "Out of memory\n");
    exit (EXIT_FAILURE);
    }
  }
}

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)) { //使用ioctl VIDIOC_QUERYCAP 来查询当前driver是否合乎规范 因为V4L2要求所有driver 和Device都支持这个Ioctl
    if (EINVAL == errno) {  /* Invalid argument */
      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 */  //c是表示采集窗口的大小的结构体，
    if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
      switch (errno) {
        case EINVAL:
        /* Cropping not supported. */
        break;
        default:
        /* Errors ignored. */
        break;
      }
    }
  } 
  else {
    /* Errors ignored. */
  }

  int ret;
  struct v4l2_fmtdesc fmt_my;
  memset(&fmt_my, 0, sizeof(fmt_my));
  fmt_my.index = 0;
  fmt_my.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  while ((ret = ioctl(fd, VIDIOC_ENUM_FMT, &fmt_my)) == 0) {  //查询支持的格式
    printf("{ pixelformat = '%c%c%c%c', description = '%s' }\n",
        fmt_my.pixelformat & 0xFF, (fmt_my.pixelformat >> 8) & 0xFF,
        (fmt_my.pixelformat >> 16) & 0xFF, (fmt_my.pixelformat >> 24) & 0xFF,
        fmt_my.description);
        fmt_my.index++;
   }

  CLEAR (fmt);
  fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  fmt.fmt.pix.width = Img_WIDTH;
  fmt.fmt.pix.height = Img_HEIGHT;
  #ifdef YUYV
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;//V4L2_PIX_FMT_MJPEG;//
  #endif
  #ifdef MJPEG
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;//V4L2_PIX_FMT_YUYV;//
  #endif
  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;



    struct v4l2_streamparm Stream_Parm;
    memset(&Stream_Parm, 0, sizeof(struct v4l2_streamparm));  
    Stream_Parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    Stream_Parm.parm.capture.timeperframe.denominator =FrameRate; //分母
    Stream_Parm.parm.capture.timeperframe.numerator = 1;  //分子
    if(-1 == xioctl(fd, VIDIOC_S_PARM, &Stream_Parm))  //设置帧数
    {
      printf("Set frame rate failed\n");
    }
    memset(&Stream_Parm, 0, sizeof(struct v4l2_streamparm));  
    Stream_Parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    if(-1 == xioctl(fd, VIDIOC_G_PARM, &Stream_Parm))  //获取帧数
    {
      printf("Get frame rate failed\n");
    }
    int capability = Stream_Parm.parm.capture.capability;
    int capturemode = Stream_Parm.parm.capture.capturemode;
    int numerator = Stream_Parm.parm.capture.timeperframe.numerator;
    int denominator = Stream_Parm.parm.capture.timeperframe.denominator;
    std::cout<<" numerator = "<<numerator<<std::endl;
    std::cout<<" denominator = "<<denominator<<std::endl;
    std::cout<<" capability = "<<capability<<std::endl;  //4096 表示能设置帧率
    std::cout<<" capturemode = "<<capturemode<<std::endl;  //

  struct v4l2_queryctrl  Setting;
  Setting.id = V4L2_CID_GAIN;
  if(-1 == xioctl(fd, VIDIOC_QUERYCTRL, &Setting))  //查询支持的增益设置
  {
    printf(" Query GAIN settings failed \n");
  }
  else
    printf(" V4L2_CID_GAIN Setting \n minimum = '%d' maximum = '%d' step = '%d' default_value = '%d' \n",
        Setting.minimum, Setting.maximum,Setting.step,Setting.default_value);

  struct v4l2_control ctrl;
  ctrl.id = V4L2_CID_GAIN;
  ctrl.value = 4;
  if( -1 == ioctl(fd, VIDIOC_S_CTRL, &ctrl))  //设置增益
  {
    printf(" Set GAIN failed \n");
  }

   Setting.id = V4L2_CID_EXPOSURE_ABSOLUTE;
  if(-1 == xioctl(fd, VIDIOC_QUERYCTRL, &Setting))  //查询支持的曝光时间
  {
    printf(" Query EXPOSURE settings failed \n");
  }
  else
    printf(" V4L2_CID_EXPOSURE Setting \n minimum = '%d' maximum = '%d' step = '%d' default_value = '%d' \n",
        Setting.minimum, Setting.maximum,Setting.step,Setting.default_value);

  ctrl.id = V4L2_CID_EXPOSURE_AUTO;
  ctrl.value = V4L2_EXPOSURE_MANUAL;
  if(-1 == ioctl(fd, VIDIOC_S_CTRL, &ctrl))  //设置曝光模式
  {    
    printf("  set EXPOSURE Mode failed\n");
  }
  ctrl.id = V4L2_CID_EXPOSURE_ABSOLUTE;
  ctrl.value = 300;
  if( -1 == ioctl(fd, VIDIOC_S_CTRL, &ctrl))   //设置曝光时间
  {
    printf("  set EXPOSURE Time failed\n");
  }

  Setting.id = V4L2_CID_BRIGHTNESS;
  if(-1 == xioctl(fd, VIDIOC_QUERYCTRL, &Setting))  //查询支持的亮度
  {
    printf(" Query BRIGHTNESS settings failed \n");
  }
  else
    printf(" V4L2_CID_BRIGHTNESS Setting \n minimum = '%d' maximum = '%d' step = '%d' default_value = '%d' \n",
        Setting.minimum, Setting.maximum,Setting.step,Setting.default_value);
  ctrl.id = V4L2_CID_BRIGHTNESS;
  ctrl.value = 0;
  if( -1 == ioctl(fd, VIDIOC_S_CTRL, &ctrl))   //设置亮度
  {
    printf("set BRIGHTNESS failed\n");
  }


  Setting.id = V4L2_CID_CONTRAST;
  if(-1 == xioctl(fd, VIDIOC_QUERYCTRL, &Setting))  //查询支持的对比度
  {
    printf(" Query CONTRAST settings failed \n");
  }
  else
    printf(" V4L2_CID_CONTRAST Setting \n minimum = '%d' maximum = '%d' step = '%d' default_value = '%d' \n",
        Setting.minimum, Setting.maximum,Setting.step,Setting.default_value);
  ctrl.id = V4L2_CID_CONTRAST;
  ctrl.value = 0;
  if( -1 == ioctl(fd, VIDIOC_S_CTRL, &ctrl))   //设置对比度
  {
    printf("set BRIGHTNESS failed\n");
  }


  Setting.id = V4L2_CID_SATURATION;
  if(-1 == xioctl(fd, VIDIOC_QUERYCTRL, &Setting))  //查询支持的饱和度
  {
    printf(" Query SATURATION settings failed \n");
  }
  else
    printf(" V4L2_CID_SATURATION Setting \n minimum = '%d' maximum = '%d' step = '%d' default_value = '%d' \n",
        Setting.minimum, Setting.maximum,Setting.step,Setting.default_value);
  ctrl.id = V4L2_CID_SATURATION;
  ctrl.value = 0;
  if( -1 == xioctl(fd, VIDIOC_S_CTRL, &ctrl))   //设置饱和度
  {
    printf("set BRIGHTNESS failed\n");
  }

    Setting.id = V4L2_CID_HUE;
  if(-1 == xioctl(fd, VIDIOC_QUERYCTRL, &Setting))  //查询支持的色彩
  {
    printf(" Query HUE settings failed \n");
  }
  else
    printf(" V4L2_CID_HUE Setting \n minimum = '%d' maximum = '%d' step = '%d' default_value = '%d' \n",
        Setting.minimum, Setting.maximum,Setting.step,Setting.default_value);
  ctrl.id = V4L2_CID_HUE;         
  ctrl.value = 0;
  if( -1 == xioctl(fd, VIDIOC_S_CTRL, &ctrl))   //设置色彩
  {
    printf("set HUE failed\n");
  }

    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 close_device(void)
{
  if (-1 == close (fd))
  errno_exit ("close");
  fd = -1;
}

static void open_device(void)
{
  struct stat st;
  if (-1 == stat (dev_name, &st)) { //将dev_name的状态复制到st里面
    fprintf(stderr, "Cannot identify '%s': %d, %s\n",dev_name, errno, strerror (errno));
    exit (EXIT_FAILURE);
  }
  if (!S_ISCHR (st.st_mode)) { //判断是否字符
    fprintf (stderr, "%s is no device\n", dev_name);
    exit (EXIT_FAILURE);
  }
  fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);//打开设备 成功返回新分配的文件描述符  可读可写打开 对于设备文件，以O_NONBLOCK方式打开可以做非阻塞I/O（Nonblock I/O）。
  if (-1 == fd) {
    fprintf (stderr, "Cannot open '%s': %d, %s\n",
    dev_name, errno, strerror (errno));
    exit (EXIT_FAILURE);
  }
}

static void usage(FILE * fp,int argc,char ** argv)
{
  fprintf (fp,
  "Usage: %s [options]\n\n"
  "Options:\n"
  "-d | --device name Video device name [/dev/video]\n"
  "-h | --help Print this message\n"
  "-m | --mmap Use memory mapped buffers\n"
  "-r | --read Use read() calls\n"
  "-u | --userp Use application allocated buffers\n"
  "",
  argv[0]);
}

static const char short_options [] = "d:hmru";
static const struct option long_options [] = {
    { "device", required_argument, NULL, 'd' },
    { "help", no_argument, NULL, 'h' },
    { "mmap", no_argument, NULL, 'm' },
    { "read", no_argument, NULL, 'r' },
    { "userp", no_argument, NULL, 'u' },
    { 0, 0, 0, 0 }
};
int main (int argc, char ** argv)
{
  dev_name = "/dev/video";
  for (;;) {
    int index;
    int c;
    c = getopt_long (argc, argv,short_options, long_options,&index);
    if (-1 == c)
    break;
    switch (c) {
      case 0: /* getopt_long() flag */
      break;
      case 'd':
        dev_name = optarg;
        break;
      case 'h':
        usage (stdout, argc, argv);
        exit (EXIT_SUCCESS);
      case 'm':
        io = IO_METHOD_MMAP;
        break;
      case 'r':
        io = IO_METHOD_READ;
        break;
      case 'u':
        io = IO_METHOD_USERPTR;
        break;
      default:
        usage (stderr, argc, argv);
        exit (EXIT_FAILURE);
    }
  }
  open_device ();
  init_device ();
  start_capturing ();
  mainloop ();
  stop_capturing ();
  uninit_device ();
  close_device ();
  exit (EXIT_SUCCESS);
  return 0;
}