移动物体监控系统(2)—摄像头子系统开发

一、摄像头驱动开发

1.摄像头驱动架构

视频监控本就是嵌入式Linux的重要应用场合，所以如何合理高效的管理摄像系统，便成为嵌入式Linux一大热点！当前最流行的摄像头软件架构就是V4L2架构，从字面意思知道是专门为Linux设计的一个视频子系统的第二个版本。V4L2有一段历史了。早在1998的时候就出现了，经过长足的发展，它于2002年11 月，发布2.5.46 时，融入了内核主干之中。然而直到今天，仍有一部分内核驱动不支持新的API，这种新旧API 的转换工作仍在进行。它的主要功能是使程序具有发现设备和操作设备的能力.它主要是用一系列的回调函数来实现这些功能。像设置摄像头的频率、帧频、视频压缩格式和图像参数等等。当然也可以用于其他多媒体的开发，如音频等。但是该架构目前只能用于Linux操作系统上。整个V4L2的架构示意图如下：

可以看出，整个架构主要分为四个部分：
- 用户空间的应用程序：比如后面要用到的Motion以及ffmpeg等开源应用程序
- V4L2核心组件（驱动核心）：这是Linux内核专门用来管理视频子系统的核心组件，也正是由于这个组建的存在，才让我们可以在用户空间使用统一的一套编程接口API去控制底层的不同硬件。
- 具体的V4L2驱动：这部分主要是针对不同的摄像头有不同的驱动程序，这写驱动程序相互独立，但是共同注册到V4L2子系统下，以便和用户空间应用程序进行通信。
- 底层硬件：就是实际的摄像头等物理硬件。
V4L2核心是Linux系统自带的组件，它可以屏蔽摄像头驱动层的差异，不管底层的摄像头有什么差异，上层应用统一调用V4L2来实现对摄像头的操作，因此驱动程序和应用程序都需要遵循V4L2规范。

2.摄像头驱动使能

由于本项目采用的是基于ZC3XX系列芯片的USB摄像头，所以需要在内核里面添加该USB摄像头驱动。以后如果换成别的摄像头，根据自己摄像头的驱动芯片加载合适的驱动模块到内核即可，毕竟现在Linux支持了市面上大部分的摄像头，一般能购买到的摄像头都有相应的驱动程序，只需要自己在内核使能即可！按照如下步骤可以使能USB摄像头。

2.1 进入配置菜单

在内核源代码顶层目录执行 make menuconfig ARCH=arm命令。进入配置菜单。

2.2 依次选择如下配置选项：

Device Drivers --->（毫无疑问，只要是添加驱动都是要进入这个选项）
Multimedia devices --->（显然视频摄像头属于多媒体范畴）
- [*] Video capture adapters --->（视频捕获也即是摄像头）
  - [*] V4L USB devices --->（我们采用的是USB摄像头）
    - <*> GSPCA based webcams --->（万能摄像头驱动）
      - <*> ZC3XX USB Camera Driver（我们采用的具体USB摄像头对应的驱动程序）

2.3 保存配置文件，退出配置模式，开始编译新内核

#make uImage ARCH=arm CROSS_COMPILE=arm-linux-
拷贝uImage到/tftpboot/目录下

2.4 下载并启动linux内核

往开发板上插入摄像头后，会弹出相应提示，同时使用ls /dev/可以查看是否有vedeo的驱动文件，如果有则说明驱动开发成功。

3. 摄像头驱动测试

3.1 初步测试

插上USB摄像头看开发板串口控制台的提示，有如下信息输出:

由上面的提示信息我们知道，驱动使能成功，再通过ls命令查看dev目录下的设备文件，即ls /dev有：

表明我们的USB摄像头在开发板的系统里创建的对应设备文件是/dev/video0，当然读者要根据自身实际情况判断对应的设备文件是什么，有可能是video3，video4等。

3.2 编写应用程序进行测试

使用camera.c（下接会讲如何编写）文件交叉编译出在开发板运行的测试应用程序。在编译之前要记得修改文件里打开的设备文件，也就是前面说的/dev/video0，根据再记得设备文件修改open函数，如果传递给你open函数的参数不是你摄像头对应的实际设备文件，那么打开会有无法预知的结果，有可能失败，也可能打开某个文件导致抓取的图片是空的等情况。修改完毕以后使用如下命令进行编译：arm-linux-gcc -g camera.c -o camera
得到的camera就是可执行文件，将他复制到开发板的文件系统的根目录，并在开发板的串口控制台执行./camera命令，Mini2440有如下提示：

