OpenEdv-开源电子网

标题: 《I.MX6U嵌入式Linux C应用编程指南 V1.1》第二十六章 V4L2摄像头应用编程 [打印本页]

---

作者: 正点原子运营    时间: 2021-8-28 16:12
标题: 《I.MX6U嵌入式Linux C应用编程指南 V1.1》第二十六章 V4L2摄像头应用编程
1）实验平台：正点原子阿尔法Linux开发板
2)  章节摘自【正点原子】《I.MX6U嵌入式Linux C应用编程指南 V1.1》
3）购买链接:https://detail.tmall.com/item.htm?id=609033604451
4）全套实验源码+手册+视频下载地址：https://www.openedv.com/docs/boards/arm-linux/zdyz-i.mx6ull.html
5）正点原子官方B站：https://space.bilibili.com/394620890
6）正点原子阿尔法Linux交流群：1027879335 (, 下载次数: 0)

上传

点击文件名下载附件

(, 下载次数: 0)

上传

点击文件名下载附件

(, 下载次数: 0)

上传

点击文件名下载附件

第二十六章 V4L2摄像头应用编程

ALPHA/Mini I.MX6U开发板配套支持多种不同的摄像头，包括正点原子的ov5640（500W像素）、ov2640（200W像素）以及ov7725（不带FIFO、30W像素）这三款摄像头，在开发板出厂系统上，可以使用这些摄像头；当然，除此之外我们还可以使用USB摄像头，直接将USB摄像头插入到开发板上的USB接口即可！本章我们就来学习Linux下的摄像头应用编程。
本章将会讨论如下主题内容。
V4L2简介；
V4L2设备应用编程介绍；
摄像头应用编程实战；



26.1V4L2简介
大家可以看到我们本章的标题叫做“V4L2摄像头应用编程”，那什么是V4L2呢？对Linux下摄像头驱动程序开发有过了解的读者，应该知道这是什么意思。
V4L2是Video for linux two的简称，是Linux内核中视频类设备的一套驱动框架，为视频类设备驱动开发和应用层提供了一套统一的接口规范，那什么是视频类设备呢？一个非常典型的视频类设备就是视频采集设备，譬如各种摄像头；当然还包括其它类型视频类设备，这里就不再给介绍了。
使用V4L2设备驱动框架注册的设备会在Linux系统/dev/目录下生成对应的设备节点文件，设备节点的名称通常为videoX（X标准一个数字编号，0、1、2、3……），每一个videoX设备文件就代表一个视频类设备。应用程序通过对videoX设备文件进行I/O操作来配置、使用设备类设备，下小节将向大家详细介绍！

(, 下载次数: 0)

上传

点击文件名下载附件
图 26.1.1 video类设备节点

26.2V4L2摄像头应用程序
V4L2设备驱动框架向应用层提供了一套统一、标准的接口规范，应用程序按照该接口规范来进行应用编程，从而使用摄像头。对于摄像头设备来说，其编程模式如下所示：
1.首先是打开摄像头设备；
2.查询设备的属性或功能；
3.设置设备的参数，譬如像素格式、帧大小、帧率；
4.申请帧缓冲、内存映射；
5.帧缓冲入队；
6.开启视频采集；
7.帧缓冲出队、对采集的数据进行处理；
8.处理完后，再次将帧缓冲入队，往复；
9.结束采集。
流程图如下所示：

(, 下载次数: 0)

上传

点击文件名下载附件
图 26.2.1 摄像头视频采集流程图

从流程图中可以看到，几乎对摄像头的所有操作都是通过ioctl()来完成，搭配不同的V4L2指令（request参数）请求不同的操作，这些指令定义在头文件linux/videodev2.h中，在摄像头应用程序代码中，需要包含头文件linux/videodev2.h，该头文件中申明了很多与摄像头应用编程相关的数据结构以及宏定义，大家可以打开这个头文件看看。
在videodev2.h头文件中，定义了很多ioctl()的指令，以宏定义的形式提供（VIDIOC_XXX），如下所示：

1. /*
   
2. *        I O C T L   C O D E S   F O R   V I D E O   D E V I C E S
   
3. *
   
4. */
   
5. #define VIDIOC_QUERYCAP                        _IOR('V',  0, struct v4l2_capability)
   
6. #define VIDIOC_RESERVED                        _IO('V',  1)
   
7. #define VIDIOC_ENUM_FMT                 _IOWR('V',  2, struct v4l2_fmtdesc)
   
8. #define VIDIOC_G_FMT                                _IOWR('V',  4, struct v4l2_format)
   
9. #define VIDIOC_S_FMT                                _IOWR('V',  5, struct v4l2_format)
   
10. #define VIDIOC_REQBUFS                                _IOWR('V',  8, struct v4l2_requestbuffers)
    
11. #define VIDIOC_QUERYBUF                        _IOWR('V',  9, struct v4l2_buffer)
    
12. #define VIDIOC_G_FBUF                                 _IOR('V', 10, struct v4l2_framebuffer)
    
13. #define VIDIOC_S_FBUF                                 _IOW('V', 11, struct v4l2_framebuffer)
    
14. #define VIDIOC_OVERLAY                         _IOW('V', 14, int)
    
15. #define VIDIOC_QBUF                                        _IOWR('V', 15, struct v4l2_buffer)
    
16. #define VIDIOC_EXPBUF                                _IOWR('V', 16, struct v4l2_exportbuffer)
    
17. #define VIDIOC_DQBUF                                _IOWR('V', 17, struct v4l2_buffer)
    
18. #define VIDIOC_STREAMON                         _IOW('V', 18, int)
    
19. #define VIDIOC_STREAMOFF                         _IOW('V', 19, int)
    
20. #define VIDIOC_G_PARM                                _IOWR('V', 21, struct v4l2_streamparm)
    
21. #define VIDIOC_S_PARM                                _IOWR('V', 22, struct v4l2_streamparm)
    
22. #define VIDIOC_G_STD                                 _IOR('V', 23, v4l2_std_id)
    
23. #define VIDIOC_S_STD                                 _IOW('V', 24, v4l2_std_id)
    
24. #define VIDIOC_ENUMSTD                        _IOWR('V', 25, struct v4l2_standard)
    
25. #define VIDIOC_ENUMINPUT                        _IOWR('V', 26, struct v4l2_input)
    
26. #define VIDIOC_G_CTRL                                _IOWR('V', 27, struct v4l2_control)
    
27. #define VIDIOC_S_CTRL                                _IOWR('V', 28, struct v4l2_control)
    
28. #define VIDIOC_G_TUNER                                _IOWR('V', 29, struct v4l2_tuner)
    
29. #define VIDIOC_S_TUNER                                 _IOW('V', 30, struct v4l2_tuner)
    
30. #define VIDIOC_G_AUDIO                                 _IOR('V', 33, struct v4l2_audio)
    
31. #define VIDIOC_S_AUDIO                                 _IOW('V', 34, struct v4l2_audio)
    
32. #define VIDIOC_QUERYCTRL                        _IOWR('V', 36, struct v4l2_queryctrl)
    
33. #define VIDIOC_QUERYMENU                        _IOWR('V', 37, struct v4l2_querymenu)
    
34. #define VIDIOC_G_INPUT                                 _IOR('V', 38, int)
    
35. #define VIDIOC_S_INPUT                                _IOWR('V', 39, int)
    
36. #define VIDIOC_G_EDID                                _IOWR('V', 40, struct v4l2_edid)
    
37. #define VIDIOC_S_EDID                                _IOWR('V', 41, struct v4l2_edid)
    
38. #define VIDIOC_G_OUTPUT                         _IOR('V', 46, int)
    
39. #define VIDIOC_S_OUTPUT                        _IOWR('V', 47, int)
    
40. #define VIDIOC_ENUMOUTPUT                _IOWR('V', 48, struct v4l2_output)
    
41. #define VIDIOC_G_AUDOUT                         _IOR('V', 49, struct v4l2_audioout)
    
42. #define VIDIOC_S_AUDOUT                         _IOW('V', 50, struct v4l2_audioout)
    
43. #define VIDIOC_G_MODULATOR                _IOWR('V', 54, struct v4l2_modulator)
    
44. #define VIDIOC_S_MODULATOR                 _IOW('V', 55, struct v4l2_modulator)
    
45. #define VIDIOC_G_FREQUENCY                _IOWR('V', 56, struct v4l2_frequency)
    
46. #define VIDIOC_S_FREQUENCY                 _IOW('V', 57, struct v4l2_frequency)
    
47. #define VIDIOC_CROPCAP                                _IOWR('V', 58, struct v4l2_cropcap)
    
48. #define VIDIOC_G_CROP                                _IOWR('V', 59, struct v4l2_crop)
    
49. #define VIDIOC_S_CROP                                 _IOW('V', 60, struct v4l2_crop)
    
50. #define VIDIOC_G_JPEGCOMP                         _IOR('V', 61, struct v4l2_jpegcompression)
    
51. #define VIDIOC_S_JPEGCOMP                         _IOW('V', 62, struct v4l2_jpegcompression)
    
52. #define VIDIOC_QUERYSTD                       _IOR('V', 63, v4l2_std_id)
    
