Chinaunix首页 | 论坛 | 博客

飘摇的人.飘摇的生活

首页　| 　博文目录　| 　关于我

andyluo324324

  • 博客访问： 713499
  • 博文数量： 240
  • 博客积分： 3616
  • 博客等级： 大校
  • 技术积分： 2663
  • 用 户 组： 普通用户
  • 注册时间： 2010-04-21 23:59
文章分类

全部博文（240）

文章存档

2013年（6）

2012年（80）

2011年（119）

2010年（35）

我的朋友
最近访客
推荐博文
v4l2驱动浅析

分类：

2012-10-16 23:55:27

原文地址：v4l2驱动浅析 作者：lapset

选自《v4l2研究进展》 作者lapset
简介：本文所附代码是根据v4l2官方文档以及demo(capture.c)修改而来，纯粹为学习交流之用，请勿使用在商用场合。
地址：由于官方网的域名有敏感词汇，所以请google一下。
一 ，操作流程简单看
 
 
 
二 模块概要分析
 
以下是所附代码所涉及到的全局变量，摆出来只是参考，具体修改的话请自行安排。
  1. #define CLEAR(x) memset (&(x), 0, sizeof (x))

  3. typedef enum {
  4. #ifdef IO_READ
  5.         IO_METHOD_READ,
  6. #endif
  7. #ifdef IO_MMAP
  8.         IO_METHOD_MMAP,
  9. #endif
  10. #ifdef IO_USERPTR
  11.         IO_METHOD_USERPTR,
  12. #endif
  13. } io_method;

  15. struct buffer {
  16.         void * start;
  17.         size_t length;
  18. };

  20. static io_method io = IO_METHOD_MMAP;
  21. static int fd = -1;
  22. struct buffer * buffers = NULL;
  23. static unsigned int n_buffers = 0;

  25. // global settings

  27. static unsigned int width = 640;
  28. static unsigned int height = 480;
  29. static unsigned char jpegQuality = 70;
  30. static char* jpegFilename = NULL;
  31. static char* deviceName = "/dev/video0";
1，deviceOpen
   主要就是打开你的设备文件，一般情况下就是，/dev/vedio0 取决于你的设备数量。前面提到的stat这个结构体主要是记录了文件的基本信息。通过这一点来校验文件的打开权限。
 
2，deviceInit
   这个模块稍微复杂些，它主要是使用了v4l2中定义的4种相关的数据结构。以下列出每种结构的具体属性。
  
  1. struct v4l2_cropcap {

  3. enum v4l2_buf_type type;

  5.        struct v4l2_rect bounds;

  7. struct v4l2_rect defrect;

  9. struct v4l2_fract pixelaspect;

  11. };





  17. struct v4l2_crop {

  19. enum v4l2_buf_type type;

  21. struct v4l2_rect c;

  23. };





  29. struct v4l2_capability {

  31. __u8 driver[16]; /* i.e. "bttv" */

  33. __u8 card[32]; /* i.e. "Hauppauge WinTV" */

  35. __u8 bus_info[32]; /* "PCI:" + pci_name(pci_dev) */

  37. __u32 version; /* should use KERNEL_VERSION() */

  39. __u32 capabilities; /* Device capabilities */

  41. __u32 reserved[4];

  43. };





  49. struct v4l2_format {

  51. enum v4l2_buf_type type;

  53. union {

  55. struct v4l2_pix_format pix; /* V4L2_BUF_TYPE_VIDEO_CAPTURE */

  57. struct v4l2_window win; /* V4L2_BUF_TYPE_VIDEO_OVERLAY */

  59. struct v4l2_vbi_format vbi; /* V4L2_BUF_TYPE_VBI_CAPTURE */

  61. struct v4l2_sliced_vbi_format sliced; /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */

  63. __u8 raw_data[200]; /* user-defined */

  65. } fmt;

  67. };