同时在根目录生成test.jpg文件，通过windows的samba可以查看其效果如下所示：

二、V4L2图像编程接口深度学习

1.相关介绍

Video for Linuxtwo(Video4Linux2)简称V4L2，是V4L的改进版。V4L2是linux操作系统下用于采集图片、视频和音频数据的API接口，配合适当的视频采集设备和相应的驱动程序，可以实现图片、视频、音频等的采集。在远程会议、可视电话、视频监控系统和嵌入式多媒体终端中都有广泛的应用。
在Linux下，所有外设都被看成一种特殊的文件，称为“设备文件”，可以象访问普通文件一样对其进行读写。一般来说，采用V4L2驱动的摄像头设备文件是/dev/video0。V4L2支持两种方式来采集图像：内存映射方式(mmap)和直接读取方式(read)。V4L2在include/ linux/videodev.h文件中定义了一些重要的数据结构，在采集图像的过程中，就是通过对这些数据的操作来获得最终的图像数据。Linux系统V4L2的能力可在Linux内核编译阶段配置，默认情况下都有此开发接口。
摄像头所用的主要是capature了，视频的捕捉，具体linux的调用可以参考下图。

2.视频采集的原理

V4L2支持内存映射方式(mmap)和直接读取方式(read)来采集数据，前者一般用于连续视频数据的采集，后者常用于静态图片数据的采集，本文重点讨论内存映射方式的视频采集。
应用程序通过V4L2接口采集视频数据分为五个步骤：
- 首先，打开视频设备文件，进行视频采集的参数初始化，通过V4L2接口设置视频图像的采集窗口、采集的点阵大小和格式;
- 其次，申请若干视频采集的帧缓冲区，并将这些帧缓冲区从内核空间映射到用户空间，便于应用程序读取/处理视频数据;
- 第三，将申请到的帧缓冲区在视频采集输入队列排队，并启动视频采集;
- 第四，驱动开始视频数据的采集，应用程序从视频采集输出队列取出帧缓冲区，处理完后，将帧缓冲区重新放入视频采集输入队列，循环往复采集连续的视频数据;
- 第五，停止视频采集。

具体的程序实现流程可以参考下面的流程图:
其实其他的都比较简单，就是通过ioctl这个接口去设置一些参数。最主要的就是buf管理。他有一个或者多个输入队列和输出队列。
启动视频采集后，驱动程序开始采集一帧数据，把采集的数据放入视频采集输入队列的第一个帧缓冲区，一帧数据采集完成，也就是第一个帧缓冲区存满一帧数据后，驱动程序将该帧缓冲区移至视频采集输出队列，等待应用程序从输出队列取出。驱动程序接下来采集下一帧数据，放入第二个帧缓冲区，同样帧缓冲区存满下一帧数据后，被放入视频采集输出队列。
应用程序从视频采集输出队列中取出含有视频数据的帧缓冲区，处理帧缓冲区中的视频数据，如存储或压缩。
最后，应用程序将处理完数据的帧缓冲区重新放入视频采集输入队列，这样可以循环采集，如图所示：

每一个帧缓冲区都有一个对应的状态标志变量，其中每一个比特代表一个状态
- V4L2_BUF_FLAG_UNMAPPED 0B0000
- V4L2_BUF_FLAG_MAPPED 0B0001
- V4L2_BUF_FLAG_ENQUEUED 0B0010
- V4L2_BUF_FLAG_DONE 0B0100
缓冲区的状态转化如图所示：

3.函数介绍

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

3.1 设备的打开和关闭

#include <fcntl.h>

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

#include <unistd.h>

int close(int fd);

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

3.2 查询设备属性：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\nCard Name:%s\nBus info:%s\nDriver Version:%u.%u.%u\n”,cap.driver,cap.card,cap.bus_info,(cap.version>>16)&0XFF, (cap.version>>8)&0XFF,cap.version&0XFF);

3.3 设置视频的制式和帧格式

制式包括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 操作命令设置视频捕捉格式。如下图所示：

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

