Camera 驱动和编程

Camera 驱动和编程

了解了framebuffer，摄像头便只是fb的数据来源而已。

先了解些相关的概念：

V4L2(video 4 linux 2)

可以支持多种设备,它可以有以下几种接口:

1.视频采集接口(video capture interface):这种应用的设备可以是高频头或者摄像头. V4L2的最初设计就是应用于这种功能的.

2. 视频输出接口(video output interface):可以驱动计算机的外围视频图像设备--像可以输出电视信号格式的设备.

3. 直接传输视频接口(video overlay interface):它的主要工作是把从视频采集设备采集过来的信号直接输出到输出设备之上,而不用经过系统的CPU.

4. 视频间隔消隐信号接口(VBI interface):它可以使应用可以访问传输消隐期的视频信号.

5. 收音机接口(radio interface):可用来处理从AM或FM高频头设备接收来的音频流.

Video4linux下视频编程的流程：

（1）打开视频设备：

（2）读取设备信息

（3）更改设备当前设置（没必要的话可以不做）

（4）进行视频采集，两种方法:

a.内存映射

b.直接从设备读取

（5）对采集的视频进行处理

（6）关闭视频设备。

/* 这样的流程地球人都晓得*/

关键步骤介绍：

（1）打开视频：

Open（”/dev/video0”，vdàfd);

关闭视频设备用close（”/dev/video0”，vdàfd);

（2）读video_capability中信息

ioctl(vd->fd, VIDIOCGCAP, &(vd->capability))

成功后可读取vd->capability各分量eg.

（3）读video_picture中信息

ioctl(vd->fd, VIDIOCGPICT, &(vd->picture))；（4）改变video_picture中分量的值（可以不做的）先为分量赋新值，再调用VIDIOCSPICT

Eg.

vd->picture.colour = 65535;

if(ioctl(vd->fd, VIDIOCSPICT, &(vd->picture)) < 0) {

perror("VIDIOCSPICT");

return -1;

}

（5）初始化channel （可以不做的）

必须先做得到vd->capability中的信息

for (i = 0; i < vd->capability.channels; i++)

vd->channel[i].channel = i;

if (ioctl(vd->fd, VIDIOCGCHAN, &(vd->channel[i])) < 0)

{

perror("v4l_get_channel:");

return -1;

}

}

/* 通过ioctl，将struct v4l_struct作为参数的设备操作而已，那么重点将是整个结构体：s truct v4l_struct*/

typedef struct v4l_struct

{

int fd;

struct video_capability capability;

struct video_channel channel[4];

struct video_picture picture;

struct video_window window;

struct video_capture capture;

struct video_buffer buffer;

struct video_mmap mmap;

struct video_mbuf mbuf;

unsigned char *map;

int frame;

int framestat[2];

}vd;

/* 那么，对该结构体的了解便成了关键*/

Video4linux支持的数据结构及其用途

（1）video_capability包含设备的基本信息（设备名称、支持的最大最小分辨率、信号源信息等）,包含的分量：

name[32] //设备名称

maxwidth ,

maxheight,

minwidth,

minheight

Channels //信号源个数

type //是否能capture，彩色还是黑白，是否能裁剪等等。值如VID_TYPE_CAPTURE等（2）video_picture设备采集的图象的各种属性

brightness 0~65535

hue

colour

contrast

whiteness

depth // 24

palette // VIDEO_PALETTE_RGB24

（3）video_channel关于各个信号源的属性

Channel //信号源的编号

name

tuners

Type // VIDEO_TYPE_TV | IDEO_TYPE_CAMERA

Norm制式

（4）video_window //包含关于capture area的信息

x x windows 中的坐标.

y x windows 中的坐标.

width The width of the image capture.

height The height of the image capture.

chromakey A host order RGB32 value for the chroma key. flags Additional capture flags.

clips A list of clipping rectangles. (Set only)

clipcount The number of clipping rectangles. (Set only)（5）video_mbuf //利用mmap进行映射的帧的信息

size //每帧大小

Frames //最多支持的帧数

Offsets //每帧相对基址的偏移

（6）video_buffer 最底层对buffer的描述

void *baseBase // physical address of the buffer

int height // Height of the frame buffer

int width // Width of the frame buffer

int depth // Depth of the frame buffer

int bytesperline // Number of bytes of memory between the start of two adjacent li nes

