Linux下USB摄像头驱动研究

时间:2021-12-23 16:18:22

知识点

video4linux

Video4linux2(简称V4L2),是linux中关于视频设备的内核驱动。在Linux中,视频设备是设备文件,可以像访问普通文件一样对其进行读写,摄像头在/dev下。

使用命令ls /dev/video* 就可以显示所有的摄像头。


格式

首先我们必须要弄清楚自己使用的USB摄像头的输出格式

方法一:

使用命令lsusb

Bus 001 Device 007: ID 1871:01f0 AveoTechnology Corp.---上海嘉映微电子有限公司

再输入命令

lsusb -s 001:007 -v

这样可以显示详细的信息。

方法二:

利用ffmpeg的命令,可以打印信息:

[video4linux2,v4l2 @ 0x4cdd0] The driver changed the time per frame from 1/2 to 1/1
Input #0, video4linux2,v4l2, from '/dev/video2':
Duration: N/A, start: 55.844440, bitrate: 1228 kb/s
Stream #0:0: Video: rawvideo (YUY2 / 0x32595559), yuyv422, 320x240, 1228 kb/s, 1 fps, 1 tbr, 1000k tbn, 1000k tbc
Output #0, mp4, to '/home/f.mp4':
Metadata:
encoder : Lavf55.12.100
Stream #0:0: Video: mpeg4 ( [0][0][0] / 0x0020), yuv420p, 320x240, q=2-31, 200 kb/s, 16384 tbn, 2 tbc
Stream mapping:
Stream #0:0 -> #0:0 (rawvideo -> mpeg4)

可以看出,摄像头输出的是yuyv422。


标识符和结构体

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

struct v4l2_requestbuffers reqbufs;//向驱动申请帧缓冲的请求,里面包含申请的个数struct v4l2_capability cap;        //这个设备的功能,比如是否是视频输入设备struct v4l2_input input;           //视频输入struct v4l2_standard std;          //视频的制式,比如PAL,NTSCstruct v4l2_format fmt;            //帧的格式,比如宽度,高度等struct v4l2_buffer buf;            //代表驱动中的一帧v4l2_std_id stdid;                 //视频制式,例如:V4L2_STD_PAL_Bstruct v4l2_queryctrl query;       //查询的控制struct v4l2_control control;       //具体控制的值

操作摄像头流程

1. 打开设备文件。 int fd=open(”/dev/video0″,O_RDWR);
2. 取得设备的capability,看看设备具有什么功能,比如是否具有视频输入,或者音频输入输出等。VIDIOC_QUERYCAP,struct v4l2_capability
3. 选择视频输入,一个视频设备可以有多个视频输入。VIDIOC_S_INPUT,struct v4l2_input
4. 设置视频的制式和帧格式,制式包括PAL,NTSC,帧的格式个包括宽度和高度等。
VIDIOC_S_STD,VIDIOC_S_FMT,struct v4l2_std_id,struct v4l2_format
5. 向驱动申请帧缓冲,一般不超过5个。struct v4l2_requestbuffers
6. 将申请到的帧缓冲映射到用户空间,这样就可以直接操作采集到的帧了,而不必去复制。mmap
7. 将申请到的帧缓冲全部入队列,以便存放采集到的数据.VIDIOC_QBUF,struct v4l2_buffer
8. 开始视频的采集。VIDIOC_STREAMON
9. 出队列以取得已采集数据的帧缓冲,取得原始采集数据。VIDIOC_DQBUF
10. 将缓冲重新入队列尾,这样可以循环采集。VIDIOC_QBUF
11. 停止视频的采集。VIDIOC_STREAMOFF
12. 关闭视频设备。close(fd);


程序剖析

常用函数介绍

首先讲一下常用的一些功能函数:

void *calloc(unsigned n,unsigned size) 

功 能: 在内存的动态存储区中分配n个长度为size的连续空间,函数返回一个指向分配起始地址的指针;如果分配不成功,返回NULL。跟malloc的区别:calloc在动态分配完内存后,自动初始化该内存空间为零,而malloc不初始化,里边数据是随机的垃圾数据 。

void *memcpy(void *dest, const void *src, size_t n);
从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中
所需头文件include <string.h>

#include <sys/mman.h>
void *mmap(void *start, size_t length, int prot, int flags,int fd, off_t offset);
int munmap(void *start, size_t length);

mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上,如果文件的大小不是所有页的大小之和,最后一个页不被使用的空间将会清零

start:映射区的开始地址,设置为0时表示由系统决定映射区的起始地址
length:映射区的长度
prot:期望的内存保护标志,不能与文件的打开模式冲突。是以下的某个值,可以通过or运算合理地组合在一起 PROT_EXEC //页内容可以被执行
PROT_READ //页内容可以被读取
PROT_WRITE //页可以被写入
PROT_NONE //页不可访问
flags:指定映射对象的类型,映射选项和映射页是否可以共享
MAP_SHARED //与其它所有映射这个对象的进程共享映射空间。对共享区的写入,相当于输出到文件。直到msync()或者munmap()被调用,文件实际上不会被更新
fd:有效的文件描述词。一般是由open()函数返回,其值也可以设置为-1,此时需要指定flags参数中的MAP_ANON,表明进行的是匿名映射
offset:被映射对象内容的起点

成功执行时,mmap()返回被映射区的指针,munmap()返回0。失败时,mmap()返回MAP_FAILED[其值为(void *)-1],munmap返回-1




在程序中,我们使用摄像头,当然就要先打开摄像头

int fd = open("/dev/video0",O_RDWR,0);


然后就可以获取摄像头的信息,比如支持那些格式等

int ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);  

获取到的信息都保存在cap结构体中,这个结构体就是

struct v4l2_capability {  
        __u8    driver[16];     //i.e. "bttv"            //驱动名称,  
        __u8    card[32];       // i.e. "Hauppauge WinTV"         //  
        __u8    bus_info[32];   // "PCI:" + pci_name(pci_dev)     //PCI总线信息  
        __u32   version;        // should use KERNEL_VERSION()   
        __u32   capabilities;   // Device capabilities         //设备能力  
        __u32   reserved[4];  
}; 

其中,最重要的就是:视频捕获功能V4L2_CAP_VIDEO_CAPTURE或V4L2_CAP_STREAMING。


接下来就需要知道视频设备支持的视频格式,视频格式保存在一个结构体v4l2_fmtdesc 中,可以保存多中格式,

int ret;  
fmtdesc.index=0;  
fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
 ret=ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc);  
 while (ret != 0)  
  {  
     fmtdesc.index++;  
      ret=ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc);  
  }  
  printf("--------VIDIOC_ENUM_FMT---------\n");  
  printf("get the format what the device support\n{ pixelformat = ''%c%c%c%c'', description = ''%s'' }\n",fmtdesc.pixelformat & 0xFF, (fmtdesc.pixelformat >> 8) & 0xFF, (fmtdesc.pixelformat >> 16) & 0xFF,(fmtdesc.pixelformat >> 24) & 0xFF, fmtdesc.description);  

其中这个结构体的定义为:

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];  
};

其中最重要的就是视频的格式,例如YUV4:2:2


这里,可以先编写一个简单的例子

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm/types.h>
#include <linux/videodev2.h>


#define CAMERA_DEVICE "/dev/video0"


#define CAPTURE_FILE "frame_yuyv_new.jpg"
#define CAPTURE_RGB_FILE "frame_rgb_new.bmp"
#define CAPTURE_show_FILE "a.bmp"


#define VIDEO_WIDTH 640
#define VIDEO_HEIGHT 480
#define VIDEO_FORMAT V4L2_PIX_FMT_YUYV
#define BUFFER_COUNT 4

int fd;
struct v4l2_capability cap;
struct v4l2_fmtdesc fmtdesc;
struct v4l2_format fmt;
struct v4l2_requestbuffers reqbuf;
struct v4l2_buffer buf;
int main()
{
int i,ret;
fd = open(CAMERA_DEVICE, O_RDWR, 0);
if (fd < 0) {
printf("Open %s failed\n",CAMERA_DEVICE);
}
ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);
if (ret < 0) {
printf("VIDIOC_QUERYCAP failed (%d)\n", ret);
}

printf("------------VIDIOC_QUERYCAP-----------\n");
printf("Capability Informations:\n");
printf(" driver: %s\n", cap.driver);
printf(" card: %s\n", cap.card);
printf(" bus_info: %s\n", cap.bus_info);
printf(" version: %08X\n", cap.version);
printf(" capabilities: %08X\n\n", cap.capabilities);