相关函数

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

相关结构体

struct v4l2_fmtdesc
{
    u32 index; // 要查询的格式序号，应用程序设置

    enum v4l2_buf_type type; // 帧类型，应用程序设置

    u32 flags; // 是否为压缩格式

    u8 description[32]; // 格式名称

    u32 pixelformat; // 格式

    u32 reserved[4]; // 保留
};

例：显示所有支持的格式

struct v4l2_fmtdesc fmtdesc; 
fmtdesc.index=0; 
fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; 
printf("Support format:\n");

while(ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc) != -1)
{

    printf("\t%d.%s\n",fmtdesc.index+1,fmtdesc.description);

    fmtdesc.index++;

}

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

检查是否支持某种格式：VIDIOC_TRY_FMT
相关函数

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

相关结构体

struct v4l2_format
{
    enum v4l2_buf_type type; // 帧类型，应用程序设置

    union fmt

    {
        struct v4l2_pix_format pix; // 视频设备使用

        struct v4l2_window win;

        struct v4l2_vbi_format vbi;

        struct v4l2_sliced_vbi_format sliced;

        u8 raw_data[200];
    };
};

struct v4l2_pix_format

{
    u32 width; // 帧宽，单位像素

    u32 height; // 帧高，单位像素

    u32 pixelformat; // 帧格式

    enum v4l2_field field;

    u32 bytesperline;

    u32 sizeimage;

    enum v4l2_colorspace colorspace;

    u32 priv;

};

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

struct v4l2_format fmt; 
fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; 
ioctl(fd, VIDIOC_G_FMT, &fmt);

printf(“Current data format information:\n\twidth:%d\n\theight:%d\n”,

fmt.fmt.pix.width,fmt.fmt.pix.height);

struct v4l2_fmtdesc fmtdesc; 
fmtdesc.index=0; 
fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; 

while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)
{

    if(fmtdesc.pixelformat & fmt.fmt.pix.pixelformat)
    {
        printf(“\tformat:%s\n”,fmtdesc.description);
        break;
    }

       fmtdesc.index++;
}

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

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!\n”);

3.4 图像的缩放 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设置。

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

相关函数

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

相关结构体

struct v4l2_cropcap
{
    enum v4l2_buf_type type; // 数据流的类型，应用程序设置

    struct v4l2_rect bounds; // 这是 camera 的镜头能捕捉到的窗口大小的局限

    struct v4l2_rect defrect; // 定义默认窗口大小，包括起点位置及长,宽的大小，大小以像素为单位

    struct v4l2_fract pixelaspect; // 定义了图片的宽高比
};

3.4.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);

相关结构体

struct v4l2_crop
{
    enum v4l2_buf_type type;// 应用程序设置

    struct v4l2_rect c;
}

3.5 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);

相关结构体

struct v4l2_input 
{
    __u32 index; /* Which input */
    __u8 name[32]; /* Label */
    __u32 type; /* Type of input */
    __u32 audioset; /* Associated audios (bitfield) */
    __u32 tuner; /* Associated tuner */
    v4l2_std_id std;
    __u32 status;
    __u32 reserved[4];
};

我们可以通过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。
例：列举当前输入视频所支持的视频格式

struct v4l2_input input;
struct v4l2_standard standard;

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

// 首先获得当前输入的 index,注意只是 index，要获得具体的信息，就的调用列举操作
if (-1 == ioctl (fd, VIDIOC_G_INPUT, &input.index)) 
{
    perror (”VIDIOC_G_INPUT”);
    exit (EXIT_FAILURE);
}

// 调用列举操作，获得 input.index 对应的输入的具体信息
if (-1 == ioctl (fd, VIDIOC_ENUMINPUT, &input)) 
{
    perror (”VIDIOC_ENUM_INPUT”);
    exit (EXIT_FAILURE);
}

printf (”Current input %s supports:\n”, input.name); 
memset (&standard, 0, sizeof (standard)); 
standard.index = 0;

// 列举所有的所支持的 standard，如果 standard.id 与当前 input 的 input.std 有共同的

bit flag，意味着当前的输入支持这个 standard,这样将所有驱动所支持的 standard 列举一个

遍，就可以找到该输入所支持的所有 standard 了。

