luvcview分析--2.将图像写到文件中

1.思路
a. 使用v4l2截取camera中的一帧图像,并转为rgb24,然后写到文件中去
b. 因为从camera中输出的图像是yuv422格式的,要想直接预览需要先转成rgb格式。
c. 查看raw格式的rgb,可以用win下的IrfanView,它可以指定w与h然后预览
2.代码

cong@msi:/work/test/uvcview/2capture$ cat capture.c
#include "utils.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/videodev2.h>
#include <sys/mman.h>

#define VIDEO_DEVICE "/dev/video0"
#define NB_BUFFER  4
convert_yuv_to_rgb_pixel(int y, int u, int v)
{
    unsigned int pixel32 = 0;
    unsigned char *pixel = (unsigned char *)&pixel32;
    int r, g, b;
    r = y + (1.370705 * (v-128));
    g = y - (0.698001 * (v-128)) - (0.337633 * (u-128));
    b = y + (1.732446 * (u-128));
    if(r > 255) r = 255;
    if(g > 255) g = 255;
    if(b > 255) b = 255;
    if(r < 0) r = 0;
    if(g < 0) g = 0;
    if(b < 0) b = 0;
    pixel[0] = r ;
    pixel[1] = g ;
    pixel[2] = b ;
    return pixel32;
}

convert_yuv_to_rgb_buffer(unsigned char *yuv, unsigned char *rgb, unsigned int width, unsigned int height)
{
    unsigned int in, out = 0;
    unsigned int pixel_16;
    unsigned char pixel_24[3];
    unsigned int pixel32;
    int y0, u, y1, v;

    for(in = 0; in < width * height * 2; in += 4)
    {
        pixel_16 =
            yuv[in + 3] << 24 |
            yuv[in + 2] << 16 |
            yuv[in + 1] << 8 |
            yuv[in + 0];
        y0 = (pixel_16 & 0x000000ff);
        u = (pixel_16 & 0x0000ff00) >> 8;
        y1 = (pixel_16 & 0x00ff0000) >> 16;
        v = (pixel_16 & 0xff000000) >> 24;
        pixel32 = convert_yuv_to_rgb_pixel(y0, u, v);
        pixel_24[0] = (pixel32 & 0x000000ff);
        pixel_24[1] = (pixel32 & 0x0000ff00) >> 8;
        pixel_24[2] = (pixel32 & 0x00ff0000) >> 16;
        rgb[out++] = pixel_24[0];
        rgb[out++] = pixel_24[1];
        rgb[out++] = pixel_24[2];
        pixel32 = convert_yuv_to_rgb_pixel(y1, u, v);
        pixel_24[0] = (pixel32 & 0x000000ff);
        pixel_24[1] = (pixel32 & 0x0000ff00) >> 8;
        pixel_24[2] = (pixel32 & 0x00ff0000) >> 16;
        rgb[out++] = pixel_24[0];
        rgb[out++] = pixel_24[1];
        rgb[out++] = pixel_24[2];
    }
    return 0;
}

