imx6ull + ov2640 + LCD 的视频流显示问题

逍暗博

[size=15.008px]目前我使用的是IMX6ULL， 摄像头是ov2640 .
摄像头驱动和LCD驱动已经完成；
应用程序使用的是正点原子的V4l2测试程序，debug发现 ioctl(fd, VIDIOC_ENUM_FRAMESIZES,&fsize) 出错. 这一项枚举不成功，返回值是 -1 ；

1. # ./a.out /dev/video0
   
2. width =480,height= 272
   
3. 枚举成功0
   
4. 枚举成功1
   
5. 枚举成功2
   
6. 枚举成功3
   
7. format<0x56595559>, description<YUYV-16>
   
8. ret = -1
   
9. Inappropriate ioctl for device
   
10. format<0x59565955>, description<UYVY-16>
    
11. ret = -1
    
12. Inappropriate ioctl for device
    
13. format<0x50424752>, description<RGB565_BE>
    
14. ret = -1
    
15. Inappropriate ioctl for device
    
16. format<0x50424752>, description<RGB565_LE>
    
17. ret = -1
    
18. Inappropriate ioctl for device
    
19. v4l2_set_format : width =480,height=272
    
20. RGB565设置成功
    
21. 视频帧大小<640 * 480>

复制代码

[size=15.008px]应用层代码如下：

1. /***************************************************************
   
2. Copyright © ALIENTEK Co., Ltd. 1998-2021. All rights reserved.
   
3. 文件名 : v4l2_camera.c
   
4. 作者 : 邓涛
   
5. 版本 : V1.0
   
6. 描述 : V4L2摄像头应用编程实战
   
7. 其他 : 无
   
8. 论坛 : www.openedv.com
   
9. 日志 : 初版 V1.0 2021/7/09 邓涛创建
   
10. ***************************************************************/
    
11. 
    
12. #include <stdio.h>
    
13. #include <stdlib.h>
    
14. #include <sys/types.h>
    
15. #include <sys/stat.h>
    
16. #include <fcntl.h>
    
17. #include <unistd.h>
    
18. #include <sys/ioctl.h>
    
19. #include <string.h>
    
20. #include <errno.h>
    
21. #include <sys/mman.h>
    
22. #include <linux/videodev2.h>
    
23. #include <linux/fb.h>
    
24. 
    
25. #define FB_DEV              "/dev/fb0"      //LCD设备节点
    
26. #define FRAMEBUFFER_COUNT   10               //帧缓冲数量
    
27. 
    
28. /*** 摄像头像素格式及其描述信息 ***/
    
29. typedef struct camera_format {
    
30.     unsigned char description[32];  //字符串描述信息
    
31.     unsigned int pixelformat;       //像素格式
    
32. } cam_fmt;
    
33. 
    
34. /*** 描述一个帧缓冲的信息 ***/
    
35. typedef struct cam_buf_info {
    
36.     unsigned short *start;      //帧缓冲起始地址
    
37.     unsigned long length;       //帧缓冲长度
    
38. } cam_buf_info;
    
39. 
    
40. static int width;                       //LCD宽度
    
41. static int height;                      //LCD高度
    
42. static unsigned short *screen_base = NULL;//LCD显存基地址
    
43. static int fb_fd = -1;                  //LCD设备文件描述符
    
44. static int v4l2_fd = -1;                //摄像头设备文件描述符
    
45. static cam_buf_info buf_infos[FRAMEBUFFER_COUNT];
    
46. static cam_fmt cam_fmts[10];
    
47. static int frm_width, frm_height;   //视频帧宽度和高度
    
48. 
    
49. static int fb_dev_init(void)
    
