Linux下V4L2一个调试问题方法可以改参数

http://blog.csdn.net/tankai19880619/article/details/9997505

一、源码

1.test.c

[cpp] view
plain copy

#include <fcntl.h>

#include <stdlib.h>

#include <sys/mman.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <linux/videodev2.h>

#include "test.h"

int fd = 0;

int v4l2QueryControl(int control, struct v4l2_queryctrl *queryctrl)

{

int err =0;

queryctrl->id = control;

if ((err= ioctl(fd, VIDIOC_QUERYCTRL, queryctrl)) < 0) {

printf("ioctl querycontrol error %d,%d \n",errno,control);

} else if (queryctrl->flags & V4L2_CTRL_FLAG_DISABLED) {

printf("control %s disabled \n", (char *) queryctrl->name);

} else if (queryctrl->flags & V4L2_CTRL_TYPE_BOOLEAN) {

return 1;

} else if (queryctrl->type & V4L2_CTRL_TYPE_INTEGER) {

return 0;

} else {

printf("contol %s unsupported \n", (char *) queryctrl->name);

}

return -1;

}

int v4l2GetControl(int control)

{

struct v4l2_queryctrl queryctrl;

struct v4l2_control control_s;

int err;

if (v4l2QueryControl(control, &queryctrl) < 0)

return -1;

control_s.id = control;

if ((err = ioctl(fd, VIDIOC_G_CTRL, &control_s)) < 0) {

printf("ioctl get control error\n");

return -1;

}

return control_s.value;

}

int main(){

//////

int result = mkdir("./v4l2test/",S_IFDIR+S_ISGID+S_IRWXU+S_IRWXG+S_IRWXO);

/////////////1280*720 mjpeg

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

printf("TK------->>>fd is %d\n",fd);

//////

struct v4l2_capability cap;

ioctl(fd,VIDIOC_QUERYCAP,&cap);

printf("TK---------->>>>>Driver Name:%s\nCard Name:%s\nBus info:%s\n",cap.driver,cap.card,cap.bus_info);

//////

struct v4l2_fmtdesc fmtdesc;

fmtdesc.index = 0; fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc) != -1){

printf("TK-------->>>>>fmtdesc.description is %s\n",fmtdesc.description);

fmtdesc.index ++;

}

//////

struct v4l2_format fmt;

memset(&fmt,0,sizeof(fmt));

fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

fmt.fmt.pix.width = 1280;

fmt.fmt.pix.height = 720;

fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;

fmt.fmt.pix.field = V4L2_FIELD_NONE;//V4L2_FIELD_INTERLACED;

fmt.fmt.pix.colorspace = 8;

int fmtreslt = ioctl(fd,VIDIOC_S_FMT,&fmt);

printf("TK--------_>>>>fmtreslt is %d\n",fmtreslt);

fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

ioctl(fd,VIDIOC_G_FMT,&fmt);

printf("TK----------->>>>>fmt.fmt.width is %d\nfmt.fmt.pix.height is %d\nfmt.fmt.pix.colorspace is %d\n",fmt.fmt.pix.width,fmt.fmt.pix.height,fmt.fmt.pix.colorspace);

////////////////////////////////////////////////start

struct v4l2_requestbuffers req;

req.count = 4;

req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

req.memory = V4L2_MEMORY_MMAP;

ioctl(fd,VIDIOC_REQBUFS,&req);

struct buffer{

void *start;

unsigned int length;

}*buffers;

buffers = (struct buffer*)calloc (req.count, sizeof(*buffers));

unsigned int n_buffers = 0;

for(n_buffers = 0; n_buffers < req.count; ++n_buffers){

struct v4l2_buffer buf;

memset(&buf,0,sizeof(buf));

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = n_buffers;

if(ioctl(fd,VIDIOC_QUERYBUF,&buf) == -1){

printf("TK---------_>>>>>>error\n");

close(fd);

exit(-1);

}

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){

printf("TK--------__>>>>>error 2\n");

close(fd);

exit(-1);

}

}

////

unsigned int i;

enum v4l2_buf_type type;

for(i = 0; i < 4; i++){

struct v4l2_buffer buf;

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = i;

ioctl(fd,VIDIOC_QBUF,&buf);

}

type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

ioctl(fd,VIDIOC_STREAMON,&type);

////

unsigned int j;