实际显示的部分一般比它描述的部分小

（7）video_mmap//用于mmap

背景：

阅读新闻

Camera 驱动和编程

[日期：2012-12-31] 来源：Linux社区作者：iibull [字体：大中小]

重点：

用mmap（内存映射）方式截取视频

mmap( )系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以向访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。

两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A 可以即时看到进程B对共享内存中数据的更新，反之亦然

采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝

（1）设置picture的属性

（2）初始化video_mbuf，以得到所映射的buffer的信息

ioctl(vd->fd, VIDIOCGMBUF, &(vd->mbuf))

（3）可以修改video_mmap和帧状态的当前设置

Eg. vd->mmap.format = VIDEO_PALETTE_RGB24

vd->framestat[0] = vd->framestat[1] = 0; vd->frame = 0;

（4）将mmap与video_mbuf绑定

void* mmap ( void * addr , size_t len , int prot , int flags , int fd , off_t offset )

len // 映射到调用进程地址空间的字节数，它从被映射文件开头offset个字节开始算起

Prot // 指定共享内存的访问权限PROT_READ（可读）, PROT_WRITE （可写）, PROT_EXEC （可执行）flags // MAP_SHARED MAP_PRIVATE中必选一个// MAP_ FIXED不推荐使用addr //共内存享的起始地址，一般设0，表示由系统分配

Mmap( ) // 返回值是系统实际分配的起始地址

if((vd->map = (unsigned char*)mmap(0, vd->mbuf.size, PROT_READ|PROT_WRITE, MAP_SHARED,

vd->fd, 0)) < 0)

{

perror("v4l_mmap mmap:");

return -1;

}

（5）Mmap方式下真正做视频截取的VIDIOCMCAPTURE

ioctl(vd->fd, VIDIOCMCAPTURE, &(vd->mmap)) ;

若调用成功，开始一帧的截取，是非阻塞的，

是否截取完毕留给VIDIOCSYNC来判断

（6）调用VIDIOCSYNC等待一帧截取结束

if(ioctl(vd->fd, VIDIOCSYNC, &frame) < 0)

{

perror("v4l_sync:VIDIOCSYNC");

return -1;

}

若成功，表明一帧截取已完成。可以开始做下一次VIDIOCMCAPTURE

frame是当前截取的帧的序号。

****关于双缓冲：

video_mbuf mbuf.frames = 2; //一帧被处理时可以采集另一帧

int frame; //当前采集的是哪一帧

int framestat[2]; //帧的状态没开始采集| 等待采集结束

帧的地址由 vd->map+ vd->mbuf.offsets[vd->frame]得到

采集工作结束后调用munmap取消绑定

munmap(vd->map, vd->mbuf.size)

/* 关于直接读取的方式，太落伍，不再赘述*/

背景：

阅读新闻

Camera 驱动和编程

[日期：2012-12-31] 来源：Linux社区作者：iibull [字体：大中小] 我们要区分video为顺序式和交错式：

顺序式video顺序的传输video image所有的行，

交错式video则把一个video划分成两个fields，分别保存video image的奇数行和偶数行，被称作奇数field 和偶数field.

阴极射线电视机需要交替的显示行来组成一个完整的帧，交替的时延需要我们交替的传输奇数field和偶数field.

这个奇怪的技术的引用是因为：在刷新率接近电影时，图片会消退的过快。使用field可以避免使用double buffer以及额外的带宽需求。

首先要明确camera并不是在同一时间曝光一帧，camera通过许多fields来传输这些帧的，这些field是在

不同瞬间拍照。屏幕上的一个对象因此会在两个field之间产生动画效果。这种情况下需要识别哪一帧更老一点，也称作“瞬间序”

当驱动通过fields 提供或者接收images，应用层应该知道如何通过这些fields组合成帧，通过划分为top bottom field, “空间序”:

top field的第一行是帧的第一行,

bottom field的第一行是帧的第二行。

/* 问题：多个fields和一个完整的帧的关系*/

然而因为field是一个跟着一个拍的，争论帧是由top还是bottom开始的是没意义的，任何两个相邻的top bottom field, 或者bottom top field都可以组成一个有效的帧。

与直觉相反top field不一定是older field, older filed是否包含top 或者bottom lines是由video标准决定的. 因此要区分瞬间序和空间序。下面的图会给出清晰的解释。