while (0 == ioctl (fd, VIDIOC_ENUMSTD, &standard))
 {
    if (standard.id & input.std)
        printf (”%s\n”, standard.name);

    standard.index++;
}

/* EINVAL indicates the end of the enumeration, which cannot be empty unless this device falls under the USB exception. */

if (errno != EINVAL || standard.index == 0) 
{
    perror (”VIDIOC_ENUMSTD”);
    exit (EXIT_FAILURE);
}

3.6 Video standards

相关函数

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

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

相关结构体

typedef u64 v4l2_std_id;

struct v4l2_standard 
{
    u32 index;

    v4l2_std_id id;

    u8 name[24];

    struct v4l2_fract frameperiod; /* Frames, not fields */

    u32 framelines;

    u32 reserved[4];
};

当然世界上现在有多个视频标准，如NTSC和PAL，他们又细分为好多种，那么我们的设备输入/输出究竟支持什么样的标准呢？我们的当前在使用的输入和输出正在使用的是哪个标准呢？我们怎么设置我们的某个输入输出使用的标准呢？这都是有方法的。
查询我们的输入支持什么标准，首先就得找到当前的这个输入的index，然后查出它的属性，在其属性里面可以得到该输入所支持的标准，将它所支持的各个标准与所有的标准的信息进行比较，就可以获知所支持的各个标准的属性。一个输入所支持的标准应该是一个集合，而这个集合是用bit与的方式用一个64位数字表示。因此我们所查到的是一个数字。

struct v4l2_standard standard;

// VIDIOC_G_STD就是获得当前输入使用的standard，不过这里只是得到了该标准的id

// 即flag，还没有得到其具体的属性信息，具体的属性信息要通过列举操作来得到。

if (-1 == ioctl (fd, VIDIOC_G_STD, &std_id)) 
{ 
    //获得了当前输入使用的standard
    // Note when VIDIOC_ENUMSTD always returns EINVAL this is no video device
    // or it falls under the USB exception, and VIDIOC_G_STD returning EINVAL
    // is no error.
    perror (”VIDIOC_G_STD”);
    exit (EXIT_FAILURE);
}

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

standard.index = 0; // 从第一个开始列举

// VIDIOC_ENUMSTD用来列举所支持的所有的video标准的信息，不过要先给standard
// 结构的index域制定一个数值，所列举的标 准的信息属性包含在standard里面，
// 如果我们所列举的标准和std_id有共同的bit，那么就意味着这个标准就是当前输
// 入所使用的标准，这样我们就得到了当前输入使用的标准的属性信息

while (0 == ioctl (fd, VIDIOC_ENUMSTD, &standard)) 
{
    if (standard.id & std_id) 
    {
        printf (”Current video standard: %s\n”, standard.name);
        exit (EXIT_SUCCESS);
    }

    standard.index++;
}

/* EINVAL indicates the end of the enumeration, which cannot be empty unless this device falls under the USB exception. */

if (errno == EINVAL || standard.index == 0) 
{
   perror (”VIDIOC_ENUMSTD”);
   exit (EXIT_FAILURE);
}

3.7 申请和管理缓冲区

应用程序和设备有三种交换数据的方法，直接read/write、内存映射(memory mapping)和用户指针。这里只讨论内存映射(memory mapping)。

3.7.1 向设备申请缓冲区 VIDIOC_REQBUFS

相关函数

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

相关结构体

struct v4l2_requestbuffers
{
    u32 count; // 缓冲区内缓冲帧的数目

    enum v4l2_buf_type type; // 缓冲帧数据格式

    enum v4l2_memory memory; // 区别是内存映射还是用户指针方式

    u32 reserved[2];
};

注：enum v4l2_memoy
{
V4L2_MEMORY_MMAP, V4L2_MEMORY_USERPTR
};
// count,type,memory 都要应用程序设置
例：申请一个拥有四个缓冲帧的缓冲区

struct v4l2_requestbuffers req; 

req.count=4; req.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; 

req.memory=V4L2_MEMORY_MMAP; 

ioctl(fd,VIDIOC_REQBUFS,&req);

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

相关函数

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

相关结构体

