9、基于Linux的v4l2视频架构应用编写

Linux系统中，视频设备被当作一个设备文件来看待，设备文件存放在 /dev目录下，完整路径的设备文件名为： /dev/video0 .

视频采集基本步骤流程如下：打开视频设备，设置视频设备属性及采集方式、视频数据处理，关闭视频设备，如下图所示：

一、打开视频设备

打开视频设备非常简单，在V4L2中，视频设备被看做一个文件。使用open函数打开这个设备：

1. 用非阻塞模式打开摄像头设备
int cameraFd;
cameraFd = open("/dev/video0", O_RDWR | O_NONBLOCK);

2. 如果用阻塞模式打开摄像头设备，上述代码变为：
cameraFd = open("/dev/video0", O_RDWR);

关于阻塞模式和非阻塞模式

应用程序能够使用阻塞模式或非阻塞模式打开视频设备，如果使用非阻塞模式调用视频设备，即使尚未捕获到信息，驱动依旧会把缓存（DQBUFF）里的东西返回给应用程序。

二、Linux视频设备驱动常用控制命令使用说明

设置视频设备属性通过ioctl来进行设置，ioctl有三个参数，分别是fd, cmd,和parameter,表示设备描述符，控制命令和控制命令参数。

Linux 视频设备驱动接口V4L2支持的常用控制命令如下：

1．控制命令 VIDIOC_ENUM_FMT //ENUM什么意思？自己查查去

功能：获取当前视频设备支持的视频格式。

参数说明：参数类型为V4L2的视频格式描述符类型 struct v4l2_fmtdesc

返回值说明：执行成功时，函数返回值为 0；struct v4l2_fmtdesc 结构体中的 .pixelformat和 .description 成员返回当前视频设备所支持的视频格式；

使用举例：

-------------------------------------------------------------------------------------------------

struct v4l2_fmtdesc fmt;

memset(&fmt, 0, sizeof(fmt));

fmt.index = 0;

fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

while ((ret = ioctl(dev, VIDIOC_ENUM_FMT, &fmt)) == 0) {

fmt.index++;

printf("{ pixelformat = ''%c%c%c%c'', description = ''%s'' } ",

fmt.pixelformat & 0xFF, (fmt.pixelformat >> 8) & 0xFF,

(fmt.pixelformat >> 16) & 0xFF, (fmt.pixelformat >> 24) & 0xFF,

fmt.description);

}

-------------------------------------------------------------------------------------------------------

2．控制命令VIDIOC_QUERYCAP //query 和cap各代表什么意思

功能：查询视频设备的功能；

参数说明：参数类型为V4L2的能力描述类型struct v4l2_capability ；

返回值说明：执行成功时，函数返回值为 0；函数执行成功后，struct v4l2_capability 结构体变量中的返回当前视频设备所支持的功能；例如支持视频捕获功能V4L2_CAP_VIDEO_CAPTURE、V4L2_CAP_STREAMING等。

使用举例：

-------------------------------------------------------------------------------------------------------

struct v4l2_capability cap;

iret = ioctl(fd_usbcam, VIDIOC_QUERYCAP, &cap);

if(iret < 0)

{

printf("get vidieo capability error,error code: %d ", errno);

return ;

}

------------------------------------------------------------------------------------------------------

执行完VIDIOC_QUERYCAP命令后，cap变量中包含了该视频设备的能力信息，程序中通过检查cap中的设备能力信息来判断设备是否支持某项功能。

3．控制命令VIDIOC_S_FMT //直接告诉你，s是set的意思

功能：设置视频设备的视频数据格式，例如设置视频图像数据的长、宽，图像格式（JPEG、YUYV格式）；

参数说明：参数类型为V4L2的视频数据格式类型 struct v4l2_format ；

返回值说明：执行成功时，函数返回值为 0；

使用举例：

----------------------------------------------------------------------------------------------------------

struct v4l2_format tv4l2_format;

tv4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

tv4l2_format.fmt.pix.width = img_width;

tv4l2_format.fmt.pix.height = img_height;

tv4l2_format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;

tv4l2_format.fmt.pix.field = V4L2_FIELD_INTERLACED;

iret = ioctl(fd_usbcam, VIDIOC_S_FMT, &tv4l2_format);

-----------------------------------------------------------------------------------------------------------

