V4L2开发要点

你的名字 2022-06-13 10:49 209阅读 0赞

首先来看 Read/Write ，如果 VIDIOC\_QUERYCAP 调用返回的 v4l2\_capability 参数中， V4L2\_CAP\_READWRITE 被设置成真了的话，就说明支持 Read/Write I/O 。这是最简单最原始的方法，它需要进行**数据** 的拷贝 ( 而不是像memory map 那样只需要进行指针的交换 ) ，而且不会交换元数据 ( 比如说帧计数器和时间戳之类的可用于识别帧丢失和进行帧同步 ) ，虽然它是最原始的方法，但因为其简单，所以对于简单的**应用** 程序比如只需要 capture静态图像是很有用的 。

如果使用 Read/Write 方法支持的话，必须同时支持另外两个函数 select() 和 poll() ，这两个函数用来进行 I/0 的多路复用。

对于 streaming 它有两种方式， driver 对两种方式的支持要使用 VIDIOC\_REQBUFS 来确定：

int ioctl(int fd, int request, struct v4l2\_requestbuffers \*argp);

对于 memory mapped 方式， Memory mapped buffers 是通过 VIDIOC\_REQBUFS 在 device memory 中申请的，而且必须在 map 进应用程序虚拟地址**空间** 之前就申请好。而对于 User pointers ， User buffers 是在应用程序自己开辟的，只是通过 VIDIOC\_REQBUFS 将驱动转化到 user pointer 的 I/O 模式下。这两种方式都不会拷贝数据，而只是 buffer 指针的交互。

首先来看一下 v4l2\_requestbuffers 这个数据结构：

\_\_u32 count

// 要申请的 buffer 的数量，只有当 memory 被设置成 V4L2\_MEMORY\_MMAP 的时候才会设置这个参数

enum v4l2\_buf\_type type

enum v4l2\_memory memory

// 要么是 V4L2\_MEMORY\_MMAP ，要么是 V4L2\_MEMORY\_USERPTR

对于 memory mapped 模式，要在 device memory 下申请 buffer ，应用程序必须初始化上面的 3 个参数，驱动最后返回的 buffer 的个数可能等于 count ，也可能少于或者多于 count ，少于可能是因为内存不足，多于则可能是驱动为更好地完成相应功能增加的 buffer 。如果 driver 不支持 memory mapped 调用这个 ioctl 就会返回 EINVAL。

因为 memory map 模式下分配的是实实在在的物理内存，不是虚拟内存，所以使用完以后一定要使用 munmap()释放。

应用程序可以重新调用 VIDICO\_REQBUFS 来改变 buffer 的个数，但前提是必须先释放已经 mapped 的 buffer ，可以先 munmap ，然后设置参数 count 为 0 来释放所有的 buffer 。

对于 User pointer I/O ，应用程序只需设置上面的 type 和 memory 类型就可以了。

申请好 buffer 后在进行 memory mapped 之前，首先要使用 VIDIOC\_QUERYBUF 来获得分配的 buffer 信息，以传给函数 mmap() 来进行 map ：

int ioctl(int fd, int request, struct v4l2\_buffer \*argp);

VIDIOC\_QUERYBUF 是 memory mapped 这种模式下使用的方法，在 User pointer 模式下不需要使用这个函数，在调用之前应用程序需要设定 v4l2\_buffer 中的两个参数，一个是 buffer 类型，另外一个是 index number( 有效值从0 到申请的 buffer 数目减 1) ，调用这个 ioctl 会将相应 buffer 中的 flag ： V4L2\_BUF\_FLAG\_MAPPED, V4L2\_BUF\_FLAG\_QUEUED 和 V4L2\_BUF\_FLAG\_DONE 设置为有效。下面我们来仔细看看 v4l2\_buffer 这个数据结构：

\_\_u32 index

// 应用程序来设定，仅仅用来申明是哪个 buffer

enum v4l2\_buf\_type type

\_\_u32 bytesused

//buffer 中已经使用的 byte 数，如果是 input stream 由 driver 来设定，相反则由应用程序来设定

\_\_u32 flags

// 定义了 buffer 的一些标志位，来表明这个 buffer 处在哪个队列，比如输入队列或者输出队列(V4L2\_BUF\_FLAG\_QUEUED V4L2\_BUF\_FLAG\_DONE) ，是否关键帧等等，具体可以参照 spec

enum v4l2\_memory memory

//V4L2\_MEOMORY\_MMAP ／ V4L2\_MEMORY\_USERPTR ／ V4L2\_MEMORY\_OVERLAY

union m

\_\_u32 offset

