V4L2驱动程序架构

1 V4L2简介

video4linux2(V4L2)是Linux内核中关于视频设备的内核驱动，它为Linux中视频设备访问提供了通用接口，在Linux系统中，V4L2驱动的Video设备节点路径通常/dev/video/中的videoX
V4L2驱动对用户空间提供字符设备，主设备号为81，对于视频设备，其次设备号为0-63。除此之外，次设备号为64-127的Radio设备，次设备号为192-223的是Teletext设备,次设备号为224-255的是VBI设备
V4L2驱动的Video设备在用户空间通过各种ioctl调用进行控制，并且可以使用mmap进行内存映射

1.1 V4L2驱动主要使用的ioctl

命令值如下所示：

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

#define VIDIOC_QUERYCAP _IOR('V', 0, struct v4l2_capability)  /*查询能力*/#define VIDIO_G_FMT _IOWR('V', 4, struct v4l2_format) /*获得格式*/#define VIDIOC_S_FMT _IOWR('V', 5, struct v4l2_format) /*设置格式*/#define VIDIOC_REQBUFS _IOWR('V', 8, strut v4l2_requestbuffers) /*申请内存*/#define VIDIOC_G_FBUF _IOW('V', 10, struct v4l2_framebuffer) /*获得Framebuffer*/#define VIDIOC_S_BUF _IOW('V', 11, struct v4l2_framebuffer) /*设置Framebuffer*/#define VIDIOC_OVERLAY _IOW('V', 14, int) /*设置Overlay*/#define VIDIOC_QBUF _IOWR('V', 15, struct v4l2_buffer) /*将内存加入队列*/#define VIDIOC_DQBUF _IOWR('V', 17, strut v4l2_buffer) /*从队列取出内存*/#define VIDIOC_STREAMON _IOW('V', 18, int) /*开始流*/#define VIDIOC_STREAMOFF _IOW('V', 19, int) /*停止流*/#define VIDIOC_G_CTRL _IOWR('V', 27, struct v4l2_control) /*得到控制*/#define VIDIOC_S_CTRL _IOWR('V', 28, struct v4l2_control) /*设置控制*/---------------------------------------------------------------------

1.2 重要结构

头文件 include/linux/videodev2.h

include/media/v4l2-dev.h

V4L2驱动核心实现文件：driver/media/video/v4l2-dev.c

v4l2-dev.h中定义的video_device是V4L2驱动程序的核心数据结构

