深入学习Linux内核之v4l2驱动框架(一)

news2025/1/17 5:51:15

一，概述

V4L2（Video for Linux 2）是Linux操作系统中用于支持摄像头和视频设备的框架。它提供了一组API和驱动程序接口，用于在Linux系统中进行视频采集、视频流处理和视频播放等操作。

V4L2的设计目标是支持多种设备，包括摄像头、视频采集卡等，并允许应用程序与这些设备通信。通过V4L2，可以实现图片、视频和音频的采集，这些功能在远程会议、可视电话、视频监控系统和嵌入式多媒体终端等场景中都有广泛的应用。

V4L2框架具有设备抽象层，这使得应用程序可以与各种不同类型的视频设备进行通信，而无需关心具体的硬件细节。此外，V4L2还提供了一系列回调函数，用于设置设备的参数，如摄像头的频率、帧频、视频压缩格式和图像参数等。

在编程方面，V4L2是针对uvc免驱USB设备的编程框架，主要用于采集USB摄像头等。在Linux编程中，一般使用ioctl函数来对设备的I/O通道进行管理，通过不同的命令标志符来执行各种操作，如分配内存、查询驱动功能、获取视频格式、设置频捕获格式等。

总的来说，V4L2是Linux系统中用于支持摄像头和视频设备的重要框架，为开发者提供了丰富的功能和灵活的编程接口。

V4L2支持三类设备：视频输入输出设备、VBI设备和radio设备(其实还支持更多类型的设备，暂不讨论)，分别会在/dev目录下产生videoX、radioX和vbiX设备节点。我们常见的视频输入设备主要是摄像头，也是本文主要分析对象。下图V4L2在Linux系统中的结构图：
在这里插入图片描述二，V4L2框架

在这里插入图片描述

Linux系统中视频输入设备主要包括以下四个部分：

字符设备驱动程序核心：V4L2本身就是一个字符设备，具有字符设备所有的特性，暴露接口给用户空间；

V4L2驱动核心：主要是构建一个内核中标准视频设备驱动的框架，为视频操作提供统一的接口函数；

平台V4L2设备驱动：在V4L2框架下，根据平台自身的特性实现与平台相关的V4L2驱动部分，包括注册video_device和v4l2_dev。

具体的sensor驱动：主要上电、提供工作时钟、视频图像裁剪、流IO开启等，实现各种设备控制方法供上层调用并注册v4l2_subdev。

V4L2的核心源码位于drivers/media/v4l2-core，源码以实现的功能可以划分为四类：

核心模块实现：由v4l2-dev.c实现，主要作用申请字符主设备号、注册class和提供video device注册注销等相关函数；

V4L2框架：由v4l2-device.c、v4l2-subdev.c、v4l2-fh.c、v4l2-ctrls.c等文件实现，构建V4L2框架；

Videobuf管理：由videobuf2-core.c、videobuf2-dma-contig.c、videobuf2-dma-sg.c、videobuf2-memops.c、videobuf2-vmalloc.c、v4l2-mem2mem.c等文件实现，完成videobuffer的分配、管理和注销。

Ioctl框架：由v4l2-ioctl.c文件实现，构建V4L2ioctl的框架。

video_device、v4l2_device和v4l2_subdev的关系：
在这里插入图片描述三，V4L2的数据结构

video_device
video_device结构体用于在/dev目录下生成设备节点文件，把操作设备的接口暴露给用户空间。

struct video_device
{
    /* character device */
	struct cdev *cdev;
    
    /* v4l2_device parent */
	struct v4l2_device *v4l2_dev;

   	/* device ops */
	const struct v4l2_file_operations *fops;
    
	/* ioctl callbacks */
	const struct v4l2_ioctl_ops *ioctl_ops;
};

可以看到video_device中含有一个cdev还有v4l2_device，此外还有fops和ioctl_ops，从应用层进行系统调用会经过v4l2的核心层回调到这里

Video_device分配和释放，用于分配和释放video_device结构体：

struct video_device *video_device_alloc(void)

void video_device_release(struct video_device *vdev)

video_device注册和注销，实现video_device结构体的相关成员后，就可以调用下面的接口进行注册：

static inline int __must_checkvideo_register_device(struct video_device *vdev,

                   inttype, int nr)

void video_unregister_device(struct video_device*vdev);

vdev：需要注册和注销的video_device；