int main ( int argc, char *argv[] )
{
    int i;
    int fd;
    int ret = 0;
    struct v4l2_capability cap;
    struct v4l2_format fmt;
    struct v4l2_requestbuffers rb;
    struct v4l2_buffer vbuf;
    void* vmem[NB_BUFFER];
    int framesize;
    int type;

    FILE *outfile_fd;
    //开始时先设定输出图像的宽高及格式:640*480,yuyv格式
    int width = 640; //1280; //640;
    int height= 480; // 720; // 480;
    float fps = 30.0;
    int format = V4L2_PIX_FMT_YUYV;

    unsigned char* yuv;
    unsigned char* rgb;
    outfile_fd = fopen("test.raw", "w");  //将图像输出到文件中

    if( (fd = v4l2_open(VIDEO_DEVICE,O_RDWR)) == -1)  //v4l2_a. open
    {
        dbmsg("error: %s", strerror(errno));
        return 0;
    }
    //check format is valid                 //这个地方需要检查上面配的640*480*YUYV的参数camera是否支持
    //fix me                                //检查时跟上一篇的check很类似

    //set format and frame size
    memset(&fmt, 0, sizeof(struct v4l2_fmtdesc));
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = width;
    fmt.fmt.pix.height = height;
    fmt.fmt.pix.field = V4L2_FIELD_ANY;
    if( (ret = v4l2_ioctl(fd, VIDIOC_S_FMT, &fmt)) < 0)  //v4l2_b.设置输出视频的格式
    {
        dbmsg("error: %s", strerror(errno));
        return 0;
    }

    //mmap buffer: reqbufs-> querybuf -> mmap -> QBUF
    memset(&rb, 0, sizeof(struct v4l2_requestbuffers));
    rb.count = NB_BUFFER;                                   //NB_BUFFER=4,共需申请4块内存
    rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    rb.memory = V4L2_MEMORY_MMAP;
    if( (ret = v4l2_ioctl(fd, VIDIOC_REQBUFS, &rb)) < 0 )  //v4l2_c.请求v4l2驱动分配缓冲区内存
    {
        dbmsg("error: %s", strerror(errno));
        return 0;
    }
    for(i=0; i<NB_BUFFER; i++)
    {
        memset(&vbuf, 0, sizeof(struct v4l2_buffer));
        vbuf.index = i;
        vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        vbuf.memory = V4L2_MEMORY_MMAP;
        if( (ret = v4l2_ioctl(fd, VIDIOC_QUERYBUF, &vbuf)) < 0)  //v4l2_d.查询请求的缓冲区成功了没有
        {
            dbmsg("error: %s", strerror(errno));
            return 0;
        }                                                       //v4l2_e.己成功分配了缓冲区就映射到用户空间
        dbmsg("len=%d, offset=%d", vbuf.length, vbuf.m.offset); //v4l2_e2.为毛这儿没有用v4l2_mmap?
        //if( (vmem[i] = v4l2_mmap(0, vbuf.length, PROT_READ, MAP_SHARED, fd, vbuf.m.offset)) == MAP_FAILED)
        if( (vmem[i] = mmap(0, vbuf.length, PROT_READ, MAP_SHARED, fd, vbuf.m.offset)) == MAP_FAILED)
        {
            dbmsg("error: %s", strerror(errno));
            return 0;
        }
    }
    for(i=0; i<NB_BUFFER; i++)
    {
        memset(&vbuf, 0, sizeof(struct v4l2_buffer));
        vbuf.index = i;
        vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        vbuf.memory = V4L2_MEMORY_MMAP;
        if( (ret = v4l2_ioctl(fd, VIDIOC_QBUF, &vbuf)) < 0)   //v4l2_f.将空的视频缓冲区入队,这样出队时就是数据了
        {
            dbmsg("error: %s", strerror(errno));
            return 0;
        }
    }

    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    if( (ret = v4l2_ioctl(fd, VIDIOC_STREAMON, &type)) < 0)   //v4l2_g.启动采集命令,设置完后就会有图像输出
    {
        dbmsg("error: %s", strerror(errno));
        return 0;
    }

    //while(1)
    {
        memset(&vbuf, 0, sizeof(struct v4l2_buffer));
        vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        vbuf.memory = V4L2_MEMORY_MMAP;                      //v4l2_h.空的缓冲区vbuf入队,采集数据到vub中
        if( (ret = v4l2_ioctl(fd, VIDIOC_DQBUF, &vbuf)) < 0) //v4l2_h.这一步DQBUF,将缓冲区出队后,用户就可以使用这个缓冲区了
        {
            dbmsg("error: %s", strerror(errno));
            return 0;
        }

        dbmsg("index=%d, used=%d", vbuf.index, vbuf.bytesused);
        yuv = vmem[vbuf.index];
        rgb = malloc(width*height*3);
        convert_yuv_to_rgb_buffer(yuv, rgb, width, height);   //camera输出的是yuv422格式的,要想预览需要转成rgb24格式
        fwrite(rgb, width*height*3, 1, outfile_fd);           //最后将转换好的rgb24写到文件中
        if( (ret = v4l2_ioctl(fd, VIDIOC_QBUF, &vbuf)) < 0)   //单看这个程序,这一步是不需要的
        {
            dbmsg("error: %s", strerror(errno));
            return 0;
        }
    }

    return EXIT_SUCCESS;
}