这里不得不提醒一点，通常usb摄像头驱动，都会提供3种不同的数据传输方式，1,read IO 2,mmap内存映射 3，USERPTR（这一种是测试方法，具体可以去查询）
本文暂且只讨论常见的操作方法，即mmap内存映射方式.
通过一段时间的学习，才知道为什么只支持mmap，其实是我们所用的去架构是基于uvc.在uvc架构中，是不支持read/write io mode 以及用户扩展模式。
 
 
 
 
  1. static void deviceInit(void)
  2. {
  3.   struct v4l2_capability cap;
  4.   struct v4l2_cropcap cropcap; 
  5.   struct v4l2_crop crop;
  6.   struct v4l2_format fmt;
  7.   unsigned int min;

  9.   if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) { //get the capab info about

  11.     if (EINVAL == errno) {
  12.       fprintf(stderr, "%s is no V4L2 device\n",deviceName);
  13.       exit(EXIT_FAILURE);
  14.     } else {
  15.       errno_exit("VIDIOC_QUERYCAP");
  16.     }
  17.   }

  19.   if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { //check is it support capture mode ?

  21.     fprintf(stderr, "%s is no video capture device\n",deviceName);
  22.     exit(EXIT_FAILURE);
  23.   }

  25.   
  26.      if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
  27.         fprintf(stderr, "%s does not support streaming i/o\n",deviceName);
  28.         exit(EXIT_FAILURE);
  29.       }


  33.   /* Select video input, video standard and tune here. */
  34.   CLEAR(cropcap);// init -0    it is a initialize func about set 0 to parameter  


  37.   cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  39.   if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {
  40.     crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  41.     crop.c = cropcap.defrect; /* reset to default */

  43.     if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {
  44.       switch (errno) {
  45.         case EINVAL:
  46.           /* Cropping not supported. */
  47.           break;
  48.         default:
  49.           /* Errors ignored. */
  50.           break;
  51.       }
  52.     }
  53.   } else {
  54.   
  55.   }

  57.   CLEAR (fmt);

  59.   // v4l2_format

  61.   fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;        //mode is capture
  62.   fmt.fmt.pix.width = width;                     //define pixee width
  63.   fmt.fmt.pix.height = height;                   //define pixel height
  64.   fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;   //define pixel format
  65.   fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;      

  67.   if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))       //set fmt
  68.     errno_exit("VIDIOC_S_FMT");

  70.   /* Note VIDIOC_S_FMT may change width and height. */
  71.   if (width != fmt.fmt.pix.width) {
  72.     width = fmt.fmt.pix.width;
  73.     fprintf(stderr,"Image width set to %i by device %s.\n",width,deviceName);
  74.   }
  75.   if (height != fmt.fmt.pix.height) {
  76.     height = fmt.fmt.pix.height;
  77.     fprintf(stderr,"Image height set to %i by device %s.\n",height,deviceName);
  78.   }

  80.   /* Buggy driver paranoia. */
  81.   min = fmt.fmt.pix.width * 2;
  82.   if (fmt.fmt.pix.bytesperline < min)
  83.     fmt.fmt.pix.bytesperline = min;
  84.   min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
  85.   if (fmt.fmt.pix.sizeimage < min)
  86.     fmt.fmt.pix.sizeimage = min;

  88.   
  89.   //this function is important to init mmap pre_work
  90.   mmapInit();
  93. }
 
可以看到上面主要是初始化工作，具体的参数意义，请参看v4l2的specification 。
 
  1. static void mmapInit(void)
  2. {
  3.   struct v4l2_requestbuffers req;//apply for frame buffer


  6.   CLEAR (req);

  8.   req.count = 4;
  9.   req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  10.   req.memory = V4L2_MEMORY_MMAP;

  12.   if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
  13.     if (EINVAL == errno) {
  14.       fprintf(stderr, "%s does not support memory mapping\n", deviceName);
  15.       exit(EXIT_FAILURE);
  16.     } else {
  17.       errno_exit("VIDIOC_REQBUFS");
  18.     }
  19.   }

  21.   if (req.count < 2) {
  22.     fprintf(stderr, "Insufficient buffer memory on %s\n", deviceName);
  23.     exit(EXIT_FAILURE);
  24.   }

  26.   buffers = calloc(req.count, sizeof(*buffers));

  28.   if (!buffers) {
  29.     fprintf(stderr, "Out of memory\n");
  30.     exit(EXIT_FAILURE);
  31.   }

  33.   for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
  34.     struct v4l2_buffer buf;

  36.     CLEAR (buf);

  38.     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  39.     buf.memory = V4L2_MEMORY_MMAP;
  40.     buf.index = n_buffers;

  42.     if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))
  43.       errno_exit("VIDIOC_QUERYBUF");

  45.     buffers[n_buffers].length = buf.length;
  46.     buffers[n_buffers].start =
  47.     mmap (NULL /* start anywhere */, buf.length, PROT_READ | PROT_WRITE /* required */, MAP_SHARED /* recommended */, fd, buf.m.offset);

  49.     if (MAP_FAILED == buffers[n_buffers].start)
  50.       errno_exit("mmap");
  51.   }
  52. }
 
 