50. {
    
51.     struct fb_var_screeninfo fb_var = {0};
    
52.     struct fb_fix_screeninfo fb_fix = {0};
    
53.     unsigned long screen_size;
    
54. 
    
55.     /* 打开framebuffer设备 */
    
56.     fb_fd = open(FB_DEV, O_RDWR);
    
57.     if (0 > fb_fd) {
    
58.         fprintf(stderr, "open error: %s: %s\n", FB_DEV, strerror(errno));
    
59.         return -1;
    
60.     }
    
61. 
    
62.     /* 获取framebuffer设备信息 */
    
63.     ioctl(fb_fd, FBIOGET_VSCREENINFO, &fb_var);
    
64.     ioctl(fb_fd, FBIOGET_FSCREENINFO, &fb_fix);
    
65. 
    
66.     screen_size = fb_fix.line_length * fb_var.yres * 8;
    
67.     width = fb_var.xres;
    
68.     height = fb_var.yres;
    
69.     printf("width =%d,height= %d\n",width,height) ;
    
70.     /* 内存映射 */
    
71.     screen_base = mmap(NULL, screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
    
72.     if (MAP_FAILED == (void *)screen_base) {
    
73.         perror("mmap error");
    
74.         close(fb_fd);
    
75.         return -1;
    
76.     }
    
77. 
    
78.     /* LCD背景刷白 */
    
79.     memset(screen_base, 0xFF, screen_size);
    
80.     return 0;
    
81. }
    
82. 
    
83. static int v4l2_dev_init(const char *device)
    
84. {
    
85.     struct v4l2_capability cap = {0};
    
86. 
    
87.     /* 打开摄像头 */
    
88.     v4l2_fd = open(device, O_RDWR);
    
89.     if (0 > v4l2_fd) {
    
90.         fprintf(stderr, "open error: %s: %s\n", device, strerror(errno));
    
91.         return -1;
    
92.     }
    
93. 
    
94.     /* 查询设备功能 */
    
95.     ioctl(v4l2_fd, VIDIOC_QUERYCAP, &cap);
    
96. 
    
97.     /* 判断是否是视频采集设备 */
    
98.     if (!(V4L2_CAP_VIDEO_CAPTURE & cap.capabilities)) {
    
99.         fprintf(stderr, "Error: %s: No capture video device!\n", device);
    
100.         close(v4l2_fd);
     
101.         return -1;
     
102.     }
     
103. 
     
104.     return 0;
     
105. }
     
106. 
     
107. static void v4l2_enum_formats(void)
     
108. {
     
109.     struct v4l2_fmtdesc fmtdesc = {0};
     
110. 
     
111.     /* 枚举摄像头所支持的所有像素格式以及描述信息 */
     
112.     fmtdesc.index = 0;
     
113.     fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
114.     while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FMT, &fmtdesc)) {
     
115.         printf("枚举成功%d\n",fmtdesc.index) ;
     
116.         // 将枚举出来的格式以及描述信息存放在数组中
     
117.         cam_fmts[fmtdesc.index].pixelformat = fmtdesc.pixelformat;
     
118.         strcpy(cam_fmts[fmtdesc.index].description, fmtdesc.description);
     
119.         fmtdesc.index++;
     
120.     }
     
121. }
     
122. 
     
123. static void v4l2_print_formats(void)
     
124. {
     
125.     struct v4l2_frmsizeenum frmsize = {0};
     
126.     struct v4l2_frmivalenum frmival = {0};
     
127.     int i;
     
128.     int ret = 0 ;
     
129.     frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
130.     frmival.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
131.     for (i = 0; cam_fmts[i].pixelformat; i++) {
     
132. 
     
133.         printf("format<0x%x>, description<%s>\n", cam_fmts[i].pixelformat,
     
134.                     cam_fmts[i].description);
     
135. 
     
136.         /* 枚举出摄像头所支持的所有视频采集分辨率 */
     
137.         frmsize.index = 0;
     
138.         frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE ;
     
139.         frmsize.pixel_format = cam_fmts[i].pixelformat;
     
140.         frmival.pixel_format = cam_fmts[i].pixelformat;
     
141. 
     
142.         printf("ret = %d\n",ret= ioctl(v4l2_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize) )  ;
     
143.         if(ret < 0)
     
144.             fprintf(stderr, "%s\n", strerror(errno));
     
145. 
     
146.         while ( ret>= 0 ) {
     
147.             printf("LQB\n");
     
148.             printf("size<%d*%d> ",
     
149.                     frmsize.discrete.width,
     
150.                     frmsize.discrete.height);
     
151.             frmsize.index++;
     
152. 
     
153.             /* 获取摄像头视频采集帧率 */
     
154.             frmival.index = 0;
     
155.             frmival.width = frmsize.discrete.width;
     
156.             frmival.height = frmsize.discrete.height;
     
157.             while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival)) {
     
158. 
     
159.                 printf("<%dfps>", frmival.discrete.denominator /
     
160.                         frmival.discrete.numerator);
     
161.                 frmival.index++;
     
162.             }
     
163.         }
     