for(j = 0; j < 4; j++){

struct v4l2_buffer buf;

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = 0;

ioctl(fd,VIDIOC_DQBUF,&buf);

char path[30];

snprintf(path,sizeof(path),"./v4l2test/720pmjpeg%d",buf.index);

int fdyuyv = open(path,O_WRONLY|O_CREAT,00700);

printf("TK--------->>>>fdyuyv is %d\n",fdyuyv);

int resultyuyv = write(fdyuyv,buffers[buf.index].start,1280*720*2);

printf("TK--------->>>resultyuyv is %d\n",resultyuyv);

close(fdyuyv);

}

ioctl(fd,VIDIOC_STREAMOFF,&type);

for(i = 0; i < 4; i++)

munmap(buffers[i].start,buffers[i].length);

free(buffers);

usleep(10000);

close(fd);

///////////////////////////////////////////////////////////////////////////end

//////1280*720 yuyv

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

printf("TK------------>>>start 2222222222222222\n");

ioctl(fd, VIDIOC_QUERYCAP, &cap);

memset(&fmt,0,sizeof(fmt));

fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

fmt.fmt.pix.width = 1280;

fmt.fmt.pix.height = 720;

fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;

fmt.fmt.pix.field = V4L2_FIELD_NONE;//V4L2_FIELD_INTERLACED;

fmt.fmt.pix.colorspace = 8;

fmtreslt = ioctl(fd,VIDIOC_S_FMT,&fmt);

printf("TK--------_>>>>fmtreslt is %d\n",fmtreslt);

fmtreslt = ioctl(fd,VIDIOC_TRY_FMT,&fmt);

printf("TK--------_>>>>fmtreslt is %d\n",fmtreslt);

fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

ioctl(fd,VIDIOC_G_FMT,&fmt);

printf("TK----------->>>>>fmt.fmt.width is %d\nfmt.fmt.pix.height is %d\nfmt.fmt.pix.colorspace is %d\n",fmt.fmt.pix.width,fmt.fmt.pix.height,fmt.fmt.pix.colorspace);

req.count = 4;

req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

req.memory = V4L2_MEMORY_MMAP;

ioctl(fd,VIDIOC_REQBUFS,&req);

buffers = (struct buffer*)calloc (req.count, sizeof(*buffers));

for(n_buffers = 0; n_buffers < req.count; ++n_buffers){

struct v4l2_buffer buf;

memset(&buf,0,sizeof(buf));

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = n_buffers;

if(ioctl(fd,VIDIOC_QUERYBUF,&buf) == -1){

printf("TK---------_>>>>>>error\n");

close(fd);

exit(-1);

}

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){

printf("TK--------__>>>>>error 2\n");

close(fd);

exit(-1);

}

}

for(i = 0; i < 4; i++){

struct v4l2_buffer buf;

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = i;

ioctl(fd,VIDIOC_QBUF,&buf);

}

type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

ioctl(fd,VIDIOC_STREAMON,&type);

for(j = 0; j < 4; j++){

struct v4l2_buffer buf;

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = 0;

ioctl(fd,VIDIOC_DQBUF,&buf);

char path[30];

snprintf(path,sizeof(path),"./v4l2test/720pyuyv%d",buf.index);

int fdyuyv = open(path,O_WRONLY|O_CREAT,00700);

printf("TK--------->>>>fdyuyv is %d\n",fdyuyv);

printf("TK--------->>>>>buffers[buf.index].start is 0x%x\n",buffers[buf.index].start);

int resultyuyv = write(fdyuyv,buffers[buf.index].start,1280*720*2);

printf("TK--------->>>resultyuyv is %d\n",resultyuyv);

close(fdyuyv);

}

printf("TK------->>>>v4l2GetControl(V4L2_CID_AUTO_FOCUS_STATUS) is %d\n",v4l2GetControl(V4L2_CID_AUTO_FOCUS_STATUS));