53. #define VIDIOC_TRY_FMT                      _IOWR('V', 64, struct v4l2_format)
    
54. #define VIDIOC_ENUMAUDIO                        _IOWR('V', 65, struct v4l2_audio)
    
55. #define VIDIOC_ENUMAUDOUT                _IOWR('V', 66, struct v4l2_audioout)
    
56. #define VIDIOC_G_PRIORITY                         _IOR('V', 67, __u32) /* enum v4l2_priority */
    
57. #define VIDIOC_S_PRIORITY                         _IOW('V', 68, __u32) /* enum v4l2_priority */
    
58. #define VIDIOC_G_SLICED_VBI_CAP         _IOWR('V', 69, struct v4l2_sliced_vbi_cap)
    
59. #define VIDIOC_LOG_STATUS               _IO('V', 70)
    
60. #define VIDIOC_G_EXT_CTRLS                _IOWR('V', 71, struct v4l2_ext_controls)
    
61. #define VIDIOC_S_EXT_CTRLS                        _IOWR('V', 72, struct v4l2_ext_controls)
    
62. #define VIDIOC_TRY_EXT_CTRLS                _IOWR('V', 73, struct v4l2_ext_controls)
    
63. #define VIDIOC_ENUM_FRAMESIZES        _IOWR('V', 74, struct v4l2_frmsizeenum)
    
64. #define VIDIOC_ENUM_FRAMEINTERVALS                _IOWR('V', 75, struct v4l2_frmivalenum)
    
65. #define VIDIOC_G_ENC_INDEX             _IOR('V', 76, struct v4l2_enc_idx)
    
66. #define VIDIOC_ENCODER_CMD            _IOWR('V', 77, struct v4l2_encoder_cmd)
    
67. #define VIDIOC_TRY_ENCODER_CMD         _IOWR('V', 78, struct v4l2_encoder_cmd)

复制代码

每一个不同的指令宏就表示向设备请求不同的操作，从上面可以看到，每一个宏后面（_IOWR/_IOR/_IOW）还携带了一个struct数据结构体，譬如struct v4l2_capability、struct v4l2_fmtdesc，这就是调用ioctl()时需要传入的第三个参数的类型；调用ioctl()前，定义一个该类型变量，调用ioctl()时、将变量的指针作为ioctl()的第三个参数传入，譬如：

1. struct v4l2_capability cap;
   
2. ……
   
3. ioctl(fd, VIDIOC_QUERYCAP, &cap);

复制代码

在实际的应用编程中，并不是所有的指令都会用到，针对视频采集类设备，以下笔者列出了一些常用的指令：

(, 下载次数: 0)

上传

点击文件名下载附件
表 26.2.1 v4l2摄像头常用的ioctl指令

26.2.1打开摄像头
视频类设备对应的设备节点为/dev/videoX，X为数字编号，通常从0开始；摄像头应用编程的第一步便是打开设备，调用open打开，得到文件描述符fd，如下所示：

1. int fd = -1;
   
2. 
   
3. /* 打开摄像头 */
   
4. fd = open("/dev/video0", O_RDWR);
   
5. if (0 > fd) {
   
6.         fprintf(stderr, "open error: %s: %s\n", "/dev/video0", strerror(errno));
   
7.         return -1;
   
8. }

复制代码

打开设备文件时，需要使用O_RDWR指定读权限和写权限。
26.2.2查询设备的属性/能力/功能
打开设备之后，接着需要查询设备的属性，确定该设备是否是一个视频采集类设备、以及其它一些属性，怎么查询呢？自然是通过ioctl()函数来实现，ioctl()对于设备文件来说是一个非常重要的系统调用，凡是涉及到配置设备、获取设备配置等操作都会使用ioctl来完成，在前面章节内容中我们就已经见识过了；但对于普通文件来说，ioctl()几乎没什么用。
查询设备的属性，使用的指令为VIDIOC_QUERYCAP，如下所示：

1. ioctl(int fd, VIDIOC_QUERYCAP, struct v4l2_capability *cap);

复制代码

此时通过ioctl()将获取到一个struct v4l2_capability类型数据，struct v4l2_capability数据结构描述了设备的一些属性，结构体定义如下所示：
示例代码 26.2.1 struct v4l2_capability结构体

1. struct v4l2_capability {
   
2.     __u8    driver[16];                  /* 驱动的名字 */
   
3.     __u8    card[32];               /* 设备的名字 */
   
4.     __u8    bus_info[32];          /* 总线的名字 */
   
5.     __u32   version;                /* 版本信息 */
   
6.     __u32   capabilities;           /* 设备拥有的能力 */
   
7.     __u32   device_caps;
   
8.     __u32   reserved[3];            /* 保留字段 */
   
9. };

复制代码

我们重点关注的是capabilities字段，该字段描述了设备拥有的能力，该字段的值如下（可以是以下任意一个值或多个值的位或关系）：

1. /* Values for 'capabilities' field */
   
2. #define V4L2_CAP_VIDEO_CAPTURE                0x00000001  /* Is a video capture device */
   
3. #define V4L2_CAP_VIDEO_OUTPUT                0x00000002  /* Is a video output device */
   
4. #define V4L2_CAP_VIDEO_OVERLAY                0x00000004  /* Can do video overlay */
   
5. #define V4L2_CAP_VBI_CAPTURE                        0x00000010  /* Is a raw VBI capture device */
   
6. #define V4L2_CAP_VBI_OUTPUT                        0x00000020  /* Is a raw VBI output device */
   
7. #define V4L2_CAP_SLICED_VBI_CAPTURE        0x00000040  /* Is a sliced VBI capture device */
   
8. #define V4L2_CAP_SLICED_VBI_OUTPUT        0x00000080  /* Is a sliced VBI output device */
   
9. #define V4L2_CAP_RDS_CAPTURE                                0x00000100  /* RDS data capture */
   
10. #define V4L2_CAP_VIDEO_OUTPUT_OVERLAY        0x00000200  /* Can do video output overlay */
    
11. #define V4L2_CAP_HW_FREQ_SEEK                        0x00000400  /* Can do hardware frequency seek  */
    
12. #define V4L2_CAP_RDS_OUTPUT                                0x00000800  /* Is an RDS encoder */
    
13. 
    
14. /* Is a video capture device that supports multiplanar formats */
    
15. #define V4L2_CAP_VIDEO_CAPTURE_MPLANE        0x00001000
    
16. /* Is a video output device that supports multiplanar formats */
    
17. #define V4L2_CAP_VIDEO_OUTPUT_MPLANE        0x00002000
    
18. /* Is a video mem-to-mem device that supports multiplanar formats */
    
19. #define V4L2_CAP_VIDEO_M2M_MPLANE                0x00004000
    
20. /* Is a video mem-to-mem device */
    
21. #define V4L2_CAP_VIDEO_M2M                                0x00008000
    
22. 
    
23. #define V4L2_CAP_TUNER                                                0x00010000  /* has a tuner */
    
24. #define V4L2_CAP_AUDIO                                                0x00020000  /* has audio support */
    
25. #define V4L2_CAP_RADIO                                                0x00040000  /* is a radio device */
    
26. #define V4L2_CAP_MODULATOR                                0x00080000  /* has a modulator */
    
27. 
    
28. #define V4L2_CAP_SDR_CAPTURE                                0x00100000  /* Is a SDR capture device */
    
29. #define V4L2_CAP_EXT_PIX_FORMAT                        0x00200000  /* Supports the extended pixel format */
    
30. #define V4L2_CAP_SDR_OUTPUT                                0x00400000  /* Is a SDR output device */
    
31. #define V4L2_CAP_META_CAPTURE                        0x00800000  /* Is a metadata capture device */
    
32. 
    
33. #define V4L2_CAP_READWRITE                      0x01000000  /* read/write systemcalls */
    
34. #define V4L2_CAP_ASYNCIO                        0x02000000  /* async I/O */
    
35. #define V4L2_CAP_STREAMING                      0x04000000  /* streaming I/O ioctls */
    
36. 
    
37. #define V4L2_CAP_TOUCH                          0x10000000  /* Is a touch device */
    
38. 
    
39. #define V4L2_CAP_DEVICE_CAPS                    0x80000000  /* sets device capabilities field */

复制代码

这些宏都是在videodev2.h头文件中所定义的，大家可以自己去看。对于摄像头设备来说，它的capabilities字段必须包含V4L2_CAP_VIDEO_CAPTURE，表示它支持视频采集功能。所以我们可以通过判断capabilities字段是否包含V4L2_CAP_VIDEO_CAPTURE、来确定它是否是一个摄像头设备，譬如：

1. /* 查询设备功能 */
   
2. ioctl(fd, VIDIOC_QUERYCAP, &vcap);
   
3. 
   
4. /* 判断是否是视频采集设备 */
   
5. if (!(V4L2_CAP_VIDEO_CAPTURE & vcap.capabilities)) {
   
6.         fprintf(stderr, "Error: No capture video device!\n");
   
7.         return -1;
   
8. }

复制代码