// 当 memory 类型是 V4L2\_MEOMORY\_MMAP 的时候，主要用来表明 buffer 在 device momory 中相对起始位置的偏移，主要用在 mmap() 参数中，对应用程序没有左右

unsigned long userptr

// 当 memory 类型是 V4L2\_MEMORY\_USERPTR 的时候，这是一个指向虚拟内存中 buffer 的指针，由应用程序来设定。

\_\_u32 length

//buffer 的 size

在 driver 内部**管理** 着两个 buffer queues ，一个输入队列，一个输出队列。对于 capture device 来说，当输入队列中的 buffer 被塞满数据以后会自动变为输出队列，等待调用 VIDIOC\_DQBUF 将数据进行处理以后重新调用VIDIOC\_QBUF 将 buffer 重新放进输入队列；对于 output device 来说 buffer 被显示以后自动变为输出队列。

刚初始化的所有 map 过的 buffer 开始都处于 dequeced 的状态，由 driver 来管理对应用程序是不可访问的。对于 capture 应用程序来说，首先是通过 VIDIOC\_QBUF 将所有 map 过的 buffer 加入队列，然后通过VIDIOC\_STREAMON 开始 capture ，并进入 read loop ，在这里应用程序会等待直到有一个 buffer 被填满可以从队列中 dequeued ，当数据使用完后再 enqueue 进输入队列；对于 output 应用程序来说，首先应用程序会buffer 装满数据然后 enqueued ，当足够的 buffer 进入队列以后就调用 VIDIOC\_STREAMON 将数据输出。

有两种方法来阻塞应用程序的执行，直到有 buffer 能被 dequeued ，默认的是当调用 VIDIOC\_DQBUF 的时候会被阻塞，直到有数据在 outgoing queue ，但是如果打开设备**文件** 的时候使用了 O\_NONBLOCK ，则当调用VIDIOC\_DQBUF 而又没有数据可读的时候就会立即返回。另外一种方法是调用 select 和 poll 来对文件描述符进行监听是否有数据可读。

VIDIOC\_STREAMON 和 VIDIOC\_STREAMOFF 两个 ioctl 用来开始和停止 capturing 或者 output ，而且VIDIOC\_STREAMOFF 会删除输入和输出队列中的所有 buffer 。

因此 drvier 如果要实现 memory mapping I/O 必须支持 VIDIOC\_REQBUFS, VIDIOC\_QUERYBUF, VIDIOC\_QBUF, VIDIOC\_DQBUF, VIDIOC\_STREAMON 和 VIDIOC\_STREAMOFF ioctl, the mmap(), munmap(), select() 和 poll() 函数。

User Pointers 是一种综合了 Read/Write 和 memory mappded 优势的 I/O 方法， buffer 是由应用程序自己申请的，可以是在虚拟内存或者共享内存中。在 capture 和 output 方面基本来说和 memory mapped 方式是相同的，在这里只提一下它申请内存的方式。

User pointer 方式下，申请的内存也 memory page size 为单位对齐，而且 buffersize 也有一定限制，例示代码中是这样计算 buffer size 的，暂时还不知道这样分配 buffer size 的依据是什么，先简单地这样用就好了：

page\_size = getpagesize ();

buffer\_size = (buffer\_size + page\_size - 1) & ~(page\_size – 1);

buffers\[n\_buffers\].start = memalign ( page\_size,

buffer\_size);

3 、 start\_capturing

经过上面的一系列的数据协商已经 buffer 的分配以后就可以调用 VIDIOC\_QBUF 将 buffer 全部加入输入队列中，并调用 VIDIOC\_STREAM0N 开始捕获数据了：

int ioctl(int fd, int request, struct v4l2\_buffer \*argp);

//VIDIOC\_QBUF VIDIOC\_DQBUF

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

//VIDIOC\_STREAM0N VIDIOC\_STREAMOFF （ int 参数是 buffer 类型）

4 、 mainloop

开始捕获数据以后就会进入一个主循环，可以使用 select 或者 poll 来监听文件描述符的状态，一旦有数据可读，就调用函数来读取数据。

5 、 read\_frame

读取数据根据 I/O 方式的不同而不同：

Read/Write 方式直接从文件描述符中读一个帧大小的数据；

Memory mapped 方式下先从输出队列中 dequeued 一个 buffer ，然后对帧数据进行处理，处理完成以后再放入输入队列。

User pointer 方式下也是首先从输出队列中 dequeued 一个 buffer ，然后对这个 buffer 进行判断，看是否是应用程序开始申请的 buffer ，然后再对这个 buffer 进行处理，最后放入输入队列。