struct v4l2_buffer
{
    u32 index; // buffer 序号
    enum v4l2_buf_type type; // buffer 类型
    u32 byteused; // buffer 中已使用的字节数
    u32 flags; // 区分是MMAP 还是USERPTR
    enum v4l2_field field;
    struct timeval timestamp; // 获取第一个字节时的系统时间
    struct v4l2_timecode timecode;
    u32 sequence; // 队列中的序号
    enum v4l2_memory memory; // IO 方式，被应用程序设置
    
    union m
    {
        u32 offset; // 缓冲帧地址，只对MMAP 有效
        unsigned long userptr;            
    };

    u32 length; // 缓冲帧长度
    u32 input;
    u32 reserved;
};

3.7.3 内存映射MMAP 及定义一个结构体来映射每个缓冲帧。

相关结构体

struct buffer
{
    void* start;
    unsigned int length;
}*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指针记录。

buffers = (buffer *)calloc (req.count, sizeof (*buffers));

if (!buffers) 
{
    // 映射
    fprintf (stderr, "Out of memory/n");
    exit (EXIT_FAILURE);
}

for (unsigned int n_buffers = 0; n_buffers < req.count; ++n_buffers)
{
    struct v4l2_buffer buf;

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

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    buf.index = n_buffers;

    // 查询序号为n_buffers 的缓冲区，得到其起始物理地址和大小
    if (-1 == ioctl (fd, VIDIOC_QUERYBUF, &buf))
        exit(-1);

    buffers[n_buffers].length = buf.length;

    // 映射内存
    buffers[n_buffers].start =mmap (NULL,buf.length,PROT_READ | PROT_WRITE ,MAP_SHARED,fd, buf.m.offset);

    if (MAP_FAILED == buffers[n_buffers].start)
        exit(-1);
}

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

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

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

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

VIDIOC_QBUF // 把帧放入队列
VIDIOC_DQBUF // 从队列中取出帧

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

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

unsigned int i;
enum v4l2_buf_type type;

for (i = 0; i < 4; ++i) // 将缓冲帧放入队列
{
    struct v4l2_buffer buf;

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    buf.index = i;

    ioctl (fd, VIDIOC_QBUF, &buf);
}

type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

ioctl (fd, VIDIOC_STREAMON, &type);

// 这有个问题，这些buf 看起来和前面申请的buf 没什么关系，为什么呢?

例：获取一帧并处理

struct v4l2_buffer buf; CLEAR (buf);

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;

ioctl (fd, VIDIOC_DQBUF, &buf); // 从缓冲区取出一个缓冲帧

process_image (buffers[buf.index.]start); //

ioctl (fdVIDIOC_QBUF&buf); //

4.实例代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h>           
#include <fcntl.h>            
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
 
#include <asm/types.h>        
#include <linux/videodev2.h>

struct buffer
{
	void *start;
	size_t length; 	
};

struct buffer *buffers;
int fd;
int file_fd; 

void read_frame()
{
    struct v4l2_buffer buf; 
	
    // 1.取出帧缓冲（出队）
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    ioctl (fd, VIDIOC_DQBUF, &buf);
    
    // 2.访问帧缓冲
    write(file_fd,buffers[buf.index].start,buffers[buf.index].length);
    
    // 3.帧缓冲重新入队
    ioctl(fd, VIDIOC_QBUF, &buf);
}