type：设备类型，包括VFL_TYPE_GRABBER、VFL_TYPE_VBI、VFL_TYPE_RADIO和VFL_TYPE_SUBDEV。
ps： GRABBER在英文中的意思是掠夺者，video grabber 即 视频捕获器

nr：设备节点名编号，如/dev/video[nr]。

其中v4l2_file_operations和v4l2_ioctl_ops如下

struct v4l2_file_operations {
	struct module *owner;
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
	unsigned int (*poll) (struct file *, struct poll_table_struct *);
	long (*ioctl) (struct file *, unsigned int, unsigned long);
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	unsigned long (*get_unmapped_area) (struct file *, unsigned long,
				unsigned long, unsigned long, unsigned long);
	int (*mmap) (struct file *, struct vm_area_struct *);
	int (*open) (struct file *);
	int (*release) (struct file *);
};

熟悉v4l2应用编程的应该都知道v4l2有很多ioctl操作，具体实现都在这里

struct v4l2_ioctl_ops {
	int (*vidioc_querycap)(struct file *file, void *fh, struct v4l2_capability *cap);
	/* Buffer handlers */
	int (*vidioc_reqbufs) (struct file *file, void *fh, struct v4l2_requestbuffers *b);
	int (*vidioc_querybuf)(struct file *file, void *fh, struct v4l2_buffer *b);
	int (*vidioc_qbuf)    (struct file *file, void *fh, struct v4l2_buffer *b);
	int (*vidioc_dqbuf)   (struct file *file, void *fh, struct v4l2_buffer *b);
    /* Stream on/off */
	int (*vidioc_streamon) (struct file *file, void *fh, enum v4l2_buf_type i);
	int (*vidioc_streamoff)(struct file *file, void *fh, enum v4l2_buf_type i);
   	...
};

v4l2_device

struct v4l2_device {
	/* used to keep track of the registered subdevs */
	struct list_head subdevs;
    ...
};

可以看到v4l2_device中有一个v4l2_subdev的链表，v4l2_device的主要目的时用来管理v4l2_subdev

可以看出v4l2_device的主要作用是管理注册在其下的子设备，方便系统查找引用到。

V4l2_device的注册和注销：

int v4l2_device_register(struct device*dev, struct v4l2_device *v4l2_dev)

static void v4l2_device_release(struct kref *ref)

v4l2_subdev

struct v4l2_subdev {
	struct list_head list;
	struct v4l2_device *v4l2_dev;
	const struct v4l2_subdev_ops *ops;
};

v4l2_subdev中有一个v4l2_subdev_ops，实现了一系列的操作，供v4l2_device调用

struct v4l2_subdev_ops {
	const struct v4l2_subdev_core_ops	*core;
	const struct v4l2_subdev_tuner_ops	*tuner;
	const struct v4l2_subdev_audio_ops	*audio;
	const struct v4l2_subdev_video_ops	*video;
	const struct v4l2_subdev_vbi_ops	*vbi;
	const struct v4l2_subdev_ir_ops		*ir;
	const struct v4l2_subdev_sensor_ops	*sensor;
};