6 、 stop\_capturing / uninit\_device / close device

最后就是捕捉以及资源释放并关闭 device

下面给出一个示例代码：

1.  \#include <stdio.h>  
    
2.  \#include <stdlib.h>  
    
3.  \#include <string.h>  
    
4.  \#include <fcntl.h> /\* low\-level i/o \*/  
    
5.  \#include <unistd.h>  
    
6.  \#include <errno.h>  
    
7.  \#include <malloc.h>  
    
8.  \#include <sys/stat.h>  
    
9.  \#include <sys/types.h>  
    
10. \#include <sys/time.h>  
    
11. \#include <sys/mman.h>  
    
12. \#include <sys/ioctl.h>  
    
13. \#include <linux/videodev2.h>  
    
14. \#define DEVICE "/dev/video"  
    
15. static struct v4l2\_requestbuffers req;  
    
16. struct buffer  
    
17. \{   
    
18.     void\* start;  
    
19.     unsigned int length;  
    
20. \};   
    
21. static struct buffer \*buffers;  
    
22. static struct v4l2\_buffer buf;

usb\_camera.c

1.  \#include "head.h"  
    
2.  int main()  
    
3.  \{   
    
4.      int fd;  
    
5.      fd=open\_device();  
    
6.      get\_device\_info(fd);  
    
7.      get\_frame\_fmt(fd);  
    
8.      get\_current\_frame\_info(fd);  
    
9.      try\_format\_support(fd);  
    
10.     set\_frame\_format(fd);  
    
11.     apply\_memory\_buf(fd);  
    
12.     memory\_mapping(fd);  
    
13.     buffer\_enqueue(fd);  
    
14.     close(fd);  
    
15.     return 0;  
    
16. \}  
    
17. int open\_device()  
    
18. \{   
    
19.     int fd;  
    
20.     if(\-1==(fd=open(DEVICE,O\_RDWR)))  
    
21.         printf("info:Can't open video device\\n");  
    
22.     else  
    
23.         printf("info:Open the device :%d\\n",fd);  
    
24.     return fd;  
    
25. \}  
    
26. int get\_device\_info(int fd)  
    
27. \{   
    
28.     struct v4l2\_capability cap;  
    
29.     if(\-1==ioctl(fd,VIDIOC\_QUERYCAP,&cap))  
    
30.         printf("info:VIDIOC\_QUERYCAP ERROR\\n");  
    
31.     else  
    
32.         printf("info:Driver Name:%s....Card Name:%s....Bus info:%s....Driver Version:%u.%u.%u\\n",  
    
33.         cap.driver,cap.card,cap.bus\_info,(cap.version>>16)&0XFF,(cap.version>>8)&0XFF,cap.version&0XFF);  
    
34.     return 1;  
    
35. \}  
    
36. int get\_frame\_fmt(int fd)  
    
37. \{   
    
38.     struct v4l2\_fmtdesc fmtdesc;  
    
39.     fmtdesc.index=0;  
    
40.     fmtdesc.type=V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE;  
    
41.     printf("info:Support format:");  
    
42.     while(ioctl(fd,VIDIOC\_ENUM\_FMT,&fmtdesc)!=\-1)  
    
43.     \{   
    
44.         printf("\\t%d.%s",fmtdesc.index\+1,fmtdesc.description);  
    
45.         fmtdesc.index\+\+;  
    
46.     \}  
    
47.     printf("\\n");  
    
48.     return 1;  
    
49. \}  
    
50. int get\_current\_frame\_info(int fd)  
    
51. \{   
    
52.     struct v4l2\_format fmt;  
    
53.     fmt.type=V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE;  
    
54.     ioctl(fd,VIDIOC\_G\_FMT,&fmt);  
    
55.     printf("info:Current data format information:\\n\\twidth:%d\\n\\theight:%d\\n",fmt.fmt.pix.width,fmt.fmt.pix.height);  
    
56.     struct v4l2\_fmtdesc fmtdesc;  
    
57.     fmtdesc.index=0;  
    
58.     fmtdesc.type=V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE;  
    
59.     while(ioctl(fd,VIDIOC\_ENUM\_FMT,&fmtdesc)!=\-1)  
    
60.     \{   
    
61.         if(fmtdesc.pixelformat & fmt.fmt.pix.pixelformat)  
    
62.         \{   
    
63.             printf("\\tformat:%s\\n",fmtdesc.description);  
    
64.             break;  
    
65.         \}  
    
66.         fmtdesc.index\+\+;  
    
67.     \}   
    
68.     return 1;  
    
69. \}  
    
70. int try\_format\_support(int fd)  
    