int main()
{
	struct v4l2_capability cap;
	struct v4l2_format fmt;
	struct v4l2_requestbuffers req; 
	struct v4l2_buffer buf; 
	enum v4l2_buf_type type;
	
	int i;	
	fd_set fds;
	
	file_fd = open("test.jpg", O_RDWR | O_CREAT, 0777);
	
	// 1.打开摄像头设备文件
	fd = open("/dev/video0", O_RDWR | O_NONBLOCK, 0);	
	
	// 2.获取驱动信息
	ioctl(fd, VIDIOC_QUERYCAP, &cap);
	printf("Driver Name:%s\nCard Name:%s\nBus info:%s\n\n", cap.driver, cap.card, cap.bus_info);
	
	// 3.设置图像格式
	fmt.type		        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	fmt.fmt.pix.width       = 320;
	fmt.fmt.pix.height     = 240;
	fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;

	ioctl(fd, VIDIOC_S_FMT, &fmt);
	
	// 4.申请帧缓冲区
	req.count 	= 4;
	req.type	= V4L2_BUF_TYPE_VIDEO_CAPTURE;
	req.memory  = V4L2_MEMORY_MMAP;
	
	ioctl(fd, VIDIOC_REQBUFS, &req);
	
	buffers =calloc(4, sizeof(*buffers));
	
	for (i = 0; i < req.count; ++i)
	{
		// 5.获取帧缓冲的地址以及长度信息
		buf.type	= V4L2_BUF_TYPE_VIDEO_CAPTURE;  
		buf.memory  = V4L2_MEMORY_MMAP;  
		buf.index	= i;
		
		ioctl(fd, VIDIOC_QUERYBUF, &buf);
		
		buffers[i].length = buf.length;	
		
		// 6.使用mmp把内核空间的帧缓冲映射到用户空间
		buffers[i].start = mmap (NULL ,buf.length, PROT_READ | PROT_WRITE, MAP_SHARED,fd, buf.m.offset); // 通过mmap建立映射关系                                                                                                                                                                                                                               
	}
	
	// 7.帧缓冲入队列
	for (i = 0; i< 4; ++i) 
	{
		buf.type	= V4L2_BUF_TYPE_VIDEO_CAPTURE;  
		buf.memory  = V4L2_MEMORY_MMAP;  
		buf.index   = i;
		  
		ioctl (fd,VIDIOC_QBUF, &buf); 	
	}
	
	// 8.开始采集图像
	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
	ioctl(fd, VIDIOC_STREAMON, &type);
	
	// 判断设备是否准备好 
	FD_ZERO(&fds);
    FD_SET(fd, &fds);
	select(fd + 1, &fds, NULL, NULL, NULL);
	
	// 读取一幅图像
	read_frame();
	
	// 取消映射
	for (i = 0; i < 4; ++i)
      	munmap (buffers[i].start, buffers[i].length); 
      	
   close (fd);
   close (file_fd);
   printf("Camera Done.\n");

   return 0;
}

我们可以得出如下的操作流程：

1. 打开摄像头设备文件。
2. 获取驱动信息-VIDIOC_QUERYCAP；在此之后可以获取更多的信息，不仅仅是本程序中后面的获取设置图像格式，我们还可以获取摄像头所支持的图像格式等信息。
3. 设置图像格式-VIDIOC_S_FMT；
4. 申请帧缓冲区-VIDIOC_REQBUFS；在Linux里面，必须要有帧缓冲区才可以进行图像的捕获，有了帧缓冲区以后，可以将帧缓冲区设置为输入队列，经过驱动程序以后，就将图像信息写到帧缓冲区，写入图像数据以后的帧缓冲区会加入输出队列，用户空间的应用程序最重要取出输出队列的帧缓冲区，然后读里面的内容，最后将被读取数据以后的帧缓冲区再次放回到输入队列，如此循环完成视频监控功能。但是要注意的是，这里申请的帧缓冲区是内核空间的，所以应用程序不能直接访问，需要通过映射等操作。而且输入队列和输出队列都是帧缓冲构成的。
5. 获取帧缓冲的地址以及长度信息-VIDIOC_QUERYBUF；
6. 使用mmap将内核空间的帧缓冲映射到用户空间；
7. 帧缓冲入队列-VIDIOC_QBUF；
8. 开始采集图像-VIDIOC_STREAMON；在此之后需要使用select函数等待输出缓冲有数据可读再进行下一步操作。
9. 取出帧缓冲（出队）-VIDIOC_DQBUF；
10. 访问帧缓冲读取数据-使用write等函数将数据写入到目标文件。
11. 帧缓冲重新入队列-VIDIOC_QBUF；已经读取过数据的帧缓冲要放入输入队列。
12. 关闭相关设备和文件进行以及解除映射等扫尾工作。

移动物体监控系统(2)—摄像头子系统开发

《Python进阶》学习笔记

Leetcode 3161. 物块放置查询

leetcode 60 排列序列

一个docker容器暴露多个端口

微服务实践之使用 Visual Studio 2022 调试Dapr 应用程序

wpf附加属性理解 WPF附加属性

c語言深度剖析(27)—數組的本質分析

c語言深度剖析(31)—字符串典型問題分析

c語言深度剖析(33)—main函數與命令行參數

SPI驅動程序設計(1)—SPI總線介紹

c語言深度剖析(35)—數組參數和指針參數分析

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結