注意：如果该视频设备驱动不支持你所设定的图像格式，视频驱动会重新修改struct v4l2_format结构体变量的值为该视频设备所支持的图像格式，所以在程序设计中，设定完所有的视频格式后，要获取实际的视频格式，要重新读取struct v4l2_format结构体变量。

4．控制命令VIDIOC_REQBUFS //我不问了，你自己问自己吧

功能：请求V4L2驱动分配视频缓冲区（申请V4L2视频驱动分配内存），V4L2是视频设备的驱动层，位于内核空间，所以通过VIDIOC_REQBUFS控制命令字申请的内存位于内核空间，应用程序不能直接访问，需要通过调用mmap内存映射函数把内核空间内存映射到用户空间后，应用程序通过访问用户空间地址来访问内核空间。

参数说明：参数类型为V4L2的申请缓冲区数据结构体类型struct v4l2_requestbuffers ；

返回值说明：执行成功时，函数返回值为 0；V4L2驱动层分配好了视频缓冲区；

使用举例：

-----------------------------------------------------------------------------------------------------

struct v4l2_requestbuffers tV4L2_reqbuf;

memset(&tV4L2_reqbuf, 0, sizeof(struct v4l2_requestbuffers ));

tV4L2_reqbuf.count = 1; //申请缓冲区的个数

tV4L2_reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

tV4L2_reqbuf.memory = V4L2_MEMORY_MMAP;

iret = ioctl(fd_usbcam, VIDIOC_REQBUFS, &tV4L2_reqbuf);

-----------------------------------------------------------------------------------------------------

注意：VIDIOC_REQBUFS会修改tV4L2_reqbuf的count值，tV4L2_reqbuf的count值返回实际申请成功的视频缓冲区数目；

5．控制命令VIDIOC_QUERYBUF

功能：查询已经分配的V4L2的视频缓冲区的相关信息，包括视频缓冲区的使用状态、在内核空间的偏移地址、缓冲区长度等。在应用程序设计中通过调VIDIOC_QUERYBUF来获取内核空间的视频缓冲区信息，然后调用函数mmap把内核空间地址映射到用户空间，这样应用程序才能够访问位于内核空间的视频缓冲区。

参数说明：参数类型为V4L2缓冲区数据结构类型 struct v4l2_buffer ；

返回值说明：执行成功时，函数返回值为 0；struct v4l2_buffer结构体变量中保存了指令的缓冲区的相关信息；

一般情况下，应用程序中调用VIDIOC_QUERYBUF取得了内核缓冲区信息后，紧接着调用mmap函数把内核空间地址映射到用户空间，方便用户空间应用程序的访问。

使用举例：

-------------------------------------------------------------------------------------------------------

struct v4l2_buffer tV4L2buf;

memset(&tV4L2buf, 0, sizeof(struct v4l2_buffer));

tV4L2buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

tV4L2buf.memory = V4L2_MEMORY_MMAP;

tV4L2buf.index = i; // 要获取内核视频缓冲区的信息编号

iret = ioctl(fd_usbcam, VIDIOC_QUERYBUF, &tV4L2buf);

// 把内核空间缓冲区映射到用户空间缓冲区

AppBufLength = tV4L2buf.length;

AppBufStartAddr = mmap(NULL /* start anywhere */ ,

tV4L2buf.length,

PROT_READ | PROT_WRITE /* access privilege */ ,

MAP_SHARED /* recommended */ ,

fd_usbcam, tV4L2buf.m.offset);

-------------------------------------------------------------------------------------------------------

上述代码在通过调用VIDIOC_QUERYBUF取得内核空间的缓冲区信息后，接着调用mmap函数把内核空间缓冲区映射到用户空间；关于mmap函数的用法，请读者查询相关资料；

6．控制命令VIDIOC_QBUF

功能：投放一个空的视频缓冲区到视频缓冲区输入队列中；

参数说明：参数类型为V4L2缓冲区数据结构类型 struct v4l2_buffer ；

返回值说明：执行成功时，函数返回值为 0；函数执行成功后，指令(指定)的视频缓冲区进入视频输入队列，在启动视频设备拍摄图像时，相应的视频数据被保存到视频输入队列相应的视频缓冲区中。

使用举例：

-------------------------------------------------------------------------------------------------------

struct v4l2_buffer tV4L2buf;

memset(&tV4L2buf, 0, sizeof(struct v4l2_buffer));

tV4L2buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

tV4L2buf.memory = V4L2_MEMORY_MMAP;

tV4L2buf.index = i; //指令（指定）要投放到视频输入队列中的内核空间视频缓冲区的编号；