164.     }
     
165. }
     
166. 
     
167. static int v4l2_set_format(void)
     
168. {
     
169.     struct v4l2_format fmt = {0};
     
170.     struct v4l2_streamparm streamparm = {0};
     
171. 
     
172.     /* 设置帧格式 */
     
173.     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type类型
     
174.     fmt.fmt.pix.width = width;  //视频帧宽度
     
175.     fmt.fmt.pix.height = height;//视频帧高度
     
176.     printf("v4l2_set_format : width =%d,height=%d\n",width,height) ;
     
177.     fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;  //像素格式
     
178.     if (0 > ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt)) {
     
179.         fprintf(stderr, "ioctl error: VIDIOC_S_FMT: %s\n", strerror(errno));
     
180.         return -1;
     
181.     }
     
182.     /*** 判断是否已经设置为我们要求的RGB565像素格式
     
183.     如果没有设置成功表示该设备不支持RGB565像素格式 */
     
184.     if (V4L2_PIX_FMT_RGB565 != fmt.fmt.pix.pixelformat) {
     
185.         fprintf(stderr, "Error: the device does not support RGB565 format!\n");
     
186.         return -1;
     
187.     }
     
188.     else
     
189.         printf("RGB565设置成功\n");
     
190.     frm_width = fmt.fmt.pix.width;  //获取实际的帧宽度
     
191.     frm_height = fmt.fmt.pix.height;//获取实际的帧高度
     
192.     printf("视频帧大小<%d * %d>\n", frm_width, frm_height);
     
193. 
     
194.     /* 获取streamparm */
     
195.     streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
196.     ioctl(v4l2_fd, VIDIOC_G_PARM, &streamparm);
     
197. 
     
198.     /** 判断是否支持帧率设置 **/
     
199.     if (V4L2_CAP_TIMEPERFRAME & streamparm.parm.capture.capability) {
     
200.         streamparm.parm.capture.timeperframe.numerator = 1;
     
201.         streamparm.parm.capture.timeperframe.denominator = 30;//30fps
     
202.         if (0 > ioctl(v4l2_fd, VIDIOC_S_PARM, &streamparm)) {
     
203.             fprintf(stderr, "ioctl error: VIDIOC_S_PARM: %s\n", strerror(errno));
     
204.             return -1;
     
205.         }
     
206.     }
     
207. 
     
208.     return 0;
     
209. }
     
210. 
     
211. static int v4l2_init_buffer(void)
     
212. {
     
213.     struct v4l2_requestbuffers reqbuf = {0};
     
214.     struct v4l2_buffer buf = {0};
     
215. 
     
216.     /* 申请帧缓冲 */
     
217.     reqbuf.count = FRAMEBUFFER_COUNT;       //帧缓冲的数量
     
218.     reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
219.     reqbuf.memory = V4L2_MEMORY_MMAP;
     
220.     if (0 > ioctl(v4l2_fd, VIDIOC_REQBUFS, &reqbuf)) {
     
221.         fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
     
222.         return -1;
     
223.     }
     
224. 
     
225.     /* 建立内存映射 */
     
226.     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
227.     buf.memory = V4L2_MEMORY_MMAP;
     
228.     for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {
     
229. 
     
230.         ioctl(v4l2_fd, VIDIOC_QUERYBUF, &buf);
     
231.         buf_infos[buf.index].length = buf.length;
     
232.         buf_infos[buf.index].start = mmap(NULL, buf.length,
     
233.                 PROT_READ | PROT_WRITE, MAP_SHARED,
     
234.                 v4l2_fd, buf.m.offset);
     
235.         if (MAP_FAILED == buf_infos[buf.index].start) {
     
236.             perror("mmap error");
     
237.             return -1;
     
238.         }
     
239.     }
     
240. 
     
241.     /* 入队 */
     
242.     for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {
     
243. 
     
244.         if (0 > ioctl(v4l2_fd, VIDIOC_QBUF, &buf)) {
     
245.             fprintf(stderr, "ioctl error: VIDIOC_QBUF: %s\n", strerror(errno));
     
246.             return -1;
     
247.         }
     
248.     }
     
249. 
     
250.     return 0;
     
251. }
     
