OV8858

MUCHWAY

Lubancat 1IO使用VO8858摄像头，按照野火说明资料里面的说明：鲁班猫摄像头使用，可以正常使用摄像头，保存图片和保存视频都没有问题。


但是我现在想在我的应用程序中使用V4L2提供的API调用摄像头，参照网上的教程：手把手教你使用linux摄像头（V4L2框架）进行设置：

1. #include <stdio.h>
   
2. #include <sys/types.h>
   
3. #include <sys/stat.h>
   
4. #include <fcntl.h>
   
5. #include <stdlib.h>
   
6. #include <unistd.h>
   
7. 
   
8. #include <sys/ioctl.h>
   
9. #include <linux/videodev2.h>
   
10. 
    
11. int main(void)
    
12. {
    
13.     int fd = open("/dev/video0",O_RDWR);
    
14.     if (fd < 0)
    
15.     {
    
16.         perror("打开设备失败");
    
17.         return -1;
    
18.     }
    
19. 
    
20.     //获取摄像头支持格式 ioctl(文件描述符,命令，与命令对应的结构体)
    
21.     struct v4l2_fmtdesc vfmt;
    
22.     vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//摄像头采集
    
23. 
    
24.     int i = 0;
    
25.     while(1)         //使用while循环从0开始测试index索引值
    
26.     {
    
27.         vfmt.index = i;
    
28.         i++;
    
29.         int ret = ioctl(fd,VIDIOC_ENUM_FMT,&vfmt);
    
30.         if (ret < 0)
    
31.         {
    
32.             perror("获取失败");
    
33.             break;
    
34.         }
    
35.         printf("index=%d\n",vfmt.index);
    
36.         printf("flags=%d\n",vfmt.flags);
    
37.         printf("discription=%s\n",vfmt.description);
    
38.         unsigned char *p = (unsigned char *)&vfmt.pixelformat;
    
39.         printf("pixelformat=%c%c%c%c\n",p[0],p[1],p[2],p[3]);
    
40.         printf("reserved=%d\n",vfmt.reserved[0]);
    
41.     }
    
42.     close(fd);
    
43.     return 0;
    
44. }
    

复制代码

执行这段代码，总有报错：获取失败: Invalid argument
并且我参考这个链接：Linux-使用V4L2，这其其中凡是涉及用ioctl函数去设置摄像头的地方，都有 Invalid argument的报错。
而我换成一个USB免驱摄像头，做上面的同样试验，则完全没有问题。
还请教一下懂的大佬指点一下，或者有没有可以参考的例程学习一下。

おおおじ。

不是"/dev/video0 ？

MUCHWAY

おおおじ。 发表于 2024-4-7 22:34
不是"/dev/video0 ？

是dev/video0的，代码也改了的，只是这里贴的代码是video1，用v4l2-ctl命令行可以正常使用的，就是写应用程序就不行，

349810385

我也在弄这个，刚拿到手，资料翻了个遍，就是没找到官方例子，你搞定了吗，只要读取数据，设置参数

cldr

鲁班猫的例程是比t-firefly要少，贴下我的代码，直接从摄像头取数据刷屏fb0和保存nv12的。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <fcntl.h>
   
5. #include <unistd.h>
   
6. #include <errno.h>
   
7. #include <sys/types.h>
   
8. #include <sys/time.h>
   
9. #include <sys/mman.h>
   
10. #include <sys/ioctl.h>
    
11. #include <asm/types.h>
    
12. #include <linux/videodev2.h>
    
13. #include <linux/v4l2-subdev.h>
    
14. 
    
15. #define FMT_NUM_PLANES 1
    
16. 
    
17. struct buffer
    
18. {
    
19.     void *start;
    
20.     size_t length;
    
21. };
    
22. 
    
23. struct v4l2_dev
    
24. {
    
25.     int fd;
    
26.     int sub_fd;
    
27.     const char *path;
    
28.     const char *name;
    
29.     const char *subdev_path;
    
30.     const char *out_type;
    
31.     enum v4l2_buf_type buf_type;
    
32.     int format;
    
33.     int width;
    
34.     int height;
    
35.     unsigned int req_count;
    
36.     enum v4l2_memory memory_type;
    
37.     struct buffer *buffers;
    
38.     unsigned long int timestamp;
    
39.     int data_len;
    
40.     unsigned char *out_data;
    
41. };
    
42. 
    