所有的video capture和out devices必须汇报当前的field顺序。一些驱动可能允许选择不同的序，end 应用可以在调用VIDIOC_S_FMT前初始化struct v4l2_pix_format的field成员。否则可以使用

V4L2_FIELD_ANY

下面列出了可能的field类型

V4L2_FIELD_ANY 0Application 可以请求使用这个参数，如果

V4L2_FIELD_NONE, V4L2_FIELD_TOP,

V4L2_FIELD_BOTTOM Ｖ4L2_FIELD_INTERLACE 中任何一个格式都支持．驱动选择使用哪一个格式依赖于硬件能力，以及请求的image尺寸，驱动选择一个然后返回这个格式。struct_buffer的field成员不可以为

V4L2_FIELD_ANY.

V4L2_FIELD_NONE 1Images是顺序式格式，驱动可以指定这种order，当驱动无法区分V4L2_FIELD_TOP和V4L2_FIELD_BOTTOM

V4L2_FIELD_TOP 2

Images仅仅包含top field

V4L2_FIELD_BOTTOM 3Images仅仅包含bottom field. 应用可能希望防止设备捕获interlaced的图片，因为这种图片会在运动物体周围产生毛状特效

V4L2_FIELD_INTERLACED 4Images包含top和bottom field, 隔行交替，fields的瞬间序依赖于当前video的标准。Ｍ/NTSC首先传输bottom field, 其他的则先传输top field

V4L2_FIELD_SEQ_TB 5Images包含top和bottom field, top field的行首先存放在memory中，然后紧跟着bottom field的行。Fields 一直以瞬间序存储，较老的放在内存前面。Images的尺寸和帧相关，而不是field

V4L2_FIELD_SEQ_BT 6Images包含top和bottom field, bottom field的行首先存放在memory中，然后紧跟着top field的行。Fields 一直以瞬间序存储，较老的放在内存前面。Images的尺寸和帧相关，而不是field

V4L2_FIELD_ALTERATE 7一个帧的两个field分别放在不同的buffer, 按照瞬间序，也就是说老的一个是第一个。driver或者应用指明field

的奇偶性（奇偶性：当前的field是top 还是bottom field）. 任何两个连续的field构成一个frame，是否两个field是连续的，不需要drop掉他们，可以通过v4l2_buffer中的sequence 成员判定。Images的尺寸和frame而不是fields相关

V4L2_FIELD_INTERLACED_TB 8Images 包含top和bottom field, 每行交替，top field 在前面。top field首先传送

V4L2_FIELD_INTERLACED_BT 9Images 包含top和bottom field, 每行交替，bottom field在前面。bottom field首先传送

Field Order, Top Field First Transmitted

Field Order, Bottom Field First Transmitted

背景：

阅读新闻

Camera 驱动和编程

[日期：2012-12-31] 来源：Linux社区作者：iibull [字体：大中小] /*一点小小的补充，两篇文章足以掌握摄像头的编程方法*/

Video4Linux(简V4L)是Linux中关于视频设备的内核驱动，它为针对视频设备的应用程序编程提供一系列接口函数，这些视频设备包括现今市场上流行的TV卡、视频捕捉卡和USB摄像头等。对于USB口摄像头，其驱动程序中需要提供基本的I/O操作接口函数open、read、write、close的实现。

对中断的处理实现，内存映射功能以及对I/O通道的控制接口函数ioct1的实现等，并把它们定义在struct file_operations中。这样当应用程序对设备文件进行诸如open、close、read、write等系统调用操作时，Linux内核将通过file_operations结构访问驱动程序提供的函数。例如，当应用程序对设备文件执行读操作时，内核将调用file_operations结构中的read函数。

在系统平台上对USB口数码摄像头驱动，首先把USB控制器驱动模块静态编译进内核，使平台中支持USB 接口，再在需要使用摄像头采集时，使用insmod动态加载其驱动模块，这样摄像头就可正常工作了，接着进行了下一步对视频流的采集编程。

程序中定义的数据结构

struct video_capability grab_cap;

struct video_picture grab_pic;

struct video_mmap grab_buf;

struct video_mbuf grab_vm；

这些数据结构都是由Video4Linux支持的，它们的用途如下：

*video_capability包含摄像头的基本信息，例如设备名称、支持的最大最小分辨率、信号源信息等，分别对应着结构体中成员变量name [32]、maxwidth、maxheight、minwidth、minheight、channels(信号源个数)、type等；