注:源码中的YUV422转RGB24是copy的百度文库的内容

2capture.rar (下载后改名为2capture.tar.gz)
图像及软件放在一块截图了

---

3.关于v4l2的命令
这个文章写得很好:
http://blog.chinaunix.net/uid-26851094-id-3356224.html
v4l2架构入门其实并不是很难，高级的我还没资格说，想当初我刚开始看的时候，也是感觉超级难啊，因为没有抓住体系，对整体没有认识，所以我就花了两天时间天天研究那几篇文章和程序
程序属这两篇文章最为经典了：


基础知识，我就直接贴出来算了  ，//后是我添加的
基于Linux视频驱动接口V4L2视频采集编程44253105764
Linux系统中，视频设备被当作一个设备文件来看待，设备文件存放在 /dev目录下，完整路径的设备文件名为： /dev/video0 .
视频采集基本步骤流程如下： 打开视频设备，设置视频设备属性及采集方式、视频数据处理，关闭视频设备，如下图所示：
一、打开视频设备
打开视频设备非常简单，在V4L2中，视频设备被看做一个文件。使用open函数打开这个设备：
1.     用非阻塞模式打开摄像头设备

int cameraFd;
cameraFd = open("/dev/video0", O_RDWR | O_NONBLOCK);

2.     如果用阻塞模式打开摄像头设备，上述代码变为：

cameraFd = open("/dev/video0", O_RDWR);

关于阻塞模式和非阻塞模式
应用程序能够使用阻塞模式或非阻塞模式打开视频设备，如果使用非阻塞模式调用视频设备，即使尚未捕获到信息，驱动依旧会把缓存（DQBUFF）里的东西返回给应用程序。

二、Linux视频设备驱动常用控制命令使用说明
设置视频设备属性通过ioctl来进行设置，ioctl有三个参数，分别是fd, cmd,和parameter,表示设备描述符，控制命令和控制命令参数。
Linux 视频设备驱动接口V4L2支持的常用控制命令如下：
1． 控制命令 VIDIOC_ENUM_FMT      //ENUM什么意思？自己查查去
功能： 获取当前视频设备支持的视频格式 。
参数说明：参数类型为V4L2的视频格式描述符类型 struct v4l2_fmtdesc
返回值说明： 执行成功时，函数返回值为 0；struct v4l2_fmtdesc 结构体中的 .pixelformat和 .description 成员返回当前视频设备所支持的视频格式；
使用举例：

struct v4l2_fmtdesc fmt;
memset(&fmt, 0, sizeof(fmt));
fmt.index = 0;
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
while ((ret = ioctl(dev, VIDIOC_ENUM_FMT, &fmt)) == 0) {
   fmt.index++;
   printf("{ pixelformat = ''%c%c%c%c'', description = ''%s'' }\n",
            fmt.pixelformat & 0xFF, (fmt.pixelformat >> 8) & 0xFF,
            (fmt.pixelformat >> 16) & 0xFF, (fmt.pixelformat >> 24) & 0xFF,
            fmt.description);
}

2． 控制命令VIDIOC_QUERYCAP        //query 和cap各代表什么意思
功能： 查询视频设备的功能 ；
参数说明：参数类型为V4L2的能力描述类型struct v4l2_capability ；
返回值说明： 执行成功时，函数返回值为 0；函数执行成功后，struct v4l2_capability 结构体变量中的返回当前视频设备所支持的功能；例如支持视频捕获功能V4L2_CAP_VIDEO_CAPTURE、V4L2_CAP_STREAMING等。
使用举例：

struct v4l2_capability cap;
iret = ioctl(fd_usbcam, VIDIOC_QUERYCAP, &cap);
if(iret < 0)
{
    printf("get vidieo capability error,error code: %d \n", errno);
    return ;
}

执行完VIDIOC_QUERYCAP命令后，cap变量中包含了该视频设备的能力信息，程序中通过检查cap中的设备能力信息来判断设备是否支持某项功能。

3． 控制命令VIDIOC_S_FMT           //直接告诉你，s是set的意思
功能： 设置视频设备的视频数据格式，例如设置视频图像数据的长、宽，图像格式（JPEG、YUYV格式）；
参数说明：参数类型为V4L2的视频数据格式类型    struct v4l2_format  ；
返回值说明： 执行成功时，函数返回值为 0；
使用举例：