struct v4l2_subdev_core_ops {
    ...
	int (*s_config)(struct v4l2_subdev *sd, int irq, void *platform_data);
	int (*init)(struct v4l2_subdev *sd, u32 val);
	int (*s_gpio)(struct v4l2_subdev *sd, u32 val);
	int (*g_ctrl)(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
	int (*s_ctrl)(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
	int (*s_std)(struct v4l2_subdev *sd, v4l2_std_id norm);
	long (*ioctl)(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
	...
};

struct v4l2_subdev_video_ops {
	...
    int (*enum_fmt)(struct v4l2_subdev *sd, struct v4l2_fmtdesc *fmtdesc);
	int (*g_fmt)(struct v4l2_subdev *sd, struct v4l2_format *fmt);
	int (*try_fmt)(struct v4l2_subdev *sd, struct v4l2_format *fmt);
	int (*s_fmt)(struct v4l2_subdev *sd, struct v4l2_format *fmt);
	int (*cropcap)(struct v4l2_subdev *sd, struct v4l2_cropcap *cc);
	int (*g_crop)(struct v4l2_subdev *sd, struct v4l2_crop *crop);
	int (*s_crop)(struct v4l2_subdev *sd, struct v4l2_crop *crop);
	int (*g_parm)(struct v4l2_subdev *sd, struct v4l2_streamparm *param);
	int (*s_parm)(struct v4l2_subdev *sd, struct v4l2_streamparm *param);
	...
};

Subdev的注册和注销

当我们把v4l2_subdev需要实现的成员都已经实现，就可以调用以下函数把子设备注册到V4L2核心层：

int v4l2_device_register_subdev(struct v4l2_device*v4l2_dev, struct v4l2_subdev *sd)

当卸载子设备时，可以调用以下函数进行注销：

void v4l2_device_unregister_subdev(struct v4l2_subdev*sd)

四，ioctl框架

你可能观察到用户空间对V4L2设备的操作基本都是ioctl来实现的，V4L2设备都有大量可操作的功能(配置寄存器)，所以V4L2的ioctl也是十分庞大的。它是一个怎样的框架，是怎么实现的呢？

Ioctl框架是由v4l2_ioctl.c文件实现，文件中定义结构体数组v4l2_ioctls，可以看做是ioctl指令和回调函数的关系表。用户空间调用系统调用ioctl，传递下来ioctl指令，然后通过查找此关系表找到对应回调函数。

以下是截取数组的两项：

IOCTL_INFO_FNC(VIDIOC_QUERYBUF, v4l_querybuf,v4l_print_buffer, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_buffer, length)),

IOCTL_INFO_STD(VIDIOC_G_FBUF, vidioc_g_fbuf,v4l_print_framebuffer, 0),

内核提供两个宏(IOCTL_INFO_FNC和IOCTL_INFO_STD)来初始化结构体，参数依次是ioctl指令、回调函数或者v4l2_ioctl_ops结构体成员、debug函数、flag。如果回调函数是v4l2_ioctl_ops结构体成员，则使用IOCTL_INFO_STD；如果回调函数是v4l2_ioctl.c自己实现的，则使用IOCTL_INFO_FNC。

IOCTL调用的流程图如下：
在这里插入图片描述
用户空间通过打开/dev/目录下的设备节点，获取到文件的file结构体，通过系统调用ioctl把cmd和arg传入到内核。通过一系列的调用后最终会调用到__video_do_ioctl函数，然后通过cmd检索v4l2_ioctls[]，判断是INFO_FL_STD还是INFO_FL_FUNC。如果是INFO_FL_STD会直接调用到视频设备驱动中video_device->v4l2_ioctl_ops函数集。如果是INFO_FL_FUNC会先调用到v4l2自己实现的标准回调函数，然后根据arg再调用到video_device->v4l2_ioctl_ops或v4l2_fh->v4l2_ctrl_handler函数集。

五，IO访问

V4L2支持三种不同IO访问方式(内核中还支持了其它的访问方式，暂不讨论)：

read和write，是基本帧IO访问方式，通过read读取每一帧数据，数据需要在内核和用户之间拷贝，这种方式访问速度可能会非常慢；

内存映射缓冲区(V4L2_MEMORY_MMAP)，是在内核空间开辟缓冲区，应用通过mmap()系统调用映射到用户地址空间。这些缓冲区可以是大而连续DMA缓冲区、通过vmalloc()创建的虚拟缓冲区，或者直接在设备的IO内存中开辟的缓冲区(如果硬件支持)；

用户空间缓冲区(V4L2_MEMORY_USERPTR)，是用户空间的应用中开辟缓冲区，用户与内核空间之间交换缓冲区指针。很明显，在这种情况下是不需要mmap()调用的，但驱动为有效的支持用户空间缓冲区，其工作将也会更困难。

Read和write方式属于帧IO访问方式，每一帧都要通过IO操作，需要用户和内核之间数据拷贝，而后两种是流IO访问方式，不需要内存拷贝，访问速度比较快。内存映射缓冲区访问方式是比较常用的方式。

内存映射缓存区方式

硬件层的数据流传输

Camerasensor捕捉到图像数据通过并口或MIPI传输到CAMIF(camera interface)，CAMIF可以对图像数据进行调整(翻转、裁剪和格式转换等)。然后DMA控制器设置DMA通道请求AHB将图像数据传到分配好的DMA缓冲区。

待图像数据传输到DMA缓冲区之后，mmap操作把缓冲区映射到用户空间，应用就可以直接访问缓冲区的数据。

vb2_queue

为了使设备支持流IO这种方式，驱动需要实现struct vb2_queue，来看下这个结构体：

 struct vb2_queue {

         enumv4l2_buf_type                  type;  //buffer类型

         unsignedint                        io_modes;  //访问IO的方式:mmap、userptr etc

 

         conststruct vb2_ops                 *ops;   //buffer队列操作函数集合

         conststruct vb2_mem_ops     *mem_ops;  //buffer memory操作集合

 

         structvb2_buffer              *bufs[VIDEO_MAX_FRAME];  //代表每个buffer

         unsignedint                        num_buffers;    //分配的buffer个数

……

};

Vb2_queue代表一个videobuffer队列，vb2_buffer是这个队列中的成员，vb2_mem_ops是缓冲内存的操作函数集，vb2_ops用来管理队列。

vb2_mem_ops

vb2_mem_ops包含了内存映射缓冲区、用户空间缓冲区的内存操作方法：

 struct vb2_mem_ops {

         void           *(*alloc)(void *alloc_ctx, unsignedlong size);  //分配视频缓存

         void           (*put)(void *buf_priv);            //释放视频缓存

//获取用户空间视频缓冲区指针

         void           *(*get_userptr)(void *alloc_ctx,unsigned long vaddr, 

                                               unsignedlong size, int write);

         void           (*put_userptr)(void *buf_priv);       //释放用户空间视频缓冲区指针

 

//用于缓存同步

         void           (*prepare)(void *buf_priv);

         void           (*finish)(void *buf_priv);

 

         void           *(*vaddr)(void *buf_priv);

         void           *(*cookie)(void *buf_priv);

         unsignedint     (*num_users)(void *buf_priv);         //返回当期在用户空间的buffer数

 

         int              (*mmap)(void *buf_priv, structvm_area_struct *vma);  //把缓冲区映射到用户空间

};

这是一个相当庞大的结构体，这么多的结构体需要实现还不得累死，幸运的是内核都已经帮我们实现了。提供了三种类型的视频缓存区操作方法：连续的DMA缓冲区、集散的DMA缓冲区以及vmalloc创建的缓冲区，分别由videobuf2-dma-contig.c、videobuf2-dma-sg.c和videobuf-vmalloc.c文件实现，可以根据实际情况来使用。

vb2_buffer是缓存队列的基本单位，内嵌在其中v4l2_buffer是核心成员。当开始流IO时，帧以v4l2_buffer的格式在应用和驱动之间传输。一个缓冲区可以有三种状态：

在驱动的传入队列中，驱动程序将会对此队列中的缓冲区进行处理，用户空间通过IOCTL:VIDIOC_QBUF把缓冲区放入到队列。对于一个视频捕获设备，传入队列中的缓冲区是空的，驱动会往其中填充数据；

在驱动的传出队列中，这些缓冲区已由驱动处理过，对于一个视频捕获设备，缓存区已经填充了视频数据，正等用户空间来认领；

用户空间状态的队列，已经通过IOCTL:VIDIOC_DQBUF传出到用户空间的缓冲区，此时缓冲区由用户空间拥有，驱动无法访问。

这三种状态的切换如下图所示：
在这里插入图片描述v4l2_buffer结构如下：

 struct v4l2_buffer {

         __u32                          index;  //buffer 序号

         __u32                          type;   //buffer类型

         __u32                          bytesused;  缓冲区已使用byte数

         __u32                          flags;

         __u32                          field;

         structtimeval           timestamp;  //时间戳，代表帧捕获的时间

         structv4l2_timecode       timecode;

         __u32                          sequence;

 

         /*memory location */

         __u32                          memory;  //表示缓冲区是内存映射缓冲区还是用户空间缓冲区

         union {

                   __u32           offset;  //内核缓冲区的位置

                   unsignedlong   userptr;   //缓冲区的用户空间地址

                   structv4l2_plane *planes;

                   __s32                 fd;

         } m;

         __u32                          length;   //缓冲区大小，单位byte

};

当用户空间拿到v4l2_buffer，可以获取到缓冲区的相关信息。Byteused是图像数据所占的字节数，如果是V4L2_MEMORY_MMAP方式，m.offset是内核空间图像数据存放的开始地址，会传递给mmap函数作为一个偏移，通过mmap映射返回一个缓冲区指针p，p+byteused是图像数据在进程的虚拟地址空间所占区域；如果是用户指针缓冲区的方式，可以获取的图像数据开始地址的指针m.userptr，userptr是一个用户空间的指针，userptr+byteused便是所占的虚拟地址空间，应用可以直接访问。

六，源码剖析

V4L2驱动模板

此示例中并没有设计到v4l2_subdev，这部分将会在后面分析具体的驱动中出现

#include <...>

static struct video_device* video_dev;
static struct v4l2_device v4l2_dev;

/* 实现各种系统调用 */
static const struct v4l2_file_operations video_dev_fops = {
	.owner		    = THIS_MODULE,
	.release        = vdev_close,
	.read           = vdev_read,
	.poll		    = vdev_poll,
	.ioctl          = video_ioctl2,
	.mmap           = vdev_mmap,
};

/* 实现各种系统调用 */
static const struct v4l2_ioctl_ops video_dev_ioctl_ops = {
	.vidioc_querycap      = vidioc_querycap,
	.vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
	.vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
	.vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
	.vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
	.vidioc_reqbufs       = vidioc_reqbufs,
	.vidioc_querybuf      = vidioc_querybuf,
	.vidioc_qbuf          = vidioc_qbuf,
	.vidioc_dqbuf         = vidioc_dqbuf,
	.vidioc_enum_input    = vidioc_enum_input,
	.vidioc_g_input       = vidioc_g_input,
	.vidioc_s_input       = vidioc_s_input,
	.vidioc_streamon      = vidioc_streamon,
	.vidioc_streamoff     = vidioc_streamoff,
};

static int __init video_init(void)
{
    /* 分配并设置一个video_device */
    video_dev = video_device_alloc();
    video_dev->fops = &video_dev_fops;
    video_dev->ioctl_ops = &video_dev_ioctl_ops;
    video_dev->release = video_device_release;

    /* 注册一个v4l2_device */
    v4l2_device_register(video_dev->dev, &v4l2_dev);    
    video_dev->v4l2_dev = &video_dev;

    /* 注册一个video_device字符设备 */
    video_register_device(video_dev, VFL_TYPE_GRABBER, -1);

    return 0;
}

static void __exit video_exit(void)
{
    video_unregister_device(video_dev);
    v4l2_device_unregister(&v4l2_dev);
    video_device_release(video_dev);
}


module_init(video_init);
module_exit(video_exit);

如果你熟悉v4l2应用编程的话，你应该知道v4l2有许多ioctl操作，上面的模板就实现了很多ioctl操作

下面我们来分析分析源码

在上面的video_init中，我们分配并设置了video_dev，注册了v4l2_device(v4l2_device_register)，然后向v4l2核心层注册video_device(video_register_device)

我们先来看v4l2_device_register

int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
{
    INIT_LIST_HEAD(&v4l2_dev->subdevs);
    spin_lock_init(&v4l2_dev->lock);
    dev_set_drvdata(dev, v4l2_dev);
    ...
}

从源码中可以看出v4l2_device_register并没有做什么事，只是初始化链表，自旋锁，还有设置数据，这函数并不是我们的重点

下面来仔细分析video_register_device

int video_register_device(struct video_device *vdev, int type, int nr)
{   
    /* 分配字符设备 */
    vdev->cdev = cdev_alloc();
    
    /* 设置fops */
    vdev->cdev->ops = &v4l2_fops;
    
    /* 注册字符设备 */
    cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);

	/* 生成设备节点 */
	dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);
    device_register(&vdev->dev);
    