26.2.3设置帧格式、帧率
一个摄像头通常会支持多种不同的像素格式，譬如RGB、YUYV以及压缩格式MJPEG等，并且还支持多种不同的视频采集分辨率，譬如640*480、320*240、1280*720等，除此之外，同一分辨率可能还支持多种不同的视频采集帧率（15fps、30fps）。所以，通常在进行视频采集之前、需要在应用程序中去设置这些参数。
a)枚举出摄像头支持的所有像素格式：VIDIOC_ENUM_FMT
要设置像素格式，首先得知道该设备支持哪些像素格式，如何得知呢？使用VIDIOC_ENUM_FMT指令：

1. ioctl(int fd, VIDIOC_ENUM_FMT, struct v4l2_fmtdesc *fmtdesc);

复制代码

使用VIDIOC_ENUM_FMT可以枚举出设备所支持的所有像素格式，调用ioctl()需要传入一个struct v4l2_fmtdesc *指针，ioctl()会将获取到的数据写入到fmtdesc指针所指向的对象中。struct v4l2_fmtdesc结构体描述了像素格式相关的信息，我们来看看struct v4l2_fmtdesc结构体的定义：
示例代码 26.2.2 struct v4l2_fmtdesc结构体

1. /*
   
2. *  F O R M A T   E N U M E R A T I O N
   
3. */
   
4. struct v4l2_fmtdesc {
   
5.     __u32           index;                /* Format number */
   
6.     __u32           type;                  /* enum v4l2_buf_type */
   
7.     __u32           flags;
   
8.     __u8            description[32];         /* Description string */
   
9.     __u32           pixelformat;            /* Format fourcc */
   
10.     __u32           reserved[4];
    
11. };

复制代码

index表示编号，在枚举之前，需将其设置为0，然后每次ioctl()调用之后将其值加1。一次ioctl()调用只能得到一种像素格式的信息，如果设备支持多种像素格式，则需要循环调用多次，通过index来控制，index从0开始，调用一次ioctl()之后加1，直到ioctl()调用失败，表示已经将所有像素格式都枚举出来了；所以index就是一个编号，获取index编号指定的像素格式。
description字段是一个简单地描述性字符串，简单描述pixelformat像素格式。
pixelformat字段则是对应的像素格式编号，这是一个无符号32位数据，每一种像素格式都会使用一个u32类型数据来表示，如下所示：

1. /* RGB formats */
   
2. #define V4L2_PIX_FMT_RGB332          v4l2_fourcc('R', 'G', 'B', '1')                 /* 8  RGB-3-3-2     */
   
3. #define V4L2_PIX_FMT_RGB444          v4l2_fourcc('R', '4', '4', '4')                 /* 16  xxxxrrrr ggggbbbb */
   
4. #define V4L2_PIX_FMT_ARGB444         v4l2_fourcc('A', 'R', '1', '2')                 /* 16  aaaarrrr ggggbbbb */
   
5. #define V4L2_PIX_FMT_XRGB444         v4l2_fourcc('X', 'R', '1', '2')                 /* 16  xxxxrrrr ggggbbbb */
   
6. #define V4L2_PIX_FMT_RGB555          v4l2_fourcc('R', 'G', 'B', 'O')                 /* 16  RGB-5-5-5     */
   
7. #define V4L2_PIX_FMT_ARGB555         v4l2_fourcc('A', 'R', '1', '5')                 /* 16  ARGB-1-5-5-5  */
   
8. #define V4L2_PIX_FMT_XRGB555         v4l2_fourcc('X', 'R', '1', '5')                 /* 16  XRGB-1-5-5-5  */
   
9. #define V4L2_PIX_FMT_RGB565          v4l2_fourcc('R', 'G', 'B', 'P')                 /* 16  RGB-5-6-5     */
   
10. ......
    
11. /* Grey formats */
    
12. #define V4L2_PIX_FMT_GREY            v4l2_fourcc('G', 'R', 'E', 'Y')                 /* 8  Greyscale     */
    
13. #define V4L2_PIX_FMT_Y4              v4l2_fourcc('Y', '0', '4', ' ')                 /* 4  Greyscale     */
    
14. #define V4L2_PIX_FMT_Y6              v4l2_fourcc('Y', '0', '6', ' ')                 /* 6  Greyscale     */
    
15. #define V4L2_PIX_FMT_Y10             v4l2_fourcc('Y', '1', '0', ' ')                 /* 10  Greyscale     */
    
16. ......
    
17. /* Luminance+Chrominance formats */
    
18. #define V4L2_PIX_FMT_YUYV            v4l2_fourcc('Y', 'U', 'Y', 'V')                 /* 16  YUV 4:2:2     */
    
19. #define V4L2_PIX_FMT_YYUV            v4l2_fourcc('Y', 'Y', 'U', 'V')                 /* 16  YUV 4:2:2     */
    
20. #define V4L2_PIX_FMT_YVYU            v4l2_fourcc('Y', 'V', 'Y', 'U')                 /* 16 YVU 4:2:2 */
    
21. #define V4L2_PIX_FMT_UYVY            v4l2_fourcc('U', 'Y', 'V', 'Y')                 /* 16  YUV 4:2:2     */
    
22. ......
    
23. /* compressed formats */
    
24. #define V4L2_PIX_FMT_MJPEG            v4l2_fourcc('M', 'J', 'P', 'G')                 /* Motion-JPEG   */
    
25. #define V4L2_PIX_FMT_JPEG             v4l2_fourcc('J', 'P', 'E', 'G')                 /* JFIF JPEG     */
    
26. #define V4L2_PIX_FMT_DV               v4l2_fourcc('d', 'v', 's', 'd')                 /* 1394          */
    
27. #define V4L2_PIX_FMT_MPEG            v4l2_fourcc('M', 'P', 'E', 'G')                 /* MPEG-1/2/4 Multiplexed */

复制代码

以上列举出来的只是其中一部分，篇幅有限、不能将所有的像素格式都列举出来，大家可以自己查看videodev2.h头文件。可以看到后面有一个v4l2_fourcc宏，其实就是通过这个宏以及对应的参数合成的一个u32类型数据。
type字段指定类型，表示我们要获取设备的哪种功能对应的像素格式，因为有些设备它可能即支持视频采集功能、又支持视频输出等其它的功能；type字段可取值如下：

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.         V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY        = 8,
   
10.         V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE         = 9,
    
11.         V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE          = 10,
    
12.         V4L2_BUF_TYPE_SDR_CAPTURE                  = 11,
    
13.         V4L2_BUF_TYPE_SDR_OUTPUT                   = 12,
    
14.         V4L2_BUF_TYPE_META_CAPTURE                 = 13,
    
15.         /* Deprecated, do not use */
    
16.         V4L2_BUF_TYPE_PRIVATE                              = 0x80,
    
17. };

复制代码

type字段需要在调用ioctl()之前设置它的值，对于摄像头，需要将type字段设置为V4L2_BUF_TYPE_VIDEO_CAPTURE，指定我们将要获取的是视频采集的像素格式。
使用示例如下所示：

1. struct v4l2_fmtdesc fmtdesc;
   
2. 
   
3. /* 枚举出摄像头所支持的所有像素格式以及描述信息 */
   
4. fmtdesc.index = 0;
   
5. fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
6. while (0 == ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc)) {
   
7. 
   
8.         printf("fmt: %s <0x%x>\n", fmtdesc.description, fmtdesc.pixelformat);
   
9.         fmtdesc.index++;
   
10. }

复制代码

b)枚举摄像头所支持的所有视频采集分辨率：VIDIOC_ENUM_FRAMESIZES
使用VIDIOC_ENUM_FRAMESIZES指令可以枚举出设备所支持的所有视频采集分辨率，用法如下所示：
ioctl(int fd, VIDIOC_ENUM_FRAMESIZES, struct v4l2_frmsizeenum *frmsize);
调用ioctl()需要传入一个struct v4l2_frmsizeenum *指针，ioctl()会将获取到的数据写入到frmsize指针所指向的对象中。struct v4l2_frmsizeenum结构体描述了视频帧大小相关的信息，我们来看看struct v4l2_frmsizeenum结构体的定义：
示例代码 26.2.3 struct v4l2_frmsizeenum结构体

1. struct v4l2_frmsizeenum {
   
2.     __u32           index;                     /* Frame size number */
   
3.     __u32           pixel_format;           /* 像素格式 */
   
4.     __u32           type;                       /* type */
   
5. 
   
6.     union {                 /* Frame size */
   
7.         struct v4l2_frmsize_discrete    discrete;
   
8.         struct v4l2_frmsize_stepwise    stepwise;
   
9.     };
   
10. 
    
11.     __u32   reserved[2];                    /* Reserved space for future use */
    
12. };
    
13. 
    
14. struct v4l2_frmsize_discrete {
    
15.     __u32           width;                      /* Frame width [pixel] */
    
16.     __u32           height;                     /* Frame height [pixel] */
    
17. };

复制代码