iret = ioctl(fd_usbcam, VIDIOC_QBUF, &tV4L2buf);

7．控制命令VIDIOC_STREAMON

功能：启动视频采集命令，应用程序调用VIDIOC_STREAMON启动视频采集命令后，视频设备驱动程序开始采集视频数据，并把采集到的视频数据保存到视频驱动的视频缓冲区中。

参数说明：参数类型为V4L2的视频缓冲区类型 enum v4l2_buf_type ；

返回值说明：执行成功时，函数返回值为 0；函数执行成功后，视频设备驱动程序开始采集视频数据，此时应用程序一般通过调用select函数来判断一帧视频数据是否采集完成，当视频设备驱动完成一帧视频数据采集并保存到视频缓冲区中时，select函数返回，应用程序接着可以读取视频数据；否则select函数阻塞直到视频数据采集完成。Select函数的使用请读者参考相关资料。

使用举例：

----------------------------------------------------------------------------------------------------------

enum v4l2_buf_type v4l2type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

fd_set fds ;

struct timeval tv;

iret = ioctl(fd_usbcam, VIDIOC_STREAMON, &v4l2type);

FD_ZERO(&fds);

FD_SET(fd_usbcam, &fds);

tv.tv_sec = 2; /* Timeout. */

tv.tv_usec = 0;

iret = select(fd_usbcam+ 1, &fds, NULL, NULL, &tv);

----------------------------------------------------------------------------------------------------------

8．控制命令VIDIOC_DQBUF //第二个D是删除的意思

功能：从视频缓冲区的输出队列中取得一个已经保存有一帧视频数据的视频缓冲区；

参数说明：参数类型为V4L2缓冲区数据结构类型 struct v4l2_buffer ；

返回值说明：执行成功时，函数返回值为 0；函数执行成功后，相应的内核视频缓冲区中保存有当前拍摄到的视频数据，应用程序可以通过访问用户空间来读取该视频数据。（前面已经通过调用函数mmap做了用户空间和内核空间的内存映射）.

使用举例：

----------------------------------------------------------------------------------------------------------

struct v4l2_buffer tV4L2buf;

memset(&tV4L2buf, 0, sizeof(struct v4l2_buffer));

tV4L2buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

tV4L2buf.memory = V4L2_MEMORY_MMAP;

iret = ioctl(fd_usbcam, VIDIOC_DQBUF, &tV4L2buf);

Sasoritattoo注释：VIDIOC_DQBUF命令结果使从队列删除的缓冲帧信息传给了此tVL2buf。V4L2_buffer结构体的作用就相当于申请的缓冲帧的代理，找缓冲帧的都要先问问它，通过它来联系缓冲帧，起了中间桥梁的作用。

----------------------------------------------------------------------------------------------------------

9．控制命令VIDIOC_STREAMOFF

功能：停止视频采集命令，应用程序调用VIDIOC_ STREAMOFF停止视频采集命令后，视频设备驱动程序不在采集视频数据。

参数说明：参数类型为V4L2的视频缓冲区类型 enum v4l2_buf_type ；

返回值说明：执行成功时，函数返回值为 0；函数执行成功后，视频设备停止采集视频数据。

使用举例：

----------------------------------------------------------------------------------------------------------

enum v4l2_buf_type v4l2type;

v4l2type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

iret = ioctl(fd_usbcam, VIDIOC_STREAMOFF, &v4l2type);

-----------------------------------------------------------------------------------------------------------

以上就是Linux 视频设备驱动V4L2最常用的控制命令使用说明，通过使用以上控制命令，可以完成一幅视频数据的采集过程。V4L2更多的控制命令使用说明请参考：http://v4l2spec.bytesex.org/spec/book1.htm

Linux之V4L2基础编程

1. 定义

V4L2(Video For Linux Two) 是内核提供给应用程序访问音、视频驱动的统一接口。

2. 工作流程：

打开设备－> 检查和设置设备属性－> 设置帧格式－> 设置一种输入输出方法（缓冲区管理）－> 循环获取数据－> 关闭设备。

3. 设备的打开和关闭：

#include <fcntl.h>

int open(const char *device_name, int flags);

#include <unistd.h>

int clo se(int fd);

例：

int fd=open(“/dev/video0”,O_RDWR); // 打开设备

close(fd); // 关闭设备

注意：V4L2 的相关定义包含在头文件<linux/videodev2.h> 中.