struct video_device{const struct v4l2_file_operations *fops;struct cdev *cdev;//字符设备struct device *parent;//父设备struct v4l2_device *v4l2_dev;//父v4l2_devicechar name[32];//名称int vfl_type;//类型int minor;//次设备号/*释放回调*/void (*release)(struct video_device *vdev);/*ioctl回调*/const struct v4l2_ioctl_ops *ioctl_ops;}常用的结构参见/include/linux/videodev2.h1)设备能力结构struct v4l2_capability{__u8 driver[16];//驱动名__u8 card[32];//例如Hauppauge winTV__u8 bus_info[32];//PCI总线信息__u32 version;//内核版本__u32 capabilities;//设备能力__u32 reserved[4];};2)数据格式结构struct v4l2_format{enum v4l2_buf_type type;//本结构的数据类型};3)像素格式结构struct v4l2_pix_format{__u32width;//宽度__u32height;//高度}4)请求缓冲struct v4l2_requestbuffers{__u32count;//缓存数量enum v4l2_buf_type type;//数据流类型}5)数据流类型包括V4L2_MEMORY_MMAP和V4L2_MEMORY_USERPTRenum v4l2_memory{};

2 V4L2驱动注册

2.1 video_register_device

video4linux2驱动程序的注册drivers/media/video

video_register_device函数用来注册一个v4l驱动程序

int video_register_device(struct video_device *vdev, int type, int nr){return __video_register_device(vdev, type, nr, 1);}其中参数type支持的类型如下#define VFL_TYPE_GRABBER 0//视频#defineVFL_TYPE_VBI1//从视频消隐的时间取得信息的设备#define VFL_TYPE_RADIO2 //广播#define VFL_TYPE_VTX3//视传设备#defineVFL_TYPE_MAX4//最大值----------------->返回调用 __video_register_device()__video_register_device 函数先检查设备类型，接下来寻找一个可用的子设备号，最后注册相应的字符设备static int __video_register_device(struct video_device *vdev, int type, int nr, int warn_if_nr_in_use){switch (type) {case VFL_TYPE_GRABBER:minor_offset = 0;minor_cnt = 64;break;case VFL_TYPE_RADIO:minor_offset = 64;minor_cnt = 64;break;case VFL_TYPE_VTX:minor_offset = 192;minor_cnt = 32;break;case VFL_TYPE_VBI:minor_offset = 224;minor_cnt = 32;break;nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);}nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);vdev->cdev->ops = &v4l2_fops;//注册字符设备ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);ret = device_register(&vdev->dev);//注册完毕设备信息存储在video_device数组中mutex_lock(&videodev_lock);video_device[vdev->minor] = vdev;mutex_unlock(&videodev_lock);}

2.2 v4l2_fops接口

v4l2_fops为video4linux2设备提供了统一的应用层接口，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,.unlocked_ioctl = v4l2_ioctl,.release = v4l2_release,.poll = v4l2_poll,.llseek = no_llseek,};v4l2_fops中的成员函数最终要调用struct video_device->fops中相应的成员struct video_device->fops是具体video4linux2摄像头驱动程序必须实现的接口static ssize_t v4l2_read(struct file *filp, char __user *buf, size_t sz, loff_t *off){return vdev->fops->read(filp, buf, sz, off);}

2.3 /drivers/media/video/samsung/fimc/s3c_fimc_core.c

驱动探测函数s3c_fimc_probe定义

static int s3c_fimc_probe(struct platform_device *dev){ctrl = s3c_fimc_register_controller(pdev);clk_enable(ctrl->clock);//使能时钟//注册V4L2驱动ret = video_register_device(ctrl->vd, VFL_TYPE_GRABBER, ctrl->id);}s3c_fimc_register_contoller函数主要用来分配资源与申请中断static struct s3c_fimc_control *s3c_fimc_register_controller(struct platform_device *pdev){ctrl->vd = &s3c_fimc_video_device[id];//申请中断ctrl->irq = platform_get_irq(pdev, 0);if(request_irq(ctrl->irq, s3c_fimc_irq, IRQF_DISABLED, ctrl->name, ctrl))};struct video_device s3c_fimc_video_device[S3C_FIMC_MAX_CTRLS] = {[0] = {.vfl_type = VID_TYPE_OVERLAY | VID_TYPE_CAPTURE | VID_TYPE_CLIPPING | VID_TYPE_SCALES,.fops = &s3c_fimc_fops,.ioctl_ops = &s3c_fimc_v4l2_ops,.release  = s3c_fimc_vdev_release,.name = "sc3_video0",},}s3c_fimc_v4l2_ops,是在drivers/media/video/samsung/fimc中实现的v4l2_ioctl_ops，在用户空间进行ioctl等调用时，要调用到具体实现的各个函数指针

3 V4L2 操作

3.1 s3c_fimc_open

static int s3c_fimc_open(struct file *filp){struct s3c_fimc_control *ctrl;int id, ret;id =0;ctrl = &s3c_fimc.ctrl[id];mutex_lock(&ctrl->lock);if (atomic_read(&ctrl->in_use)) {ret = -EBUSY;goto resource_busy;} else {atomic_inc(&ctrl->in_use);s3c_fimc_reset(ctrl);filp->private_data = ctrl;}mutex_unlock(&ctrl->lock);return 0;resource_busy:mutex_unlock(&ctrl->lock);return ret;}用户空间打开设备文件fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);