index字段与struct v4l2_fmtdesc结构体的index字段意义相同，一个摄像头通常支持多种不同的视频采集分辨率，一次ioctl()调用只能得到一种视频帧大小信息，如果设备支持多种视频帧大小，则需要循环调用多次，通过index来控制。
pixel_format字段指定像素格式，而type字段与struct v4l2_fmtdesc结构体的type字段意义相同；在调用ioctl()之前，需要先设置type字段与pixel_format字段，确定我们将要枚举的是：设备的哪种功能、哪种像素格式支持的视频帧大小。
可以看到struct v4l2_frmsizeenum结构体中有一个union共用体，type= V4L2_BUF_TYPE_VIDEO_CAPTURE情况下，discrete生效，这是一个struct v4l2_frmsize_discrete类型变量，描述了视频帧大小信息（包括视频帧的宽度和高度），也就是视频采集分辨率大小。
譬如我们要枚举出摄像头RGB565像素格式所支持的所有视频帧大小：

1. struct v4l2_frmsizeenum frmsize;
   
2. 
   
3. frmsize.index = 0;
   
4. frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
5. frmsize.pixel_format = V4L2_PIX_FMT_RGB565;
   
6. while (0 == ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) {
   
7. 
   
8.         printf("frame_size<%d*%d>\n", frmsize.discrete.width, frmsize.discrete.height);
   
9.         frmsize.index++;
   
10. }

复制代码

c)枚举摄像头所支持的所有视频采集帧率：VIDIOC_ENUM_FRAMEINTERVALS
同一种视频帧大小，摄像头可能会支持多种不同的视频采集帧率，譬如常见的15fps、30fps、45fps以及60fps等；使用VIDIOC_ENUM_FRAMEINTERVALS指令可以枚举出设备所支持的所有帧率，使用方式如下：

1. ioctl(int fd, VIDIOC_ENUM_FRAMEINTERVALS, struct v4l2_frmivalenum *frmival);

复制代码

调用ioctl()需要传入一个struct v4l2_frmivalenum *指针，ioctl()会将获取到的数据写入到frmival指针所指向的对象中。struct v4l2_frmivalenum结构体描述了视频帧率相关的信息，我们来看看struct v4l2_frmivalenum结构体的定义：
示例代码 26.2.4 struct v4l2_frmivalenum结构体

1. struct v4l2_frmivalenum {
   
2.     __u32           index;      /* Frame format index */
   
3.     __u32           pixel_format;/* Pixel format */
   
4.     __u32           width;      /* Frame width */
   
5.     __u32           height;     /* Frame height */
   
6.     __u32           type;       /* type */
   
7. 
   
8.     union {                 /* Frame interval */
   
9.         struct v4l2_fract                       discrete;
   
10.         struct v4l2_frmival_stepwise                stepwise;
    
11.     };
    
12. 
    
13.     __u32   reserved[2];            /* Reserved space for future use */
    
14. };
    
15. 
    
16. struct v4l2_fract {
    
17.     __u32   numerator;      //分子
    
18.     __u32   denominator;    //分母
    
19. };

复制代码

index、type字段与struct v4l2_frmsizeenum结构体的index、type字段意义相同。
width、height字段用于指定视频帧大小，pixel_format字段指定像素格式。
以上这些字段都是需要在调用ioctl()之前设置它的值。
可以看到struct v4l2_frmivalenum结构体也有一个union共用体，当type= V4L2_BUF_TYPE_VIDEO_CAPTURE时，discrete生效，这是一个struct v4l2_fract类型变量，描述了视频帧率信息（一秒钟采集图像的次数）；struct v4l2_fract结构体中，numerator表示分子、denominator表示分母，使用numerator / denominator来表示图像采集的周期（采集一幅图像需要多少秒），所以视频帧率便等于denominator / numerator。
使用示例，譬如，我们要枚举出RGB565像素格式下640*480帧大小所支持的所有视频采集帧率：

1. struct v4l2_frmivalenum frmival;
   
2. 
   
3. frmival.index = 0;
   
4. frmival.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
5. frmival.pixel_format = V4L2_PIX_FMT_RGB565;
   
6. frmival.width = 640;
   
7. frmival.height = 480;
   
8. 
   
9. while (0 == ioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival)) {
   
10. 
    
11.         printf("Frame interval<%ffps> ", frmival.discrete.denominator / frmival.discrete.numerator);
    
12.         frmival.index++;
    
13. }

复制代码

d)查看或设置当前的格式：VIDIOC_G_FMT、VIDIOC_S_FMT
前面介绍的指令只是枚举设备支持的像素格式、视频帧大小以及视频采集帧率等这些信息，将下来我们将介绍如何设置这些参数。
首先可以使用VIDIOC_G_FMT指令查看设备当期的格式，用法如下所示

1. int ioctl(int fd, VIDIOC_G_FMT, struct v4l2_format *fmt);

复制代码

调用ioctl()需要传入一个struct v4l2_format *指针，ioctl()会将获取到的数据写入到fmt指针所指向的对象中，struct v4l2_format结构体描述了格式相关的信息。
使用VIDIOC_S_FMT指令设置设备的格式，用法如下所示：

1. int ioctl(int fd, VIDIOC_S_FMT, struct v4l2_format *fmt);

复制代码

ioctl()会使用fmt所指对象的数据去设置设备的格式。我们来看看v4l2_format结构体的定义：
示例代码 26.2.5 struct v4l2_format结构体

1. struct v4l2_format {
   
2.     __u32    type;
   
3.     union {
   
4.         struct v4l2_pix_format              pix;           /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
   
5.         struct v4l2_pix_format_mplane         pix_mp;         /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE */
   
6.         struct v4l2_window                      win;           /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
   
7.         struct v4l2_vbi_format              vbi;           /* V4L2_BUF_TYPE_VBI_CAPTURE */
   
8.         struct v4l2_sliced_vbi_format           sliced;          /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
   
9.         struct v4l2_sdr_format              sdr;            /* V4L2_BUF_TYPE_SDR_CAPTURE */
   
10.         struct v4l2_meta_format             meta;          /* V4L2_BUF_TYPE_META_CAPTURE */
    
11.         __u8    raw_data[200];                      /* user-defined */
    
12.     } fmt;
    
13. };

复制代码

type字段依然与前面介绍的结构体中的type字段意义相同，不管是获取格式、还是设置格式都需要在调用ioctl()函数之前设置它的值。
接下来是一个union共用体，当type被设置为V4L2_BUF_TYPE_VIDEO_CAPTURE时，pix变量生效，它是一个struct v4l2_pix_format类型变量，记录了视频帧格式相关的信息，如下所示：
示例代码 26.2.6 struct v4l2_pix_format结构体

1. struct v4l2_pix_format {
   
2.     __u32           width;                      //视频帧的宽度（单位：像素）
   
3.     __u32           height;                 //视频帧的高度（单位：像素）
   
4.     __u32           pixelformat;            //像素格式
   
5.     __u32           field;                      /* enum v4l2_field */
   
6.     __u32           bytesperline;           /* for padding, zero if unused */
   
7.     __u32           sizeimage;
   
8.     __u32           colorspace;                 /* enum v4l2_colorspace */
   
9.     __u32           priv;                       /* private data, depends on pixelformat */
   
10.     __u32           flags;                      /* format flags (V4L2_PIX_FMT_FLAG_*) */
    
11.     union {
    
12.         /* enum v4l2_ycbcr_encoding */
    
13.         __u32       ycbcr_enc;
    
14.         /* enum v4l2_hsv_encoding */
    
15.         __u32       hsv_enc;
    
16.     };
    
17.     __u32           quantization;           /* enum v4l2_quantization */
    
18.     __u32           xfer_func;                  /* enum v4l2_xfer_func */
    
19. };

复制代码

colorspace字段描述的是一个颜色空间，可取值如下：

1. enum v4l2_colorspace {
   
2.     /*
   
3.      * Default colorspace, i.e. let the driver figure it out.
   
4.      * Can only be used with video capture.
   
5.      */
   
6.     V4L2_COLORSPACE_DEFAULT             = 0,
   
7. 
   
8.     /* SMPTE 170M: used for broadcast NTSC/PAL SDTV */
   
9.     V4L2_COLORSPACE_SMPTE170M             = 1,
   
10. 
    
11.     /* Obsolete pre-1998 SMPTE 240M HDTV standard, superseded by Rec 709 */
    
12.     V4L2_COLORSPACE_SMPTE240M             = 2,
    
13. 
    
14.     /* Rec.709: used for HDTV */
    
15.     V4L2_COLORSPACE_REC709                = 3,
    
16. 
    
17.     /*
    
18.      * Deprecated, do not use. No driver will ever return this. This was
    
19.      * based on a misunderstanding of the bt878 datasheet.
    
20.      */
    
21.     V4L2_COLORSPACE_BT878                 = 4,
    
22. 
    
23.     /*
    
24.      * NTSC 1953 colorspace. This only makes sense when dealing with
    
25.      * really, really old NTSC recordings. Superseded by SMPTE 170M.
    
26.      */
    
27.     V4L2_COLORSPACE_470_SYSTEM_M         = 5,
    
28. 
    
29.     /*
    
30.      * EBU Tech 3213 PAL/SECAM colorspace. This only makes sense when
    
31.      * dealing with really old PAL/SECAM recordings. Superseded by
    
32.      * SMPTE 170M.
    
33.      */
    
34.     V4L2_COLORSPACE_470_SYSTEM_BG        = 6,
    
35. 
    
36.     /*
    
37.      * Effectively shorthand for V4L2_COLORSPACE_SRGB, V4L2_YCBCR_ENC_601
    
38.      * and V4L2_QUANTIZATION_FULL_RANGE. To be used for (Motion-)JPEG.
    
39.      */
    
40.     V4L2_COLORSPACE_JPEG                  = 7,
    
41. 
    
42.     /* For RGB colorspaces such as produces by most webcams. */
    
43.     V4L2_COLORSPACE_SRGB                 = 8,
    
44. 
    
45.     /* AdobeRGB colorspace */
    
46.     V4L2_COLORSPACE_ADOBERGB            = 9,
    
47. 
    
48.     /* BT.2020 colorspace, used for UHDTV. */
    
49.     V4L2_COLORSPACE_BT2020                = 10,
    
50. 
    
51.     /* Raw colorspace: for RAW unprocessed images */
    
52.     V4L2_COLORSPACE_RAW                  = 11,
    
53. 
    
54.     /* DCI-P3 colorspace, used by cinema projectors */
    
55.     V4L2_COLORSPACE_DCI_P3              = 12,
    
56. };

