【已解决】通过V4L2采集的图片怎么无法打开？请教什么原因

Huntsmen

在网上找的一个V4L2编程的经典例子，程序运行后，保存了2张jpg的图片，但是保存图片在windows下无法打开，想请教一下是什么原因？

PS：实验环境是arm9开发板，usb的UVC摄像头；利用开发板自带的usb摄像头测试app是能看到图像的；
[ 8802.695000] usb 1-1.2: new full-speed USB device number 3 using s3c2410-ohci
[ 8802.825000] uvcvideo: Found UVC 1.00 device USB 2.0 CAMERA (1c4f:3002)
[ 8802.890000] input: USB 2.0 CAMERA as /devices/platform/s3c2410-ohci/usb1/1-1/1-1.2/1-1.2:1.0/input/input1

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <errno.h>
   
4. #include <stdlib.h>
   
5. #include <sys/types.h>
   
6. #include <sys/stat.h>
   
7. #include <fcntl.h>
   
8. #include <sys/mman.h>
   
9. #include <assert.h>
   
10. #include <linux/videodev2.h>
    
11. 
    
12. 
    
13. typedef struct
    
14. {
    
15.         void *start;
    
16.         int length;
    
17. }BUFTYPE;
    
18. 
    
19. BUFTYPE *user_buf;
    
20. int n_buffer = 0;
    
21. 
    
22. //打开摄像头设备
    
23. int open_camer_device()
    
24. {
    
25.         int fd;
    
26. 
    
27.         if((fd = open("/dev/video0",O_RDWR | O_NONBLOCK)) < 0)
    
28.         {
    
29.                 perror("Fail to open");
    
30.                 exit(EXIT_FAILURE);
    
31.         }
    
32.        
    
33.         return fd;
    
34. }
    
35. 
    
36. int init_mmap(int fd)
    
37. {
    
38.         int i = 0;
    
39.         struct v4l2_requestbuffers reqbuf;
    
40. 
    
41.         bzero(&reqbuf,sizeof(reqbuf));
    
42.         reqbuf.count = 4;
    
43.         reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
44.         reqbuf.memory = V4L2_MEMORY_MMAP;
    
45.        
    
46.         //申请视频缓冲区(这个缓冲区位于内核空间，需要通过mmap映射)
    
47.         //这一步操作可能会修改reqbuf.count的值，修改为实际成功申请缓冲区个数
    
48.         if(-1 == ioctl(fd,VIDIOC_REQBUFS,&reqbuf))
    
49.         {
    
50.                 perror("Fail to ioctl 'VIDIOC_REQBUFS'");
    
51.                 exit(EXIT_FAILURE);
    
52.         }
    
53.        
    
54.         n_buffer = reqbuf.count;
    
55.        
    
56.         printf("n_buffer = %d\n",n_buffer);
    
57. 
    
58.         user_buf = calloc(reqbuf.count,sizeof(*user_buf));
    
59.         if(user_buf == NULL){
    
60.                 fprintf(stderr,"Out of memory\n");
    
61.                 exit(EXIT_FAILURE);
    
62.         }
    
63. 
    
64.         //将内核缓冲区映射到用户进程空间
    
65.         for(i = 0; i < reqbuf.count; i ++)
    
66.         {
    
67.                 struct v4l2_buffer buf;
    
68.                
    
69.                 bzero(&buf,sizeof(buf));
    
70.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
71.                 buf.memory = V4L2_MEMORY_MMAP;
    
72.                 buf.index = i;
    
73.                 //查询申请到内核缓冲区的信息
    
74.                 if(-1 == ioctl(fd,VIDIOC_QUERYBUF,&buf))
    
75.                 {
    
76.                         perror("Fail to ioctl : VIDIOC_QUERYBUF");
    
77.                         exit(EXIT_FAILURE);
    
78.                 }
    
79. 
    
80.                 user_buf[i].length = buf.length;
    
81.                 user_buf[i].start =
    
82.                         mmap(
    
83.                                         NULL,/*start anywhere*/
    
84.                                         buf.length,
    
85.                                         PROT_READ | PROT_WRITE,
    
86.                                         MAP_SHARED,
    
87.                                         fd,buf.m.offset
    
88.                                 );
    
89.                 if(MAP_FAILED == user_buf[i].start)
    
90.                 {
    
91.                         perror("Fail to mmap");
    
92.                         exit(EXIT_FAILURE);
    
93.                 }
    
94.         }       
    
95. 
    
96.         return 0;
    
97. }
    
98. 
    
99. //初始化视频设备
    
100. int init_camer_device(int fd)
     
