深入学习Linux摄像头(三)虚拟摄像头驱动分析

深入学习Linux摄像头系列

深入学习Linux摄像头(一)v4l2应用编程

深入学习Linux摄像头(二)v4l2驱动框架

深入学习Linux摄像头(三)虚拟摄像头驱动分析

深入学习Linux摄像头(四)三星平台fimc驱动详解

深入学习Linux摄像头(三)虚拟摄像头驱动分析

上一篇文章讲解了V4L2的驱动框架,这一节我们来分析一个驱动程序,Linux内核带有一个虚拟摄像头驱动(vivi.c),这个虚拟摄像头使用V4L2驱动框架编写,只是少了硬件操作,数据来源是虚拟的,这篇文章就来分析它

看一个驱动程序首先从入口开始看起

module_init(vivi_init);
static int __init vivi_init(void)
{
    vivi_create_instance(i);
}

入口函数调用了vivi_create_instance

static int __init vivi_create_instance(int inst)
{
    struct vivi_dev *dev;
    struct video_device *vfd;

    /* 分配vivi_dev */
    dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    
    /* 初始化缓存队列 */
    videobuf_queue_vmalloc_init(&dev->vb_vidq, &vivi_video_qops, // 赋值和初始化
                                NULL, &dev->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
                                V4L2_FIELD_INTERLACED,
                                sizeof(struct vivi_buffer), dev);

    /* 分配video_device */
    vfd = video_device_alloc();

    /* 设置video_device */
	*vfd = vivi_template;
    
    /* 注册video_device */
    video_register_device(vfd, VFL_TYPE_GRABBER, video_nr);
}

从上面可以看到,首分配一个vivi_dev,看一看vivi_dev

struct vivi_dev {
	struct v4l2_device 	   v4l2_dev;
    struct video_device        *vfd; 
    ...
    /* 像素格式 */
    struct vivi_fmt            *fmt;
}

然后初始化缓存队列,videobuf_queue_vmalloc_init这个函数v4l2的videobuf提供的接口,作用是初始化一个缓存队列struct videobuf_queue,其中就设置了vivi_video_qops

struct videobuf_queue {
    /* 缓存 */
	struct videobuf_buffer     *bufs[VIDEO_MAX_FRAME];
    
	/* capture via mmap() + ioctl(QBUF/DQBUF) */
	struct list_head           stream; // 维护缓存队列的一个链表
}
static struct videobuf_queue_ops vivi_video_qops = {
	.buf_setup      = buffer_setup,
	.buf_prepare    = buffer_prepare,
	.buf_queue      = buffer_queue,
	.buf_release    = buffer_release,
};

这些函数会在操作缓存队列的时候会被调用

再接下来就是分配一个video_device,设置它,然后再注册它

上一篇文章我们分析了调用video_register_device会为video_device注册一个字符设备并生成设备节点,当应用层发生系统调用时,会先调用到字符设备的fops,经过v4l2的核心层,最终回调到video_device的fops

我们来看一看是如何设置video_device

static struct video_device vivi_template = {
	.name		= "vivi",
	.fops       = &vivi_fops,
	.ioctl_ops 	= &vivi_ioctl_ops,
	.release	= video_device_release,

	.tvnorms              = V4L2_STD_525_60,
	.current_norm         = V4L2_STD_NTSC_M,
};

可以看到vivi.c提供的video_device模板设置了vivi_fopsvivi_ioctl_ops,这两个结构体中有一大堆回调函数,我们先看一眼,稍后再具体分析

static const struct v4l2_file_operations vivi_fops = {
	.owner		= THIS_MODULE,
	.release        = vivi_close,
	.read           = vivi_read,
	.poll		= vivi_poll,
	.ioctl          = video_ioctl2, /* V4L2 ioctl handler */
	.mmap           = vivi_mmap,
};
static const struct v4l2_ioctl_ops vivi_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_s_std         = vidioc_s_std,
	.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,
	.vidioc_queryctrl     = vidioc_queryctrl,
	.vidioc_g_ctrl        = vidioc_g_ctrl,
	.vidioc_s_ctrl        = vidioc_s_ctrl,
};