4. 查询设备属性： VIDIOC_QUERYCAP

相关函数：

int ioctl(int fd, int request, struct v4l2_capability *argp);

相关结构体：

struct v4l2_capability

{

u8 driver[16]; // 驱动名字

u8 card[32]; // 设备名字

u8 bus_info[32]; // 设备在系统中的位置

u32 version; // 驱动版本号

u32 capabilities; // 设备支持的操作

u32 reserved[4]; // 保留字段

};

capabilities 常用值:

V4L2_CAP_VIDEO_CAPTURE // 是否支持图像获取

例：显示设备信息

struct v4l2_capability cap;

ioctl(fd,VIDIOC_QUERYCAP,&cap);

printf(“Driver Name:%s
Card Name:%s
Bus info:%s
Driver Version:%u.%u.%u
”,cap.driver,cap.card,cap.bus_info,(cap.version>>16)&0XFF, (cap.version>>8)&0XFF,cap.version&0XFF);

5. 设置视频的制式和帧格式

制式包括PAL，NTSC，帧的格式个包括宽度和高度等。

相关函数：

int ioctl(int fd, int request, struct v4l2_fmtdesc *argp);

int ioctl(int fd, int request, struct v4l2_format *argp);

相关结构体：

v4l2_cropcap 结构体用来设置摄像头的捕捉能力，在捕捉上视频时应先先设置

v4l2_cropcap 的 type 域，再通过 VIDIO_CROPCAP 操作命令获取设备捕捉能力的参数，保存于 v4l2_cropcap 结构体中，包括 bounds（最大捕捉方框的左上角坐标和宽高），defrect

（默认捕捉方框的左上角坐标和宽高）等。

v4l2_format 结构体用来设置摄像头的视频制式、帧格式等，在设置这个参数时应先填好 v4l2_format 的各个域，如 type（传输流类型），fmt.pix.width(宽)，

fmt.pix.heigth(高)，fmt.pix.field(采样区域，如隔行采样)，fmt.pix.pixelformat(采

样类型，如 YUV4:2:2)，然后通过 VIDIO_S_FMT 操作命令设置视频捕捉格式。如下图所示：

5.1 查询并显示所有支持的格式：VIDIOC_ENUM_FMT

相关函数：

int ioctl(int fd, int request, struct v4l2_fmtdesc *argp);

相关结构体：

 1 struct v4l2_fmtdesc
 2 
 3 {
 4 
 5 u32 index; // 要查询的格式序号，应用程序设置
 6 
 7 enum v4l2_buf_type type; // 帧类型，应用程序设置
 8 
 9 u32 flags; // 是否为压缩格式
10 
11 u8 description[32]; // 格式名称
12 
13 u32 pixelformat; // 格式
14 
15 u32 reserved[4]; // 保留
16 
17 };

例：显示所有支持的格式

 1 struct v4l2_fmtdesc fmtdesc; fmtdesc.index=0; fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; printf("Support format:
");
 2 
 3 while(ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc) != -1)
 4 
 5 {
 6 
 7 printf("	%d.%s
",fmtdesc.index+1,fmtdesc.description);
 8 
 9 fmtdesc.index++;
10 
11 }

5.2 查看或设置当前格式： VIDIOC_G_FMT, VIDIOC_S_FMT

检查是否支持某种格式：VIDIOC_TRY_FMT

相关函数：

int ioctl(int fd, int request, struct v4l2_format *argp);

相关结构体：

 1 struct v4l2_format
 2 
 3 {
 4 
 5 enum v4l2_buf_type type; // 帧类型，应用程序设置
 6 
 7 union fmt
 8 
 9 {
10 
11 struct v4l2_pix_format pix; // 视频设备使用
12 
13 struct v4l2_window win;
14 
15 struct v4l2_vbi_format vbi;
16 
17 struct v4l2_sliced_vbi_format sliced;
18 
19 u8 raw_data[200];
20 
21 };
22 
23 };
24 
25 struct v4l2_pix_format
26 
27 {
28 
29 u32 width; // 帧宽，单位像素
30 
31 u32 height; // 帧高，单位像素
32 
33 u32 pixelformat; // 帧格式
34 
35 enum v4l2_field field;
36 
37 u32 bytesperline;
38 
39 u32 sizeimage;
40 
41 enum v4l2_colorspace colorspace;
42 
43 u32 priv;
44 
45 };

例：显示当前帧的相关信息

 1 struct v4l2_format fmt; fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; ioctl(fd, VIDIOC_G_FMT, &fmt);
 2 
 3 printf(“Current data format information:
	%d
	height:%d
”,
 4 
 5 fmt.fmt.pix.width,fmt.fmt.pix.height);
 6 
 7 struct v4l2_fmtdesc fmtdesc; fmtdesc.index=0; fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)
 8 
 9 {
10 
11 if(fmtdesc.pixelformat & fmt.fmt.pix.pixelformat)
12 
13 {
14 
15 printf(“	format:%s
”,fmtdesc.description);
16 
17 break;
18 
19 }
20 
21 fmtdesc.index++;
22 
23 }