printf("TK------->>>>v4l2GetControl(V4L2_CID_AUTO_WHITE_BALANCE) is %d\n",v4l2GetControl(V4L2_CID_AUTO_WHITE_BALANCE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_BACKLIGHT_COMPENSATION) is %d\n",v4l2GetControl(V4L2_CID_BACKLIGHT_COMPENSATION));

printf("TK------->>>>v4l2GetControl(V4L2_CID_BRIGHTNESS) is %d\n",v4l2GetControl(V4L2_CID_BRIGHTNESS));

printf("TK------->>>>v4l2GetControl(V4L2_CID_COLORFX) is %d\n",v4l2GetControl(V4L2_CID_COLORFX));

printf("TK------->>>>v4l2GetControl(V4L2_CID_CONTRAST) is %d\n",v4l2GetControl(V4L2_CID_CONTRAST));

printf("TK------->>>>v4l2GetControl(V4L2_CID_DO_WHITE_BALANCE) is %d\n",v4l2GetControl(V4L2_CID_DO_WHITE_BALANCE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_EXPOSURE) is %d\n",v4l2GetControl(V4L2_CID_EXPOSURE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_EXPOSURE_ABSOLUTE) is %d\n",v4l2GetControl(V4L2_CID_EXPOSURE_ABSOLUTE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_EXPOSURE_AUTO) is %d\n",v4l2GetControl(V4L2_CID_EXPOSURE_AUTO));

printf("TK------->>>>v4l2GetControl(V4L2_CID_EXPOSURE_AUTO_PRIORITY) is %d\n",v4l2GetControl(V4L2_CID_EXPOSURE_AUTO_PRIORITY));

printf("TK------->>>>v4l2GetControl(V4L2_CID_FOCUS_ABSOLUTE) is %d\n",v4l2GetControl(V4L2_CID_FOCUS_ABSOLUTE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_FOCUS_AUTO) is %d\n",v4l2GetControl(V4L2_CID_FOCUS_AUTO));

printf("TK------->>>>v4l2GetControl(V4L2_CID_HFLIP) is %d\n",v4l2GetControl(V4L2_CID_HFLIP));

printf("TK------->>>>v4l2GetControl(V4L2_CID_POWER_LINE_FREQUENCY) is %d\n",v4l2GetControl(V4L2_CID_POWER_LINE_FREQUENCY));

printf("TK------->>>>v4l2GetControl(V4L2_CID_SATURATION) is %d\n",v4l2GetControl(V4L2_CID_SATURATION));

printf("TK------->>>>v4l2GetControl(V4L2_CID_SHARPNESS) is %d\n",v4l2GetControl(V4L2_CID_SHARPNESS));

printf("TK------->>>>v4l2GetControl(V4L2_CID_WHITENESS) is %d\n",v4l2GetControl(V4L2_CID_WHITENESS));

printf("TK------->>>>v4l2GetControl(V4L2_CID_ZOOM_ABSOLUTE) is %d\n",v4l2GetControl(V4L2_CID_ZOOM_ABSOLUTE));

ioctl(fd,VIDIOC_STREAMOFF,&type);

for(i = 0; i < 4; i++)

munmap(buffers[i].start,buffers[i].length);

free(buffers);

usleep(10000);

close(fd);

/////////end

//////640*480 mjpeg

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

printf("TK------------>>>start 3333333333333\n");

ioctl(fd, VIDIOC_QUERYCAP, &cap);

memset(&fmt,0,sizeof(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_MJPEG;

fmt.fmt.pix.field = V4L2_FIELD_NONE;//V4L2_FIELD_INTERLACED;

fmt.fmt.pix.colorspace = 8;

fmtreslt = ioctl(fd,VIDIOC_S_FMT,&fmt);

printf("TK--------_>>>>fmtreslt is %d\n",fmtreslt);

fmtreslt = ioctl(fd,VIDIOC_TRY_FMT,&fmt);

printf("TK--------_>>>>fmtreslt is %d\n",fmtreslt);

fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

ioctl(fd,VIDIOC_G_FMT,&fmt);

printf("TK----------->>>>>fmt.fmt.width is %d\nfmt.fmt.pix.height is %d\nfmt.fmt.pix.colorspace is %d\n",fmt.fmt.pix.width,fmt.fmt.pix.height,fmt.fmt.pix.colorspace);

req.count = 4;

req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

req.memory = V4L2_MEMORY_MMAP;

ioctl(fd,VIDIOC_REQBUFS,&req);

buffers = (struct buffer*)calloc (req.count, sizeof(*buffers));

for(n_buffers = 0; n_buffers < req.count; ++n_buffers){

struct v4l2_buffer buf;

memset(&buf,0,sizeof(buf));

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = n_buffers;

if(ioctl(fd,VIDIOC_QUERYBUF,&buf) == -1){

printf("TK---------_>>>>>>error\n");

close(fd);

exit(-1);

}

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){

printf("TK--------__>>>>>error 2\n");

close(fd);

exit(-1);

}

}

for(i = 0; i < 4; i++){

struct v4l2_buffer buf;

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = i;

ioctl(fd,VIDIOC_QBUF,&buf);

}

type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

ioctl(fd,VIDIOC_STREAMON,&type);

for(j = 0; j < 4; j++){

struct v4l2_buffer buf;

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = 0;

ioctl(fd,VIDIOC_DQBUF,&buf);

char path[30];

snprintf(path,sizeof(path),"./v4l2test/480pmjpeg%d",buf.index);

int fdyuyv = open(path,O_WRONLY|O_CREAT,00700);

printf("TK--------->>>>fdyuyv is %d\n",fdyuyv);

printf("TK--------->>>>>buffers[buf.index].start is 0x%x\n",buffers[buf.index].start);

int resultyuyv = write(fdyuyv,buffers[buf.index].start,640*480*2);

printf("TK--------->>>resultyuyv is %d\n",resultyuyv);

close(fdyuyv);

}

ioctl(fd,VIDIOC_STREAMOFF,&type);

for(i = 0; i < 4; i++)

munmap(buffers[i].start,buffers[i].length);

free(buffers);

usleep(10000);

close(fd);

/////////end

//////640*480 yuyv

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

printf("TK------------>>>start 444444444444\n");

ioctl(fd, VIDIOC_QUERYCAP, &cap);

memset(&fmt,0,sizeof(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_NONE;//V4L2_FIELD_INTERLACED;

fmt.fmt.pix.colorspace = 8;

fmtreslt = ioctl(fd,VIDIOC_S_FMT,&fmt);

printf("TK--------_>>>>fmtreslt is %d\n",fmtreslt);

fmtreslt = ioctl(fd,VIDIOC_TRY_FMT,&fmt);

printf("TK--------_>>>>fmtreslt is %d\n",fmtreslt);

fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

ioctl(fd,VIDIOC_G_FMT,&fmt);

printf("TK----------->>>>>fmt.fmt.width is %d\nfmt.fmt.pix.height is %d\nfmt.fmt.pix.colorspace is %d\n",fmt.fmt.pix.width,fmt.fmt.pix.height,fmt.fmt.pix.colorspace);

req.count = 4;

req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

req.memory = V4L2_MEMORY_MMAP;

ioctl(fd,VIDIOC_REQBUFS,&req);

buffers = (struct buffer*)calloc (req.count, sizeof(*buffers));

for(n_buffers = 0; n_buffers < req.count; ++n_buffers){

struct v4l2_buffer buf;

memset(&buf,0,sizeof(buf));

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = n_buffers;

if(ioctl(fd,VIDIOC_QUERYBUF,&buf) == -1){

printf("TK---------_>>>>>>error\n");

close(fd);

exit(-1);

}

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){

printf("TK--------__>>>>>error 2\n");

close(fd);

exit(-1);

}

}

for(i = 0; i < 4; i++){

struct v4l2_buffer buf;

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = i;

ioctl(fd,VIDIOC_QBUF,&buf);

}

type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

ioctl(fd,VIDIOC_STREAMON,&type);

for(j = 0; j < 4; j++){

struct v4l2_buffer buf;

buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

buf.index = 0;

ioctl(fd,VIDIOC_DQBUF,&buf);

char path[30];

snprintf(path,sizeof(path),"./v4l2test/480pyuyv%d",buf.index);

int fdyuyv = open(path,O_WRONLY|O_CREAT,00700);

printf("TK--------->>>>fdyuyv is %d\n",fdyuyv);

printf("TK--------->>>>>buffers[buf.index].start is 0x%x\n",buffers[buf.index].start);

int resultyuyv = write(fdyuyv,buffers[buf.index].start,640*480*2);

printf("TK--------->>>resultyuyv is %d\n",resultyuyv);

close(fdyuyv);

}

printf("TK------->>>>v4l2GetControl(V4L2_CID_AUTO_FOCUS_STATUS) is %d\n",v4l2GetControl(V4L2_CID_AUTO_FOCUS_STATUS));

printf("TK------->>>>v4l2GetControl(V4L2_CID_AUTO_WHITE_BALANCE) is %d\n",v4l2GetControl(V4L2_CID_AUTO_WHITE_BALANCE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_BACKLIGHT_COMPENSATION) is %d\n",v4l2GetControl(V4L2_CID_BACKLIGHT_COMPENSATION));

printf("TK------->>>>v4l2GetControl(V4L2_CID_BRIGHTNESS) is %d\n",v4l2GetControl(V4L2_CID_BRIGHTNESS));

printf("TK------->>>>v4l2GetControl(V4L2_CID_COLORFX) is %d\n",v4l2GetControl(V4L2_CID_COLORFX));

printf("TK------->>>>v4l2GetControl(V4L2_CID_CONTRAST) is %d\n",v4l2GetControl(V4L2_CID_CONTRAST));

printf("TK------->>>>v4l2GetControl(V4L2_CID_DO_WHITE_BALANCE) is %d\n",v4l2GetControl(V4L2_CID_DO_WHITE_BALANCE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_EXPOSURE) is %d\n",v4l2GetControl(V4L2_CID_EXPOSURE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_EXPOSURE_ABSOLUTE) is %d\n",v4l2GetControl(V4L2_CID_EXPOSURE_ABSOLUTE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_EXPOSURE_AUTO) is %d\n",v4l2GetControl(V4L2_CID_EXPOSURE_AUTO));

printf("TK------->>>>v4l2GetControl(V4L2_CID_EXPOSURE_AUTO_PRIORITY) is %d\n",v4l2GetControl(V4L2_CID_EXPOSURE_AUTO_PRIORITY));

printf("TK------->>>>v4l2GetControl(V4L2_CID_FOCUS_ABSOLUTE) is %d\n",v4l2GetControl(V4L2_CID_FOCUS_ABSOLUTE));

printf("TK------->>>>v4l2GetControl(V4L2_CID_FOCUS_AUTO) is %d\n",v4l2GetControl(V4L2_CID_FOCUS_AUTO));

printf("TK------->>>>v4l2GetControl(V4L2_CID_HFLIP) is %d\n",v4l2GetControl(V4L2_CID_HFLIP));

printf("TK------->>>>v4l2GetControl(V4L2_CID_POWER_LINE_FREQUENCY) is %d\n",v4l2GetControl(V4L2_CID_POWER_LINE_FREQUENCY));

printf("TK------->>>>v4l2GetControl(V4L2_CID_SATURATION) is %d\n",v4l2GetControl(V4L2_CID_SATURATION));

printf("TK------->>>>v4l2GetControl(V4L2_CID_SHARPNESS) is %d\n",v4l2GetControl(V4L2_CID_SHARPNESS));

printf("TK------->>>>v4l2GetControl(V4L2_CID_WHITENESS) is %d\n",v4l2GetControl(V4L2_CID_WHITENESS));

printf("TK------->>>>v4l2GetControl(V4L2_CID_ZOOM_ABSOLUTE) is %d\n",v4l2GetControl(V4L2_CID_ZOOM_ABSOLUTE));

ioctl(fd,VIDIOC_STREAMOFF,&type);

for(i = 0; i < 4; i++)

munmap(buffers[i].start,buffers[i].length);

free(buffers);

usleep(10000);

close(fd);

/////////end

return 0;

}

2.test.h

[plain] view
plain copy

#define V4L2_CID_AUTO_FOCUS_STATUS (V4L2_CID_CAMERA_CLASS_BASE+30)

二、编译及测试

1.gcc test.c -o test

2../test

3.ll v4l2test/

[plain] view
plain copy

drwxr-xr-x 2 root root 4096 2013-08-16 09:27 ./

drwxr-xr-x 3 root root 4096 2013-08-16 10:24 ../

-rwxrwxrwx 1 root root 614400 2013-08-16 09:27 480pmjpeg0*

-rwxrwxrwx 1 root root 614400 2013-08-16 09:27 480pmjpeg1*

-rwxrwxrwx 1 root root 614400 2013-08-16 09:27 480pmjpeg2*

-rwxrwxrwx 1 root root 614400 2013-08-16 09:27 480pmjpeg3*

-rwxrwxrwx 1 root root 614400 2013-08-16 09:27 480pyuyv0*

-rwxrwxrwx 1 root root 614400 2013-08-16 09:27 480pyuyv1*

-rwxrwxrwx 1 root root 614400 2013-08-16 09:27 480pyuyv2*

-rwxrwxrwx 1 root root 614400 2013-08-16 09:27 480pyuyv3*

-rwxrwxrwx 1 root root 1843200 2013-08-16 09:27 720pmjpeg0*

-rwxrwxrwx 1 root root 1843200 2013-08-16 09:27 720pmjpeg1*

-rwxrwxrwx 1 root root 1843200 2013-08-16 09:27 720pmjpeg2*

-rwxrwxrwx 1 root root 1843200 2013-08-16 09:27 720pmjpeg3*

-rwxrwxrwx 1 root root 1843200 2013-08-16 09:27 720pyuyv0*

-rwxrwxrwx 1 root root 1843200 2013-08-16 09:27 720pyuyv1*

-rwxrwxrwx 1 root root 1843200 2013-08-16 09:27 720pyuyv2*

-rwxrwxrwx 1 root root 1843200 2013-08-16 09:27 720pyuyv3*

三、极力推荐一款window下的图像查看工具YUVviewerPlus

该工具可以将原始yuyv（如yuv422选择yuy2，需要后缀改为.yuv），rgb（rgb24选择gbmp24，需要后缀改为.bmp）等数据文件显示出来。

另外说明：yuyv和jpeg数据大小为width*height*2；rgb为width*height*3；单位为Bytes。

附免费下载地址：http://download.csdn.net/detail/tankai19880619/6617647