上面已经介绍了vivi.c大概做了什么事了,接下来我们按照v4l2的应用编写流程来具体分析每个回调函数的实现细节

这篇文章深入学习Linux摄像头(一)v4l2应用编程对v4l2应用编程作了详解的讲解

v4l2的操作流程

  • 查询设备功能(VIDIOC_QUERYCAP)
  • 枚举像素格式(VIDIOC_ENUM_FMT)
  • 设置像素格式(VIDIOC_S_FMT)
  • 申请缓存(VIDIOC_REQBUFS)
  • 映射缓存(mmap)
  • 缓存入队列(VIDIOC_QBUF)
  • 打开流(VIDIOC_STREAMON)
  • 等待数据可读(poll)
  • 缓存出队列(VIDIOC_DQBUF)

下面按照这些流程来分析虚拟摄像头驱动

  • VIDIOC_QUERYCAP

    返回设备的功能

    static int vidioc_querycap(struct file *file, void  *priv,
    					struct v4l2_capability *cap)
    {
        cap->version = VIVI_VERSION;
    	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING | \
    			    V4L2_CAP_READWRITE;
    }
    

    V4L2_CAP_VIDEO_CAPTURE:表示捕获设备

    V4L2_CAP_STREAMING:数据的读取支持流形式

    V4L2_CAP_READWRITE:数据的读取支持read/write操作

  • VIDIOC_ENUM_FMT

    枚举设备支持的像素格式

    static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
    					struct v4l2_fmtdesc *f)
    {
        fmt = &formats[f->index];
        strlcpy(f->description, fmt->name, sizeof(f->description));
        f->pixelformat = fmt->fourcc;
    }
    

    从代码中可以看到,根据下表从formats数组中获取一项,然后将结果返回

    看一看formats,表示vivi支持的像素格式

    static struct vivi_fmt formats[] = {
    	{
    		.name     = "4:2:2, packed, YUYV",
    		.fourcc   = V4L2_PIX_FMT_YUYV,
    		.depth    = 16,
    	},
    	{
    		.name     = "4:2:2, packed, UYVY",
    		.fourcc   = V4L2_PIX_FMT_UYVY,
    		.depth    = 16,
    	},
    	{
    		.name     = "RGB565 (LE)",
    		.fourcc   = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
    		.depth    = 16,
    	},
    	{
    		.name     = "RGB565 (BE)",
    		.fourcc   = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
    		.depth    = 16,
    	},
    	{
    		.name     = "RGB555 (LE)",
    		.fourcc   = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
    		.depth    = 16,
    	},
    	{
    		.name     = "RGB555 (BE)",
    		.fourcc   = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
    		.depth    = 16,
    	},
    };
    
  • VIDIOC_S_FMT

    设置像素格式

    static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
    					struct v4l2_format *f)
    {
        struct vivi_dev *dev = video_drvdata(file);
        
        /* 测试是否支持此格式 */
        vidioc_try_fmt_vid_cap(file, priv, f);
        
        /* 设置好格式 */
        dev->fmt = get_format(f);
    }
    

    首先调用vidioc_try_fmt_vid_cap测试是否支持此格式

    如果支持就记录在vivi_dev中

    看一看vidioc_try_fmt_vid_cap

    static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
    			struct v4l2_format *f)
    {
        /* 判断是否能从formats数组中获取该像素 */
    	fmt = get_format(f);   
        if (!fmt)
            return -EINVAL;
        
        /* 对齐 */
        v4l_bound_align_image();
    }
    
  • VIDIOC_REQBUFS

    申请缓存

    static int vidioc_reqbufs(struct file *file, void *priv,
    			  struct v4l2_requestbuffers *p)
    {
        videobuf_reqbufs(&dev->vb_vidq, p);
    }
    

    通过调用videobuf提供的接口

    其中的dev->vb_vidq是在vivi_create_instance中初始化的struct videobuf_queue对象

    static int __init vivi_create_instance(int inst)
    {
        ...
        /* 初始化缓存队列 */
        videobuf_queue_vmalloc_init(&dev->vb_vidq, &vivi_video_qops, // 赋值和初始化
                                    NULL, &dev->slock, V4L2_BUF_TYPE_VIDEO_CAPTURE,
                                    V4L2_FIELD_INTERLACED,
                                    sizeof(struct vivi_buffer), dev);
        ...
    }
    

    看一看videobuf_reqbufs做了什么

    int videobuf_reqbufs(struct videobuf_queue *q,
    		 struct v4l2_requestbuffers *req)
    {
        count = req->count;
        
        /* 回到buf_setup函数获取buf的个数和大小 */
        q->ops->buf_setup(q, &count, &size);
        
        /* 申请缓存 */
        __videobuf_mmap_setup(q, count, size, req->memory);
    }
    

    其中的q->ops是在初始化缓存队列时设置的(videobuf_queue_vmalloc_init),内容如下

    static struct videobuf_queue_ops vivi_video_qops = {
    	.buf_setup      = buffer_setup,
    	.buf_prepare    = buffer_prepare,
    	.buf_queue      = buffer_queue,
    	.buf_release    = buffer_release,
    };
    

    我们看一看buffer_setup函数

    static int
    buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
    {
        /* 返回一帧图像的字节数 */
        *size = dev->width * dev->height * 2;
        
        /* 设置好缓存个数 */
    	while (*size * *count > vid_limit * 1024 * 1024)
    		(*count)--;
    }
    

    接下来看一看__videobuf_mmap_setup如何申请缓存

    int __videobuf_mmap_setup(struct videobuf_queue *q,
    			unsigned int bcount, unsigned int bsize,
    			enum v4l2_memory memory)
    {
    	for (i = 0; i < bcount; i++) {
         	q->bufs[i] = videobuf_alloc(q); //分配缓存
    		q->bufs[i]->i      = i; //缓存编号
            q->bufs[i]->boff = PAGE_ALIGN(bsize) * i; //缓存偏移量
        }
    }
    

    可以看到调用了videobuf_alloc分配缓存

    struct videobuf_buffer *videobuf_alloc(struct videobuf_queue *q)
    {
        q->int_ops->alloc(q->msize);
    }
    

    videobuf_alloc又通过回调函数来分配缓存,那么这个回调函数是在什么时候设置的呢?

    videobuf_queue_vmalloc_init初始化的时候

    videobuf_queue_vmalloc_init()
    {
    	videobuf_queue_core_init(..., &qops);
    }
    
    void videobuf_queue_core_init(..., struct videobuf_qtype_ops *int_ops)
    {
        q->int_ops   = int_ops;
    }
    

    可以看到int_ops被设置为&qops

    static struct videobuf_qtype_ops qops = {
    	.magic        = MAGIC_QTYPE_OPS,
    
    	.alloc        = __videobuf_alloc, //申请缓存
    	.iolock       = __videobuf_iolock,
    	.mmap_mapper  = __videobuf_mmap_mapper,
    	.vaddr        = videobuf_to_vmalloc, //得到缓存地址
    };
    

    所以videobuf_alloc最终会调用到qops__videobuf_alloc

    最后分配videobuf_buffer结构体,此时并未分配真正的视频缓存区

    static struct videobuf_buffer *__videobuf_alloc(size_t size)
    {
        struct videobuf_buffer *vb;
        vb = kzalloc(size + sizeof(*mem), GFP_KERNEL);
    }
    

    为什么分配内存要搞得如此复杂呢?

    因为并非所有视频设备都使用相同形式得缓存区,事实上至少有三种变化

    • 分散在物理和(内核)虚拟地址空间中的缓冲区
    • 物理上分散但实际上是连续的缓冲物
    • 物理上连续的缓冲区

    videobuf支持这三种形式,提供了三种操作函数集,分别在缓存队列的初始化时设置

    videobuf_queue_vmalloc_init()
    videobuf_queue_dma_contig_init()
    videobuf_queue_sg_init()
    
  • mmap

    映射缓存

    static int vivi_mmap(struct file *file, struct vm_area_struct *vma)
    {
        videobuf_mmap_mapper(&dev->vb_vidq, vma);
    }
    

    videobuf_mmap_mapper时videobuf提供得接口

    int videobuf_mmap_mapper(struct videobuf_queue *q, struct vm_area_struct *vma)
    {
        /* 根据偏移值找到缓存队列中对应的缓存 */
        for (i = 0; i < VIDEO_MAX_FRAME; i++) {
            struct videobuf_buffer *buf = q->bufs[i];
            if(buf->boff == (vma->vm_pgoff << PAGE_SHIFT))
                CALL(q, mmap_mapper, q, buf, vma); //找到调用函数
        }
    }
    

    CALL是一个宏定义,其定义如下

    #define CALL(q, f, arg...)						\
    	((q->int_ops->f) ? q->int_ops->f(arg) : 0)
    

    又回调到int_opsint_ops在缓存队列初始化的时候被设置为qops

    static struct videobuf_qtype_ops qops = {
    	.magic        = MAGIC_QTYPE_OPS,
    
    	.alloc        = __videobuf_alloc, //申请缓存
    	.iolock       = __videobuf_iolock,
    	.mmap_mapper  = __videobuf_mmap_mapper,
    	.vaddr        = videobuf_to_vmalloc, //得到缓存地址
    };
    

    所以最终会调用到__videobuf_mmap_mapper,此函数真正地分配了视频缓存区,并映射到用户空间

    static int __videobuf_mmap_mapper(struct videobuf_queue *q,
    				  struct videobuf_buffer *buf,
    				  struct vm_area_struct *vma)
    {
        mem->vmalloc = vmalloc_user(pages); //分配视频缓存区
        
        remap_vmalloc_range(vma, mem->vmalloc, 0); //映射
    }
    
  • VIDIOC_QBUF

    缓存入队列

    static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
    {
    	videobuf_dqbuf(&dev->vb_vidq, p,
    				file->f_flags & O_NONBLOCK);
    }
    

    调用videobuf提供的videobuf_dqbuf

    int videobuf_qbuf(struct videobuf_queue *q, struct v4l2_buffer *b)
    {
        /* 回调buf_prepare函数 */
        q->ops->buf_prepare(q, buf, field);
        
        /* 将缓存添加到缓存队列中 */
        list_add_tail(&buf->stream, &q->stream);
    }
    

    buf_prepare在缓存队列初始化的时候设置为

    static struct videobuf_queue_ops vivi_video_qops = {
    	.buf_setup      = buffer_setup,
    	.buf_prepare    = buffer_prepare,
    	.buf_queue      = buffer_queue,
    	.buf_release    = buffer_release,
    };
    
    static int
    buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
    						enum v4l2_field field)
    {
        /* 设置好图像格式 */
    	buf->fmt       = dev->fmt;
    	buf->vb.width  = dev->width;
    	buf->vb.height = dev->height;
        precalculate_bars(dev);
        precalculate_line(dev);
        
        /* 设置缓存状态 */
        buf->vb.state = VIDEOBUF_PREPARED;
    }
    
  • VIDIOC_STREAMON

    打开流

    static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
    {
        videobuf_streamon(&dev->vb_vidq);
        vivi_start_generating(file);
    }
    

    调用videobuf提供的videobuf_streamon设置好缓存的状态,准备生产数据

    调用vivi_start_generating开始生产数据

    下面好好分析vivi_start_generating函数

    static void vivi_start_generating(struct file *file)
    {
        /* 启动一个线程 */
        kthread_run(vivi_thread, dev, dev->v4l2_dev.name);
    }
    

    看一看线程函数,此函数负责生产图像数据

    static int vivi_thread(void *data)
    {
    	for (;;) {
    		vivi_sleep(dev); //只要队列中的buf被请求,那么就填充数据,然后唤醒等待队列
    	}
    }
    
    static void vivi_sleep(struct vivi_dev *dev)
    {   
        vivi_thread_tick(dev); //填充图像数据
        
        schedule_timeout_interruptible(timeout); //调度,等待超时或者被唤醒继续填充数据
    }
    
    static void vivi_thread_tick(struct vivi_dev *dev)
    {
        /* 取出队列的第一个buf */
    	buf = list_entry(dma_q->active.next,
    			 struct vivi_buffer, vb.queue);
        
        /* 填充buf数据,设置buf的状态VIDEOBUF_DONE; */
        vivi_fillbuff(dev, buf);
        
        /* 唤醒正在等待此缓存的进程 */
        wake_up(&buf->vb.done);
    }
    

    总结一下:vidioc_streamon会调用vivi_start_generating启动了一个线程,此线程会填充buf的图像数据,然后唤醒正在等待此buf的线程,最后睡眠等待超时或者被唤醒继续填充下一块buf的图像数据

  • poll

    等待缓存区有缓存准备好

    static unsigned int
    vivi_poll(struct file *file, struct poll_table_struct *wait)
    {
        videobuf_poll_stream(file, q, wait);
    }
    

    调用了videobuf提供的videobuf_poll_stream

    unsigned int videobuf_poll_stream(struct file *file,
    				  struct videobuf_queue *q,
    				  poll_table *wait)
    {
        struct videobuf_buffer *buf = NULL;
        
        /* 取得队列头的buf */
        buf = list_entry(q->stream.next, //得到队列头
                         struct videobuf_buffer, stream);
        
        /* 阻塞等待这个buf */
        poll_wait(file, &buf->done, wait);
    }
    

    看到其中回调用poll_wait(file, &buf->done, wait)去等待这个buf,而在我们上面中讲到在vivi_thread中,只要填充完buf的数据后,就会唤醒等待这个buf的进程

  • VIDIOC_DQBUF

    缓存出队列

    static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
    {
    	videobuf_dqbuf(&dev->vb_vidq, p,
    				file->f_flags & O_NONBLOCK);
    }
    

    会调用videobuf提供的videobuf_dqbuf

    int videobuf_dqbuf(struct videobuf_queue *q,
    		   struct v4l2_buffer *b, int nonblocking)
    {
        /* 拿出队列的第一个buf */
        stream_next_buffer(q, &buf, nonblocking);
        
        /* 判断buf的状态是否是VIDEOBUF_DONE */
        switch (buf->state) {
            ...
            case VIDEOBUF_DONE:    	
        	...
        }
         
        /* 返回信息给用户空间 */
        videobuf_status(q, b, buf, q->type);
        
        /* 从队列中删除,设置buf的状态 */
        list_del(&buf->stream);
        buf->state = VIDEOBUF_IDLE;
    }
    

    应用层得到buf的信息后,可以知道buf的编号,然后从之前mmap的缓存里取出队列的缓存读取图像的数据,处理完之后再次将缓存放入缓存队列中(VIDIOC_QBUF)

