Ubuntu10.04中利用V4L2读取摄像头数据并保存成文件

转载：http://blog.chinaunix.net/uid-29339876-id-4042245.html
    
    利用V4L2读取UVC摄像头数据并保存成视频文件，主要参考http://linuxtv.org/downloads/v4l-dvb-apis/index.html中的示例Appendix D. Video Capture Example ， 将读取的文件保存在当前目录下的file.yuv中，修改后的完成代码如下：
    

点击(此处)折叠或打开

1. /*
   
2.  * V4L2 video capture example
   
3.  * AUTHOT : WANGTISHENG
   
4.  * DATA : 2013-12-18
   
5.  */
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. #include <string.h>
   
9. #include <assert.h>
   
10. #include <getopt.h> /* getopt_long() */
    
11. #include <fcntl.h> /* low-level i/o */
    
12. #include <unistd.h>
    
13. #include <errno.h>
    
14. #include <sys/stat.h>
    
15. #include <sys/types.h>
    
16. #include <sys/time.h>
    
17. #include <sys/mman.h>
    
18. #include <sys/ioctl.h>
    
19. 
    
20. #include <linux/videodev2.h>
    
21. 
    
22. #define CLEAR(x) memset(&(x), 0, sizeof(x))
    
23. 
    
24. struct buffer {
    
25.         void *start;
    
26.         size_t length;
    
27. };
    
28. 
    
29. static char *dev_name;
    
30. static int fd = -1;        //DEVICE NUMBER
    
31. struct buffer *buffers;
    
32. static unsigned int n_buffers;
    
33. static int frame_count = 70;
    
34. FILE *fp;                                //FILE POINTOR
    
35. 
    
36. static void errno_exit(const char *s)
    
37. {
    
38.         fprintf(stderr, "%s error %d, %s\n", s, errno, strerror(errno));
    
39.         exit(EXIT_FAILURE);
    
40. }
    
41. 
    
42. static int xioctl(int fh, int request, void *arg)
    
43. {
    
44.         int r;
    
45.         do {
    
46.                 r = ioctl(fh, request, arg);
    
47.         } while (-1 == r && EINTR == errno);
    
48.         return r;
    
49. }
    
50. //处理函数
    
51. static void process_image(const void *p, int size)
    
52. {
    
53.         fwrite(p,size, 1, fp); 
    
54. }
    
55. 
    
56. static int read_frame(FILE *fp)
    
57. {
    
58.         struct v4l2_buffer buf;
    
59.         CLEAR(buf);
    
60. 
    
61.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
62.         buf.memory = V4L2_MEMORY_MMAP;
    
63.         
    
64.         if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) 
    
65.                 errno_exit("VIDIOC_DQBUF");
    
66.         
    
67.         process_image(buffers[buf.index].start, buf.bytesused);
    
68. 
    
69.         if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
    
70.             errno_exit("VIDIOC_QBUF"); 
    
71. 
    
72.         return 1;
    
73. }
    
74. 
    
75. static void mainloop(void)
    
76. {
    
77.         unsigned int count;
    
78.         count = frame_count;
    
79.         while (count-- > 0) {
    
80.             printf("No.%d\n",frame_count - count);        //显示当前帧数目
    
81.             read_frame(fp);
    
82.         }
    
83.         printf("\nREAD AND SAVE DONE!\n");
    
84. }
    
85. 
    
86. static void stop_capturing(void)
    
87. {
    
88.         enum v4l2_buf_type type;
    
89. 
    
90.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
91.         if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))
    
92.             errno_exit("VIDIOC_STREAMOFF");
    
93. }
    
94. 
    
95. static void start_capturing(void)
    
96. {
    
97.         unsigned int i;
    
98.         enum v4l2_buf_type type;
    
99. 
    
100.         for (i = 0; i < n_buffers; ++i) {
     
101.                 struct v4l2_buffer buf;
     
102. 
     
103.                 CLEAR(buf);
     
104.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
105.                 buf.memory = V4L2_MEMORY_MMAP;
     
106.                 buf.index = i;
     
107. 
     
108.                 if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
     
109.                         errno_exit("VIDIOC_QBUF");
     
110.         }
     
111.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
112.         if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
     
113.                 errno_exit("VIDIOC_STREAMON");
     
114. }
     
115. 
     
116. static void uninit_device(void)
     
117. {
     
118.         unsigned int i;
     
119. 
     
120.         for (i = 0; i < n_buffers; ++i)
     
121.                 if (-1 == munmap(buffers[i].start, buffers[i].length))
     
122.                         errno_exit("munmap");
     
123. 
     
124.         free(buffers);
     
125. }
     
126. 
     
127. 
     
128. 
     
129. static void init_mmap(void)
     
130. {
     
131.         struct v4l2_requestbuffers req;
     
132. 
     
133.         CLEAR(req);
     
134. 
     
135.         req.count = 4;
     
136.         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
137.         req.memory = V4L2_MEMORY_MMAP;
     
138. 
     
139.         if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
     
140.                 if (EINVAL == errno) {
     
141.                         fprintf(stderr, "%s does not support "
     
142.                                  "memory mapping\n", dev_name);
     
143.                         exit(EXIT_FAILURE);
     
144.                 } else {
     
145.                         errno_exit("VIDIOC_REQBUFS");
     
146.                 }
     
147.         }
     