memset(&fmtdesc,0,sizeof(fmtdesc));
fmtdesc.index=0;
fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ret=ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc);
while (ret != 0)
{
fmtdesc.index++;
ret=ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc);
}
printf("--------VIDIOC_ENUM_FMT---------\n");
printf("get the format what the device support\n");
printf("pixelformat = %c%c%c%c, description = %s \n",fmtdesc.pixelformat & 0xFF, (fmtdesc.pixelformat >> 8) & 0xFF, (fmtdesc.pixelformat >> 16) & 0xFF,(fmtdesc.pixelformat >> 24) & 0xFF, fmtdesc.description);


}


运行结果如下:

Linux下USB摄像头驱动研究











接下来就是设定视频的格式,设置的时候并不一定会成功,因此需要重新读取视频格式

VIDIOC_S_FMT 设置

VIDIOC_G_FMT 读取

VIDIOC_TRY_FMT 验证

先定义一个格式结构体

struct v4l2_format {
        enum v4l2_buf_type type;    //数据流类型,必须永远是V4L2_BUF_TYPE_VIDEO_CAPTURE
        union {
                struct v4l2_pix_format          pix;     // V4L2_BUF_TYPE_VIDEO_CAPTURE 
                struct v4l2_window              win;     // V4L2_BUF_TYPE_VIDEO_OVERLAY 
                struct v4l2_vbi_format          vbi;     // V4L2_BUF_TYPE_VBI_CAPTURE 
                struct v4l2_sliced_vbi_format   sliced;  // V4L2_BUF_TYPE_SLICED_VBI_CAPTURE 
                __u8    raw_data[200];                   // user-defined 
        } 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;
};
具体程序:

	fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width=VIDEO_WIDTH;
fmt.fmt.pix.height=VIDEO_HEIGHT;
fmt.fmt.pix.pixelformat=fmtdesc.pixelformat;//V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.field=V4L2_FIELD_INTERLACED;
ret = ioctl(fd, VIDIOC_S_FMT, &fmt);
if (ret < 0) {
printf("VIDIOC_S_FMT failed (%d)\n", ret);
return;
}
ret = ioctl(fd, VIDIOC_G_FMT, &fmt);
if (ret < 0) {
printf("VIDIOC_G_FMT failed (%d)\n", ret);
return;
}
printf("Stream Format Informations:\n");
printf(" type: %d\n", fmt.type);
printf(" width: %d\n", fmt.fmt.pix.width);
printf(" height: %d\n", fmt.fmt.pix.height);

假如一致,那么说明设置成功。



接下来就是分配内存,获取空间后,将其映射到用户空间,然后投放到视频输入队列中。因为程序无法直接访问内核空间。

申请缓冲区的一个重要的结构体就是:

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];
};

reqbuf.count = BUFFER_COUNT;
reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqbuf.memory = V4L2_MEMORY_MMAP;
ret = ioctl(fd , VIDIOC_REQBUFS, &reqbuf);

接下来程序就使用查询命令VIDIOC_QUERYBUF来查询缓冲区的状态,保存在结构体中,结构体是

struct v4l2_buffer {
        __u32                   index;
        enum v4l2_buf_type      type;
        __u32                   bytesused;
        __u32                   flags;
        enum v4l2_field         field;
        struct timeval          timestamp;
        struct v4l2_timecode    timecode;
        __u32                   sequence;
        ////////// memory location ////////
        enum v4l2_memory        memory;
        union {
                __u32           offset;
                unsigned long   userptr;
        } m;
        __u32                   length;
        __u32                   input;
        __u32                   reserved;
};
一般情况下,应用程序中调用VIDIOC_QUERYBUF取得了内核缓冲区信息后,紧接着调用mmap函数把内核空间地址映射到用户空间方便用户空间应用程序的访问

	reqbuf.count = BUFFER_COUNT;
reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqbuf.memory = V4L2_MEMORY_MMAP;
ret = ioctl(fd , VIDIOC_REQBUFS, &reqbuf);
if(ret < 0) {
printf("VIDIOC_REQBUFS failed (%d)\n", ret);

}
printf("the buffer has been assigned successfully!\n");