252. 
     
253. static int v4l2_stream_on(void)
     
254. {
     
255.     /* 打开摄像头、摄像头开始采集数据 */
     
256.     enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
257. 
     
258.     if (0 > ioctl(v4l2_fd, VIDIOC_STREAMON, &type)) {
     
259.         fprintf(stderr, "ioctl error: VIDIOC_STREAMON: %s\n", strerror(errno));
     
260.         return -1;
     
261.     }
     
262. 
     
263.     return 0;
     
264. }
     
265. 
     
266. static void v4l2_read_data(void)
     
267. {
     
268.     struct v4l2_buffer buf = {0};
     
269.     unsigned short *base;
     
270.     unsigned short *start;
     
271.     int min_w, min_h;
     
272.     int j;
     
273. 
     
274.     if (width > frm_width)
     
275.         min_w = frm_width;
     
276.     else
     
277.         min_w = width;
     
278.     if (height > frm_height)
     
279.         min_h = frm_height;
     
280.     else
     
281.         min_h = height;
     
282. 
     
283.     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
284.     buf.memory = V4L2_MEMORY_MMAP;
     
285.     for ( ; ; ) {
     
286. 
     
287.         for(buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {
     
288. 
     
289.             ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);     //出队
     
290.             for (j = 0, base=screen_base, start=buf_infos[buf.index].start;
     
291.                         j < min_h; j++) {
     
292. 
     
293.                 memcpy(base, start, min_w * 2); //RGB565 一个像素占2个字节
     
294.                 base += width;  //LCD显示指向下一行
     
295.                 start += frm_width;//指向下一行数据
     
296.             }
     
297. 
     
298.             // 数据处理完之后、再入队、往复
     
299.             ioctl(v4l2_fd, VIDIOC_QBUF, &buf);
     
300.         }
     
301.     }
     
302. }
     
303. 
     
304. int main(int argc, char *argv[])
     
305. {
     
306.     if (2 != argc) {
     
307.         fprintf(stderr, "Usage: %s <video_dev>\n", argv[0]);
     
308.         exit(EXIT_FAILURE);
     
309.     }
     
310. 
     
311.     /* 初始化LCD */
     
312.     if (fb_dev_init())
     
313.         exit(EXIT_FAILURE);
     
314. 
     
315.     /* 初始化摄像头 */
     
316.     if (v4l2_dev_init(argv[1]))
     
317.         exit(EXIT_FAILURE);
     
318. 
     
319.     /* 枚举所有格式并打印摄像头支持的分辨率及帧率 */
     
320.     v4l2_enum_formats();
     
321.     v4l2_print_formats();
     
322. 
     
323.     /* 设置格式 */
     
324.     if (v4l2_set_format())
     
325.         exit(EXIT_FAILURE);
     
326. 
     
327.     /* 初始化帧缓冲：申请、内存映射、入队 */
     
328.     if (v4l2_init_buffer())
     
329.         exit(EXIT_FAILURE);
     
330. 
     
331.     /* 开启视频采集 */
     
332.     if (v4l2_stream_on())
     
333.         exit(EXIT_FAILURE);
     
334. 
     
335.     /* 读取数据：出队 */
     
336.     v4l2_read_data();       //在函数内循环采集数据、将其显示到LCD屏
     
337. 
     
338.     exit(EXIT_SUCCESS);
     
339. }

复制代码

[size=15.008px]