复制代码

使用VIDIOC_S_FMT指令设置格式时，通常不需要用户指定colorspace，底层驱动会根据像素格式pixelformat来确定对应的colorspace。
例子：获取当前的格式、并设置格式

1. struct v4l2_format fmt;
   
2. 
   
3. fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
4. if (0 > ioctl(fd, VIDIOC_G_FMT, &fmt)) {        //获取格式信息
   
5.         perror("ioctl error");
   
6.         return -1;
   
7. }
   
8. 
   
9. printf("width:%d, height:%d format:%d\n", fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.pixelformat);
   
10. 
    
11. fmt.fmt.pix.width = 800;
    
12. fmt.fmt.pix.height = 480;
    
13. fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;
    
14. if (0 > ioctl(fd, VIDIOC_S_FMT, &fmt)) {        //设置格式
    
15.         perror("ioctl error");
    
16.         return -1;
    
17. }

复制代码

使用指令VIDIOC_S_FMT设置格式时，实际设置的参数并不一定等于我们指定的参数，譬如上面我们指定视频帧宽度为800、高度为480，但这个摄像头不一定支持这种视频帧大小，或者摄像头不支持V4L2_PIX_FMT_RGB565这种像素格式；通常在这种情况下，底层驱动程序并不会按照我们指定的参数进行设置，它会对这些参数进行修改，譬如，如果摄像头不支持800*480，那么底层驱动可能会将其修改为640*480（假设摄像头支持这种分辨率）；所以，当ioctl()调用返回后，我们还需要检查返回的struct v4l2_format类型变量，以确定我们指定的参数是否已经生效：

1. struct v4l2_format fmt;
   
2. 
   
3. fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
4. fmt.fmt.pix.width = 800;
   
5. fmt.fmt.pix.height = 480;
   
6. fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;
   
7. if (0 > ioctl(fd, VIDIOC_S_FMT, &fmt)) {        //设置格式
   
8.         perror("ioctl error");
   
9.         return -1;
   
10. }
    
11. 
    
12. if (800 != fmt.fmt.pix.width ||
    
13.         480 != fmt.fmt.pix.height){
    
14.         do_something();
    
15. }
    
16. 
    
17. if (V4L2_PIX_FMT_RGB565 != fmt.fmt.pix.pixelformat) {
    
18.         do_something();
    
19. }

复制代码

e)设置或获取当前的流类型相关参数：VIDIOC_G_PARM、VIDIOC_S_PARM
使用VIDIOC_G_PARM指令可以获取设备的流类型相关参数（Stream type-dependent parameters），使用方式如下：

1. ioctl(int fd, VIDIOC_G_PARM, struct v4l2_streamparm *streamparm);

复制代码

调用ioctl()需要传入一个struct v4l2_streamparm *指针，ioctl()会将获取到的数据写入到streamparm指针所指向的对象中，struct v4l2_streamparm结构体描述了流类型相关的信息，具体的内容等会在介绍。
使用VIDIOC_S_PARM指令设置设备的流类型相关参数，用法如下所示：

1. ioctl(int fd, VIDIOC_S_PARM, struct v4l2_streamparm *streamparm);

复制代码

ioctl()会使用streamparm所指对象的数据去设置设备的流类型相关参数。我们来看看struct v4l2_streamparm结构体的定义：
示例代码 26.2.7 struct v4l2_streamparm结构体

1. struct v4l2_streamparm {
   
2.     __u32    type;          /* enum v4l2_buf_type */
   
3.     union {
   
4.         struct v4l2_captureparm         capture;
   
5.         struct v4l2_outputparm          output;
   
6.         __u8    raw_data[200];  /* user-defined */
   
7.     } parm;
   
8. };
   
9. 
   
10. struct v4l2_captureparm {
    
11.     __u32                  capability;                  /*  Supported modes */
    
12.     __u32                  capturemode;           /*  Current mode */
    
13.     struct v4l2_fract        timeperframe;          /*  Time per frame in seconds */
    
14.     __u32                  extendedmode;        /*  Driver-specific extensions */
    
15.     __u32                  readbuffers;           /*  # of buffers for read */
    
16.     __u32                  reserved[4];
    
17. };
    
18. 
    
19. struct v4l2_fract {
    
20.     __u32   numerator;                /*  分子 */
    
21.     __u32   denominator;                 /*  分母 */
    
22. };

复制代码

type字段与前面一样，不再介绍，在调用ioctl()之前需先设置它的值。
当type= V4L2_BUF_TYPE_VIDEO_CAPTURE时，union共用体中capture变量生效，它是一个struct v4l2_captureparm类型变量，struct v4l2_captureparm结构体描述了摄像头采集相关的一些参数，譬如视频采集帧率，上面已经给出了该结构体的定义。
struct v4l2_captureparm结构体中，capability字段表示设备支持的模式有哪些，可取值如下（以下任意一个或多个的位或关系）：

1. /*  Flags for 'capability' and 'capturemode' fields */
   
2. #define V4L2_MODE_HIGHQUALITY        0x0001        /*  High quality imaging mode 高品质成像模式 */
   
3. #define V4L2_CAP_TIMEPERFRAME        0x1000        /*  timeperframe field is supported 支持设置timeperframe字段 */

复制代码

capturemode则表示当前的模式，与capability字段的取值相同。
timeperframe字段是一个struct v4l2_fract结构体类型变量，描述了设备视频采集的周期，前面已经给大家介绍过。使用VIDIOC_S_PARM可以设置视频采集的周期，也就是视频采集帧率，但是很多设备并不支持应用层设置timeperframe字段，只有当capability字段包含V4L2_CAP_TIMEPERFRAME时才表示设备支持timeperframe字段，这样应用层才可以去设置设备的视频采集帧率。
所以，在设置之前，先通过VIDIOC_G_PARM命令获取到设备的流类型相关参数，判断capability字段是否包含V4L2_CAP_TIMEPERFRAME，如下所示：

1. struct v4l2_streamparm streamparm;
   
2. 
   
3. streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
4. ioctl(v4l2_fd, VIDIOC_G_PARM, &streamparm);
   
5. 
   
6. /** 判断是否支持帧率设置 **/
   
7. if (V4L2_CAP_TIMEPERFRAME & streamparm.parm.capture.capability) {
   
8.         streamparm.parm.capture.timeperframe.numerator = 1;
   
9.         streamparm.parm.capture.timeperframe.denominator = 30;//30fps
   
10. 
    
11.         if (0 > ioctl(v4l2_fd, VIDIOC_S_PARM, &streamparm)) {//设置参数
    
12.                 fprintf(stderr, "ioctl error: VIDIOC_S_PARM: %s\n", strerror(errno));
    
13.                 return -1;
    
14.         }
    
15. }
    
16. else
    
17.         fprintf(stderr, "不支持帧率设置");

复制代码

26.2.4申请帧缓冲、内存映射
读取摄像头数据的方式有两种，一种是read方式，也就是直接通过read()系统调用读取摄像头采集到的数据；另一种则是streaming方式；26.2.2小节中介绍了使用VIDIOC_QUERYCAP指令查询设备的属性、得到一个struct v4l2_capability类型数据，其中capabilities字段记录了设备拥有的能力，当该字段包含V4L2_CAP_READWRITE时，表示设备支持read I/O方式读取数据；当该字段包含V4L2_CAP_STREAMING时，表示设备支持streaming I/O方式；事实上，绝大部分设备都支持streaming I/O方式读取数据，使用streaming I/O方式，我们需要向设备申请帧缓冲，并将帧缓冲映射到应用程序进程地址空间中。
当完成对设备的配置之后，接下来就可以去申请帧缓冲了，帧缓冲顾名思义就是用于存储一帧图像数据的缓冲区，使用VIDIOC_REQBUFS指令可申请帧缓冲，使用方式如下所示：
ioctl(int fd, VIDIOC_REQBUFS, struct v4l2_requestbuffers *reqbuf);
调用ioctl()需要传入一个struct v4l2_requestbuffers *指针，struct v4l2_requestbuffers结构体描述了申请帧缓冲的信息，ioctl()会根据reqbuf所指对象填充的信息进行申请。我们来看看struct v4l2_requestbuffers结构体的定义：
示例代码 26.2.8 struct v4l2_requestbuffers结构体