3.2 获取设备的capability,查看设备有什么功能

1）结构体

struct v4l2_capability cap;ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);/include/linux/videodev2.hstruct v4l2_capability {__u8driver[16];/* i.e. "bttv" */__u8card[32];/* i.e. "Hauppauge WinTV" */__u8bus_info[32];/* "PCI:" + pci_name(pci_dev) */__u32   version;        /* should use KERNEL_VERSION() */__u32capabilities;/* Device capabilities */__u32reserved[4];};驱动实现static int s3c_fimc_v4l2_querycap(struct file *filp, void *fh,struct v4l2_capability *cap){struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;strcpy(cap->driver, "Samsung FIMC Driver");strlcpy(cap->card, ctrl->vd->name, sizeof(cap->card));sprintf(cap->bus_info, "FIMC AHB-bus");cap->version = 0;cap->capabilities = (V4L2_CAP_VIDEO_OVERLAY | \V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING);return 0;}应用层调用static int video_capability(int fd){int ret = 0;/***********get the device capability********/struct v4l2_capability cap;ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);if (ret < 0) {perror("VIDIOC_QUERYCAP failed ");return ret;}printf("\n****Capability informations****\n");printf("driver:   %s\n", cap.driver);if (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)printf("Capture capability is supported\n");if (cap.capabilities & V4L2_CAP_STREAMING) printf("Streaming capability is supported\n");if (cap.capabilities & V4L2_CAP_VIDEO_OVERLAY) printf("Overlay capability is supported\n");return 0;}

3.3 选择视频输入，一个视频设备可以有多个视频输入