*video_picture包含设备采集图像的各种属性，如brightness(亮度)、hue(色调)、contrast(对比度)、whiteness(色度)、depth(深度)等；

*video_mmap用于内存映射；

*video_mbuf利用mmap进行映射的帧信息，实际上是输入到摄像头存储器缓冲中的帧信息，包括size （帧的大小）、frames（最多支持的帧数）、offsets（每帧相对基址的偏移）。

程序中用到的主要系统调用函数有：

open("/dev/voideo0",int flags)、

close(fd)、

mmap(void *start,size_t length,int prot,int flags,int fd,off_t offset)、

munmap(void *start,size_tlength)、

ioctl(int fd,int cmd,…)。

前面提到Linux系统中把设备看成设备文件，在用户空间可以通过标准的I/O系统调用函数操作设备文件，从而达到与设备通信交互的目的。当然，在设备驱动中要提供对这些函数的相应支持。

这里说明一下ioctl(int fd,int cmd,…)函数，它在用户程序中用来控制I/O通道，其中，fd代表设备文件描述符，cmd代表用户程序对设备的控制命令，省略号一般是一个表示类型长度的参数，也可没有。

***采集程序实现过程***

首先打开视频设备，摄像头在系统中对应的设备文件为/dev/video0，采用系统调用函数

grab_fd=open("/dev/video0", O_RDWR),grab_fd是设备打开后返回的文件描述符（打开错误返回-1），以后的系统调用函数就可使用它来对设备文件进行操作了。

接着，利用 ioctl（grab_fd,VIDIOCGCAP,&grab_cap）函数读取struct video_capability中有关摄像头的信息。该函数成功返回后，这些信息从内核空间拷贝到用户程序空间grab_cap各成员分量中，使用printf 函数就可得到各成员分量信息，例如printf("maxheight=%d",grab_fd.maxheight)获得最大垂直分辨率的

大小。

用ioctl(grab_fd,VIDIOCGPICT,&grab_pic) 函数读取摄像头缓冲中video_picture信息。在用户空间程序中可以改变这些信息，具体方法为先给分量赋新值，再调用VIDIOCSPICT ioctl函数，例如：grab_pic.depth=3;

if(ioctl(grab_fd, VIDIOCSPICT, &grab_pic)<0)

{

perror("VIDIOCSP[1]ICT");

return -1;

};

完成以上初始化设备工作后，就可以对视频图像截取了，有两种方法：

一种是read()直接读取； // 通过内核缓冲区来读取数据

另外一种mmap()内存映射。

/* mmap()通过把设备文件映射到内存中，绕过了内核缓冲区，最快的磁盘访问往往还是慢于最慢的内存访问，所以mmap()方式加速了I/O访问。

另外，mmap()系统调用使得进程之间通过映射同一文件实现共享内存，各进程可以像访问普通内存一样对文件进行访问，访问时只需要使用指针而不用调用文件操作函数。因为mmap()的以上优点，所以在程序实现中采用了内存映射方式，即mmap()方式。*/

利用mmap()方式视频裁取具体进行操作如下。

①先使用ioctl(grab_fd, VIDIOCGMBUF, &grab_vm) 函数获得摄像头存储缓冲区的帧信息，

之后修改video_mmap中的设置，例如重新设置图像帧的垂直及水平分辨率、彩色显示格式。可利用如下语句

grab_buf.height=240;

grab_buf.width=320;

grab_buf.format=VIDEO_PALETTE_RGB24;

②接着把摄像头对应的设备文件映射到内存区，具体使用

grab_data=(unsigned char*)mmap(0, grab_vm.size, PROT_READ|PROT_WRITE,

MAP_SHARED, grad_fd, 0)

这样设备文件的内容就映射到内存区，该映射内容区可读可写并且不同进程间可共享。该函数成功时返回映像内存区的指针，挫败时返回值为-1。

背景：

阅读新闻

Camera 驱动和编程

[日期：2012-12-31] 来源：Linux社区作者：iibull [字体：大中小] 下面对单帧采集和连续帧采集进行说明：

*单帧采集

在上面获取的摄像头存储缓冲区帧信息中，最多可支持的帧数（frames的值）一般为两帧。对于单帧采集只需设置grab_buf.frame=0，即采集其中的第一帧，使用ioctl(grab_fd,VIDIOCMCAPTURE,&grab_buf) 函数，若调用成功，则激活设备真正开始一帧图像的截取，是非阻塞的。