43. struct v4l2_dev ov8858 = {
    
44.     .fd = -1,
    
45.     .sub_fd = -1,
    
46.     .path = "/dev/video0",
    
47.     .name = "ov8858",
    
48.     .subdev_path = "/dev/v4l-subdev3",
    
49.     .out_type = "nv12",
    
50.     .buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
    
51.     .format = V4L2_PIX_FMT_NV12,
    
52.     .width = 1024,
    
53.     .height = 800,
    
54.     .req_count = 3,
    
55.     .memory_type = V4L2_MEMORY_MMAP,
    
56.     .buffers = NULL,
    
57.     .timestamp = 0,
    
58.     .data_len = 0,
    
59.     .out_data = NULL,
    
60. };
    
61. 
    
62. 
    
63. void close_device(struct v4l2_dev *dev)
    
64. {
    
65.     if (dev->buffers) {
    
66.         for (unsigned int i = 0; i < dev->req_count; ++i) {
    
67.             if (dev->buffers[i].start) {
    
68.                 munmap(dev->buffers[i].start, dev->buffers[i].length);
    
69.             }
    
70.         }
    
71.         free(dev->buffers);
    
72.     }
    
73.     if (-1 != dev->fd) {
    
74.         close(dev->fd);
    
75.     }
    
76.     if (-1 != dev->sub_fd) {
    
77.         close(dev->sub_fd);
    
78.     }
    
79.     return;
    
80. }
    
81. 
    
82. void exit_failure(struct v4l2_dev *dev)
    
83. {
    
84.     close_device(dev);
    
85.     exit(EXIT_FAILURE);
    
86. }
    
87. 
    
88. void open_device(struct v4l2_dev *dev)
    
89. {
    
90.     dev->fd = open(dev->path, O_RDWR | O_CLOEXEC, 0);
    
91.     if (dev->fd < 0) {
    
92.         printf("Cannot open %s\n\n", dev->path);
    
93.         exit_failure(dev);
    
94.     }
    
95.     printf("Open %s succeed - %d\n\n", dev->path, dev->fd);
    
96. 
    
97.     dev->sub_fd = open(dev->subdev_path, O_RDWR|O_CLOEXEC, 0);
    
98.     if (dev->sub_fd < 0) {
    
99.         printf("Cannot open %s\n\n", dev->subdev_path);
    
100.         exit_failure(dev);
     
101.     }
     
102.     printf("Open %s succeed\n\n", dev->subdev_path);
     
103.     return;
     
104. }
     
105. 
     
106. void get_capabilities(struct v4l2_dev *dev)
     
107. {
     
108.     struct v4l2_capability cap;
     
109.     if (ioctl(dev->fd, VIDIOC_QUERYCAP, &cap) < 0) {
     
110.         printf("VIDIOC_QUERYCAP failed\n");
     
111.         return;
     
112.     }
     
113.     printf("------- VIDIOC_QUERYCAP ----\n");
     
114.     printf("  driver: %s\n", cap.driver);
     
115.     printf("  card: %s\n", cap.card);
     
116.     printf("  bus_info: %s\n", cap.bus_info);
     
117.     printf("  version: %d.%d.%d\n",
     
118.            (cap.version >> 16) & 0xff,
     
119.            (cap.version >> 8) & 0xff,
     
120.            (cap.version & 0xff));
     
121.     printf("  capabilities: %08X\n", cap.capabilities);
     
122. 
     
123.     if (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)
     
124.         printf("        Video Capture\n");
     
125.     if (cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)
     
126.         printf("        Video Output\n");
     
127.     if (cap.capabilities & V4L2_CAP_VIDEO_OVERLAY)
     
128.         printf("        Video Overly\n");
     
129.     if (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)
     
130.         printf("        Video Capture Mplane\n");
     
131.     if (cap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)
     
132.         printf("        Video Output Mplane\n");
     
133.     if (cap.capabilities & V4L2_CAP_READWRITE)
     
134.         printf("        Read / Write\n");
     
135.     if (cap.capabilities & V4L2_CAP_STREAMING)
     
136.         printf("        Streaming\n");
     
137.     printf("\n");
     
138.     return;
     
139. }
     
140. 
     
141. 
     
142. 
     
143. void set_fmt(struct v4l2_dev *dev)
     