    /* 设置全局数组 */
    video_device[vdev->minor] = vdev;
}

可以看到这个函数会为video_device分配一个cdev，然后设置fops，向内核注册字符设备，再者生成设备节点

然后设置video_device全局数组，video_device一个全局数组

static struct video_device *video_device[VIDEO_NUM_DEVICES];

保存着注册的video_device

另外，在sys/class/video4linux/下可以找到我们的设备节点。

我们注册的设备类型为VFL_TYPE_GRABBER，对应的节点名称video
第一个注册的设备从0开始，以此类推，因此节点名称为video0

用户可以打开dev/video0节点，通过IOCTL命令和内核空间进行通信。

接下来看一下其中设置的fops(v4l2_fops)

static const struct file_operations v4l2_fops = {
	.owner = THIS_MODULE,
	.read = v4l2_read,
	.write = v4l2_write,
	.open = v4l2_open,
	.get_unmapped_area = v4l2_get_unmapped_area,
	.mmap = v4l2_mmap,
	.ioctl = v4l2_ioctl,
	.release = v4l2_release,
	.poll = v4l2_poll,
	.llseek = no_llseek,
};

这个是video_device中的字符设备对应的fops，应用层发生系统调用会率先调用到这里，我们来好好看一看这些调用

v4l2_open