接着使用ioctl(grab_fd,VIDIOCSYNC,&frame) 函数判断该帧图像是否截取完毕，成功返回表示截取完毕，之后就可把图像数据保存成文件的形式。

ioctl (grab_fd, VIDIOCMCAPTURE, &grab_buf)

ioctl (grab_fd, VIDIOCSYNC, &frame)

*连续帧采集

在单帧的基础上，利用grab_fd.frames值确定采集完毕摄像头帧缓冲区帧数据进行循环的次数。

在循环语句中，也是使用VIDIOCMCCAPTURE ioct1和VIDIOCSYNC ioctl函数完成每帧截取，但要给采集到的每帧图像赋地址，利用语句buf=grab_data+grab_vm.offsets[frame],然后保存文件的形式。

若要继续采集可再加一个外循环，在外循环语句只要给原来的内循环再赋frame=0即可。

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

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#define CLEAR(x) memset (&(x), 0, sizeof (x))

struct buffer {

void * start;

size_t length;

};

static char * dev_name = "/dev/video0";

static int fd = -1;

struct buffer * buffers = NULL;

FILE *file_fd;

static unsigned long file_length;

static unsigned char *file_name;

int main (int argc,char ** argv)

{

struct v4l2_capability cap;

struct v4l2_format fmt;

file_fd = fopen("test.jpg", "w");

fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0); ioctl (fd, VIDIOC_QUERYCAP, &cap);

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;

fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

ioctl (fd, VIDIOC_S_FMT, &fmt);

file_length = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height; buffers = calloc (1, sizeof (*buffers));

buffers[0].length = file_length;

buffers[0].start = malloc (file_length);

for (;;)

{

fd_set fds;

struct timeval tv;

int r;

FD_ZERO (&fds);

FD_SET (fd, &fds);

/* Timeout. */

https://www.360docs.net/doc/fc3922052.html,_sec = 3;

https://www.360docs.net/doc/fc3922052.html,_usec = 0;

r = select (fd + 1, &fds, NULL, NULL, &tv);

if (-1 == r) {

if (EINTR == errno)

continue;

printf ("select");

}

if (0 == r) {

fprintf (stderr, "select timeout\n");

exit (EXIT_FAILURE);

}

if (read (fd, buffers[0].start, buffers[0].length))

break;

}

fwrite(buffers[0].start, buffers[0].length, 1, file_fd);

free (buffers[0].start);

close (fd);

fclose (file_fd);

exit (EXIT_SUCCESS);

return 0;

}

linux 下视频设备设置的几个参数v4l video4linux v4l2 ioctl

用一系列的ioctl发命令控制设备。v4l支持的ioctl命令大概有二十几个，为了尽快的编出一个

简单的图象捕捉程序，让我们先来看看几个主要的命令：

1. ioctl(fd,VIDIOCGCAP,&cap);

该命令主要是为了获取电视卡的功能信息。例如电视卡的名称，类型，channel等。参数cap是一个结构，当ioctl命令返回时，结构的各成员就被赋值了，结构体的定义为：

struct video_capability

{

char name[32];

int type;

int channels; /* Num channels */

int audios; /* Num audio devices */

int maxwidth; /* Supported width */

int maxheight; /* And height */

int minwidth; /* Supported width */

int minheight; /* And height */

};

channel 指的是有几个信号输入源，例如television,composite,s-video等。

2.ioctl(fd,VIDIOCGCHAN,&vc)

3.ioctl(fd,VIDIOCSCHAN.&vc)

这两个命令用来取得和设置电视卡的channel信息，例如使用那个输入源，制式等。vc 是一个video_channel结构，其定义为：

struct video_capability

{

char name[32];

int type;

int channels; /* Num channels */

int audios; /* Num audio devices */

int maxwidth; /* Supported width */

int maxheight; /* And height */

int minwidth; /* Supported width */

int minheight; /* And height */

};

struct video_channel

{

int channel;

char name[32];

int tuners; //number of tuners for this input

__u32 flags;

__u16 type;

__u16 norm;

};

成员channel代表输入源，通常，

0: television 1:composite1 2:s-video

name 表示该输入源的名称。

norm 表示制式，通常，

0:pal 1:ntsc 2:secam 3:auto