例：检查是否支持某种帧格式

struct v4l2_format fmt; fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; fmt.fmt.pix.pixelformat=V4L2_PIX_FMT_RGB32; if(ioctl(fd,VIDIOC_TRY_FMT,&fmt)==-1) if(errno==EINVAL)

printf(“not support format RGB32!
”);

6. 图像的缩放 VIDIOC_CROPCAP

相关函数：

int ioctl(int fd, int request, struct v4l2_cropcap *argp);

int ioctl(int fd, int request, struct v4l2_crop *argp);

int ioctl(int fd, int request, const struct v4l2_crop *argp);

相关结构体：

Cropping 和 scaling 主要指的是图像的取景范围及图片的比例缩放的支持。Crop 就是把得到的数据作一定的裁剪和伸缩，裁剪可以只取样我们可以得到的图像大小的一部分，剪裁的主要参数是位置、长度、宽度。而 scale 的设置是通过 VIDIOC_G_FMT 和 VIDIOC_S_FMT 来获得和设置当前的 image 的长度，宽度来实现的。看下图

我们可以假设 bounds 是 sensor 最大能捕捉到的图像范围，而 defrect 是设备默认的最大取样范围，这个可以通过 VIDIOC_CROPCAP 的 ioctl 来获得设备的 crap 相关的属性 v4l2_cropcap，其中的 bounds 就是这个 bounds，其实就是上限。每个设备都有个默认的取样范围，就是 defrect，就是 default rect 的意思，它比 bounds 要小一些。这个范围也是通过 VIDIOC_CROPCAP 的 ioctl 来获得的 v4l2_cropcap 结构中的 defrect 来表示的，我们可以通过 VIDIOC_G_CROP 和 VIDIOC_S_CROP 来获取和设置设备当前的 crop 设置。

6.1 设置设备捕捉能力的参数

相关函数：

int ioctl(int fd, int request, struct v4l2_cropcap *argp);

相关结构体：

 1 struct v4l2_cropcap
 2 
 3 {
 4 
 5 enum v4l2_buf_type type; // 数据流的类型，应用程序设置
 6 
 7 struct v4l2_rect bounds; // 这是 camera 的镜头能捕捉到的窗口大小的局限
 8 
 9 struct v4l2_rect defrect; // 定义默认窗口大小，包括起点位置及长,宽的大小，大小以像素为单位
10 
11 struct v4l2_fract pixelaspect; // 定义了图片的宽高比
12 
13 };

6.2 设置窗口取景参数 VIDIOC_G_CROP 和 VIDIOC_S_CROP

相关函数：

int ioctl(int fd, int request, struct v4l2_crop *argp);

int ioctl(int fd, int request, const struct v4l2_crop *argp);

相关结构体：

1 struct v4l2_crop
2 
3 {
4 
5 enum v4l2_buf_type type;// 应用程序设置
6 
7 struct v4l2_rect c;
8 
9 }

7.video Inputs and Outputs

VIDIOC_G_INPUT 和 VIDIOC_S_INPUT 用来查询和选则当前的 input，一个 video 设备节点可能对应多个视频源，比如 saf7113 可以最多支持四路 cvbs 输入，如果上层想在四个cvbs视频输入间切换，那么就要调用 ioctl(fd, VIDIOC_S_INPUT, &input) 来切换。

VIDIOC_G_INPUT and VIDIOC_G_OUTPUT 返回当前的 video input和output的index.

相关函数：

int ioctl(int fd, int request, struct v4l2_input *argp);

相关结构体：

 1 struct v4l2_input {
 2 __u32 index; /* Which input */
 3 __u8 name[32]; /* Label */
 4 __u32 type; /* Type of input */
 5 __u32 audioset; /* Associated audios (bitfield) */
 6 __u32 tuner; /* Associated tuner */
 7 v4l2_std_id std;
 8 __u32 status;
 9 __u32 reserved[4];
10 };