1. /*
   
2. *  M E M O R Y - M A P P I N G   B U F F E R S
   
3. */
   
4. struct v4l2_requestbuffers {
   
5.     __u32           count;              //申请帧缓冲的数量
   
6.     __u32           type;               /* enum v4l2_buf_type */
   
7.     __u32           memory;           /* enum v4l2_memory */
   
8.     __u32           reserved[2];
   
9. };

复制代码

type字段与前面所提及到的type字段意义相同，不再介绍，在调用ioctl()之前需先设置它的值。
count字段用于指定申请帧缓冲的数量。
memory字段可取值如下：

1. enum v4l2_memory {
   
2.         V4L2_MEMORY_MMAP            = 1,
   
3.         V4L2_MEMORY_USERPTR          = 2,
   
4.         V4L2_MEMORY_OVERLAY         = 3,
   
5.         V4L2_MEMORY_DMABUF          = 4,
   
6. };

复制代码

通常将memory设置为V4L2_MEMORY_MMAP即可！使用示例如下：

1. struct v4l2_requestbuffers reqbuf;
   
2. 
   
3. reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
4. reqbuf.count = 3;                // 申请3个帧缓冲
   
5. reqbuf.memory = V4L2_MEMORY_MMAP;
   
6. 
   
7. if (0 > ioctl(fd, VIDIOC_REQBUFS, &reqbuf)) {
   
8.         fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
   
9.         return -1;
   
10. }

复制代码

streaming I/O方式会在内核空间中维护一个帧缓冲队列，驱动程序会将从摄像头读取的一帧数据写入到队列中的一个帧缓冲，接着将下一帧数据写入到队列中的下一个帧缓冲；当应用程序需要读取一帧数据时，需要从队列中取出一个装满一帧数据的帧缓冲，这个取出过程就叫做出队；当应用程序处理完这一帧数据后，需要再把这个帧缓冲加入到内核的帧缓冲队列中，这个过程叫做入队！这个很容易理解，现实当中都有很多这样的例子，这里就不再举例了。
所以由此可知，读取图像数据的过程其实就是一个不断地出队列和入队列的过程，如下图所示

(, 下载次数: 0)

上传

点击文件名下载附件
图 26.2.2 应用层读取图像数据的过程

将帧缓冲映射到进程地址空间
使用VIDIOC_REQBUFS指令申请帧缓冲，该缓冲区实质上是由内核所维护的，应用程序不能直接读取该缓冲区的数据，我们需要将其映射到用户空间中，这样，应用程序读取映射区的数据实际上就是读取内核维护的帧缓冲中的数据。
在映射之前，需要查询帧缓冲的信息，譬如帧缓冲的长度、偏移量等信息，使用VIDIOC_QUERYBUF指令查询，使用方式如下所示：
ioctl(int fd, VIDIOC_QUERYBUF, struct v4l2_buffer *buf);
调用ioctl()需要传入一个struct v4l2_buffer *指针，struct v4l2_buffer结构体描述了帧缓冲的信息，ioctl()会将获取到的数据写入到buf指针所指的对象中。我们来看看struct v4l2_buffer结构体的定义：
示例代码 26.2.9 struct v4l2_buffer结构体

1. struct v4l2_buffer {
   
2.     __u32           index;            //buffer的编号
   
3.     __u32           type;               //type
   
4.     __u32           bytesused;
   
5.     __u32           flags;
   
6.     __u32           field;
   
7.     struct timeval              timestamp;
   
8.     struct v4l2_timecode        timecode;
   
9.     __u32           sequence;
   
10. 
    
11.     /* memory location */
    
12.     __u32           memory;
    
13.     union {
    
14.         __u32                offset;         //偏移量
    
15.         unsigned long           userptr;
    
16.         struct v4l2_plane         *planes;
    
17.         __s32                       fd;
    
18.     } m;
    
19.     __u32           length;            //buffer的长度
    
20.     __u32           reserved2;
    
21.     __u32           reserved;
    
22. };

复制代码

index字段表示一个编号，申请的多个帧缓冲、每一个帧缓冲都有一个编号，从0开始。一次ioctl()调用只能获取指定编号对应的帧缓冲的信息，所以要获取多个帧缓冲的信息，需要重复调用多次，每调用一次ioctl()、index加1，指向下一个帧缓冲。
type字段与前面所提及到的type字段意义相同，不再介绍，在调用ioctl()之前需先设置它的值。
memory字段与struct v4l2_requestbuffers结构体的memory字段意义相同，需要在调用ioctl()之前设置它的值。
length字段表示帧缓冲的长度，而共同体中的offset则表示帧缓冲的偏移量，如何理解这个偏移量？因为应用程序通过VIDIOC_REQBUFS指令申请帧缓冲时，内核会向操作系统申请一块内存空间作为帧缓冲区，这块内存空间的大小就等于申请的帧缓冲数量 * 每一个帧缓冲的大小，每一个帧缓冲对应到这一块内存空间的某一段，所以它们都有一个地址偏移量。
帧缓冲的数量不要太多了，尤其是在一些内存比较吃紧的嵌入式系统中，帧缓冲的数量太多，势必会占用太多的系统内存。
使用示例，申请帧缓冲后、调用mmap()将帧缓冲映射到用户地址空间：

1. struct v4l2_requestbuffers reqbuf;
   
2. struct v4l2_buffer buf;
   
3. void *frm_base[3];
   
4. 
   
5. reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
6. reqbuf.count = 3;                // 申请3个帧缓冲
   
7. reqbuf.memory = V4L2_MEMORY_MMAP;
   
8. 
   
9. /* 申请3个帧缓冲 */
   
10. if (0 > ioctl(fd, VIDIOC_REQBUFS, &reqbuf)) {
    
11.         fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
    
12.         return -1;
    
13. }
    
14. 
    
15. /* 建立内存映射 */
    
16. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    
17. buf.memory = V4L2_MEMORY_MMAP;
    
18. for (buf.index = 0; buf.index < 3; buf.index++) {
    
19. 
    
20.         ioctl(fd, VIDIOC_QUERYBUF, &buf);
    
21.         frm_base[buf.index] = mmap(NULL, buf.length,
    
22.                                 PROT_READ | PROT_WRITE, MAP_SHARED,
    
23.                                 fd, buf.m.offset);
    
24.         if (MAP_FAILED == frm_base[buf.index]) {
    
25.                 perror("mmap error");
    
26.                 return -1;
    
27.         }
    
28. }

复制代码

在上述的示例中，我们会将三个帧缓冲映射到用户空间，并将每一个帧缓冲对应的映射区的起始地址保存在frm_base数组中，后面读取摄像头采集的数据时，直接读取映射区即可。
26.2.5入队
使用VIDIOC_QBUF指令将帧缓冲放入到内核的帧缓冲队列中，使用方式如下：

1. ioctl(int fd, VIDIOC_QBUF, struct v4l2_buffer *buf);

复制代码

调用ioctl()之前，需要设置struct v4l2_buffer类型对象的memory、type字段，使用示例如下所示：
将三个帧缓冲放入内核的帧缓冲队列（入队操作）中：

1. struct v4l2_buffer buf;
   
2. 
   
3. /* 入队操作 */
   
4. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
5. buf.memory = V4L2_MEMORY_MMAP;
   
6. for (buf.index = 0; buf.index < 3; buf.index++) {
   
7. 
   
8.         if (0 > ioctl(fd, VIDIOC_QBUF, &buf)) {
   
9.                 perror("ioctl error");
   
10.                 return -1;
    
11.         }
    
12. }

复制代码

26.2.6开启视频采集
将三个帧缓冲放入到队列中之后，接着便可以打开摄像头、开启图像采集了，使用VIDIOC_DQBUF指令开启视频采集，使用方式如下所示：

1. ioctl(int fd, VIDIOC_STREAMON, int *type);                //开启视频采集
   
2. ioctl(int fd, VIDIOC_STREAMOFF, int *type);                //停止视频采集

复制代码

type其实一个enum v4l2_buf_type *指针，通常用法如下：

1. enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
2. 
   
3. if (0 > ioctl(fd, VIDIOC_STREAMON, &type)) {
   
4.         perror("ioctl error");
   
5.         return -1;
   
6. }

复制代码

26.2.7读取数据、对数据进行处理
开启视频采集之后，接着便可以去读取数据了，前面我们已经说过，直接读取每一个帧缓冲的在用户空间的映射区即可读取到摄像头采集的每一帧图像数据。在读取数据之前，需要将帧缓冲从内核的帧缓冲队列中取出，这个操作叫做帧缓冲出队（有入队自然就有出队），前面已经给大家详细地介绍了这些理论知识。
使用VIDIOC_DQBUF指令执行出队操作，使用方式如下：