static int v4l2_open(struct inode *inode, struct file *filp)
{
    struct video_device *vdev;
    
    /* 根据次设备获得video_device */
    vdev = video_devdata(filp);
    
    /* 回调video_device的fops */
	if (vdev->fops->open)
		ret = vdev->fops->open(filp); //回调video
}

从这个函数可以看到，发生系统调用首先来到v4l2核心层的字符设备，然后再回调到对应的video_device，video_device在前面已经实现了v4l2_file_operations和v4l2_ioctl_ops一系列回调

v4l2_ioctl

V4L2的应用编程会有非常多的ioctl，会先调用到此处

static int v4l2_ioctl(struct inode *inode, struct file *filp,
		unsigned int cmd, unsigned long arg)
{
	struct video_device *vdev = video_devdata(filp);

    /* 回调到video_device中 */
	return vdev->fops->ioctl(filp, cmd, arg);
}

下面来看一看video_device怎么实现ioctl

static const struct v4l2_file_operations video_dev_fops = {
	.owner		    = THIS_MODULE,
	.release        = vdev_close,
	.read           = vdev_read,
	.poll		    = vdev_poll,
	.ioctl          = video_ioctl2,
	.mmap           = vdev_mmap,
};

从上面驱动程序的编写，我们可以知道video_device对应ioctl就是video_ioctl2，这个函数是内核提供的，我们看一看这个函数的内容