i=0;
for(i=0;i<reqbuf.count;i++)
{
buf.index =i;
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
ret = ioctl(fd , VIDIOC_QUERYBUF, &buf);
framebuf[i].length = buf.length;
framebuf[i].start = (char *) mmap(0, buf.length, PROT_READ|PROT_WRITE, MAP_SHARED, fd, buf.m.offset);
if (framebuf[i].start == MAP_FAILED) {
printf("mmap (%d) failed: %s\n", i, strerror(errno));
return;
}

ret = ioctl(fd , VIDIOC_QBUF, &buf);
if (ret < 0) {
printf("VIDIOC_QBUF (%d) failed (%d)\n", i, ret);
return;
}
printf("Frame buffer %d: address=0x%x, length=%d\n", i, (unsigned int)framebuf[i].start, framebuf[i].length);
}

接下来就是启动视频采集命令



完整截图程序如下

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm/types.h>
#include <linux/videodev2.h>


#define CAMERA_DEVICE "/dev/video0"


#define CAPTURE_FILE "frame_yuyv_new.yuyv"
#define CAPTURE_RGB_FILE "frame_rgb_new.bmp"
#define CAPTURE_show_FILE "a.bmp"


#define VIDEO_WIDTH 640
#define VIDEO_HEIGHT 480
#define VIDEO_FORMAT V4L2_PIX_FMT_YUYV
#define BUFFER_COUNT 4


#pragma pack(1)
typedef struct BITMAPFILEHEADER
{
unsigned short bfType;//位图文件的类型,
unsigned long bfSize;//位图文件的大小,以字节为单位
unsigned short bfReserved1;//位图文件保留字,必须为0
unsigned short bfReserved2;//同上
unsigned long bfOffBits;//位图阵列的起始位置,以相对于位图文件   或者说是头的偏移量表示,以字节为单位
} BITMAPFILEHEADER;
#pragma pack()
typedef struct BITMAPINFOHEADER//位图信息头类型的数据结构,用于说明位图的尺寸
{
unsigned long biSize;//位图信息头的长度,以字节为单位
unsigned long biWidth;//位图的宽度,以像素为单位
unsigned long biHeight;//位图的高度,以像素为单位
unsigned short biPlanes;//目标设备的级别,必须为1
unsigned short biBitCount;//每个像素所需的位数,必须是1(单色),4(16色),8(256色)或24(2^24色)之一
unsigned long biCompression;//位图的压缩类型,必须是0-不压缩,1-BI_RLE8压缩类型或2-BI_RLE4压缩类型之一
unsigned long biSizeImage;//位图大小,以字节为单位
unsigned long biXPelsPerMeter;//位图目标设备水平分辨率,以每米像素数为单位
unsigned long biYPelsPerMeter;//位图目标设备垂直分辨率,以每米像素数为单位
unsigned long biClrUsed;//位图实际使用的颜色表中的颜色变址数
unsigned long biClrImportant;//位图显示过程中被认为重要颜色的变址数
} BITMAPINFOHEADER;






typedef struct VideoBuffer {
void *start; //视频缓冲区的起始地址
size_t length;//缓冲区的长度
}VideoBuffer;
VideoBuffer framebuf[BUFFER_COUNT];
int fd;
struct v4l2_capability cap;
struct v4l2_fmtdesc fmtdesc;
struct v4l2_format fmt;
struct v4l2_requestbuffers reqbuf;
struct v4l2_buffer buf;

unsigned char *starter;
unsigned char *newBuf;
struct BITMAPFILEHEADER bfh;
struct BITMAPINFOHEADER bih;

void create_bmp_header()
{
bfh.bfType = (unsigned short)0x4D42;
bfh.bfSize = (unsigned long)(14 + 40 + VIDEO_WIDTH * VIDEO_HEIGHT*3);
bfh.bfReserved1 = 0;
bfh.bfReserved2 = 0;
bfh.bfOffBits= (unsigned long)(14 + 40);


bih.biBitCount = 24;
bih.biWidth = VIDEO_WIDTH;
bih.biHeight = VIDEO_HEIGHT;
bih.biSizeImage = VIDEO_WIDTH * VIDEO_HEIGHT * 3;
bih.biClrImportant = 0;
bih.biClrUsed = 0;
bih.biCompression = 0;
bih.biPlanes = 1;
bih.biSize = 40;//sizeof(bih);
bih.biXPelsPerMeter = 0x00000ec4;
bih.biYPelsPerMeter=0x00000ec4;
}