4. ioctl(fd,VIDIOCGMBUF,*mbuf)

获得电视卡缓存的信息，参数mbuf是video_mbuf结构。其定义如下：

struct video_mbuf

{

int size; /* Total memory to map */

int frames; /* Frames */

int offsets[VIDEO_MAX_FRAME];

};

size是缓存的大小，frames表明该电视卡的缓存可以容纳的帧数，数组offsets则表明

对应一帧的起始位置，0帧对应offsets[0],1帧对应offsets[1]....

执行完该命令后，就可以用mmap函数将缓存映射到内存中了。大致用法可以参考以下的代

码

struct video_mbuf mbuf;

unsigned char *buf1,*buf2;

if(ioctl(fd,VIDIOCGMBUF,&mbuf)<0)

{

perror("VIDIOCGMBUF");

return -1;

}

printf("the frame number is %d/n",mbuf.frames);

buf1 = (unsigned char*)mmap(0,mbuf.size,PROT_READ|PROT_WRITE,MAP_SHARED,fd.0);

buf1 = buf1 + mbuf.offset[0];

buf2 = buf1 + mbuf.offset[1];//当然，如果mbuf.frames=1,就不需要下面的了。

......

5. ioctl(fd.VIDIOCMCAPTURE，&mm)

启动硬件去捕捉图象，mm 是video_mmap 结构，设置捕捉图象需要设置的信息。结构体

如下定义：

struct video_mmap

{

unsigned int frame; /* Frame (0 - n) for double buffer */

int height,width;

unsigned int format; /* should be VIDEO_PALETTE_* */

};

frame :设置当前是第几帧

height,width:设置图象的高和宽。

format :颜色模式

要注意的是，该命令是非阻塞的，也就是说，它仅仅设置了硬件，而不负责是否捕捉到图象。

要确定是否捕捉到图象，要用到下一个命令。

6. ioctl(fd,VIDIOCSYNC,&frame)

等待捕捉到这一帧图象。frame 是要等待的图象，它的值应和上一个命令中设置的frame相对应。好了，说了这么多，读者大概也对视频捕捉有了一个了解，是不是想亲自动手试一下，那就让我们开始实际程序的编写吧。

下面我们会编一个程序，将捕捉到的图象存为jpeg文件。为此，还要向大家介绍一个函数，int write_jpeg(char *filename,unsigned char *buf, int quality,int width, int height, int gray) {

struct jpeg_compress_struct cinfo;

struct jpeg_error_mgr jerr;

FILE *fp;

int i;

unsigned char *line;

int line_length;

if (NULL == (fp = fopen(filename,"w")))

{

fprintf(stderr,"grab: can't open %s: %s/n",filename,strerror (errno));

return -1;

}

cinfo.err = jpeg_std_error(&jerr);

jpeg_create_compress(&cinfo);

jpeg_stdio_dest(&cinfo, fp);

cinfo.image_width = width;

cinfo.image_height = height;

cinfo.input_components = gray ? 1: 3;

cinfo.in_color_space = gray ? JCS_GRAYSCALE: JCS_RGB;

jpeg_set_defaults(&cinfo);

jpeg_set_quality(&cinfo, quality, TRUE);

jpeg_start_compress(&cinfo, TRUE);

line_length = gray ? width : width * 3;

for (i = 0, line = buf; i < height; i++, line += line_length)

jpeg_write_scanlines(&cinfo, &line, 1);

jpeg_finish_compress(&(cinfo));

jpeg_destroy_compress(&(cinfo));

fclose(fp);

return 0;

}

这个函数很通用，它的作用是把buf中的数据压缩成jpeg格式。

/* 下面是一个完整的程序test.c

* gcc test.c -o test -ljpeg

*/

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#define WIDTH 320

#define HEIGHT 240

#define V4L_DEVICE "/dev/video0"

main()

{

unsigned char* buf;

int i,j;

int fd;

int re;

struct video_capability vcap;

struct video_channel vc;

struct video_mbuf mbuf;

struct video_mmap mm;

fd = open(V4L_DEVICE, O_RDWR);

if(fd<=0)

{

perror("open");

exit(1);

}

if(ioctl(fd, VIDIOCGCAP, &vcap)<0)

{

perror("VIDIOCGCAP");

exit(1);

}

fprintf(stderr,"Video Capture Device Name : %s/n",https://www.360docs.net/doc/fc3922052.html,);