long video_ioctl2(struct file *file,
	       unsigned int cmd, unsigned long arg)
{
    __video_do_ioctl(file, cmd, parg);
}

static long __video_do_ioctl(struct file *file,
		unsigned int cmd, void *arg)
{
    /* 获取video_device */
    struct video_device *vfd = video_devdata(file);
    
    /* 获取video_device的ioctl_ops */
    const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;

    switch (cmd) {
	case VIDIOC_QUERYCAP:
        ops->vidioc_querycap(file, fh, cap);
    case VIDIOC_ENUM_FMT:
         ops->vidioc_enum_fmt_vid_cap(file, fh, f);
    ...
    }
}

可以看出，最终会调用到video_device实现的v4l2_ioctl_ops

/* 实现各种系统调用 */
static const struct v4l2_ioctl_ops video_dev_ioctl_ops = {
	.vidioc_querycap      = vidioc_querycap,
	.vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
	.vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
	.vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
	.vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
	.vidioc_reqbufs       = vidioc_reqbufs,
	.vidioc_querybuf      = vidioc_querybuf,
	.vidioc_qbuf          = vidioc_qbuf,
	.vidioc_dqbuf         = vidioc_dqbuf,
	.vidioc_enum_input    = vidioc_enum_input,
	.vidioc_g_input       = vidioc_g_input,
	.vidioc_s_input       = vidioc_s_input,
	.vidioc_streamon      = vidioc_streamon,
	.vidioc_streamoff     = vidioc_streamoff,
};

所以系统调用最先都会调用到字符设备的fops，然后经过v4l2核心层最终调用到video_device这里

关于v4l2的驱动框架就分析到这里，关于更加详细的实现v4l2驱动，将在后续文章中通过实例讲解

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1674721.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

机器学习-KNN算法

机器学习-KNN算法

机器学习-KNN算法 没有什么比顺其自然更有超凡的力量。没有什么比顺乎本性更具有迷人的魔力。 目录 机器学习-KNN算法 1.K近邻算法 2.KNN决策方式 1&#xff09;KNN分类预测规则 1&#xff09;KNN回归预测规则 3.KNN三要素 4.KNN算法实现方式 1&#xff09;蛮力实现 2&a…
阅读更多...
C++ C# 贝塞尔曲线

C++ C# 贝塞尔曲线

二阶贝塞尔曲线公式 三阶贝塞尔曲线公式 C 三维坐标点 二阶到N阶源码 //二阶公式&#xff1a; FVector BezierUtils::CalculateBezierPoint(float t, FVector startPoint, FVector controlPoint, FVector endPoint) {float t1 (1 - t) * (1 - t);float t2 2 * t * (1 - t);…
阅读更多...
【JS红宝书学习笔记】第1、2章 初识JS

【JS红宝书学习笔记】第1、2章 初识JS