我们可以通过VIDIOC_ENUMINPUT and VIDIOC_ENUMOUTPUT 分别列举一个input或者 output的信息，我们使用一个v4l2_input结构体来存放查询结果，这个结构体中有一个 index域用来指定你索要查询的是第几个input/ouput,如果你所查询的这个input是当前正在使用的，那么在v4l2_input还会包含一些当前的状态信息，如果所查询的input/output 不存在，那么回返回EINVAL错误，所以，我们通过循环查找，直到返回错误来遍历所有的 input/output. VIDIOC_G_INPUT and VIDIOC_G_OUTPUT 返回当前的video input和output 的index.

例：列举当前输入视频所支持的视频格式

 1 struct v4l2_input input;
 2 
 3 struct v4l2_standard standard;
 4 
 5 memset (&input, 0, sizeof (input));
 6 
 7 //首先获得当前输入的 index,注意只是 index，要获得具体的信息，就的调用列举操作
 8 
 9 if (-1 == ioctl (fd, VIDIOC_G_INPUT, &input.index)) {
10 
11 perror (”VIDIOC_G_INPUT”);
12 
13 exit (EXIT_FAILURE);
14 
15 }
16 
17 //调用列举操作，获得 input.index 对应的输入的具体信息
18 
19 if (-1 == ioctl (fd, VIDIOC_ENUMINPUT, &input)) {
20 
21 perror (”VIDIOC_ENUM_INPUT”);
22 
23 exit (EXIT_FAILURE);
24 
25 }
26 
27 printf (”Current input %s supports:
”, input.name); memset (&standard, 0, sizeof (standard)); standard.index = 0;
28 
29 //列举所有的所支持的 standard，如果 standard.id 与当前 input 的 input.std 有共同的
30 
31 bit flag，意味着当前的输入支持这个 standard,这样将所有驱动所支持的 standard 列举一个
32 
33 遍，就可以找到该输入所支持的所有 standard 了。
34 
35 while (0 == ioctl (fd, VIDIOC_ENUMSTD, &standard)) {
36 
37 if (standard.id & input.std)
38 
39 printf (”%s
”, standard.name);
40 
41 standard.index++;
42 
43 }
44 
45 /* EINVAL indicates the end of the enumeration, which cannot be empty unless this device falls under the USB exception. */
46 
47 if (errno != EINVAL || standard.index == 0) {
48 
49 perror (”VIDIOC_ENUMSTD”);
50 
51 exit (EXIT_FAILURE);
52 
53 }

8. Video standards

相关函数：

v4l2_std_id std_id; //这个就是个64bit得数

int ioctl(int fd, int request, struct v4l2_standard *argp);

相关结构体：

 1 typedef u64 v4l2_std_id;
 2 
 3 struct v4l2_standard {
 4 
 5 u32 index;
 6 
 7 v4l2_std_id id;
 8 
 9 u8 name[24];
10 
11 struct v4l2_fract frameperiod; /* Frames, not fields */
12 
13 u32 framelines;
14 
15 u32 reserved[4];
16 
17 };

当然世界上现在有多个视频标准，如NTSC和PAL，他们又细分为好多种，那么我们的设备输入/输出究竟支持什么样的标准呢？我们的当前在使用的输入和输出正在使用的是哪个标准呢？我们怎么设置我们的某个输入输出使用的标准呢？这都是有方法的。

查询我们的输入支持什么标准，首先就得找到当前的这个输入的index，然后查出它的属性，在其属性里面可以得到该输入所支持的标准，将它所支持的各个标准与所有的标准的信息进行比较，就可以获知所支持的各个标准的属性。一个输入所支持的标准应该是一个集合，而这个集合是用bit与的方式用一个64位数字表示。因此我们所查到的是一个数字。