3，capture_start
初始化以后就可以进行正题了，就是所谓的capture data.不过在此之前，应该打开数据流通道，重点在于最后那个ioctl函数的参数：VIDIOC_STREAMON
 
  1. static void captureStart(void) //grap after initialize

  3. {
  4.   unsigned int i;
  5.   enum v4l2_buf_type type; //page-68


  8.  #ifdef IO_MMAP
  9.     
  10.       for (i = 0; i < n_buffers; ++i) {
  11.         struct v4l2_buffer buf;

  13.         CLEAR (buf);

  15.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  16.         buf.memory = V4L2_MEMORY_MMAP;
  17.         buf.index = i;

  19.         if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
  20.           errno_exit("VIDIOC_QBUF");
  21.       }

  23.       type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  25.       if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
  26.         errno_exit("VIDIOC_STREAMON");

  28.        #endif
上面出现的两个结构体的分别定义如下：
 
  1. enum v4l2_buf_type {
  2.     V4L2_BUF_TYPE_VIDEO_CAPTURE = 1,
  3.     V4L2_BUF_TYPE_VIDEO_OUTPUT = 2,
  4.     V4L2_BUF_TYPE_VIDEO_OVERLAY = 3,
  5.     V4L2_BUF_TYPE_VBI_CAPTURE = 4,
  6.     V4L2_BUF_TYPE_VBI_OUTPUT = 5,
  7.     V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6,
  8.     V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7,
  9. #if 1
  10.     /* Experimental */
  11.     V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
  12. #endif
  13.     V4L2_BUF_TYPE_PRIVATE = 0x80,
  14. };
  1. struct v4l2_buffer {
  2.     __u32            index;
  3.     enum v4l2_buf_type type;
  4.     __u32            bytesused;
  5.     __u32            flags;
  6.     enum v4l2_field        field;
  7.     struct timeval        timestamp;
  8.     struct v4l2_timecode    timecode;
  9.     __u32            sequence;

  11.     /* memory location */
  12.     enum v4l2_memory memory;
  13.     union {
  14.         __u32 offset;
  15.         unsigned long userptr;
  16.     } m;
  17.     __u32            length;
  18.     __u32            input;
  19.     __u32            reserved;
  20. };
 
 
4，mainloop
  这个模块主要的工作就是你获得数据后如何处理，可以直接存储，也可以实时显示在屏幕上。
  1. static void mainLoop(void)//main capture control

  3. {
  4.   unsigned int count;

  6.   count = 1;

  8.   while (count-- > 0) {
  9.     for (;;) {
  10.       fd_set fds;
  11.       struct timeval tv;
  12.       int r;

  14.       FD_ZERO(&fds);
  15.       FD_SET(fd, &fds);

  17.       /* Timeout. */
  18.       tv.tv_sec = 2;
  19.       tv.tv_usec = 0;

  21.       r = select(fd + 1, &fds, NULL, NULL, &tv);

  23.       if (-1 == r) {
  24.         if (EINTR == errno)
  25.           continue;

  27.         errno_exit("select");
  28.       }

  30.       if (0 == r) {
  31.         fprintf (stderr, "select timeout\n");
  32.         exit(EXIT_FAILURE);
  33.       }

  35.       if (frameRead())
  36.         break;

  38.       /* EAGAIN - continue select loop. */
  39.     }
  40.   }
  41. }
 上面的frameRead函数很亮。请看：
  1. static int frameRead(void)
  2. {
  3.   struct v4l2_buffer buf;

  7.       CLEAR (buf);
  8.       buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  9.       buf.memory = V4L2_MEMORY_MMAP;
  10.      if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {
  11.         switch (errno) {
  12.           case EAGAIN:
  13.             return 0;
  14.           case EIO:
  15.           default:
  16.             errno_exit("VIDIOC_DQBUF");
  17.         }
  18.       }

  20.        assert(buf.index < n_buffers);//反logic
  21.        imageProcess(buffers[buf.index].start);

  23.        if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
  24.         errno_exit("VIDIOC_QBUF");

  26. }
上面的imageProcess函数，我采用的是存储的做法。也可以转换为RGB，再转换为jpg
算法如下：
 
  1. static void jpegWrite(unsigned char* img)
  2. {
  3.   struct jpeg_compress_struct cinfo;
  4.   struct jpeg_error_mgr jerr;

  6.   JSAMPROW row_pointer[1];
  7.   //char name[4]={'a','b','c','x'};



  11.   FILE *outfile = fopen( jpegFilename, "wb" );

  13.   // try to open file for saving

  15.   if (!outfile) {
  16.     errno_exit("jpeg");
  17.   }

  19.   // create jpeg data

  21.   cinfo.err = jpeg_std_error( &jerr );
  22.   jpeg_create_compress(&cinfo);
  23.   jpeg_stdio_dest(&cinfo, outfile);

  25.   // set image parameters

  27.   cinfo.image_width = width;
  28.   cinfo.image_height = height;
  29.   cinfo.input_components = 3;
  30.   cinfo.in_color_space = JCS_RGB;

  32.   // set jpeg compression parameters to default

  34.   jpeg_set_defaults(&cinfo);
  35.   // and then adjust quality setting

  37.   jpeg_set_quality(&cinfo, jpegQuality, TRUE);

  39.   // start compress

  41.   jpeg_start_compress(&cinfo, TRUE);

  43.   // feed data

  45.   while (cinfo.next_scanline < cinfo.image_height) {
  46.     row_pointer[0] = &img[cinfo.next_scanline * cinfo.image_width *

  48. cinfo.input_components];
  49.     jpeg_write_scanlines(&cinfo, row_pointer, 1);
  50.   }

  52.   // finish compression

  54.   jpeg_finish_compress(&cinfo);

  56.   // destroy jpeg data

  58.   jpeg_destroy_compress(&cinfo);

  60.   // close output file

  62.   fclose(outfile);
  63. }

  65. /**
  66.   process image read
  67. */
  68. static void imageProcess(const void* p)
  69. {
  70.   unsigned char* src = (unsigned char*)p;
  71.   unsigned char* dst = malloc(width*height*3*sizeof(char));

  73.   // convert from YUV422 to RGB888

  75.   YUV422toRGB888(width,height,src,dst);

  77.   // write jpeg

  79.   jpegWrite(dst);
  80. }


  83. static void YUV422toRGB888(int width, int height, unsigned char *src, unsigned char

  85. *dst)
  86. {
  87.   int line, column;
  88.   unsigned char *py, *pu, *pv;
  89.   unsigned char *tmp = dst;

  91.   /* In this format each four bytes is two pixels. Each four bytes is two Y's, a Cb

  93. and a Cr.
  94.      Each Y goes to one of the pixels, and the Cb and Cr belong to both pixels. */
  95.   py = src;
  96.   pu = src + 1;
  97.   pv = src + 3;

  99.   #define CLIP(x) ( (x)>=0xFF ? 0xFF : ( (x) <= 0x00 ? 0x00 : (x) ) )

  101.   for (line = 0; line < height; ++line) {
  102.     for (column = 0; column < width; ++column) {
  103.       *tmp++ = CLIP((double)*py + 1.402*((double)*pv-128.0));
  104.       *tmp++ = CLIP((double)*py - 0.344*((double)*pu-128.0) - 0.714*((double)*pv-

  106. 128.0));
  107.       *tmp++ = CLIP((double)*py + 1.772*((double)*pu-128.0));

  109.       // increase py every time

  111.       py += 2;
  112.       // increase pu,pv every second time

  114.       if ((column & 1)==1) {
  115.         pu += 4;
  116.         pv += 4;
  117.       }
  118.     }
  119.   }
  120. }
 
 
5，关闭捕捉数据流代码，重点在与ioctl（）函数的参数：VIDIOC_STREAMOFF，这个和capture_start中的VIDIOC_STREAMON成对使用。
 
  1. static void captureStop(void)
  2. {
  3.   enum v4l2_buf_type type;

  6.       type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

  8.       if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))
  9.         errno_exit("VIDIOC_STREAMOFF");
  10.  }
6， 设备关闭相关
 
  1. static void deviceUninit(void)
  2. {
  3.   unsigned int i;
  5.       for (i = 0; i < n_buffers; ++i)
  6.       if (-1 == munmap (buffers[i].start, buffers[i].length))
  7.         errno_exit("munmap");
  8.          for (i = 0; i < n_buffers; ++i)
  9.         free (buffers[i].start);
  10.       
  11.   free(buffers);
  12. }
 
 
7，关闭设备文件
  1. static void deviceClose(void)
  2. {
  3.   if (-1 == close (fd))
  4.     errno_exit("close");

  6.   fd = -1;
  7. }
阅读(742) | 评论(0) | 转发(0) |
0

上一篇：v4l2驱动浅析

下一篇：Linux内存：内存管理的实质

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6