第1章 什么是JavaScript JavaScript 是一门用来与网页交互的脚本语言&#xff0c;包含以下三个组成部分。 ECMAScript&#xff1a;由 ECMA-262 定义并提供核心功能。文档对象模型&#xff08;DOM&#xff09;&#xff1a;提供与网页内容交互的方法和接口。浏览器对象模型&…
阅读更多...
Dubbo3.x 异步转同步源码

Dubbo3.x 异步转同步源码

底层netty通信是异步的&#xff0c;那我们平时调用采取的同步是如何将底层的异步转为同步的呢&#xff1f; dubbo远程rpc协议和网络框架有多种&#xff0c;我们以默认的dubbo协议、网络框架netty作为切入点. 注意点&#xff1a;debug时将过期时间设置长一点&#xff1a; 调用…
阅读更多...
【高阶数据结构】并查集 {并查集原理；并查集优化；并查集实现；并查集应用}

【高阶数据结构】并查集 {并查集原理；并查集优化；并查集实现；并查集应用}

一、并查集原理 在一些应用问题中&#xff0c;需要将n个不同的元素划分成一些不相交的集合。开始时&#xff0c;每个元素自成一个单元素集合&#xff0c;然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类…
阅读更多...
2024年Java程序员的职业发展路径

2024年Java程序员的职业发展路径

程序员的职业路径是非常清晰的&#xff0c;但是现实情况下&#xff0c;很多人卡在了高级开发就再也上不去&#xff0c;直到遇到职业发展的危机&#xff0c;比如&#xff1a; 35岁大龄程序员找工作难&#xff0c;国内很多大型互联网公司在招聘要求上&#xff0c;会限制35岁这个年…
阅读更多...
记录Spring Boot 2.3.4.RELEASE版注解方式实现AOP和通知的执行顺序

记录Spring Boot 2.3.4.RELEASE版注解方式实现AOP和通知的执行顺序

1.advice 按照以下的顺序执行 输出结果&#xff1a;(正常和异常) 说明&#xff1a;Spring boot 2.3.4.RELEASE 版本使用的AOP是spring-aop-5.2.9.RELEASE&#xff0c;AOP的通知顺序不一样。 可以测试下Spring boot 2.1.1.RELEASE 版做对比&#xff0c;发现结果是不一样的。 2…
阅读更多...
算法-卡尔曼滤波之卡尔曼滤波的第一个方程：状态更新方程

算法-卡尔曼滤波之卡尔曼滤波的第一个方程：状态更新方程

通过一个例子来引出卡尔曼滤波的状态更新方程&#xff1b; 这里系统状态是金条的重量&#xff1b; 为了估计系统的状态&#xff0c;我们可以多次测量金条的重量&#xff0c;然后求平均值&#xff1b; 其中估计值是所有测量值的平均值&#xff1b; 由于我们使用的是静态模型&am…
阅读更多...
灵活的静态存储控制器 (FSMC)的介绍（STM32F4）

灵活的静态存储控制器 (FSMC)的介绍（STM32F4）

目录 概述 1 认识FSMC 1.1 应用介绍 1.2 FSMC的主要功能 1.2.1 FSMC用途 1.2.2 FSMC的功能 2 FSMC的框架结构 2.1 AHB 接口 2.1.1 AHB 接口的Fault 2.1.2 支持的存储器和事务 2.2 外部器件地址映射 3 地址映射 3.1 NOR/PSRAM地址映射 3.2 NAND/PC卡地址映射 概述…
阅读更多...
思维导图软件哪个好？5个软件教你自己快速制作思维导图

思维导图软件哪个好？5个软件教你自己快速制作思维导图

思维导图软件哪个好&#xff1f;5个软件教你自己快速制作思维导图 思维导图软件在现代生活和工作中扮演着重要的角色&#xff0c;它们可以帮助人们整理思维、规划项目、记录笔记等。以下是五款值得推荐的思维导图软件&#xff0c;它们各有特色&#xff0c;可以帮助您快速制作思…
阅读更多...
开发者体验官：参与华为云CodeArts开发实践，赢取千元好礼！

开发者体验官：参与华为云CodeArts开发实践，赢取千元好礼！