Example： Information about the current video standard v4l2_std_id std_id; //这个就是个64bit得数

 1 struct v4l2_standard standard;
 2 
 3 // VIDIOC_G_STD就是获得当前输入使用的standard，不过这里只是得到了该标准的id
 4 
 5 // 即flag，还没有得到其具体的属性信息，具体的属性信息要通过列举操作来得到。
 6 
 7 if (-1 == ioctl (fd, VIDIOC_G_STD, &std_id)) { //获得了当前输入使用的standard
 8 
 9 // Note when VIDIOC_ENUMSTD always returns EINVAL this is no video device
10 
11 // or it falls under the USB exception, and VIDIOC_G_STD returning EINVAL
12 
13 // is no error.
14 
15 perror (”VIDIOC_G_STD”);
16 
17 exit (EXIT_FAILURE);
18 
19 }
20 
21 memset (&standard, 0, sizeof (standard));
22 
23 standard.index = 0; //从第一个开始列举
24 
25 // VIDIOC_ENUMSTD用来列举所支持的所有的video标准的信息，不过要先给standard
26 
27 // 结构的index域制定一个数值，所列举的标 准的信息属性包含在standard里面，
28 
29 // 如果我们所列举的标准和std_id有共同的bit，那么就意味着这个标准就是当前输
30 
31 // 入所使用的标准，这样我们就得到了当前输入使用的标准的属性信息
32 
33 while (0 == ioctl (fd, VIDIOC_ENUMSTD, &standard)) {
34 
35 if (standard.id & std_id) {
36 
37 printf (”Current video standard: %s
”, standard.name);
38 
39 exit (EXIT_SUCCESS);
40 
41 }
42 
43 standard.index++;
44 
45 }
46 
47 /* EINVAL indicates the end of the enumeration, which cannot be empty unless this device falls under the USB exception. */
48 
49 if (errno == EINVAL || standard.index == 0) {
50 
51 perror (”VIDIOC_ENUMSTD”);
52 
53 exit (EXIT_FAILURE);
54 
55 }

9. 申请和管理缓冲区

应用程序和设备有三种交换数据的方法，直接 read/write、内存映射(memory mapping)

和用户指针。这里只讨论内存映射(memory mapping)。

9.1 向设备申请缓冲区 VIDIOC_REQBUFS

相关函数：

int ioctl(int fd, int request, struct v4l2_requestbuffers *argp);

相关结构体：

 1 struct v4l2_requestbuffers
 2 
 3 {
 4 
 5 u32 count; // 缓冲区内缓冲帧的数目
 6 
 7 enum v4l2_buf_type type; // 缓冲帧数据格式
 8 
 9 enum v4l2_memory memory; // 区别是内存映射还是用户指针方式
10 
11 u32 reserved[2];
12 
13 };

注：enum v4l2_memoy

{

V4L2_MEMORY_MMAP, V4L2_MEMORY_USERPTR

};

//count,type,memory 都要应用程序设置

例：申请一个拥有四个缓冲帧的缓冲区

1 struct v4l2_requestbuffers req; 
2 
3 req.count=4; req.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; 
4 
5 req.memory=V4L2_MEMORY_MMAP; 
6 
7 ioctl(fd,VIDIOC_REQBUFS,&req);

9.2 获取缓冲帧的地址，长度：VIDIOC_QUERYBUF

相关函数：

int ioctl(int fd, int request, struct v4l2_buffer *argp);

相关结构体：

 1 struct v4l2_buffer
 2 
 3 {
 4 
 5 u32 index; //buffer 序号
 6 
 7 enum v4l2_buf_type type; //buffer 类型
 8 
 9 u32 byteused; //buffer 中已使用的字节数
10 
11 u32 flags; // 区分是MMAP 还是USERPTR
12 
13 enum v4l2_field field;
14 
15 struct timeval timestamp; // 获取第一个字节时的系统时间
16 
17 struct v4l2_timecode timecode;
18 
19 u32 sequence; // 队列中的序号
20 
21 enum v4l2_memory memory; //IO 方式，被应用程序设置
22 
23 union m
24 
25 {
26 
27 u32 offset; // 缓冲帧地址，只对MMAP 有效
28 
29 unsigned long userptr;
30 
31 };
32 
33 u32 length; // 缓冲帧长度
34 
35 u32 input;
36 
37 u32 reserved;
38 
39 };

9.3 内存映射MMAP 及定义一个结构体来映射每个缓冲帧。相关结构体：

1 struct buffer
2 
3 {
4 
5 void* start;
6 
7 unsigned int length;
8 
9 }*buffers;

相关函数：

#include <sys/mman.h>

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)

//addr 映射起始地址，一般为NULL ，让内核自动选择

//length 被映射内存块的长度

//prot 标志映射后能否被读写，其值为PROT_EXEC,PROT_READ,PROT_WRITE, PROT_NONE

//flags 确定此内存映射能否被其他进程共享，MAP_SHARED,MAP_PRIVATE