144. {
     
145.     struct v4l2_format fmt;
     
146.     memset(&fmt, 0, sizeof(fmt));
     
147.     fmt.type = dev->buf_type;
     
148.     fmt.fmt.pix.pixelformat = dev->format;
     
149.     fmt.fmt.pix.width = dev->width;
     
150.     fmt.fmt.pix.height = dev->height;
     
151.     if (ioctl(dev->fd, VIDIOC_S_FMT, &fmt) < 0) {
     
152.         printf("VIDIOC_S_FMT failed - [%d]!\n", errno);
     
153.         exit_failure(dev);
     
154.     }
     
155.     printf("VIDIOC_S_FMT succeed!\n");
     
156.     dev->data_len = fmt.fmt.pix.sizeimage;
     
157.     printf("width %d, height %d, size %d, bytesperline %d, format %c%c%c%c\n\n",
     
158.            fmt.fmt.pix.width, fmt.fmt.pix.height, dev->data_len,
     
159.            fmt.fmt.pix.bytesperline,
     
160.            fmt.fmt.pix.pixelformat & 0xFF,
     
161.            (fmt.fmt.pix.pixelformat >> 8) & 0xFF,
     
162.            (fmt.fmt.pix.pixelformat >> 16) & 0xFF,
     
163.            (fmt.fmt.pix.pixelformat >> 24) & 0xFF);
     
164.     return;
     
165. }
     
166. 
     
167. 
     
168. 
     
169. void require_buf(struct v4l2_dev *dev)
     
170. {
     
171.     // 申请缓冲区
     
172.     struct v4l2_requestbuffers req;
     
173.     memset(&req, 0, sizeof(req));
     
174.     req.count = dev->req_count;
     
175.     req.type = dev->buf_type;
     
176.     req.memory = dev->memory_type;
     
177.     if (ioctl(dev->fd, VIDIOC_REQBUFS, &req) == -1) {
     
178.         printf("VIDIOC_REQBUFS failed!\n\n");
     
179.         exit_failure(dev);
     
180.     }
     
181.     if (dev->req_count != req.count) {
     
182.         printf("!!! req count = %d\n", req.count);
     
183.         dev->req_count = req.count;
     
184.     }
     
185.     printf("VIDIOC_REQBUFS succeed!\n\n");
     
186.     return;
     
187. }
     
188. 
     
189. void alloc_buf(struct v4l2_dev *dev)
     
190. {
     
191.     dev->buffers = (struct buffer *)calloc(dev->req_count, sizeof(*(dev->buffers)));
     
192.     for (unsigned int i = 0; i < dev->req_count; ++i) {
     
193.         struct v4l2_buffer buf;
     
194.         struct v4l2_plane planes[FMT_NUM_PLANES];
     
195.         memset(&buf, 0, sizeof(buf));
     
196.         memset(&planes, 0, sizeof(planes));
     
197.         buf.type = dev->buf_type;
     
198.         buf.memory = dev->memory_type;
     
199.         buf.index = i;
     
200. 
     
201.         if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == dev->buf_type) {
     
202.             buf.m.planes = planes;
     
203.             buf.length = FMT_NUM_PLANES;
     
204.         }
     
205. 
     
206.         if (ioctl(dev->fd, VIDIOC_QUERYBUF, &buf) == -1) {
     
207.             printf("VIDIOC_QUERYBUF failed!\n\n");
     
208.             exit_failure(dev);
     
209.         }
     
210.         if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == dev->buf_type) {
     
211.             dev->buffers[i].length = buf.m.planes[0].length;
     
212.             dev->buffers[i].start =
     
213.                 mmap(NULL /* start anywhere */,
     
214.                      buf.m.planes[0].length,
     
215.                      PROT_READ | PROT_WRITE /* required */,
     
216.                      MAP_SHARED /* recommended */,
     
217.                      dev->fd, buf.m.planes[0].m.mem_offset);
     
218.         } else {
     
219.             dev->buffers[i].length = buf.length;
     
220.             dev->buffers[i].start = mmap(NULL,
     
221.                                          buf.length,
     
222.                                          PROT_READ | PROT_WRITE,
     
223.                                          MAP_SHARED,
     
224.                                          dev->fd,
     
225.                                          buf.m.offset);
     
226.         }
     
227. 
     
228.         if (dev->buffers[i].start == MAP_FAILED) {
     
229.             printf("Memory map failed!\n\n");
     
230.             exit_failure(dev);
     
231.         }
     
232.     }
     
233.     printf("Memory map succeed!\n\n");
     