结构体struct v4l2_input input;int index;得到INPUTret = ioctl(fd, VIDIOC_G_INPUT, &index);input.index = index;列举INPUTret = ioctl(fd, VIDIOC_ENUMINPUT, &input);设置INPUTret = ioctl(fd, VIDIOC_S_INPUT, &index);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     capabilities;__u32     reserved[3];};Ioctl: VIDIOC_S_INPUT This IOCTL takes pointer to integer containing index of the input which has to be set. Application will provide the index number as an argument.     0 - Composite input,    1 - S-Video input.驱动static int s3c_fimc_v4l2_s_input(struct file *filp, void *fh,unsigned int i){struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;if (i >= S3C_FIMC_MAX_INPUT_TYPES)return -EINVAL;ctrl->v4l2.input = &s3c_fimc_input_types[i];if (s3c_fimc_input_types[i].type == V4L2_INPUT_TYPE_CAMERA)ctrl->in_type = PATH_IN_ITU_CAMERA;elsectrl->in_type = PATH_IN_DMA;return 0;}static struct v4l2_input s3c_fimc_input_types[] = {{.index= 0,.name= "External Camera Input",.type= V4L2_INPUT_TYPE_CAMERA,.audioset= 1,.tuner= 0,.std= V4L2_STD_PAL_BG | V4L2_STD_NTSC_M,.status= 0,}, {.index= 1,.name= "Memory Input",.type= V4L2_INPUT_TYPE_MEMORY,.audioset= 2,.tuner= 0,.std= V4L2_STD_PAL_BG | V4L2_STD_NTSC_M,.status= 0,}};static int s3c_fimc_v4l2_enum_input(struct file *filp, void *fh,struct v4l2_input *i){if (i->index >= S3C_FIMC_MAX_INPUT_TYPES)return -EINVAL;memcpy(i, &s3c_fimc_input_types[i->index], sizeof(struct v4l2_input));return 0;}应用static int video_input(int fd){/***********get and set the VIDIO INPUT********/int ret = 0;struct v4l2_input input;//视频输入信息，对应命令VIDIOC_ENUMINPUT int index;index = 0;    //0 - Composite input, 1 - S-Video input.   ret = ioctl (fd, VIDIOC_S_INPUT, &index);if (ret < 0) {perror ("VIDIOC_S_INPUT");return ret;}input.index = index;ret = ioctl (fd, VIDIOC_ENUMINPUT, &input);if (ret < 0){perror ("VIDIOC_ENUMINPUT");return ret;}printf("\n****input informations****\n");printf("name of the input = %s\n", input.name);return 0;}

3.4 遍历所有视频格式,查询驱动所支持的格式

结构struct v4l2_fmtdes fmtdes;ret = ioctl(fd, VIDIOC_ENUM_FMT, &fmtdes);struct v4l2_fmtdesc {__u32    index;             /* Format number      */enum v4l2_buf_type  type;              /* buffer type        */__u32               flags;__u8    description[32];   /* Description string */__u32    pixelformat;       /* Format fourcc      */__u32    reserved[4];};驱动static int s3c_fimc_v4l2_enum_fmt_vid_cap(struct file *filp, void *fh,struct v4l2_fmtdesc *f){struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;int index = f->index;if (index >= S3C_FIMC_MAX_CAPTURE_FORMATS)return -EINVAL;memset(f, 0, sizeof(*f));memcpy(f, ctrl->v4l2.fmtdesc + index, sizeof(*f));return 0;}#define S3C_FIMC_MAX_CAPTURE_FORMATSARRAY_SIZE(s3c_fimc_capture_formats)const static struct v4l2_fmtdesc s3c_fimc_capture_formats[] = {{.index= 0,.type= V4L2_BUF_TYPE_VIDEO_CAPTURE,.flags= FORMAT_FLAGS_PLANAR,.description= "4:2:0, planar, Y-Cb-Cr",.pixelformat= V4L2_PIX_FMT_YUV420,},{.index= 1,.type= V4L2_BUF_TYPE_VIDEO_CAPTURE,.flags= FORMAT_FLAGS_PLANAR,.description= "4:2:2, planar, Y-Cb-Cr",.pixelformat= V4L2_PIX_FMT_YUV422P,},{.index= 2,.type= V4L2_BUF_TYPE_VIDEO_CAPTURE,.flags= FORMAT_FLAGS_PACKED,.description= "4:2:2, packed, YCBYCR",.pixelformat= V4L2_PIX_FMT_YUYV,},{.index= 3,.type= V4L2_BUF_TYPE_VIDEO_CAPTURE,.flags= FORMAT_FLAGS_PACKED,.description= "4:2:2, packed, CBYCRY",.pixelformat= V4L2_PIX_FMT_UYVY,}};const static struct v4l2_fmtdesc s3c_fimc_overlay_formats[] = {{.index= 0,.type= V4L2_BUF_TYPE_VIDEO_OVERLAY,.flags= FORMAT_FLAGS_PACKED,.description= "16 bpp RGB, le",.pixelformat= V4L2_PIX_FMT_RGB565,},{.index= 1,.type= V4L2_BUF_TYPE_VIDEO_OVERLAY,.flags= FORMAT_FLAGS_PACKED,.description= "24 bpp RGB, le",.pixelformat= V4L2_PIX_FMT_RGB24,},};应用层static int video_fmtdesc(int fd){/***********Format Enumeration************/int ret = 0;struct v4l2_fmtdesc fmtdes;CLEAR(fmtdes);fmtdes.index = 0;fmtdes.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;printf("\n**********vidioc enumeration stream format informations:****\n");while (1) {ret = ioctl(fd, VIDIOC_ENUM_FMT, &fmtdes);if (ret < 0) break; printf("{ pixelformat = %c%c%c%c, description = %s }\n",(fmtdes.pixelformat & 0xFF),(fmtdes.pixelformat >> 8) & 0xFF,(fmtdes.pixelformat >> 16) & 0xFF, (fmtdes.pixelformat >> 24) & 0xFF,fmtdes.description);if (fmtdes.type == V4L2_BUF_TYPE_VIDEO_CAPTURE)printf("video capture type:\n");if (fmtdes.pixelformat == V4L2_PIX_FMT_YUYV)printf("V4L2_PIX_FMT_YUYV\n");fmtdes.index++;}return 0;}

3.5 设置视频捕获格式（重要）

结构体帧格式包括宽度和高度struct v4l2_format fmt;ret = ioctl(fd, VIDIOC_S_FMT, &fmt);struct v4l2_format {enum v4l2_buf_type type;//数据流类型，必须是V4L2_BUF_TYPE_VIDEO_CAPTUREunion {struct v4l2_pix_formatpix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */struct v4l2_windowwin;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */struct v4l2_vbi_formatvbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */struct v4l2_sliced_vbi_formatsliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */__u8raw_data[200];                   /* user-defined */} fmt;};struct v4l2_pix_format{__u32 pixelformat;//视频数据存储类型，例如是YUV4:2:2还是RGB}驱动static int s3c_fimc_v4l2_s_fmt_vid_cap(struct file *filp, void *fh,struct v4l2_format *f){struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;ctrl->v4l2.frmbuf.fmt = f->fmt.pix;if (f->fmt.pix.priv == V4L2_FMT_IN)s3c_fimc_set_input_frame(ctrl, &f->fmt.pix);elses3c_fimc_set_output_frame(ctrl, &f->fmt.pix);return 0;}int s3c_fimc_set_input_frame(struct s3c_fimc_control *ctrl,struct v4l2_pix_format *fmt){s3c_fimc_set_input_format(ctrl, fmt);return 0;}static void s3c_fimc_set_input_format(struct s3c_fimc_control *ctrl,struct v4l2_pix_format *fmt){struct s3c_fimc_in_frame *frame = &ctrl->in_frame;frame->width = fmt->width;frame->height = fmt->height;switch (fmt->pixelformat) {case V4L2_PIX_FMT_RGB565:frame->format = FORMAT_RGB565;frame->planes = 1;break;case V4L2_PIX_FMT_RGB24:frame->format = FORMAT_RGB888;frame->planes = 1;break;case V4L2_PIX_FMT_NV12:frame->format = FORMAT_YCBCR420;frame->planes = 2;frame->order_2p = LSB_CBCR;break;case V4L2_PIX_FMT_NV21:frame->format = FORMAT_YCBCR420;frame->planes = 2;frame->order_2p = LSB_CRCB;break;case V4L2_PIX_FMT_NV12X:frame->format = FORMAT_YCBCR420;frame->planes = 2;frame->order_2p = MSB_CBCR;break;case V4L2_PIX_FMT_NV21X:frame->format = FORMAT_YCBCR420;frame->planes = 2;frame->order_2p = MSB_CRCB;break;case V4L2_PIX_FMT_YUV420:frame->format = FORMAT_YCBCR420;frame->planes = 3;break;case V4L2_PIX_FMT_YUYV:frame->format = FORMAT_YCBCR422;frame->planes = 1;frame->order_1p = IN_ORDER422_YCBYCR;break;case V4L2_PIX_FMT_YVYU:frame->format = FORMAT_YCBCR422;frame->planes = 1;frame->order_1p = IN_ORDER422_YCRYCB;break;case V4L2_PIX_FMT_UYVY:frame->format = FORMAT_YCBCR422;frame->planes = 1;frame->order_1p = IN_ORDER422_CBYCRY;break;case V4L2_PIX_FMT_VYUY:frame->format = FORMAT_YCBCR422;frame->planes = 1;frame->order_1p = IN_ORDER422_CRYCBY;break;case V4L2_PIX_FMT_NV16:frame->format = FORMAT_YCBCR422;frame->planes = 2;frame->order_1p = LSB_CBCR;break;case V4L2_PIX_FMT_NV61:frame->format = FORMAT_YCBCR422;frame->planes = 2;frame->order_1p = LSB_CRCB;break;case V4L2_PIX_FMT_NV16X:frame->format = FORMAT_YCBCR422;frame->planes = 2;frame->order_1p = MSB_CBCR;break;case V4L2_PIX_FMT_NV61X:frame->format = FORMAT_YCBCR422;frame->planes = 2;frame->order_1p = MSB_CRCB;break;case V4L2_PIX_FMT_YUV422P:frame->format = FORMAT_YCBCR422;frame->planes = 3;break;}}应用层static int video_setfmt(int fd){  /***********set Stream data format********/  int ret = 0;  struct v4l2_format fmt;CLEAR(fmt);fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;fmt.fmt.pix.width =640;fmt.fmt.pix.height  = 480;fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;//for PALfmt.fmt.pix.field = V4L2_FIELD_INTERLACED;ret = ioctl(fd, VIDIOC_S_FMT, &fmt);if (ret < 0) {perror("VIDIOC_S_FMT");return ret;}return 0;}

3.6 视频格式查询

在v4l2中，有两种查询视频格式的方法，一个是遍历所有视频格式的

一个是查询出一种格式的

/*查询出一种格式*/

ret = ioctl(fd, VIDIOC_G_FMT, &fmt);

/*遍历所有视频格式,查询驱动所支持的格式*/

VIDIOC_ENUM_FMT

驱动static int s3c_fimc_v4l2_g_fmt_vid_cap(struct file *filp, void *fh,struct v4l2_format *f){struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;int size = sizeof(struct v4l2_pix_format);memset(&f->fmt.pix, 0, size);memcpy(&f->fmt.pix, &(ctrl->v4l2.frmbuf.fmt), size);return 0;}应用static int video_getfmt(int fd){/***********get Stream data format********/int ret= 0;struct v4l2_format fmt;CLEAR(fmt);fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;ret = ioctl(fd, VIDIOC_G_FMT, &fmt);if (ret < 0) {perror("VIDIOC_G_FMT");return ret;}printf("/n**********vidioc get stream format informations:****\n");if (fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV)printf("8-bit YUYVV pixel format\n");printf("Size of the buffer = %d\n", fmt.fmt.pix.sizeimage);printf("Line offset = %d\n", fmt.fmt.pix.bytesperline);if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED)printf("Storate format is interlaced frame format\n");return 0;}

3.7 向驱动申请帧缓冲，内存，一般不超过5个,帧缓冲管理

结构体struct v4l2_requestbuffers req;ret = ioctl(fd, VIDIOC_REQBUFS, &req);ret = ioctl(fd, VIDIOC_QUERYBUF, &buf);//读取缓存struct v4l2_requestbuffers {__u32count;enum v4l2_buf_type      type;enum v4l2_memory        memory;__u32reserved[2];};struct v4l2_buffer {__u32index;enum v4l2_buf_type      type;__u32bytesused;__u32flags;enum v4l2_fieldfield;struct timevaltimestamp;struct v4l2_timecodetimecode;__u32sequence;/* memory location */enum v4l2_memory        memory;union {__u32           offset;unsigned long   userptr;} m;__u32length;__u32input;__u32reserved;};使用VIDIOC_REQBUFS 我们获取了req.count个缓存，下一步通过调用VIDIOC_QUERYBUF 命令来获取这些缓存的地址，然后使用mmap函数转换成应用程序中的绝对地址，最后把这些缓存放入缓存队列。The main steps that the application must perform for buffer allocation are: Allocating Memory Getting Physical Address Mapping Kernel Space Address to User Space 驱动支持static int s3c_fimc_v4l2_reqbufs(struct file *filp, void *fh,struct v4l2_requestbuffers *b){if (b->memory != V4L2_MEMORY_MMAP) {err("V4L2_MEMORY_MMAP is only supported\n");return -EINVAL;}/* control user input */if (b->count > 4)b->count = 4;else if (b->count < 1)b->count = 1;return 0;}static int s3c_fimc_v4l2_querybuf(struct file *filp, void *fh,struct v4l2_buffer *b){struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;if (b->type != V4L2_BUF_TYPE_VIDEO_OVERLAY && \b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)return -EINVAL;if (b->memory != V4L2_MEMORY_MMAP)return -EINVAL;b->length = ctrl->out_frame.buf_size;/* * NOTE: we use the m.offset as an index for multiple frames out. * Because all frames are not contiguous, we cannot use it as * original purpose. * The index value used to find out which frame user wants to mmap. */b->m.offset = b->index * PAGE_SIZE;return 0;}static int s3c_fimc_v4l2_qbuf(struct file *filp, void *fh,struct v4l2_buffer *b){return 0;}应用层static int video_mmap(int fd){/*******step 1*****requestbuffers Allocating Memory *******/int ret = 0;struct v4l2_requestbuffers req;CLEAR(req);req.count = 4;req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;req.memory = V4L2_MEMORY_MMAP;ret = ioctl(fd, VIDIOC_REQBUFS, &req);if (ret < 0) {perror("VIDIOC_REQBUFS");return ret;}if (req.count < 2)printf("insufficient buffer memory\n");printf("Number of buffers allocated = %d\n", req.count);/*******step 2*****Getting Physical Address  *******/buffers = calloc(req.count, sizeof(*buffers));for (n_buffers = 0; n_buffers < req.count; ++n_buffers){struct v4l2_buffer buf;//驱动中的一帧CLEAR(buf);buf.type= V4L2_BUF_TYPE_VIDEO_CAPTURE;buf.memory  = V4L2_MEMORY_MMAP;buf.index= n_buffers;ret = ioctl(fd, VIDIOC_QUERYBUF, &buf);if (ret < 0) {perror("VIDIOC_QUERYBUF");return ret;}/*******step 3*****Mapping Kernel Space Address to User Space*******/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)//perror("mmap failed \n");}/************requestbuffers in queue***********/for (i = 0; i < n_buffers; ++i) {struct v4l2_buffer buf;CLEAR(buf);buf.type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;buf.memory= V4L2_MEMORY_MMAP;buf.index = i;ret = ioctl(fd, VIDIOC_QBUF, &buf);//申请的缓冲进入队列if (ret < 0) {perror("VIDIOC_QBUF");return ret;}}return 0;}

3.8 开始捕捉图像数据(重要)

结构体
enum v4l2_buf_type type;//开始捕捉图像数据type = V4L2_BUF_TYPE_VIDEO_CAPTURE;ret = ioctl(fd, VIDIOC_STREAMON, &type);enum v4l2_buf_type {V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,V4L2_BUF_TYPE_VBI_CAPTURE          = 4,V4L2_BUF_TYPE_VBI_OUTPUT           = 5,V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,#if 1/* Experimental */V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,#endifV4L2_BUF_TYPE_PRIVATE              = 0x80,};驱动static int s3c_fimc_v4l2_streamon(struct file *filp, void *fh,enum v4l2_buf_type i){struct s3c_fimc_control *ctrl = (struct s3c_fimc_control *) fh;if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)return -EINVAL;printk("s3c_fimc_v4l2_streamon is called\n");if (ctrl->in_type != PATH_IN_DMA)s3c_fimc_init_camera(ctrl);ctrl->out_frame.skip_frames = 0;FSET_CAPTURE(ctrl);FSET_IRQ_NORMAL(ctrl);s3c_fimc_start_dma(ctrl);return 0;}硬件控制寄存器的配置应用层static int video_streamon(int fd){int ret = 0;/************start stream on***********/enum v4l2_buf_type types;//开始捕捉图像数据types = V4L2_BUF_TYPE_VIDEO_CAPTURE;ret = ioctl(fd, VIDIOC_STREAMON, &types);if (ret < 0) {perror("VIDIOC_STREAMON");return ret;}return 0;}