Video for Linux two(Video4Linux2)简称V4L2，是V4L的改进版。V4L2是linux操作系统下用于采集图片、视频和音频数据的API接口，配合适当的视频采集设备和相应的驱动程序，可以实现图片、视频、音频等的采集。在远程会议、可视电话、视频监控系统和嵌入式多媒体终端中都有广泛的应用。 　　一、Video for Linux two 　　在Linux下，所有外设都被看成一种特殊的文件，成为“设备文件”，可以象访问普通文件一样对其进行读写。一般来说，采用V4L2驱动的摄像头设备文件是/dev/v4l/video0。为了通用，可以建立一个到/dev/video0的链接。V4L2支持两种方式来采集图像：内存映射方式(mmap)和直接读取方式(read)。V4L2在include/linux/videodev.h文件中定义了一些重要的数据结构，在采集图像的过程中，就是通过对这些数据的操作来获得最终的图像数据。Linux系统V4L2的能力可在Linux内核编译阶段配置，默认情况下都有此开发接口。V4L2从Linux 2.5.x版本的内核中开始出现。 　　V4L2规范中不仅定义了通用API元素(Common API Elements)，图像的格式(Image Formats)，输入/输出方法(Input/Output)，还定义了Linux内核驱动处理视频信息的一系列接口(Interfaces)，这些接口主要有： 　　视频采集接口——Video Capture Interface; 　　视频输出接口—— Video Output Interface; 　　视频覆盖/预览接口——Video Overlay Interface; 　　视频输出覆盖接口——Video Output Overlay Interface; 　　编解码接口——Codec Interface。 　　二、应用程序通过V4L2进行视频采集的原理 　　V4L2支持内存映射方式(mmap)和直接读取方式(read)来采集数据，前者一般用于连续视频数据的采集，后者常用于静态图片数据的采集，本文重点讨论内存映射方式的视频采集。 　　应用程序通过V4L2接口采集视频数据分为五个步骤： 　　首先，打开视频设备文件，进行视频采集的参数初始化，通过V4L2接口设置视频图像的采集窗口、采集的点阵大小和格式; 　　其次，申请若干视频采集的帧缓冲区，并将这些帧缓冲区从内核空间映射到用户空间，便于应用程序读取/处理视频数据; 　　第三，将申请到的帧缓冲区在视频采集输入队列排队，并启动视频采集; 　　第四，驱动开始视频数据的采集，应用程序从视频采集输出队列取出帧缓冲区，处理完后，将帧缓冲区重新放入视频采集输入队列，循环往复采集连续的视频数据; 　　第五，停止视频采集。 　　1.视频采集的参数初始化 　　在Linux下，摄像头硬件已经被映射为设备文件“/dev/video0”，用open函数打开这个设备文件，获得其文件描述符fd_v4l2，然后对这个文件描述符进行参数初始化。 　　(1) 设置视频的采集窗口参数 　　设置采集窗口就是在摄像头设备的取景范围之内设定一个视频采集区域。主要是对结构体v4l2_crop赋值，v4l2_crop由一个v4l2_buffer_type枚举类型的type和v4l2_rect类型的结构体c构成，来描述视频采集窗口的类型和大小。type设置为视频采集类型V4L2_BUF_TYPE_VIDEO_CAPTURE。c是表示采集窗口的大小的结构体，它的成员Left和Top分别表示视频采集区域的起始横坐标和纵坐标，width和height分别表示采集图像的宽度和高度。赋值后，用ioctl函数通过这个结构体对fd_v4l2进行设置。 　　struct v4l2_crop { enum v4l2_buf_type type; 　　struct v4l2_rect c; 　　}; 　　(2)设置视频点阵格式和点阵大小 　　主要是对结构体v4l2_format进行赋值，它由type和联合体fmt构成，来描述视频设备当前行为和数据的格式。 　　把type赋值为视频采集类型V4L2_BUF_TYPE_VIDEO_CAPTURE，表示定义了一个视频采集流类型的buffer。fmt中，pix为表示图形格式的v4l2_pix_format型结构体。需要设定pix里的几个变量，pixelformat表示采集格式，设置为V4L2_PIX_FMT_YUV420;width、height表示图像的宽度、高度，以字节为单位;sizeimage表示图像所占的存储空间大小，以字节为单位;bytesperline表示每一行的字节数。赋值后，用ioctl函数通过这个结构体对fd_ v4l2进行设置。 　　struct v4l2_format 　　{ enum v4l2_buf_type type; 　　union 　　{ struct v4l2_pix_format pix; // V4L2_BUF_TYPE_VIDEO_CAPTURE 　　struct v4l2_window win; // V4L2_BUF_TYPE_VIDEO_OVERLAY 　　__u8 raw_data[200]; // user-defined 　　} fmt; 　　}; 　　(3)设置视频采集的帧率 　　结构体v4l2_streamparm来描述视频流的属性，它由type和联合体parm构成。type同上，由于选的是V4L2_BUF_TYPE_VIDEO_CAPTURE，所以仅需设定parm中的v412_capture型结构体capture即可。在其中， v4l2_fract型结构体timeperframe表示平均每一帧所占的时间，由其元素numerator和denominator共同决定，该时长为numerator/denominator;而capturemode则表示采集模式，采集高质量图片值为1，一般设为0。赋值之后，用ioctl函数通过这个结构体对fd_ v4l2进行设置。 　　struct v4l2_streamparm 　　{ enum v4l2_buf_type type; 　　union 　　{ struct v4l2_captureparm capture; 　　struct v4l2_outputparm output; 　　__u8 raw_data[200]; /* user-defined */ 　　} parm; 　　}; 　　2.申请并设置视频采集的帧缓冲区 　　前期初始化完成后，只是解决了一帧视频数据的格式和大小问题，而连续视频帧数据的采集需要用帧缓冲区队列的方式来解决，即要通过驱动程序在内存中申请几个帧缓冲区来存放视频数据。 　　应用程序通过API接口提供的方法(VIDIOC_REQBUFS)申请若干个视频数据的帧缓冲区，申请帧缓冲区数量一般不低于3个，每个帧缓冲区存放一帧视频数据，这些帧缓冲区在内核空间。 　　应用程序通过API接口提供的查询方法(VIDIOC_QUERYBUF)查询到帧缓冲区在内核空间的长度和偏移量地址。 　　应用程序再通过内存映射方法(mmap)，将申请到的内核空间帧缓冲区的地址映射到用户空间地址，这样就可以直接处理帧缓冲区的数据。 　　(1)将帧缓冲区在视频输入队列排队，并启动视频采集 　　在驱动程序处理视频的过程中，定义了两个队列：视频采集输入队列(incoming queues)和视频采集输出队列(outgoing queues)，前者是等待驱动存放视频数据的队列，后者是驱动程序已经放入了视频数据的队列。如图2所示。 　　应用程序需要将上述帧缓冲区在视频采集输入队列排队(VIDIOC_QBUF)，然后可启动视频采集。 　　(2)循环往复，采集连续的视频数据 　　启动视频采集后，驱动程序开始采集一帧数据，把采集的数据放入视频采集输入队列的第一个帧缓冲区，一帧数据采集完成，也就是第一个帧缓冲区存满一帧数据后，驱动程序将该帧缓冲区移至视频采集输出队列，等待应用程序从输出队列取出。驱动程序接下来采集下一帧数据，放入第二个帧缓冲区，同样帧缓冲区存满下一帧数据后，被放入视频采集输出队列。 　　应用程序从视频采集输出队列中取出含有视频数据的帧缓冲区，处理帧缓冲区中的视频数据，如存储或压缩。 　　最后，应用程序将处理完数据的帧缓冲区重新放入视频采集输入队列,这样可以循环采集，如图1所示。 　　 　　图1 视频采集输入和输出队列示意图 　　(3)最终停止采集，释放内存帧缓冲区 　　3.用V4L2采集视频的程序流程和相关API 　　V4L2采集视频操作基本按照打开视频设备、设置视频格式、启动视频采集，循环处理视频数据、停止视频采集、关闭视频设备，具体操作通过ioctl等函数来实现。一般操作流程如下： 　　(1)打开视频设备文件。int fd=open("/dev/video0",O_RDWR); 　　(2)查询视频设备的能力，比如是否具有视频输入,或者音频输入输出等。ioctl(fd_v4l, VIDIOC_QUERYCAP, &cap) 　　(3)设置视频采集的参数 　　设置视频的制式，制式包括PAL/NTSC，使用ioctl(fd_v4l, VIDIOC_S_STD, &std_id) 　　设置视频图像的采集窗口的大小，使用ioctl(fd_v4l, VIDIOC_S_CROP, &crop) 　　设置视频帧格式，包括帧的点阵格式，宽度和高度等，使用ioctl(fd_v4l, VIDIOC_S_FMT, &fmt) 　　设置视频的帧率，使用ioctl(fd_v4l, VIDIOC_S_PARM, &parm) 　　设置视频的旋转方式，使用ioctl(fd_v4l, VIDIOC_S_CTRL, &ctrl) 　　(4)向驱动申请视频流数据的帧缓冲区 　　请求/申请若干个帧缓冲区，一般为不少于3个,使用ioctl(fd_v4l, VIDIOC_REQBUFS, &req) 　　查询帧缓冲区在内核空间中的长度和偏移量 ioctl(fd_v4l, VIDIOC_QUERYBUF, &buf) 　　(5)应用程序通过内存映射，将帧缓冲区的地址映射到用户空间，这样就可以直接操作采集到的帧了，而不必去复制。 　　buffers[i].start = mmap (NULL, buffers[i].length, PROT_READ | PROT_WRITE, MAP_SHARED, fd_v4l, buffers[i].offset); 　　(6)将申请到的帧缓冲全部放入视频采集输出队列，以便存放采集的数据。ioctl (fd_v4l, VIDIOC_QBUF, &buf) 　　(7)开始视频流数据的采集。 ioctl (fd_v4l, VIDIOC_STREAMON, &type) 　　(8) 驱动将采集到的一帧视频数据存入输入队列第一个帧缓冲区，存完后将该帧缓冲区移至视频采集输出队列。 　　(9)应用程序从视频采集输出队列中取出已含有采集数据的帧缓冲区。ioctl (fd_v4l, VIDIOC_DQBUF, &buf) ，应用程序处理该帧缓冲区的原始视频数据。 　　(10)处理完后，应用程序的将该帧缓冲区重新排入输入队列,这样便可以循环采集数据。ioctl (fd_v4l, VIDIOC_QBUF, &buf) 　　重复上述步骤8到10，直到停止采集数据。 　　(11)停止视频的采集。ioctl (fd_v4l, VIDIOC_STREAMOFF, &type) 　　(12)释放申请的视频帧缓冲区unmap，关闭视频设备文件close(fd_v4l)。 　　以上的程序流程，包含了视频设备采集连续的视频数据的逻辑关系。而在实际运用中，往往还要加入对视频数据进行处理(如压缩编码)的工作，否则，视频流数据量相当大，需要很大的存储空间和传输带宽。 　　上述过程中，每一个帧缓冲区都有一个对应的状态标志变量，其中每一个比特代表一个状态 　　V4L2_BUF_FLAG_UNMAPPED 0B0000 　　V4L2_BUF_FLAG_MAPPED 0B0001 　　V4L2_BUF_FLAG_ENQUEUED 0B0010 　　V4L2_BUF_FLAG_DONE 0B0100 　　缓冲区的状态转化如图2所示。 　　 　　图2 缓冲区的状态标志转化图 　　三、结束语 　　V4L2是Linux环境下开发视频采集设备驱动程序的一套规范(API)，它为驱动程序的编写提供统一的接口，并将所有的视频采集设备的驱动程序都纳入其的管理之中。V4L2不仅给驱动程序编写者带来极大的方便，同时也方便了应用程序的编写和移植，具有广泛的应用价值。   之前调试MXC V4L2驱动一直没有注意到output/mxc_v4l2_output.c这个文件，因为capture/*.c已经提供了still capture, stream capture, 以及overlay，所以没仔细的去看mxc_v4l2_output.c提供的功能，直到前几天负责维护overlay hal的同事提出打开了overlay hal /dev/video16这个设备节点，才让我跟到这个文件中 先从/dev/video0 和video16说起： MXC V4L2生成了三个设备节点， /dev/radio0 /dev/video0以及/dev/video16， /dev/radio0就不讨论了，项目中没接触到。 /dev/video0是mxc_v4l2_capture驱动创建的设备节点， 而/dev/video16是mxc_v4l2_output驱动创建的设备节点。 /dev/video0节点既可用于capture又可用来overlay,
而/dev/video16完全是为push mode overlay模式服务的，所谓push mode模式（以下几行纯属臆测）：应用通过stream capture从/dev/video0 dequeue到图像buffer数据，然后把这个指针再传给/dev/video16（当然是通过VIDIOC_Q_BUF），output 模块会直接将queue进来的buffer直接输出到framebuffer，这就完成了Overlay功能 push mode overlay和 /dev/video0支持的直接overlay的区别是,  push mode overlay需要应用空间参与数据的处理，用户空间参与的代价就是cpu占用率，好处是用空间有机会接触到每一帧传送到 framebuffer的数据。而直接overlay是你启动overlay后，所有数据直接从camera流动到framebuffer, 中间没有任何机会接触数据，只能在frame buffer这里截获数据，速度是真快。（先到这里吧，有任务）


push mode模式的另外一个好处是，就是你可以使用USB camera， 对camera进行处理显示 V4L2视频采集的基本流程 嵌入式的Linux使用视频驱动V4L2（Video For Linux Two）来进行视频采集、输出。本文就V4L2的使用方式做简易说明。 视频采集的基本流程 一般的，视频采集都有如下流程： 打开视频设备 在V4L2中，视频设备被看做一个文件。使用open函数打开这个设备： // 用非阻塞模式打开摄像头设备
int cameraFd;
cameraFd = open("/dev/video0", O_RDWR | O_NONBLOCK, 0);
// 如果用阻塞模式打开摄像头设备，上述代码变为：
//cameraFd = open("/dev/video0", O_RDWR, 0); 关于阻塞模式和非阻塞模式 应用程序能够使用阻塞模式或非阻塞模式打开视频设备，如果使用非阻塞模式调用视频设备，即使尚未捕获到信息，驱动依旧会把缓存（DQBUFF）里的东西返回给应用程序。 设定属性及采集方式 打开视频设备后，可以设置该视频设备的属性，例如裁剪、缩放等。这一步是可选的。在Linux编程中，一般使用ioctl函数来对设备的I/O通道进行管理： extern int ioctl (int __fd, unsigned long int __request, ...) __THROW; __fd：设备的ID，例如刚才用open函数打开视频通道后返回的cameraFd； __request：具体的命令标志符。 在进行V4L2开发中，一般会用到以下的命令标志符：

1. VIDIOC_REQBUFS：分配内存
2. VIDIOC_QUERYBUF：把VIDIOC_REQBUFS中分配的数据缓存转换成物理地址
3. VIDIOC_QUERYCAP：查询驱动功能
4. VIDIOC_ENUM_FMT：获取当前驱动支持的视频格式
5. VIDIOC_S_FMT：设置当前驱动的频捕获格式
6. VIDIOC_G_FMT：读取当前驱动的频捕获格式
7. VIDIOC_TRY_FMT：验证当前驱动的显示格式
8. VIDIOC_CROPCAP：查询驱动的修剪能力
9. VIDIOC_S_CROP：设置视频信号的边框
10. VIDIOC_G_CROP：读取视频信号的边框
11. VIDIOC_QBUF：把数据从缓存中读取出来
12. VIDIOC_DQBUF：把数据放回缓存队列
13. VIDIOC_STREAMON：开始视频显示函数
14. VIDIOC_STREAMOFF：结束视频显示函数
15. VIDIOC_QUERYSTD：检查当前视频设备支持的标准，例如PAL或NTSC。

这些IO调用，有些是必须的，有些是可选择的。 检查当前视频设备支持的标准 在亚洲，一般使用PAL（720X576）制式的摄像头，而欧洲一般使用NTSC（720X480），使用VIDIOC_QUERYSTD来检测： v4l2_std_id std;
do {
  ret = ioctl(fd, VIDIOC_QUERYSTD, &std);
} while (ret == -1 && errno == EAGAIN);
switch (std) {
    case V4L2_STD_NTSC:
        //……
    case V4L2_STD_PAL:
        //……
} 设置视频捕获格式 当检测完视频设备支持的标准后，还需要设定视频捕获格式： struct v4l2_format    fmt;
memset ( &fmt, 0, sizeof(fmt) );
fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width       = 720;
fmt.fmt.pix.height      = 576;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
if (ioctl(fd, VIDIOC_S_FMT, &fmt) == -1) {
  return -1;
} v4l2_format结构体定义如下： struct v4l2_format
{
    enum v4l2_buf_type type;    // 数据流类型，必须永远是V4L2_BUF_TYPE_VIDEO_CAPTURE
    union
    {
        struct v4l2_pix_format    pix; 
        struct v4l2_window        win; 
        struct v4l2_vbi_format    vbi; 
        __u8    raw_data[200];         
    } fmt;
};
struct v4l2_pix_format
{
    __u32                   width;         // 宽，必须是16的倍数
    __u32                   height;        // 高，必须是16的倍数
    __u32                   pixelformat;   // 视频数据存储类型，例如是YUV4：2：2还是RGB
    enum v4l2_field         field;
    __u32                   bytesperline;   
    __u32                   sizeimage;
    enum v4l2_colorspace    colorspace;
    __u32                   priv;      
}; 分配内存 接下来可以为视频捕获分配内存： struct v4l2_requestbuffers  req;
if (ioctl(fd, VIDIOC_REQBUFS, &req) == -1) {
  return -1;
} v4l2_requestbuffers定义如下： struct v4l2_requestbuffers
{
    __u32               count;  // 缓存数量，也就是说在缓存队列里保持多少张照片
    enum v4l2_buf_type  type;   // 数据流类型，必须永远是V4L2_BUF_TYPE_VIDEO_CAPTURE
    enum v4l2_memory    memory; // V4L2_MEMORY_MMAP 或 V4L2_MEMORY_USERPTR
    __u32               reserved[2];
}; 获取并记录缓存的物理空间 使用VIDIOC_REQBUFS，我们获取了req.count个缓存，下一步通过调用VIDIOC_QUERYBUF命令来获取这些缓存的地址，然后使用mmap函数转换成应用程序中的绝对地址，最后把这段缓存放入缓存队列： typedef struct VideoBuffer {
    void   *start;
    size_t  length;
} VideoBuffer;

VideoBuffer*          buffers = calloc( req.count, sizeof(*buffers) );
struct v4l2_buffer    buf;

for (numBufs = 0; numBufs < req.count; numBufs++) {
    memset( &buf, 0, sizeof(buf) );
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    buf.index = numBufs;
    // 读取缓存
    if (ioctl(fd, VIDIOC_QUERYBUF, &buf) == -1) {
        return -1;
    }

    buffers[numBufs].length = buf.length;
    // 转换成相对地址
    buffers[numBufs].start = mmap(NULL, buf.length,
        PROT_READ | PROT_WRITE,
        MAP_SHARED,
        fd, buf.m.offset);

    if (buffers[numBufs].start == MAP_FAILED) {
        return -1;
    }

    // 放入缓存队列
    if (ioctl(fd, VIDIOC_QBUF, &buf) == -1) {
        return -1;
    }
} 关于视频采集方式 操作系统一般把系统使用的内存划分成用户空间和内核空间，分别由应用程序管理和操作系统管理。应用程序可以直接访问内存的地址，而内核空间存放的是供内核访问的代码和数据，用户不能直接访问。v4l2捕获的数据，最初是存放在内核空间的，这意味着用户不能直接访问该段内存，必须通过某些手段来转换地址。 一共有三种视频采集方式：使用read、write方式；内存映射方式和用户指针模式。 read、write方式，在用户空间和内核空间不断拷贝数据，占用了大量用户内存空间，效率不高。 内存映射方式：把设备里的内存映射到应用程序中的内存控件，直接处理设备内存，这是一种有效的方式。上面的mmap函数就是使用这种方式。 用户指针模式：内存片段由应用程序自己分配。这点需要在v4l2_requestbuffers里将memory字段设置成V4L2_MEMORY_USERPTR。 处理采集数据 V4L2有一个数据缓存，存放req.count数量的缓存数据。数据缓存采用FIFO的方式，当应用程序调用缓存数据时，缓存队列将最先采集到的 视频数据缓存送出，并重新采集一张视频数据。这个过程需要用到两个ioctl命令,VIDIOC_DQBUF和VIDIOC_QBUF： struct v4l2_buffer buf;
memset(&buf,0,sizeof(buf));
buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory=V4L2_MEMORY_MMAP;
buf.index=0; //读取缓存
if (ioctl(cameraFd, VIDIOC_DQBUF, &buf) == -1)
{
    return -1;
}
//…………视频处理算法
//重新放入缓存队列
if (ioctl(cameraFd, VIDIOC_QBUF, &buf) == -1) {

    return -1;
} 关闭视频设备 使用close函数关闭一个视频设备 close(cameraFd)  

linux下开发摄像头的程序,主要用的是 video4linux来做的,界面用qt来实现,开始准备用frame buffer来直接写屏但是效果不怎么好,后来就用qt来做了,这样用起来效果还蛮好的,帧率也可以,可以上到30fps;运用v4l来编程主要掌握其 api,要提高帧率最重要的是用到内存映射,其实用qt和frame buffer的时候都要用到内存映射来做,只有这样才可以达到较高的帧率,不过要注意资源的利用问题.mmap后一定要munmap.对于frame buffer是很有意思的一个东西,特别是驱动的设计.

这次是在linux下开发摄像头的程序,主要用的是video4linux来做的,界面用qt来实现,开始准备用frame buffer来直接写屏但是效果不怎么好,后来就用qt来做了,这样用起来效果还蛮好的,帧率也可以,可以上到30fps;运用v4l来编程主要掌握其 api,要提高帧率最重要的是用到内存映射,其实用qt和frame buffer的时候都要用到内存映射来做,只有这样才可以达到较高的帧率,不过要注意资源的利用问题.mmap后一定要munmap.对于frame buffer是很有意思的一个东西,特别是驱动的设计.
代码如下:
1.open device:
video_dev = open("devvideo0",O_RDWR));
2.get the information of the video device
struct video_capability video_cap;
memset(&video_cap,0,sizeof(video_cap));
if(ioctl(video_dev,VIDIOCGCAP,&video_cap) == -1)
{
perror("Cann't get the information of the video device");
close(video_dev);
exit(1);
}
3.get the information of the channels
struct video_channel video_chan;
memset(&video_chan,0,sizeof(video_chan));
for(channel = 0;channel < video_cap.channels;channel++)
{
video_chan.channel = channel;
if(ioctl(video_dev,VIDIOCGCHAN,&video_chan) == -1)
{
perror("Cann't get the information of the channels");
close(video_dev);
exit(3);
}
if(video_chan.type == VIDEO_TYPE_TV)
{
#ifdef DEBUG
printf("NO.%d channel is %s,type is tv! ",channel,video_chan.name);
#endif
}
if(video_chan.type == VIDEO_TYPE_CAMERA)
{
if(ioctl(video_dev,VIDIOCSCHAN,&video_chan) == -1)
{
perror("Cann't set the camera channel!");
close(video_dev);
exit(4);
}
}
}
4.get the capture attributes
struct video_picture video_pic;
memset(&video_pic,0,sizeof(video_pic));
if(ioctl(video_dev,VIDIOCGPICT,&video_pic) == -1)
{
perror("Cann't get the picture attributes of the device!");
close(video_dev);
exit(5);
}
5.set capture attributes
video_pic.palette = VIDEO_PALETTE_*****;//different camera has different palette
video_pic.brightness = 65535;
video_pic.colour = 0;
if(ioctl(video_dev,VIDIOCSPICT,&video_pic) == -1)
{
perror("Cann't set the picture attributs!");
close(video_dev);
exit(6);
}
6.mmap the device
struct video_mbuf mbuf;
unsigned char *frames;
memset(&mbuf,0,sizeof(mbuf));
if(ioctl(video_dev,VIDIOCGMBUF,&mbuf) == -1)
{
perror("Cann't get the buffer information of the video device!");
close(video_dev);
exit(7);
}
frames = (unsigned char *)::mmap(0,mbuf.size,PROT_READ|PROT_WRITE,MAP_SHARED,video_dev,0);
if(!frames || frames == (unsigned char *)(long)(-1))
{
perror("The device cann't be memory mapped!");
close(video_dev);
exit(8);
}
7.capture
if(ioctl(video_dev,VIDIOCMCAPTURE,&mmap) == -1)
{
perror("Capture failed!");
close(video_dev);
exit(9);
}

else
{
//display or save the picture file
}


谢谢，我去找找video4linux来试试看，以前找的不是这个

补充资料：

v4l2_extension调用 v4l2_register_device（）函数注册设备，V4l2_register_device()函数进而调用v4l2_init_done （）函数（v4l2_device结构中的int（*initialize）（）字段已被初始化为该函数）通过写I/O地址空间具体的初始化设备，设置采 集图像的默认参数等。这时候设备已经做好了采集图像的准备工作。 下面通过典型的read一桢图像来分析具体的工作流程： 应用程序首先调用系统调用open（）来打开设备，v4l2将该调用映射为初始化设备时已经设置好的v4l2_device结构中的int （*open）（），在本文中即为v4l2_open（）；打开设备成功read一桢图像数据的命令，此时系统通过v4l2_device结构中已经设置 好的int（*open）（）字段调用相应的函数v4l2_read（），该调用负责分配内核内存缓冲区，并将采集到的数据从内核空间复制到用户空间，这 样应用程序就获得了一桢数据； 当 v4l2_capability结构中的V4L2_CAP_STREAMING标 志被设置时，这表明设备支持流采集。V4L2 的流驱动程序维护两个组织成FIFO的缓冲区队列：发送队列和接收队列。由于应用程序受到网络延迟,进程抢占或随机磁盘存储的影响,维护两个队列就可以把 异步的视频采集或输出操作与应用程序分离开，从而降低丢失数据的可能性。设备采集到图像后可以用DMA 方式直接将数据放入应用程序分配好的缓冲区中，这就大大提升了整个系统的性能。 4.2.3 测试驱动程序[6] 首先编译上述模块，然后通过命令insmod链接进内核。用于测试的简单应用程序主体部分如下所示： vid = open(device, O_RDONLY);/*打开设备*/ err = ioctl(vid, VIDIOC_QUERYCAP, &cap); /*查询设备支持的功能*/ err = ioctl(vid, VIDIOC_G_FMT, &fmt);/*设置采集图像的格式*/ data = malloc(fmt.fmt.pix.sizeimage);/*分配用户空间缓冲区*/ n = read(vid, data, fmt.fmt.pix.sizeimage);/*获取一桢数据*/ 该应用程序运行后经检查得到了预期的结果，并且在基于该驱动程序的CDMA无线视频传输系统中满足了应用的需要，获得了理想的效果。 Video4Linux是Linux下用于获取视频和音频数据的API接口，在这篇文章中，着重阐述如何利用Video4Linux获取摄像头数据，以实现连续影像的播放。 1. 摄像头的安装 在Linux下常用的摄像头驱动是spca5xx， 这是一个通用驱动，读者可以在以下网站下到这个驱动 http://mxhaard.free.fr/download.html。 这个网站还给出了这款驱动支持的摄像头的种类。另外，ov511芯片直接就支持Linux，使用者款芯片的摄像头有网眼V2000。我使用的是网眼 V2000的摄像头，和Z-Star 301p+现代7131R芯片的摄像头。后一种需要spca5xx的驱动。关于spca5xx的安装方法，网上有很多介绍，这里就不说了。 2. 摄像头的调试 安装好摄像头后，为了测试摄像头能否正常工作，可以用一下软件。比较著名的是xawtv，在网上搜以下可以下载到。安装好后，打开xawtv则可以调试摄像头。 3. Video4Linux 编程获取数据 现有的video4linux有两个版本，v4l和v4l2。本文主要是关于v4l的编程。利用v4l API获取视频图像一般有以下几步： a> 打开设备 b> 设置设备的属性，比如图像的亮度，对比度等等 c> 设定传输格式和传输方式 d> 开始传输数据，一般是一个循环，用以连续的传输数据 e> 关闭设备 下面具体介绍v4l编程的过程。首先指出，在video4linux编程时要包含头文件，其中包含了video4linux的数据结构和函数定义。 1）v4l的数据结构 在video4linux API中定义了如下数据结构，详细的数据结构定义可以参考v4l API的文档，这里就编程中经常使用的数据结构作出说明。 首先我们定义一个描述设备的数据结构，它包含了v4l中定义的所有数据结构：
typedef struct _v4ldevice
{int fd;//设备号
struct video_capability capability;
struct video_channel channel[10];
struct video_picture picture;
struct video_clip clip;
struct video_window window;
struct video_capture capture;
struct video_buffer buffer;
struct video_mmap mmap;
struct video_mbuf mbuf;
struct video_unit unit;
unsigned char *map;//mmap方式获取数据时，数据的首地址
pthread_mutex_t mutex;
int frame;
int framestat[2];
int overlay;
}v4ldevice; 下面解释上面这个数据结构中包含的数据结构，这些结构的定义都在中。
* struct video_capability
name[32] Canonical name for this interface
type Type of interface
channels Number of radio/tv channels if appropriate
audios Number of audio devices if appropriate
maxwidth Maximum capture width in pixels
maxheight Maximum capture height in pixels
minwidth Minimum capture width in pixels
minheight Minimum capture height in pixels 这一个数据结构是包含了摄像头的属性，name是摄像头的名字，maxwidth maxheight是摄像头所能获取的最大图像大小，用像素作单位。 在程序中，通过ioctl函数的VIDIOCGCAP控制命令读写设备通道已获取这个结构，有关ioctl的使用，比较复杂，这里就不说了。下面列出获取这一数据结构的代码：
int v4lgetcapability(v4ldevice *vd)
{
if(ioctl(vd->fd, VIDIOCGCAP, &(vd->capability)) < 0) {
v4lperror("v4lopen:VIDIOCGCAP");
return -1;
}
return 0;
}
* struct video_picture
brightness Picture brightness
hue Picture hue (colour only)
colour Picture colour (colour only)
contrast Picture contrast
whiteness The whiteness (greyscale only)
depth The capture depth (may need to match the frame buffer depth)
palette Reports the palette that should be used for this image 这个数据结构主要定义了图像的属性，诸如亮度，对比度，等等。这一结构的获取通过ioctl发出VIDIOCGPICT控制命令获取。
* struct video_mbuf
size The number of bytes to map
frames The number of frames
offsets The offset of each frame

这个数据结构在用mmap方式获取数据时很重要: size表示图像的大小，如果是640*480的彩 {MOD}图像，size=640*480*3 frames表示帧数 offsets表示每一帧在内存中的偏移地址，通过这个值可以得到数据在图像中的地址。 得到这个结构的数据可以用ioctl的VIDIOCGMBUF命令。源码如下：
int v4lgetmbuf(v4ldevice *vd)
{
if(ioctl(vd->fd, VIDIOCGMBUF, &(vd->mbuf))<0) {
v4lperror("v4lgetmbuf:VIDIOCGMBUF");
return -1;
}
return 0;
} 而数据的地址可以有以下方式计算：
unsigned char *v4lgetaddress(v4ldevice *vd)
{
return (vd->map + vd->mbuf.offsets[vd->frame]);
} 2）获取影像mmap方式。 在video4linux下获取影像有两种方式：overlay和mmap。由于我的摄像头不支持overlay方式，所以这里只谈mmap方式。 mmap方式是通过内存映射的方式获取数据，系统调用ioctl的VIDIOCMCAPTURE后，将图像映射到内存中，然后可以通过前面的 v4lgetmbuf(vd)函数和v4lgetaddress(vd)函数获得数据的首地址，这是李可以选择是将它显示出来还是放到别的什么地方。 下面给出获取连续影像的最简单的方法（为了简化，将一些可去掉的属性操作都去掉了）：
char* devicename="/dev/video0";
char* buffer;
v4ldevice device;
int width = 640;
int height = 480;
int frame = 0;
v4lopen("/dev/video0",&device);//打开设备
v4lgrabinit(&device,width,height);//初始化设备，定义获取的影像的大小
v4lmmap(&device);//内存映射
v4lgrabstart(&device,frame);//开始获取影像
while(1){
v4lsync(&device,frame);//等待传完一帧
frame = (frame+1)%2;//下一帧的frame
v4lcapture(&device,frame);//获取下一帧
buffer = (char*)v4lgetaddress(&device);//得到这一帧的地址
//buffer给出了图像的首地址，你可以选择将图像显示或保存......
//图像的大小为 width*height*3
..........................
} 为了更好的理解源码，这里给出里面的函数的实现，这里为了简化，将所有的出错处理都去掉了。
int v4lopen(char *name, v4ldevice *vd)
{
int i;
if((vd->fd = open(name,O_RDWR)) < 0) {
return -1;
}
if(v4lgetcapability(vd))
return -1;
}
int v4lgrabinit(v4ldevice *vd, int width, int height)
{
vd->mmap.width = width;
vd->mmap.height = height;
vd->mmap.format = vd->picture.palette;
vd->frame = 0;
vd->framestat[0] = 0;
vd->framestat[1] = 0;
return 0;
}
int v4lmmap(v4ldevice *vd)
{
if(v4lgetmbuf(vd)<0)
return -1;
if((vd->map = mmap(0, vd->mbuf.size, PROT_READ|PROT_WRITE, MAP_SHARED, vd->fd, 0)) < 0) {
return -1;
}
return 0;
}
int v4lgrabstart(v4ldevice *vd, int frame)
{
vd->mmap.frame = frame;
if(ioctl(vd->fd, VIDIOCMCAPTURE, &(vd->mmap)) < 0) {
return -1;
}
vd->framestat[frame] = 1;
return 0;
}
int v4lsync(v4ldevice *vd, int frame)
{
if(ioctl(vd->fd, VIDIOCSYNC, &frame) < 0) {
return -1;
}
vd->framestat[frame] = 0;
return 0;
}
int c4lcapture(v4ldevice *vd, int frame)
{
vd->mmap.frame = frame;
if(ioctl(vd->fd, VIDIOCMCAPTURE, &(vd->mmap)) < 0) {
return -1;
}
vd->framestat[frame] = 1; fsl的camera hal层没有实现上层到下层的设置参数的接口，所以需要自己实现。好在从应用到hal层的参数已经弄好，否则工作量就更大了。
参数设置在hal层调用的函数是status_t CameraHal::setParameters(constCameraParameters& params)。在这个函数里实现对每个参数的设置。参数设置主要通过CameraParameters这个类实现的。通过观察这个类发现，里面有个get()函数，可以分别得到各个参数。如
      const char *white_balance = params.get(CameraParameters::KEY_WHITE_BALANCE);这个可以得到目前白平衡的参数即返回值。然后根据返回值判断是哪种情况，如
    if (strcmp(white_balance,  CameraParameters::WHITE_BALANCE_AUTO) == 0) {   //判断为自动白平衡
        LOGV("white_balance to ioctl is auto ! ");
        ctl.id = V4L2_CID_AUTO_WHITE_BALANCE;    //自动白平衡命令，ctl为v4l2_control结构，该结构很有用
        ctl.value = 1;
        if (ioctl(camera_device, VIDIOC_S_CTRL, &ctl) < 0){   //通过 VIDIOC_S_CTRL把ctl结构体传下去
            LOGE("set control failed ");
                //return -1;
        }
    }else if(strcmp(white_balance,  CameraParameters::WHITE_BALANCE_INCANDESCENT) == 0){  //白炽灯模式
        LOGV("white_balance to ioctl is incandescent ! ");
        ctl.id = V4L2_CID_DO_WHITE_BALANCE;   //其它白平衡情况都用该命令
        ctl.value = 2;  //根据用户自己定义的白平衡模式数目排列
        if (ioctl(camera_device, VIDIOC_S_CTRL, &ctl) < 0){  //同样通过 VIDIOC_S_CTRL把ctl结构体传下去，然后在根据value值分情况讨论
            LOGE("set control failed ");
                //return -1;
        }
    }

传到驱动的mxc_v4l2_capture.c文件的mxc_v4l_ioctl中，mxc_v4l_ioctl调用mxc_v4l_do_ioctl，mxc_v4l_do_ioctl对命令的解释如下
    /*!
     * V4l2 VIDIOC_S_CTRL ioctl
     */
    case VIDIOC_S_CTRL: {
        pr_debug("   case VIDIOC_S_CTRL ");
        retval = mxc_v4l2_s_ctrl(cam, arg);
        break;
    }
这样就到了mxc_v4l2_s_ctrl。在mxc_v4l2_s_ctrl通过对ctl.id分情况调用
switch (c->id) {
    ......
    case V4L2_CID_AUTO_WHITE_BALANCE:
        ipu_csi_enable_mclk_if(CSI_MCLK_I2C, cam->csi, true, true);
        ret = vidioc_int_s_ctrl(cam->sensor, c);  //该函数是v4l2对应ov7670驱动中的s_ctl
        ipu_csi_enable_mclk_if(CSI_MCLK_I2C, cam->csi, false, false);
        break;
    case V4L2_CID_DO_WHITE_BALANCE:
        ipu_csi_enable_mclk_if(CSI_MCLK_I2C, cam->csi, true, true);
        ret = vidioc_int_s_ctrl(cam->sensor, c);
        ipu_csi_enable_mclk_if(CSI_MCLK_I2C, cam->csi, false, false);
        break;
     ......
其中vidioc_int_s_ctrl()是v4l2对应ov7670驱动中的 ioctl_s_ctrl，具体代码怎么对应由于篇幅原因就不贴出来。
根据ctl结构体的id分情况去实现即可。
    switch (vc->id) {
    .....
    case V4L2_CID_AUTO_WHITE_BALANCE:
        retval = ov7670_autowhitebalance(vc->value);
        break;
    case V4L2_CID_DO_WHITE_BALANCE:
        retval = ov7670_dowhitebalance(vc->value);
        break;
    ......
下面是whitebalance函数的实现
static int ov7670_autowhitebalance(int value)
{
    unsigned char v = 0;
    int ret;
    printk("0v7670_autowhitebalance called ");
    ret = ov7670_read(ov7670_data.i2c_client, REG_COM8, &v);
    if (value)
        v |= COM8_AWB;  //自动白平衡

    msleep(10);  /* FIXME */
    ret += ov7670_write(ov7670_data.i2c_client, 0x01, 0x56);
    ret += ov7670_write(ov7670_data.i2c_client, 0x02, 0x44);
    ret += ov7670_write(ov7670_data.i2c_client, REG_COM8, v);

    return ret;   
}

static int ov7670_dowhitebalance(int value)
{
    unsigned char v = 0;
    int ret;
    printk("0v7670_dowhitebalance called value:%d ",value);
    ret = ov7670_read(ov7670_data.i2c_client, REG_COM8, &v);
    if (value)
        v &= ~COM8_AWB;  //关闭自动白平衡

    msleep(10);  /* FIXME */
    ret += ov7670_write(ov7670_data.i2c_client, REG_COM8, v);
    if(value == 2) //INCANDESCENCE  //这个值就是ctl的value值
    {
        ret += ov7670_write(ov7670_data.i2c_client, 0x01, 0x8c);
        ret += ov7670_write(ov7670_data.i2c_client, 0x02, 0x59);
    }else if(value == 3)  //FLUORESCENT
    {
        ret += ov7670_write(ov7670_data.i2c_client, 0x01, 0x7e);
        ret += ov7670_write(ov7670_data.i2c_client, 0x02, 0x49);       
    }else if(value == 4)  //DAYLIGHT
    {
        ret += ov7670_write(ov7670_data.i2c_client, 0x01, 0x52);
        ret += ov7670_write(ov7670_data.i2c_client, 0x02, 0x66);
    }

    return ret;   
}
其中函数中ox01、0x02分别是蓝红通道的增益的寄存器。

上面是白平衡从hal层最终到sensor的参数设置过程。其它如 {MOD}彩效果、取景模式等都是同样的过程。
取景模式根据具体的情况如夜间模式等设定具体的寄存器即可
{MOD}彩效果主要通过设置uv的值实现的 之前调试MXC V4L2驱动一直没有注意到output/mxc_v4l2_output.c这个文件，因为capture/*.c已经提供了still capture, stream capture, 以及overlay没仔细的去看mxc_v4l2_output.c提供的功能，直到前几天负责维护overlay hal的同事提出打开了overlay hal /dev/video16这个设备节点，才让我跟到这个文件中 先从/dev/video0 和video16说起： MXC V4L2生成了三个设备节点， /dev/radio0 /dev/video0以及/dev/video16， /dev/radio0就不讨论了，项目中没接触到。 /dev/video0是mxc_v4l2_capture驱动创建的设备节点， 而/dev/video16是mxc_v4l2_output驱动创建的设备节点。 /dev/video0节点既可用于capture又可用来overlay,
而/dev/video1完全是为push mode overlay模式服务的，所谓push mode模式（以下几行纯属臆测）：应用通过stream capture从/dev/video0 dequeue到图像buffer数据，然后把这个指针再传给/dev/video16（当然是通过VIDIOC_Q_BUF），output 模块会直接将queue进来的buffer直接输出到framebuffer，这就完成了Overlay功能 push mode overlay和 /dev/video0支持的直接overlay的区别是,  push mode overlay需要应用空间参与数据的处理，用户空间参与的代价就是cpu占用率，好处是用空间有机会接触到每一帧传送到 framebuffer的数据。而直接overlay是你按下按钮，所有数据直接从camera流动到framebuffer, 中间没有任何机会接触数据，只能在frame buffer这里截获数据，速度是真快呀。