234.     return;
     
235. }
     
236. 
     
237. void queue_buf(struct v4l2_dev *dev)
     
238. {
     
239.     for (unsigned int i = 0; i < dev->req_count; ++i) {
     
240.         struct v4l2_buffer buf;
     
241.         struct v4l2_plane planes[FMT_NUM_PLANES];
     
242.         memset(&buf, 0, sizeof(buf));
     
243.         memset(&planes, 0, sizeof(planes));
     
244.         buf.type = dev->buf_type;
     
245.         buf.memory = dev->memory_type;
     
246.         buf.index = i;
     
247. 
     
248.         if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == dev->buf_type) {
     
249.             buf.m.planes = planes;
     
250.             buf.length = FMT_NUM_PLANES;
     
251.         }
     
252. 
     
253.         if (ioctl(dev->fd, VIDIOC_QBUF, &buf) < 0) {
     
254.             printf("VIDIOC_QBUF failed!\n\n");
     
255.             exit_failure(dev);
     
256.         }
     
257.     }
     
258.     printf("VIDIOC_QBUF succeed!\n\n");
     
259.     return;
     
260. }
     
261. 
     
262. void stream_on(struct v4l2_dev *dev)
     
263. {
     
264.     enum v4l2_buf_type type = dev->buf_type;
     
265.     if (ioctl(dev->fd, VIDIOC_STREAMON, &type) == -1) {
     
266.         printf("VIDIOC_STREAMON failed!\n\n");
     
267.         exit_failure(dev);
     
268.     }
     
269.     printf("VIDIOC_STREAMON succeed!\n\n");
     
270.     return;
     
271. }
     
272. 
     
273. int64_t get_ts_us( void )
     
274. {
     
275. #if HAVE_CLOCK_GETTIME
     
276.         struct timespec ts;
     
277.         clock_gettime( CLOCK_REALTIME, &ts );
     
278.         return (int64_t)ts.tv_sec * 1000000 + (int64_t)ts.tv_nsec / 1000;
     
279. #else
     
280.         struct timeval tv_date;
     
281.         gettimeofday( &tv_date, NULL );
     
282.         return (int64_t)tv_date.tv_sec * 1000000 + (int64_t)tv_date.tv_usec;
     
283. #endif
     
284. }
     
285. #include <linux/fb.h>
     
286. void NV12ToRGB(unsigned char *nv12, unsigned int *rgb, int width, int height) {
     
287.     int size = width * height;
     
288.     int w, h, x, y, u, v, yIndex, uvIndex;
     
289.     int y1192, r, g, b, uv448, uv_128, rgb_idx;
     
290. rgb_idx = 0;
     
291.     for (h = 0; h < height; h++) {
     
292.         for (w = 0; w < width; w++) {
     
293.             yIndex = h * width + w;
     
294.             uvIndex = (h / 2) * width + (w & (-2)) + size;
     
295.             u = nv12[uvIndex];
     
296.             v = nv12[uvIndex + 1];
     
297. 
     
298.             // YUV to RGB
     
299.             y1192 = 1192 * (nv12[yIndex] - 16);
     
300.             uv448 = 448 * (u - 128);
     
301.             uv_128 = 128 * (v - 128);
     
302.             r = (y1192 + uv448) >> 10;
     
303.             g = (y1192 - uv_128 - uv448) >> 10;
     
304.             b = (y1192 + uv_128) >> 10;
     
305. 
     
306.             // RGB clipping
     
307.             if (r < 0) r = 0;
     
308.             if (g < 0) g = 0;
     
309.             if (b < 0) b = 0;
     
310.             if (r > 255) r = 255;
     
311.             if (g > 255) g = 255;
     
312.             if (b > 255) b = 255;
     
313. 
     
314.             rgb[rgb_idx ++] = ((unsigned int)r << 16) | ((unsigned int)g << 8) | ((unsigned int)b << 0);
     
315.         }
     
316.     }
     
317. }
     
318. void get_frame(struct v4l2_dev *dev, int skip_frame)
     