struct v4l2_format tv4l2_format;
tv4l2_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
tv4l2_format.fmt.pix.width = img_width;
tv4l2_format.fmt.pix.height = img_height;
tv4l2_format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
tv4l2_format.fmt.pix.field = V4L2_FIELD_INTERLACED;
iret = ioctl(fd_usbcam, VIDIOC_S_FMT, &tv4l2_format);

注意：如果该视频设备驱动不支持你所设定的图像格式，视频驱动会重新修改struct v4l2_format结构体变量的值为该视频设备所支持的图像格式，所以在程序设计中，设定完所有的视频格式后，要获取实际的视频格式，要重新读取struct v4l2_format结构体变量。

4． 控制命令VIDIOC_REQBUFS            //我不问了，你自己问自己吧
功能： 请求V4L2驱动分配视频缓冲区（申请V4L2视频驱动分配内存），V4L2是视频设备的驱动层，位于内核空间，所以通过VIDIOC_REQBUFS控制命令字申请的内存位于内核空间，应用程序不能直接访问，需要通过调用mmap内存映射函数把内核空间内存映射到用户空间后，应用程序通过访问用户空间地址来访问内核空间。
参数说明：参数类型为V4L2的申请缓冲区数据结构体类型struct v4l2_requestbuffers  ；
返回值说明： 执行成功时，函数返回值为 0；V4L2驱动层分配好了视频缓冲区；
使用举例：

struct v4l2_requestbuffers  tV4L2_reqbuf;
memset(&tV4L2_reqbuf, 0, sizeof(struct v4l2_requestbuffers ));
tV4L2_reqbuf.count = 1; //申请缓冲区的个数
tV4L2_reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
tV4L2_reqbuf.memory = V4L2_MEMORY_MMAP;
iret = ioctl(fd_usbcam, VIDIOC_REQBUFS, &tV4L2_reqbuf);

注意：VIDIOC_REQBUFS会修改tV4L2_reqbuf的count值，tV4L2_reqbuf的count值返回实际申请成功的视频缓冲区数目；

5． 控制命令VIDIOC_QUERYBUF
功能： 查询已经分配的V4L2的视频缓冲区的相关信息，包括视频缓冲区的使用状态、在内核空间的偏移地址、缓冲区长度等。在应用程序设计中通过调VIDIOC_QUERYBUF来获取内核空间的视频缓冲区信息，然后调用函数mmap把内核空间地址映射到用户空间，这样应用程序才能够访问位于内核空间的视频缓冲区。
参数说明：参数类型为V4L2缓冲区数据结构类型    struct v4l2_buffer  ；
返回值说明： 执行成功时，函数返回值为 0；struct v4l2_buffer结构体变量中保存了指令的缓冲区的相关信息；
一般情况下，应用程序中调用VIDIOC_QUERYBUF取得了内核缓冲区信息后，紧接着调用mmap函数把内核空间地址映射到用户空间，方便用户空间应用程序的访问。
使用举例：

struct v4l2_buffer tV4L2buf;
memset(&tV4L2buf, 0, sizeof(struct v4l2_buffer));
tV4L2buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
tV4L2buf.memory = V4L2_MEMORY_MMAP;
tV4L2buf.index = i; // 要获取内核视频缓冲区的信息编号
iret = ioctl(fd_usbcam, VIDIOC_QUERYBUF, &tV4L2buf);
// 把内核空间缓冲区映射到用户空间缓冲区
AppBufLength = tV4L2buf.length;
AppBufStartAddr = mmap(NULL /* start anywhere */ ,
                       tV4L2buf.length,
                       PROT_READ | PROT_WRITE /* access privilege */ ,
                       MAP_SHARED /* recommended */ ,
                       fd_usbcam, tV4L2buf.m.offset);