//fd,offset, 确定被映射的内存地址返回成功映射后的地址，不成功返回MAP_FAILED ((void*)-1)

相关函数：

int munmap(void *addr, size_t length);// 断开映射

//addr 为映射后的地址，length 为映射后的内存长度

例：将四个已申请到的缓冲帧映射到应用程序，用buffers 指针记录。

 1 buffers = (buffer*)calloc (req.count, sizeof (*buffers));
 2 
 3 if (!buffers) {
 4 
 5 // 映射
 6 
 7 fprintf (stderr, "Out of memory/n");
 8 
 9 exit (EXIT_FAILURE);
10 
11 }
12 
13 for (unsigned int n_buffers = 0; n_buffers < req.count; ++n_buffers)
14 
15 {
16 
17 struct v4l2_buffer buf;
18 
19 memset(&buf,0,sizeof(buf));
20 
21 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
22 
23 buf.memory = V4L2_MEMORY_MMAP;
24 
25 buf.index = n_buffers;
26 
27 // 查询序号为n_buffers 的缓冲区，得到其起始物理地址和大小
28 
29 if (-1 == ioctl (fd, VIDIOC_QUERYBUF, &buf))
30 
31 exit(-1);
32 
33 buffers[n_buffers].length = buf.length;
34 
35 // 映射内存
36 
37 buffers[n_buffers].start =mmap (NULL,buf.length,PROT_READ | PROT_WRITE ,MAP_SHARED,fd, buf.m.offset);
38 
39 if (MAP_FAILED == buffers[n_buffers].start)
40 
41 exit(-1);
42 
43 }

10. 缓冲区处理好之后，就可以开始获取数据了

10.1 启动或停止数据流 VIDIOC_STREAMON， VIDIOC_STREAMOFF

int ioctl(int fd, int request, const int *argp);

//argp 为流类型指针，如V4L2_BUF_TYPE_VIDEO_CAPTURE.

10.2 在开始之前，还应当把缓冲帧放入缓冲队列：

VIDIOC_QBUF// 把帧放入队列

VIDIOC_DQBUF// 从队列中取出帧

int ioctl(int fd, int request, struct v4l2_buffer *argp);

例：把四个缓冲帧放入队列，并启动数据流

 1 unsigned int i;
 2 
 3 enum v4l2_buf_type type;
 4 
 5 for (i = 0; i < 4; ++i) // 将缓冲帧放入队列
 6 
 7 {
 8 
 9 struct v4l2_buffer buf;
10 
11 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
12 
13 buf.memory = V4L2_MEMORY_MMAP;
14 
15 buf.index = i;
16 
17 ioctl (fd, VIDIOC_QBUF, &buf);
18 
19 }
20 
21 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
22 
23 ioctl (fd, VIDIOC_STREAMON, &type);
24 
25 // 这有个问题，这些buf 看起来和前面申请的buf 没什么关系，为什么呢?

例：获取一帧并处理

 1 struct v4l2_buffer buf; CLEAR (buf);
 2 
 3 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 4 
 5 buf.memory = V4L2_MEMORY_MMAP;
 6 
 7 ioctl (fd, VIDIOC_DQBUF, &buf); // 从缓冲区取出一个缓冲帧
 8 
 9 process_image (buffers[buf.index.]start); //
10 
11 ioctl (fdVIDIOC_QBUF&buf); //

9、基于Linux的v4l2视频架构应用编写

Linux之V4L2基础编程

1. 定义

2. 工作流程：

3. 设备的打开和关闭：

4. 查询设备属性： VIDIOC_QUERYCAP

5. 设置视频的制式和帧格式

5.1 查询并显示所有支持的格式：VIDIOC_ENUM_FMT

5.2 查看或设置当前格式： VIDIOC_G_FMT, VIDIOC_S_FMT

6. 图像的缩放 VIDIOC_CROPCAP

6.1 设置设备捕捉能力的参数

6.2 设置窗口取景参数 VIDIOC_G_CROP 和 VIDIOC_S_CROP

7.video Inputs and Outputs

8. Video standards

9. 申请和管理缓冲区

9.1 向设备申请缓冲区 VIDIOC_REQBUFS

10. 缓冲区处理好之后，就可以开始获取数据了

10.1 启动 或 停止数据流 VIDIOC_STREAMON， VIDIOC_STREAMOFF

10.1 启动或停止数据流 VIDIOC_STREAMON， VIDIOC_STREAMOFF