319. {
     
320. int fd;
     
321. unsigned int *fb_mem  = NULL;        //设置显存的位数为32位
     
322. struct fb_var_screeninfo var;
     
323. struct fb_fix_screeninfo fix;
     
324. 
     
325.     int64_t detal_ts = 0;
     
326.     struct v4l2_buffer buf;
     
327.     struct v4l2_plane planes[FMT_NUM_PLANES];
     
328.     fd = open("/dev/fb0",O_RDWR);                        //打开framebuffer设备
     
329.         if(fd == -1){
     
330.                 perror("Open LCD");
     
331.         }
     
332.         ioctl(fd, FBIOGET_VSCREENINFO, &var);
     
333.         //获取屏幕的固定参数
     
334.         ioctl(fd, FBIOGET_FSCREENINFO, &fix);
     
335.         //设置屏幕，需要开启才能使用屏幕
     
336.         ioctl(fd, FBIOPAN_DISPLAY, &var);
     
337.         //打印分辨率
     
338.         printf("xres= %d,yres= %d \n",var.xres,var.yres);
     
339.     //打印总字节数和每行的长度
     
340.         printf("line_length=%d,smem_len= %d \n",fix.line_length,fix.smem_len);
     
341.         printf("xpanstep=%d,ypanstep= %d \n",fix.xpanstep,fix.ypanstep);
     
342.                        
     
343.         /*--------------第二步--------------*/
     
344.     fb_mem = (unsigned int *)mmap(NULL, fix.smem_len,                 //获取显存，映射内存
     
345.                         PROT_READ |  PROT_WRITE, MAP_SHARED, fd, 0);   
     
346.                                                                   
     
347.         if(fb_mem == MAP_FAILED){
     
348.                 perror("Mmap LCD");
     
349.         }
     
350. //    memset(fb_mem, 0, fix.smem_len);
     
351. /*    for (int i = 0; i < 800; i ++)
     
352.         for (int j = 0; j < 1080; j ++)
     
353.             if (j < 500)
     
354.                 fb_mem[i * 1080 + j] = 0xffffff;
     
355.             else if (j > 500 && j < 600)
     
356.                 fb_mem[i * 1080 + j] = 0xff00;
     
357.             else if (j > 600 && j < 800)
     
358.                 fb_mem[i * 1080 + j] = 0xff;
     
359.             else
     
360.                 fb_mem[i * 1080 + j] = 0xff0000;
     
361.     return;*/
     
362.     unsigned int *rgb_buf = malloc(fix.smem_len);
     
363.     for (int i = 0; i < skip_frame; i ++) {
     
364.         memset(&buf, 0, sizeof(buf));
     
365.         buf.type = dev->buf_type;
     
366.         buf.memory = dev->memory_type;
     
367. 
     
368.         if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == dev->buf_type) {
     
369.             buf.m.planes = planes;
     
370.             buf.length = FMT_NUM_PLANES;
     
371.         }
     
372. //printf("VIDIOC_DQBUF timestamp = %ld\n", get_ts_us());
     
373. detal_ts = get_ts_us();
     
374.         if (ioctl(dev->fd, VIDIOC_DQBUF, &buf) == -1) {
     
375.             printf("VIDIOC_DQBUF failed!\n\n");
     
376.             exit_failure(dev);
     
377.         }
     
378. printf("VIDIOC_DQBUF %.02fms, ", (float)(get_ts_us() - detal_ts) / 1000.0 );
     
379. 
     
380.         dev->out_data = (unsigned char *)dev->buffers[buf.index].start;
     
381. //       memcpy(fb_mem, dev->out_data, dev->data_len);
     
382. detal_ts = get_ts_us();
     
383.         NV12ToRGB(dev->out_data, rgb_buf, dev->width, dev->height);
     
384. printf("NV12ToRGB %.02fms, ", (float)(get_ts_us() - detal_ts) / 1000.0 );
     
385. detal_ts = get_ts_us();
     
386.         int cam_idx = 0;
     
387.         for(int cam_h = 0; cam_h < dev->height; cam_h ++) {
     
388.             int screen_w = cam_h * (var.xres + 8);
     
389.             for(int cam_w = 0; cam_w < dev->width; cam_w ++) {//printf("screen_w %d, cam_idx %d\n", screen_w, cam_idx);
     
390.                fb_mem[screen_w ++] = rgb_buf[cam_idx ++];
     
391.             }
     
392.         }
     
393. printf("flash %.02fms\n", (float)(get_ts_us() - detal_ts) / 1000.0);
     
394.         dev->timestamp = buf.timestamp.tv_sec * 1000000 + buf.timestamp.tv_usec;
     
395. //        printf("image: sequence = %d, timestamp = %lu, detal = %lu\r", buf.sequence, dev->timestamp, dev->timestamp - detal_ts);
     
396. //        detal_ts = dev->timestamp;
     
397. 
     
398.         if (ioctl(dev->fd, VIDIOC_QBUF, &buf) == -1) {
     
399.             printf("VIDIOC_QBUF failed!\n");
     
400.             exit_failure(dev);
     
401.         }
     
402.     }
     