上述代码在通过调用VIDIOC_QUERYBUF取得内核空间的缓冲区信息后，接着调用mmap函数把内核空间缓冲区映射到用户空间；关于mmap函数的用法，请读者查询相关资料；
6． 控制命令VIDIOC_QBUF
功能： 投放一个空的视频缓冲区到视频缓冲区输入队列中 ；
参数说明：参数类型为V4L2缓冲区数据结构类型    struct v4l2_buffer ；
返回值说明： 执行成功时，函数返回值为 0；函数执行成功后，指令(指定)的视频缓冲区进入视频输入队列，在启动视频设备拍摄图像时，相应的视频数据被保存到视频输入队列相应的视频缓冲区中。
使用举例：

struct v4l2_buffer tV4L2buf;
memset(&tV4L2buf, 0, sizeof(struct v4l2_buffer));
tV4L2buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
tV4L2buf.memory = V4L2_MEMORY_MMAP;
tV4L2buf.index = i; //指令（指定）要投放到视频输入队列中的内核空间视频缓冲区的编号；
iret = ioctl(fd_usbcam, VIDIOC_QBUF, &tV4L2buf);

7． 控制命令VIDIOC_STREAMON
功能： 启动视频采集命令，应用程序调用VIDIOC_STREAMON启动视频采集命令后，视频设备驱动程序开始采集视频数据，并把采集到的视频数据保存到视频驱动的视频缓冲区中。
参数说明：参数类型为V4L2的视频缓冲区类型 enum v4l2_buf_type ；
返回值说明： 执行成功时，函数返回值为 0；函数执行成功后，视频设备驱动程序开始采集视频数据，此时应用程序一般通过调用select函数来判断一帧视频数据是否采集完成，当视频设备驱动完成一帧视频数据采集并保存到视频缓冲区中时，select函数返回，应用程序接着可以读取视频数据；否则select函数阻塞直到视频数据采集完成。Select函数的使用请读者参考相关资料。
使用举例：

enum v4l2_buf_type v4l2type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fd_set    fds ;
struct timeval   tv;
iret = ioctl(fd_usbcam, VIDIOC_STREAMON, &v4l2type);
FD_ZERO(&fds);
FD_SET(fd_usbcam, &fds);
tv.tv_sec = 2; /* Timeout. */
tv.tv_usec = 0;
iret = select(fd_usbcam+ 1, &fds, NULL, NULL, &tv);

8． 控制命令VIDIOC_DQBUF        //第二个D是删除的意思
功能： 从视频缓冲区的输出队列中取得一个已经保存有一帧视频数据的视频缓冲区；
参数说明：参数类型为V4L2缓冲区数据结构类型    struct v4l2_buffer ；
返回值说明： 执行成功时，函数返回值为 0；函数执行成功后，相应的内核视频缓冲区中保存有当前拍摄到的视频数据，应用程序可以通过访问用户空间来读取该视频数据。（前面已经通过调用函数mmap做了用户空间和内核空间的内存映射）.
使用举例：

struct v4l2_buffer tV4L2buf;
memset(&tV4L2buf, 0, sizeof(struct v4l2_buffer));
tV4L2buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
tV4L2buf.memory = V4L2_MEMORY_MMAP;
iret = ioctl(fd_usbcam, VIDIOC_DQBUF, &tV4L2buf);

Sasoritattoo注释：VIDIOC_DQBUF命令结果 使从队列删除的缓冲帧信息 传给了此tVL2buf。V4L2_buffer结构体的作用就相当于申请的缓冲帧的代理，找缓冲帧的都要先问问它，通过它来联系缓冲帧，起了中间桥梁的作用。

9． 控制命令VIDIOC_STREAMOFF
功能： 停止视频采集命令，应用程序调用VIDIOC_ STREAMOFF停止视频采集命令后，视频设备驱动程序不在采集视频数据。
参数说明：参数类型为V4L2的视频缓冲区类型 enum v4l2_buf_type ；
返回值说明： 执行成功时，函数返回值为 0；函数执行成功后，视频设备停止采集视频数据。
使用举例：

enum v4l2_buf_type  v4l2type;
v4l2type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
iret = ioctl(fd_usbcam, VIDIOC_STREAMOFF, &v4l2type);

以上就是Linux 视频设备驱动V4L2最常用的控制命令使用说明，通过使用以上控制命令，可以完成一幅视频数据的采集过程。V4L2更多的控制命令使用说明请参考：***.org/spec/book1.htm