71. \{   
    
72.     struct v4l2\_format fmt;  
    
73.     fmt.type=V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE;  
    
74.     //fmt.fmt.pix.pixelformat=V4L2\_PIX\_FMT\_RGB32;  
    
75.     fmt.fmt.pix.pixelformat=V4L2\_PIX\_FMT\_YUYV;  
    
76.     if(ioctl(fd,VIDIOC\_TRY\_FMT,&fmt)==\-1)  
    
77.     if(errno==EINVAL)  
    
78.     printf("info:not support format RGB32!\\n");   
    
79.     return 1;  
    
80. \}  
    
81. int set\_frame\_format(int fd)  
    
82. \{   
    
83.     struct v4l2\_format fmt;  
    
84.     fmt.type=V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE;  
    
85.     fmt.fmt.pix.width=640;  
    
86.     fmt.fmt.pix.height=480;  
    
87.     fmt.fmt.pix.pixelformat = V4L2\_PIX\_FMT\_YUYV;  
    
88.     fmt.fmt.pix.field = V4L2\_FIELD\_INTERLACED;   
    
89.     if(ioctl(fd,VIDIOC\_S\_FMT,&fmt)==\-1)  
    
90.     if(errno==EINVAL)  
    
91.     printf("info:set frame format error!\\n");  
    
92.     return 1;  
    
93. \}  
    
94. int apply\_memory\_buf(int fd)  
    
95. \{   
    
96.     //struct v4l2\_requestbuffers req;  
    
97.     req.count=4;  
    
98.     req.type=V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE;  
    
99.     req.memory=V4L2\_MEMORY\_MMAP;  
    
100.     if(\-1==ioctl(fd,VIDIOC\_REQBUFS,&req))  
    
101.         printf("info:VIDIOC\_REQBUFS FAILED\\n");  
    
102.     else  
    
103.         printf("info:VIDIOC\_REQBUFS SUCCESS\\n");  
    
104.     return 1;  
    
105. \}  
    
106. int memory\_mapping(int fd)  
    
107. \{   
    
108.     unsigned int n\_buffers;  
    
109.     buffers = (struct buffer\*)calloc(req.count,sizeof(struct buffer));  
    
110.     if (!buffers) \{   
    
111.         fprintf (stderr, "Out of memory\\n");  
    
112.         exit (EXIT\_FAILURE);  
    
113.     \}  
    
114.     // 映射  
    
115.     for (n\_buffers = 0; n\_buffers < req.count; \+\+n\_buffers) \{   
    
116.         //struct v4l2\_buffer buf;  
    
117.         memset(&buf,0,sizeof(buf));  
    
118.         buf.type = V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE;  
    
119.         buf.memory = V4L2\_MEMORY\_MMAP;  
    
120.         buf.index = n\_buffers;  
    
121.         // 查询序号为n\_buffers 的缓冲区，得到其起始物理地址和大小  
    
122.         if (\-1 == ioctl (fd, VIDIOC\_QUERYBUF, &buf))  
    
123.             exit(\-1);  
    
124.         buffers\[n\_buffers\].length = buf.length;  
    
125.         // 映射内存  
    
126.         buffers\[n\_buffers\].start =mmap (NULL,buf.length,PROT\_READ | PROT\_WRITE,MAP\_SHARED,fd, buf.m.offset);  
    
127.         if (MAP\_FAILED == buffers\[n\_buffers\].start)  
    
128.             exit(\-1);  
    
129.     \}   
    
130.     printf("info:memory mapping success\\n");  
    
131.     return 1;  
    
132. \}  
    
133. int buffer\_enqueue(int fd)  
    
134. \{   
    
135.     unsigned int i;  
    
136.     enum v4l2\_buf\_type type;  
    
137.     // 将缓冲帧放入队列  
    
138.     for (i = 0; i < 4; \+\+i)  
    
139.     \{   
    
140.         struct v4l2\_buffer buf;  
    
141.         buf.type = V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE;  
    
142.         buf.memory = V4L2\_MEMORY\_MMAP;  
    
143.         buf.index = i;  
    
144.         if(\-1==ioctl (fd, VIDIOC\_QBUF, &buf))  
    
145.             printf("buffer enqueue failed\\n");  
    
146.     \}  
    
147.     type = V4L2\_BUF\_TYPE\_VIDEO\_CAPTURE;  
    
148.     //open stream   
    
149.     if(\-1==ioctl (fd, VIDIOC\_STREAMON, &type))  
    
150.         printf("info:open stream failed\\n");  
    
151.     else  
    
152.         printf("info:open stream success\\n");  
    
153.     return 1;