403.         munmap(fb_mem,fix.smem_len); //映射后的地址，通过mmap返回的值       
     
404.         close(fd);                         //关闭fb0设备文件
     
405.     return;
     
406. }
     
407. 
     
408. void save_picture(const char *filename, unsigned char *file_data, unsigned int len, int is_overwrite)
     
409. {
     
410.     FILE *fp;
     
411.     if (is_overwrite)
     
412.         fp = fopen(filename, "wb");
     
413.     else
     
414.         fp = fopen(filename, "ab");
     
415.     if (fp < 0) {
     
416.         printf("Open frame data file failed\n\n");
     
417.         return;
     
418.     }printf("file: %s, len: %d\n", filename, len);
     
419.     if (fwrite(file_data, 1, len, fp) < len) {
     
420.         printf("Out of memory!\n");
     
421. //        is_running = 0;
     
422.     }
     
423.     fflush(fp);
     
424.     fclose(fp);
     
425.     printf("Save one frame to %s succeed!\n\n", filename);
     
426.     return;
     
427. }
     
428. 
     
429. void stream_off(struct v4l2_dev *dev)
     
430. {
     
431.     enum v4l2_buf_type type;
     
432.     type = dev->buf_type;
     
433.     if (ioctl(dev->fd, VIDIOC_STREAMOFF, &type) == -1) {
     
434.         printf("VIDIOC_STREAMOFF failed!\n\n");
     
435.         exit_failure(dev);
     
436.     }
     
437.     printf("VIDIOC_STREAMOFF succeed!\n\n");
     
438.     return;
     
439. }
     
440. 
     
441. 
     
442. 
     
443. void set_fps(struct v4l2_dev *dev, unsigned int fps)
     
444. {
     
445.         int ret;
     
446.         struct v4l2_subdev_frame_interval frame_int;
     
447. 
     
448.     if (fps == 0) return;
     
449. 
     
450.         memset(&frame_int, 0x00, sizeof(frame_int));
     
451. 
     
452.         frame_int.interval.numerator = 10000;
     
453.         frame_int.interval.denominator = fps * 10000;       
     
454. 
     
455.         ret = ioctl(dev->sub_fd, VIDIOC_SUBDEV_S_FRAME_INTERVAL, &frame_int);
     
456.         if (ret < 0) {
     
457.                 printf("VIDIOC_SUBDEV_S_FRAME_INTERVAL error\n");
     
458.         goto set_fps_err;
     
459.         }
     
460.     printf("VIDIOC_SUBDEV_S_FRAME_INTERVAL [%u fps] OK\n", fps);
     
461. set_fps_err:
     
462.     return;
     
463. }
     
464. 
     
465. 
     
466. int main(int argc, char *argv[])
     
467. {
     
468.     struct v4l2_dev *camdev = &ov8858;
     
469.         unsigned int fps = 0;
     
470.     unsigned int mode = 4;
     
471.     char name[40] = {0};
     
472.        
     
473.     if (argc > 1)
     
474.         fps = atoi(argv[1]);
     
475. 
     
476.     open_device(camdev); // 1 打开摄像头设备
     
477.     get_capabilities(camdev);
     
478.     set_fmt(camdev);                 // 2 设置出图格式
     
479.     require_buf(camdev);          // 3 申请缓冲区
     
480.     alloc_buf(camdev);            // 4 内存映射
     
481.     queue_buf(camdev);            // 5 将缓存帧加入队列
     
482.     set_fps(camdev, fps);
     
483. 
     
484.     stream_on(camdev);            // 6 开启视频流
     
485.     get_frame(camdev, 100); // 7 取一帧数据
     
486. 
     
487.     snprintf(name, sizeof(name), "%s.%s", camdev->name, camdev->out_type);
     
488.     save_picture(name, camdev->out_data, camdev->data_len, 1);
     
489. 
     
490.     stream_off(camdev);   // 8 关闭视频流
     
491.     close_device(camdev); // 9 释放内存关闭文件
     
492.     return 0;
     
493. }
     
494. 
     

复制代码