1. ioctl(int fd, VIDIOC_DQBUF, struct v4l2_buffer *buf);

复制代码

帧缓冲出队之后，接下来便可读取数据了，然后对数据进行处理，譬如将摄像头采集的图像显示到LCD屏上；数据处理完成之后，再将帧缓冲入队，将队列中的下一个帧缓冲出队，然后读取数据、处理，这样往复操作。
使用示例如下：

1. struct v4l2_buffer buf;
   
2. 
   
3. buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
4. buf.memory = V4L2_MEMORY_MMAP;
   
5. for ( ; ; ) {
   
6. 
   
7.         for(buf.index = 0; buf.index < 3; buf.index++) {
   
8. 
   
9.                 ioctl(fd, VIDIOC_DQBUF, &buf);                //出队
   
10. 
    
11.                 // 读取帧缓冲的映射区、获取一帧数据
    
12.                 // 处理这一帧数据
    
13.                 do_something();
    
14. 
    
15.                 // 数据处理完之后、将当前帧缓冲入队、接着读取下一帧数据
    
16.                 ioctl(fd, VIDIOC_QBUF, &buf);
    
17.         }
    
18. }

复制代码

26.2.8结束视频采集
如果要结束视频采集，使用VIDIOC_STREAMOFF指令，用法前面已经介绍了。使用示例如下所示：

1. enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   
2. 
   
3. if (0 > ioctl(fd, VIDIOC_STREAMOFF, &type)) {
   
4.         perror("ioctl error");
   
5.         return -1;
   
6. }

复制代码

26.3V4L2摄像头应用编程实战
通过前面的介绍，我们已经知道如何对摄像头进行应用编程了，摄像头的应用编程其实并不难，基本都是按照那样的一套流程下来即可：打开设备、查询设备、设置格式、申请帧缓冲、内存映射、入队、开启视频采集、出队、对采集到的数据进行处理，虽然步骤很多，但是这些操作步骤都是容易理解的，他并没有让你感觉到很难理解这个步骤，每一个步骤基本都是通过ioctl()来实现，搭配不同请求指令。
本小节我们来编写摄像头应用程序，笔者希望大家能够自己去独立完成，通过前面的介绍，相信大家是能够独立完成的，可以适当地参考下面笔者提供的示例代码：
本例程源码对应的路径为：开发板光盘->11、Linux C应用编程例程源码->26_v4l2_camera->v4l2_camera.c。
示例代码 26.3.1 V4L2摄像头应用编程示例代码

1. /***************************************************************
   
2. Copyright &#169; ALIENTEK Co., Ltd. 1998-2021. All rights reserved.
   
3. 文件名 : v4l2_camera.c
   
4. 作者 : 邓涛
   
5. 版本 : V1.0
   
6. 描述 : V4L2摄像头应用编程实战
   
7. 其他 : 无
   
8. 论坛 : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
   
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   3               //帧缓冲数量
    
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;
    
67.     width = fb_var.xres;
    
68.     height = fb_var.yres;
    
69. 
    
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. 
     
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. 
     
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.pixel_format = cam_fmts<i>.pixelformat;
     
139.         frmival.pixel_format = cam_fmts<i>.pixelformat;
     
140.         while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) {
     
141. 
     
142.             printf("size<%d*%d> ",
     
143.                     frmsize.discrete.width,
     
144.                     frmsize.discrete.height);
     
145.             frmsize.index++;
     
146. 
     
147.             /* 获取摄像头视频采集帧率 */
     
148.             frmival.index = 0;
     
149.             frmival.width = frmsize.discrete.width;
     
150.             frmival.height = frmsize.discrete.height;
     
151.             while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival)) {
     
152. 
     
153.                 printf("<%dfps>", frmival.discrete.denominator /
     
154.                         frmival.discrete.numerator);
     
155.                 frmival.index++;
     
156.             }
     
157.             printf("\n");
     
158.         }
     
159.         printf("\n");
     
160.     }
     
161. }
     
162. 
     
163. static int v4l2_set_format(void)
     
164. {
     
165.     struct v4l2_format fmt = {0};
     
166.     struct v4l2_streamparm streamparm = {0};
     
167. 
     
168.     /* 设置帧格式 */
     
169.     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type类型
     
170.     fmt.fmt.pix.width = width;  //视频帧宽度
     
171.     fmt.fmt.pix.height = height;//视频帧高度
     
172.     fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;  //像素格式
     
173.     if (0 > ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt)) {
     
174.         fprintf(stderr, "ioctl error: VIDIOC_S_FMT: %s\n", strerror(errno));
     
175.         return -1;
     
176.     }
     
177. 
     
178.     /*** 判断是否已经设置为我们要求的RGB565像素格式
     
179.     如果没有设置成功表示该设备不支持RGB565像素格式 */
     
180.     if (V4L2_PIX_FMT_RGB565 != fmt.fmt.pix.pixelformat) {
     
181.         fprintf(stderr, "Error: the device does not support RGB565 format!\n");
     
182.         return -1;
     
183.     }
     
184. 
     
185.     frm_width = fmt.fmt.pix.width;  //获取实际的帧宽度
     
186.     frm_height = fmt.fmt.pix.height;//获取实际的帧高度
     
187.     printf("视频帧大小<%d * %d>\n", frm_width, frm_height);
     
188. 
     
189.     /* 获取streamparm */
     
190.     streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
191.     ioctl(v4l2_fd, VIDIOC_G_PARM, &streamparm);
     
192. 
     
193.     /** 判断是否支持帧率设置 **/
     
194.     if (V4L2_CAP_TIMEPERFRAME & streamparm.parm.capture.capability) {
     
195.         streamparm.parm.capture.timeperframe.numerator = 1;
     
196.         streamparm.parm.capture.timeperframe.denominator = 30;//30fps
     
197.         if (0 > ioctl(v4l2_fd, VIDIOC_S_PARM, &streamparm)) {
     
198.             fprintf(stderr, "ioctl error: VIDIOC_S_PARM: %s\n", strerror(errno));
     
199.             return -1;
     
200.         }
     
201.     }
     
202. 
     
203.     return 0;
     
204. }
     
205. 
     
206. static int v4l2_init_buffer(void)
     
207. {
     
208.     struct v4l2_requestbuffers reqbuf = {0};
     
209.     struct v4l2_buffer buf = {0};
     
210. 
     
211.     /* 申请帧缓冲 */
     
212.     reqbuf.count = FRAMEBUFFER_COUNT;       //帧缓冲的数量
     
213.     reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
214.     reqbuf.memory = V4L2_MEMORY_MMAP;
     
215.     if (0 > ioctl(v4l2_fd, VIDIOC_REQBUFS, &reqbuf)) {
     
216.         fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
     
217.         return -1;
     
218.     }
     
219. 
     
220.     /* 建立内存映射 */
     
221.     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
222.     buf.memory = V4L2_MEMORY_MMAP;
     
223.     for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {
     
224. 
     
225.         ioctl(v4l2_fd, VIDIOC_QUERYBUF, &buf);
     
226.         buf_infos[buf.index].length = buf.length;
     
227.         buf_infos[buf.index].start = mmap(NULL, buf.length,
     
228.                 PROT_READ | PROT_WRITE, MAP_SHARED,
     
229.                 v4l2_fd, buf.m.offset);
     
230.         if (MAP_FAILED == buf_infos[buf.index].start) {
     
231.             perror("mmap error");
     
232.             return -1;
     
233.         }
     
234.     }
     
235. 
     
236.     /* 入队 */
     
237.     for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {
     
238. 
     
239.         if (0 > ioctl(v4l2_fd, VIDIOC_QBUF, &buf)) {
     
240.             fprintf(stderr, "ioctl error: VIDIOC_QBUF: %s\n", strerror(errno));
     
241.             return -1;
     
242.         }
     
243.     }
     
244. 
     
245.     return 0;
     
246. }
     
247. 
     
248. static int v4l2_stream_on(void)
     
249. {
     
250.     /* 打开摄像头、摄像头开始采集数据 */
     
251.     enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
252. 
     
253.     if (0 > ioctl(v4l2_fd, VIDIOC_STREAMON, &type)) {
     
254.         fprintf(stderr, "ioctl error: VIDIOC_STREAMON: %s\n", strerror(errno));
     
255.         return -1;
     
256.     }
     
257. 
     
258.     return 0;
     
259. }
     
260. 
     
261. static void v4l2_read_data(void)
     
262. {
     
263.     struct v4l2_buffer buf = {0};
     
264.     unsigned short *base;
     
265.     unsigned short *start;
     
266.     int min_w, min_h;
     
267.     int j;
     
268. 
     
269.     if (width > frm_width)
     
270.         min_w = frm_width;
     
271.     else
     
272.         min_w = width;
     
273.     if (height > frm_height)
     
274.         min_h = frm_height;
     
275.     else
     
276.         min_h = height;
     
277. 
     
278.     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     
279.     buf.memory = V4L2_MEMORY_MMAP;
     
280.     for ( ; ; ) {
     
281. 
     
282.         for(buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {
     
283. 
     
284.             ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);     //出队
     
285.             for (j = 0, base=screen_base, start=buf_infos[buf.index].start;
     
286.                         j < min_h; j++) {
     
287. 
     
288.                 memcpy(base, start, min_w * 2); //RGB565 一个像素占2个字节
     
289.                 base += width;  //LCD显示指向下一行
     
290.                 start += frm_width;//指向下一行数据
     
291.             }
     
292. 
     
293.             // 数据处理完之后、再入队、往复
     
294.             ioctl(v4l2_fd, VIDIOC_QBUF, &buf);
     
295.         }
     
296.     }
     
297. }
     