CodeArts携华为云其他六大上云实践项目&#xff0c; 一起给大家送福利啦&#xff01; 这次我们准备了华为全套电子产品&#xff0c; 包括但不限于华为智能音箱、耳机、摄像头&#xff0c;最高价值1000元&#xff01; 只要体验完产品&#xff0c;提出相关的产品优化建议即有…
阅读更多...
【020】基于JavaWeb实现的批报管理系统

【020】基于JavaWeb实现的批报管理系统

项目介绍 基于jspservlet实现的批报管理系统采用B/S架构,该项目设计了一个角色管理员&#xff0c;管理员实现了我的案件、查询统计、项目维护等三大功能模块 技术栈 开发工具&#xff1a;Idea2020.3 运行环境&#xff1a;jdk1.8tomcat9.0mysql5.7 服务端技术&#xff1a;j…
阅读更多...
wireshark_概念

wireshark_概念

ARP (Address Resolution Protocol&#xff09;协议&#xff0c;即地址解析协议。该协议的功能就是将IP地址解析成MAC地址。 混杂模式 抓取经过网卡的所有数据包&#xff0c;包括发往本网卡和非发往本网卡的。 非混杂模式 只抓取目标地址是本网卡的数据包&#xff0c;对于发往…
阅读更多...
算法练习第21天|216.组合总和|||、17.电话号码的字母组合

算法练习第21天|216.组合总和|||、17.电话号码的字母组合

216.组合总和 III 216. 组合总和 III - 力扣&#xff08;LeetCode&#xff09;https://leetcode.cn/problems/combination-sum-iii/ 题目描述&#xff1a; 找出所有相加之和为 n 的 k 个数的组合&#xff0c;且满足下列条件&#xff1a; 只使用数字1到9每个数字 最多使用一…
阅读更多...
历史影像的下载办法总结

历史影像的下载办法总结

最近想要下黄河口的历史影像&#xff0c;试验了几个办法&#xff1a; 1&#xff09;参考文献1中的办法&#xff0c;用Global Mapper下载World Imagery Wayback网站的历史数据&#xff0c;能下载从2014年至现在的&#xff1b; 2&#xff09;参考文献1中的办法&#xff0c;用SA…
阅读更多...
SSL证书：守护网站安全的必要之选

SSL证书：守护网站安全的必要之选

随着互联网的飞速发展&#xff0c;网络安全问题愈发受到人们的关注。在这个信息爆炸的时代&#xff0c;数据的安全传输和用户的隐私保护成为了每个网站运营者必须面对的重要议题。而SSL证书&#xff0c;作为保障网站安全的重要工具&#xff0c;其重要性不言而喻。本文将详细探讨…
阅读更多...
LeetCode416：分割等和子集

LeetCode416：分割等和子集

题目描述 给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集&#xff0c;使得两个子集的元素和相等。 解题思想 [1,5,11,5] 和为22&#xff0c;其中一半为 11。如果能寻找到若干数的和为11则成立可以抽象为一个0-1背包问题&#xff1a;容…
阅读更多...
【Python 下载大量品牌网站的图片（二）】关于图片的处理和下载，吃满带宽，可多开窗口下载多个网站，DOS窗口类型

【Python 下载大量品牌网站的图片（二）】关于图片的处理和下载，吃满带宽，可多开窗口下载多个网站，DOS窗口类型

写作日期&#xff1a;2024.05.11 使用工具&#xff1a;Python 可修改功能&#xff1a;线程量、UA、Cookie、代理、存储目录、间隔时间、超时时间、图片压缩、图片缩放 默认功能&#xff1a;图片转换、断续下载、图片检测、路径处理、存储文件 GUI&#xff1a;DOS窗口 类型&…
阅读更多...
有奖调研 | OpenSCA开源社区用户调研问卷

有奖调研 | OpenSCA开源社区用户调研问卷

调研背景&#xff1a; 亲爱的OpenSCA开源社区用户&#xff0c;感谢您一路以来的支持与相伴。随着OpenSCA开源社区的不断发展&#xff0c;我们持续专注安全开发与开源治理实践&#xff0c;为全球用户提供一站式审查治理、SaaS云分析和精准情报预警的开源数字供应链安全赋能。 为…
阅读更多...
gcc跟g++ -std=c99跟-std=c++11

gcc跟g++ -std=c99跟-std=c++11

报错&#xff1a; myshell.c: In function ‘int doBuildin(char**)’: myshell.c:91:12: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings] path "."; 解决方案&#xff1a;这个waring提示我c11&#xff0c;也就是这里…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023