148. 
     
149.         if (req.count < 2) {
     
150.                 fprintf(stderr, "Insufficient buffer memory on %s\n",
     
151.                          dev_name);
     
152.                 exit(EXIT_FAILURE);
     
153.         }
     
154. 
     
155.         buffers = calloc(req.count, sizeof(*buffers));
     
156. 
     
157.         if (!buffers) {
     
158.                 fprintf(stderr, "Out of memory\n");
     
159.                 exit(EXIT_FAILURE);
     
160.         }
     
161. 
     
162.         for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
     
163.                 struct v4l2_buffer buf;
     
164. 
     
165.                 CLEAR(buf);
     
166. 
     
167.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
168.                 buf.memory = V4L2_MEMORY_MMAP;
     
169.                 buf.index = n_buffers;
     
170. 
     
171.                 if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))
     
172.                         errno_exit("VIDIOC_QUERYBUF");
     
173. 
     
174.                 buffers[n_buffers].length = buf.length;
     
175.                 buffers[n_buffers].start =
     
176.                         mmap(NULL /* start anywhere */,
     
177.                               buf.length,
     
178.                               PROT_READ | PROT_WRITE /* required */,
     
179.                               MAP_SHARED /* recommended */,
     
180.                               fd, buf.m.offset);
     
181. 
     
182.                 if (MAP_FAILED == buffers[n_buffers].start)
     
183.                         errno_exit("mmap");
     
184.         }
     
185. }
     
186. 
     
187. 
     
188. static void init_device(void)
     
189. {
     
190.         struct v4l2_capability cap;
     
191.         struct v4l2_format fmt;
     
192. 
     
193.         if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {        //测试参数
     
194.                 if (EINVAL == errno) {
     
195.                         fprintf(stderr, "%s is no V4L2 device\n",
     
196.                                  dev_name);
     
197.                         exit(EXIT_FAILURE);
     
198.                 } else {
     
199.                         errno_exit("VIDIOC_QUERYCAP");
     
200.                 }
     
201.         }
     
202. 
     
203.         if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
     
204.                 fprintf(stderr, "%s is no video capture device\n",
     
205.                          dev_name);
     
206.                 exit(EXIT_FAILURE);
     
207.         }
     
208. 
     
209.         if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
     
210.                 fprintf(stderr, "%s does not support streaming i/o\n",
     
211.                     dev_name);
     
212.                 exit(EXIT_FAILURE);
     
213.         }
     
214. 
     
215. 
     
216. 
     
217. 
     
218.         CLEAR(fmt); 
     
219.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
220.         fmt.fmt.pix.width = 640;
     
221.         fmt.fmt.pix.height = 480;
     
222.         fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
     
223.         fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
     
224. 
     
225.         if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))        //设置格式
     
226.                 errno_exit("VIDIOC_S_FMT");        
     
227.         init_mmap();
     
228. }
     
229. 
     
230. static void close_device(void)
     
231. {
     
232.         if (-1 == close(fd))
     
233.                 errno_exit("close");
     
234. 
     
235.         fd = -1;
     
236. }
     
237. 
     
238. static void open_device(void)
     
239. {
     
240.         //加上O_NONBLOCK会出现如下错误
     
241.         //VIDIOC_DQBUF error 11, Resource temporarily unavailable
     
242.         fd = open(dev_name, O_RDWR /* required */ /*| O_NONBLOCK*/, 0);
     
243. 
     
244.         if (-1 == fd) {
     
245.                 fprintf(stderr, "Cannot open '%s': %d, %s\n",
     
246.                          dev_name, errno, strerror(errno));
     
247.                 exit(EXIT_FAILURE);
     
248.         }
     
249. }
     
250. 
     
251. 
     
252. int main(int argc, char **argv)
     
253. {
     
254.         dev_name = "/dev/video0";
     
255.         
     
256.         if(argc != 2)
     
257.         {
     
258.             printf("usage :%s filename\n", argv[0]);
     
259.             exit(0);
     
260.         }
     
261.         if ((fp = fopen(argv[1], "w")) == NULL) { 
     
262.             perror("Creat file failed"); 
     
263.             exit(0); 
     
264.         } 
     
265.         open_device();
     
266.         init_device();
     
267.         start_capturing();
     
268.         mainloop();                //主要处理均在该函数中实现
     
269.         fclose(fp);
     
270.         stop_capturing();
     
271.         uninit_device();
     
272.         close_device();
     
273.         //fprintf(stderr, "\n");
     
274.         return 0;
     
275. }

Makefile   

点击(此处)折叠或打开

1. v4l2_capture_example:v4l2_capture_example.c
   
2.     gcc -Wall -o $@ $<
   
3. 
   
4. clean:
   
5.     rm -rf v4l2_capture_example

make测试
    运行方法
        $ ./v4l2_capture_example file.yuv
    可完成摄像头数据的读取和保存。附上查看YUV格式的软件一枚~~~~~~~
YUV_Tools.rar