101. {
     
102.         struct v4l2_fmtdesc fmt;
     
103.         struct v4l2_capability cap;
     
104.         struct v4l2_format stream_fmt;
     
105.         int ret;
     
106.        
     
107.         //当前视频设备支持的视频格式
     
108.         memset(&fmt,0,sizeof(fmt));
     
109.         fmt.index = 0;
     
110.         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
111. 
     
112.         while((ret = ioctl(fd,VIDIOC_ENUM_FMT,&fmt)) == 0)
     
113.         {
     
114.                 fmt.index ++ ;
     
115. 
     
116.                 printf("{pixelformat = %c%c%c%c},description = '%s'\n",
     
117.                                 fmt.pixelformat & 0xff,(fmt.pixelformat >> 8)&0xff,
     
118.                                 (fmt.pixelformat >> 16) & 0xff,(fmt.pixelformat >> 24)&0xff,
     
119.                                 fmt.description);
     
120.         }
     
121. 
     
122.         //查询视频设备驱动的功能
     
123.         ret = ioctl(fd,VIDIOC_QUERYCAP,&cap);
     
124.         if(ret < 0){
     
125.                 perror("FAIL to ioctl VIDIOC_QUERYCAP");
     
126.                 exit(EXIT_FAILURE);
     
127.         }
     
128. 
     
129.         //判断是否是一个视频捕捉设备
     
130.         if(!(cap.capabilities & V4L2_BUF_TYPE_VIDEO_CAPTURE))
     
131.         {
     
132.                 printf("The Current device is not a video capture device\n");
     
133.                 exit(EXIT_FAILURE);
     
134.        
     
135.         }
     
136. 
     
137.         //判断是否支持视频流形式
     
138.         if(!(cap.capabilities & V4L2_CAP_STREAMING))
     
139.         {
     
140.                 printf("The Current device does not support streaming i/o\n");
     
141.                 exit(EXIT_FAILURE);
     
142.         }
     
143. 
     
144.         //设置摄像头采集数据格式，如设置采集数据的
     
145.         //长,宽，图像格式(JPEG,YUYV,MJPEG等格式)
     
146.         stream_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
147.         stream_fmt.fmt.pix.width = 640;
     
148.         stream_fmt.fmt.pix.height = 480;
     
149.         stream_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
     
150.         stream_fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
     
151. 
     
152.         if(-1 == ioctl(fd,VIDIOC_S_FMT,&stream_fmt))
     
153.         {
     
154.                 perror("Fail to ioctl");
     
155.                 exit(EXIT_FAILURE);
     
156.         }
     
157. 
     
158.        
     
159.         //初始化视频采集方式(mmap)
     
160.         init_mmap(fd);
     
161. 
     
162.         return 0;
     
163. }
     
164. 
     
165. int start_capturing(int fd)
     
166. {
     
167.         unsigned int i;
     
168.         enum v4l2_buf_type type;
     
169. 
     
170.         //将申请的内核缓冲区放入一个队列中
     
171.         for(i = 0;i < n_buffer;i ++)
     
172.         {
     
173.                 struct v4l2_buffer buf;
     
174. 
     
175.                 bzero(&buf,sizeof(buf));
     
176.                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
177.                 buf.memory = V4L2_MEMORY_MMAP;
     
178.                 buf.index = i;
     
179.                
     
180.                 if(-1 == ioctl(fd,VIDIOC_QBUF,&buf))
     
181.                 {
     
182.                         perror("Fail to ioctl 'VIDIOC_QBUF'");
     
183.                         exit(EXIT_FAILURE);
     
184.                 }
     
185.         }
     
186. 
     
187.         //开始采集数据
     
188.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
189.         if(-1 == ioctl(fd,VIDIOC_STREAMON,&type))
     
190.         {
     
191.                 printf("i = %d.\n",i);
     
192.                 perror("Fail to ioctl 'VIDIOC_STREAMON'");
     
193.                 exit(EXIT_FAILURE);
     
194.         }
     
195. 
     
196.         return 0;
     
197. }
     
198. 
     
199. //将采集好的数据放到文件中
     
200. int process_image(void *addr,int length)
     
201. {
     
202.         FILE *fp;
     
203.         static int num = 0;
     
204.         char picture_name[20];
     
205.        
     
206.         sprintf(picture_name,"picture_%d.jpg",num ++);
     
207.        
     
208.         if((fp = fopen(picture_name,"w")) == NULL)
     
209.         {
     
210.                 perror("Fail to fopen");
     
211.                 exit(EXIT_FAILURE);
     
212.         }
     
213. 
     
214.         printf("len=%d\n",length);
     
215.         fwrite(addr,length,1,fp);
     
216.         usleep(500);
     
217. 
     
218.         fclose(fp);
     
219. 
     
220.         return 0;
     
221. }
     
222. 
     
223. int read_frame(int fd)
     