至此,vivi就分析完成了

  • 13
    点赞
  • 55
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
嵌入式Linux摄像头驱动是一种用于在嵌入式系统中实现对摄像头设备的控制和操作的软件模块。它是实现摄像头与嵌入式系统之间通信的桥梁,使嵌入式系统能够捕捉图像、录制视频以及进行图像处理等操作。 嵌入式Linux摄像头驱动的工作原理如下: 1. 设备识别与初始化:在嵌入式系统启动时,摄像头驱动会被加载到内核中,并通过设备树等机制识别出摄像头硬件,并对其进行初始化和配置。 2. 图像采集:驱动会根据设定的参数配置摄像头,通过调用摄像头的接口采集图像数据。采集过程中可能会进行自动曝光、自动白平衡等操作,以确保获得高质量的图像。 3. 图像处理与传输:采集到的图像数据会经过图像处理算法进行增强、滤波等处理,然后将处理后的数据传输给上层应用程序进行进一步的处理或展示。 4. 控制与配置:驱动可以提供接口供应用程序控制和配置摄像头的属性,例如调整摄像头的焦距、曝光时间等参数,以满足不同应用场景的需求。 5. 错误处理与异常情况处理:驱动会检测并处理摄像头硬件故障、数据传输错误等异常情况,保证系统的稳定运行。 嵌入式Linux摄像头驱动的开发需要熟悉嵌入式Linux内核的架构和编程,掌握相关摄像头芯片的技术文档和驱动接口规范。同时,还需要了解摄像头工作原理和图像处理算法等知识。 总结起来,嵌入式Linux摄像头驱动是一种关键的软件模块,实现了嵌入式系统对摄像头设备的控制和操作,为嵌入式系统提供了图像采集、处理和传输的能力,应用广泛于安防监控、工业检测、智能家居等领域。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值