void yuyv2rgb()
{
unsigned char YUYV[4],RGB[6];
int j,k,i;
unsigned int location=0;
j=0;
for(i=0;i < framebuf[buf.index].length;i+=4)
{
YUYV[0]=starter[i];//Y0
YUYV[1]=starter[i+1];//U
YUYV[2]=starter[i+2];//Y1
YUYV[3]=starter[i+3];//V
if(YUYV[0]<1)
{
RGB[0]=0;
RGB[1]=0;
RGB[2]=0;
}
else
{
RGB[0]=YUYV[0]+1.772*(YUYV[1]-128);//b
RGB[1]=YUYV[0]-0.34413*(YUYV[1]-128)-0.71414*(YUYV[3]-128);//g
RGB[2]=YUYV[0]+1.402*(YUYV[3]-128);//r
}
if(YUYV[2]<0)
{
RGB[3]=0;
RGB[4]=0;
RGB[5]=0;
}
else
{
RGB[3]=YUYV[2]+1.772*(YUYV[1]-128);//b
RGB[4]=YUYV[2]-0.34413*(YUYV[1]-128)-0.71414*(YUYV[3]-128);//g
RGB[5]=YUYV[2]+1.402*(YUYV[3]-128);//r


}


for(k=0;k<6;k++)
{
if(RGB[k]<0)
RGB[k]=0;
if(RGB[k]>255)
RGB[k]=255;
}


//请记住:扫描行在位图文件中是反向存储的!
if(j%(VIDEO_WIDTH*3)==0)//定位存储位置
{
location=(VIDEO_HEIGHT-j/(VIDEO_WIDTH*3))*(VIDEO_WIDTH*3);
}
bcopy(RGB,newBuf+location+(j%(VIDEO_WIDTH*3)),sizeof(RGB));


j+=6;
}
return;
}





int main()
{
int i,ret;
fd = open(CAMERA_DEVICE, O_RDWR, 0);
ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);

memset(&fmtdesc,0,sizeof(fmtdesc));
fmtdesc.index=0;
fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ret=ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc);
while (ret != 0)
{
fmtdesc.index++;
ret=ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc);
}
memset(&fmt,0,sizeof(fmt));
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width=VIDEO_WIDTH;
fmt.fmt.pix.height=VIDEO_HEIGHT;
fmt.fmt.pix.pixelformat=fmtdesc.pixelformat;//V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.field=V4L2_FIELD_INTERLACED;
ret = ioctl(fd, VIDIOC_S_FMT, &fmt);
ret = ioctl(fd, VIDIOC_G_FMT, &fmt);
reqbuf.count = BUFFER_COUNT;
reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqbuf.memory = V4L2_MEMORY_MMAP;
ret = ioctl(fd , VIDIOC_REQBUFS, &reqbuf);

i=0;
for(i=0;i<reqbuf.count;i++)
{
buf.index =i;
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
ret = ioctl(fd , VIDIOC_QUERYBUF, &buf);
framebuf[i].length = buf.length;
framebuf[i].start = (char *) mmap(0, buf.length, PROT_READ|PROT_WRITE, MAP_SHARED, fd, buf.m.offset);
if (framebuf[i].start == MAP_FAILED) {
printf("mmap (%d) failed: %s\n", i, strerror(errno));
return;
}

ret = ioctl(fd , VIDIOC_QBUF, &buf);
if (ret < 0) {
printf("VIDIOC_QBUF (%d) failed (%d)\n", i, ret);
return;
}
printf("Frame buffer %d: address=0x%x, length=%d\n", i, (unsigned int)framebuf[i].start, framebuf[i].length);
}



enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ret = ioctl(fd, VIDIOC_STREAMON, &type);
ret = ioctl(fd, VIDIOC_DQBUF, &buf);

FILE *fp = fopen(CAPTURE_FILE, "wb");
fwrite(framebuf[buf.index].start, 1, buf.length, fp);
fclose(fp);

int n_len=framebuf[buf.index].length*3/2;
newBuf=calloc((unsigned int)n_len,sizeof(unsigned char));
starter=(unsigned char *)framebuf[buf.index].start;



yuyv2rgb();
create_bmp_header();

FILE *fp1 = fopen(CAPTURE_RGB_FILE, "wb");
fwrite(&bfh,sizeof(bfh),1,fp1);
fwrite(&bih,sizeof(bih),1,fp1);
fwrite(newBuf, 1, n_len, fp1);
fclose(fp1);
ret = ioctl(fd, VIDIOC_QBUF, &buf);
for (i=0; i< 4; i++)
{
munmap(framebuf[i].start, framebuf[i].length);
}
close(fd);
}











未完待续