224. {
     
225.         struct v4l2_buffer buf;
     
226.         unsigned int i;
     
227. 
     
228.         bzero(&buf,sizeof(buf));
     
229.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
230.         buf.memory = V4L2_MEMORY_MMAP;
     
231.        
     
232.         //从队列中取缓冲区
     
233.         if(-1 == ioctl(fd,VIDIOC_DQBUF,&buf))
     
234.         {
     
235.                 perror("Fail to ioctl 'VIDIOC_DQBUF'");
     
236.                 exit(EXIT_FAILURE);
     
237.         }
     
238. 
     
239.         assert(buf.index < n_buffer);
     
240.         //读取进程空间的数据到一个文件中
     
241.         process_image(user_buf[buf.index].start,user_buf[buf.index].length);
     
242.        
     
243.         if(-1 == ioctl(fd,VIDIOC_QBUF,&buf))
     
244.         {
     
245.                 perror("Fail to ioctl 'VIDIOC_QBUF'");
     
246.                 exit(EXIT_FAILURE);
     
247.         }
     
248. 
     
249.         return 1;
     
250. }
     
251. 
     
252. int mainloop(int fd)
     
253. {
     
254.         int count = 2;
     
255. 
     
256.         while(count -- > 0)
     
257.         {
     
258.                 for(;;)
     
259.                 {
     
260.                         fd_set fds;
     
261.                         struct timeval tv;
     
262.                         int r;
     
263. 
     
264.                         FD_ZERO(&fds);
     
265.                         FD_SET(fd,&fds);
     
266. 
     
267.                         /*Timeout*/
     
268.                         tv.tv_sec = 2;
     
269.                         tv.tv_usec = 0;
     
270.                
     
271.                         r = select(fd + 1,&fds,NULL,NULL,&tv);
     
272. 
     
273.                         if(-1 == r)
     
274.                         {
     
275.                                 if(EINTR == errno)
     
276.                                         continue;
     
277.                                
     
278.                                 perror("Fail to select");
     
279.                                 exit(EXIT_FAILURE);
     
280.                         }
     
281. 
     
282.                         if(0 == r)
     
283.                         {
     
284.                                 fprintf(stderr,"select Timeout\n");
     
285.                                 exit(EXIT_FAILURE);
     
286.                         }
     
287. 
     
288.                         if(read_frame(fd))
     
289.                                 break;
     
290.                 }
     
291.         }
     
292. 
     
293.         return 0;
     
294. }
     
295. 
     
296. void stop_capturing(int fd)
     
297. {
     
298.         enum v4l2_buf_type type;
     
299.        
     
300.         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
301.         if(-1 == ioctl(fd,VIDIOC_STREAMOFF,&type))
     
302.         {
     
303.                 perror("Fail to ioctl 'VIDIOC_STREAMOFF'");
     
304.                 exit(EXIT_FAILURE);
     
305.         }
     
306.        
     
307.         return;
     
308. }
     
309. 
     
310. void uninit_camer_device()
     
311. {
     
312.         unsigned int i;
     
313. 
     
314.         for(i = 0;i < n_buffer;i ++)
     
315.         {
     
316.                 if(-1 == munmap(user_buf[i].start,user_buf[i].length))
     
317.                 {
     
318.                         exit(EXIT_FAILURE);
     
319.                 }
     
320.         }
     
321.        
     
322.         free(user_buf);
     
323. 
     
324.         return;
     
325. }
     
326. 
     
327. void close_camer_device(int fd)
     
328. {
     
329.         if(-1 == close(fd))
     
330.         {
     
331.                 perror("Fail to close fd");
     
332.                 exit(EXIT_FAILURE);
     
333.         }
     
334. 
     
335.         return;
     
336. }
     
337. 
     
338. int main()
     
339. {
     
340.         int fd;      
     
341.                         
     
342.         fd = open_camer_device();
     
343. 
     
344.         init_camer_device(fd);
     
345.        
     
346.         start_capturing(fd);
     
347.        
     
348.         mainloop(fd);
     
349.        
     
350.         stop_capturing(fd);
     
351. 
     
352.         uninit_camer_device(fd);
     
353. 
     
354.         close_camer_device(fd);
     
355. 
     
356.         return 0;
     
357. }
     

复制代码

上面程序运行结果如下：
{pixelformat = YUYV},description = 'YUV 4:2:2 (YUYV)'
n_buffer = 4
len=153600
len=153600

Huntsmen

已经知道原因，是因为这个摄像头的输出格式是YUV格式，V4L2采集保存的文件也是YUV格式的，这种格式用常见的看图工具是无法显示的，需要专门的YUV查看工具才可以看；比如YUVviewer

zuoertu

不能显示是因为格式不对，可以直接输出jpg格式的文件修改
//stream_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
stream_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
改成 V4L2_PIX_FMT_MJPEG 就可以了

peterpeter2015

你好，在你的贴子里http://bbs.chinaunix.net/thread-4120327-1-1.html 我改了stream_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV  为stream_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_GREY;因为程序输出为：{pixelformat = GREY},description = 'Greyscale 8-bit (Y800)'
n_buffer = 4
len=307200
len=307200

但是jpg文件还是不可以看，为什么？是不是不能直接将内存里的数据存为jpg?需要转换原始数据才能变成jpg?谢谢回复.