298. 
     
299. int main(int argc, char *argv[])
     
300. {
     
301.     if (2 != argc) {
     
302.         fprintf(stderr, "Usage: %s <video_dev>\n", argv[0]);
     
303.         exit(EXIT_FAILURE);
     
304.     }
     
305. 
     
306.     /* 初始化LCD */
     
307.     if (fb_dev_init())
     
308.         exit(EXIT_FAILURE);
     
309. 
     
310.     /* 初始化摄像头 */
     
311.     if (v4l2_dev_init(argv[1]))
     
312.         exit(EXIT_FAILURE);
     
313. 
     
314.     /* 枚举所有格式并打印摄像头支持的分辨率及帧率 */
     
315.     v4l2_enum_formats();
     
316.     v4l2_print_formats();
     
317. 
     
318.     /* 设置格式 */
     
319.     if (v4l2_set_format())
     
320.         exit(EXIT_FAILURE);
     
321. 
     
322.     /* 初始化帧缓冲：申请、内存映射、入队 */
     
323.     if (v4l2_init_buffer())
     
324.         exit(EXIT_FAILURE);
     
325. 
     
326.     /* 开启视频采集 */
     
327.     if (v4l2_stream_on())
     
328.         exit(EXIT_FAILURE);
     
329. 
     
330.     /* 读取数据：出队 */
     
331.     v4l2_read_data();       //在函数内循环采集数据、将其显示到LCD屏
     
332. 
     
333.     exit(EXIT_SUCCESS);
     
334. }</i></i></i></i></i>

复制代码

上述示例代码中，会将摄像头采集到的图像数据显示到开发板LCD屏上，我们将摄像头的像素格式设置为RGB565，因为这样比较好处理。其它的代码就不给大家介绍了，没什么可说的，代码中的注释信息已经描述得很清楚了，这要是讲视频还可以给扯一扯，文本形式的话，有些东西不是那么好描述！
开发板出厂系统支持正点原子的ov5640、ov7725（无FIFO）以及ov2640这几款摄像头，这几款摄像头都支持RGB565像素格式；当然除此之外，还可以板子上使用UVC USB摄像头，如果大家身边有这种摄像头，也可以进行测试，但是这种USB摄像头通常不支持RGB565格式，而更多是YUYV格式，上述代码并不支持YUYV格式的处理，需要大家进行修改，你得将采集到的YUYV数据转为RGB565数据，才能在LCD上显示采集到的图像。
接下来编译示例代码：

(, 下载次数: 0)

上传

点击文件名下载附件
图 26.3.1 编译摄像头应用程序

将编译得到的可执行文件拷贝到开发板Linux系统的用户家目录下：

(, 下载次数: 0)

上传

点击文件名下载附件
图 26.3.2 将可执行文件拷贝到开发板

首先在测试之前，我们的开发板上得插上一个摄像头，这里需要注意一下，前面我们提到开发板出厂系统支持ov5640、ov7725以及ov2640,这三款摄像头，但是不能同时生效，出厂系统默认配置使能的是ov5640，如果要使用ov7725或ov2640，则需修改设备树，具体如何修改请大家参考“开发板光盘资料A-基础资料/【正点原子】I.MX6U用户快速体验V1.7.3.pdf”文档中的3.16小节。
这里笔者以ov2640摄像头为例，笔者的测试板上已经连接了ov2640摄像头，如下所示：

(, 下载次数: 0)

上传

点击文件名下载附件
图 26.3.3 摄像头安装方式

其它摄像头的安装方式也是如此，头部朝外，注意一定是在启动之前就安装好了、而不是开发板启动之后再安装，切记！如果是USB摄像头，则可在开发板运行状态下，直接将USB摄像头插入到开发板上的USB HOST接口即可。
接着运行测试程序，我们需要传入一个参数，该参数表示摄像头的对应的设备节点：

(, 下载次数: 0)

上传

点击文件名下载附件
图 26.3.4 执行摄像头测试程序

程序运行之后，此时开发板LCD屏上将会显示摄像头所采集到的图像，如下所示：

(, 下载次数: 0)

上传

点击文件名下载附件
图 26.3.5 LCD显示摄像头采集的图像

请大家忽略手机拍摄的问题！
原本运行程序之后，终端会打印出摄像头所支持的像素格式、描述信息以及摄像头所支持的采集分辨率、帧率等信息，但是从图 26.3.4中打印信息可知，程序运行之后只打印了像素格式以及描述信息，并没有打印分辨率和帧率等信息，为什么呢？当然这个不是我们的程序有问题，而是摄像头的驱动功能不够完善，底层驱动并没有去实现这些相关的功能，这里给大家简单地提一下，免得大家以为程序有问题！这里笔者换了一个USB摄像头，给大家看下它的打印信息，如下所示：

(, 下载次数: 0)

上传

点击文件名下载附件
图 26.3.6 USB摄像头打印信息

从上图可以看到，程序打印了摄像头所支持的所有采集分辨率大小以及帧率。
好了，本章的内容到此结束了，到此为止，我们已经学习了很多硬件外设的应用编程知识了，大家要学会活学活用，把这些东西用起来，尝试着做一个综合类的好玩的小项目，提高自己的应用编程能力，笔者觉得这是非常重要，你不要跟着笔者的教程一个一个章节往下走，你得停下来思考、多动动手、在教程的基础上多往外扩展，这样你才能进步！大家加油！

---

作者: zdyzdemo    时间: 2021-9-5 08:54

我使用了V1.9内核，插入OV5640模块，无法在/dev目录下找到对应的设备节点。可能是什么原因呢？

---

作者: zdyzdemo    时间: 2021-9-5 08:58

我使用了V1.9内核，插入OV5640模块，无法在/dev目录下找到对应的设备节点。可能是什么原因呢？

---

作者: 和谐年份    时间: 2021-11-8 16:05
赞一个，讲的很详细。~

---

作者: 茂茂2019    时间: 2021-11-9 09:31

zdyzdemo 发表于 2021-9-5 08:58
我使用了V1.9内核，插入OV5640模块，无法在/dev目录下找到对应的设备节点。可能是什么原因呢？

摄像头是编译成模块的

---

作者: sky505050w    时间: 2021-11-27 22:25

茂茂2019 发表于 2021-11-9 09:31
摄像头是编译成模块的

大神，编译成模块，请问该怎么使用呢，我用的是7725

---

作者: chenjian1419    时间: 2021-12-12 12:29


我使用了USB摄像头，数据格式只支持MJPEG和YUYV422两种格式，我的lcd屏幕是800*480的，这款摄像头我只能设置位640*480分辨率采集，MJPEG解码后,刷LCD花屏，不知道哪里出错了？

---

作者: jm2006031089    时间: 2021-12-24 10:51

chenjian1419 发表于 2021-12-12 12:29
我使用了USB摄像头，数据格式只支持MJPEG和YUYV422两种格式，我的lcd屏幕是800*480的，这款摄像头我只能设 ...

同求，运行程序后，显示条纹移动。看不见

---

作者: watsonxia    时间: 2021-12-24 16:49
就想问下，支持什么型号的USB 摄像头呢？还是说都支持。

---

作者: xiaotaotao    时间: 2021-12-26 17:15

watsonxia 发表于 2021-12-24 16:49
就想问下，支持什么型号的USB 摄像头呢？还是说都支持。

支持UVC协议的USB摄像头

---

作者: YouLi20    时间: 2022-4-1 23:02

chenjian1419 发表于 2021-12-12 12:29
我使用了USB摄像头，数据格式只支持MJPEG和YUYV422两种格式，我的lcd屏幕是800*480的，这款摄像头我只能设 ...

同问，请问这个问题解决了吗

---

作者: JDmuyi    时间: 2022-4-15 12:27

YouLi20 发表于 2022-4-1 23:02
同问，请问这个问题解决了吗

我也是，在做毕设，用的是ov5640摄像头，直接用的例程代码lcd刷花屏，人麻了。

---

作者: 1900s    时间: 2022-5-17 23:24

JDmuyi 发表于 2022-4-15 12:27
我也是，在做毕设，用的是ov5640摄像头，直接用的例程代码lcd刷花屏，人麻了。

请问你现在解决了吗？我使用这个代码，lcd上都是噪点，采集不到图像。

---

作者: xiaotaotao    时间: 2022-5-21 18:33

1900s 发表于 2022-5-17 23:24
请问你现在解决了吗？我使用这个代码，lcd上都是噪点，采集不到图像。

烧写最新的出厂系统镜像

---

欢迎光临 OpenEdv-开源电子网 (https://www.openedv.com/)

Powered by Discuz! X3.4