linux拍照保存图片延时问题,Linux下V4L2一个调试问题方法（拍照偏绿）

最新推荐文章于 2023-04-20 14:08:47 发布
最新推荐文章于 2023-04-20 14:08:47 发布
阅读量376 收藏
点赞数
文章标签： linux拍照保存图片延时问题

一、源码

1.test.c

#include

#include

#include

#include

#include

#include

#include

#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

#define V4L2_CID_AUTO_FOCUS_STATUS (V4L2_CID_CAMERA_CLASS_BASE+30)二、编译及测试

1.gcc test.c -o test

2../test

3.ll v4l2test/

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。

Noamwa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
V4L2 timeout leads to NULL pointer in kernel in jetpack 4.6
jzwjzw19900922的博客
04-02 390
1. 前言 （1）条件 Xavier NX Devkit JetPack 4.6 Raspi Cam V2.1 (IMX219 driver) on CAM0 正常运行 （2）描述 采集视频中途，模拟视频断开，会导致内核空指针； 这个问题在JetPack 4.5.1及之前版本中是不存在的。 且当通过nvarguscamerasrc流媒体时，它不会发生。 只有在使用v4l2接口捕获图像时才会发生这种情况。 （3）操作如下 $ v4l2-ctl --stream-mma
我对linux理解之v4l2
qq345260600的专栏
08-23 2912
我们先看具体sensor slave怎么注册到v4l2的： static struct v4l2_int_ioctl_desc ov5642_ioctl_desc[] = {//ioctl与对应的序号联系在一起，在v4l2层将被转换成固定的名字     {vidioc_int_dev_init_num, (v4l2_int_ioctl_func *)ioctl_dev_init},
linux拍照保存图片延时问题,抓取新摄像头图像时的OpenCV VideoCapture/V4L2延迟
weixin_34476847的博客
05-14 274
对于我正在开发的计算机视觉项目，我需要使用Logitech C920摄像头抓取图像。我使用OpenCV的VideoCapture来做到这一点，但是我面临的问题是，我在某个时刻拍摄的图像没有显示相机看到的最新内容。也就是说，如果我在时间戳t处拍摄一张图像，它可以显示相机在时间戳(t-delta)处看到的内容。抓取新摄像头图像时的OpenCV VideoCapture/V4L2延迟我这样做是通过编写一...
linux media v4l2,Linux kernel drivers/media/v4l2-core/videobuf2-v4l2.c拒绝服务漏洞(CVE-2016-4568)...
weixin_32312081的博客
05-28 159
Linux kernel drivers/media/v4l2-core/videobuf2-v4l2.c拒绝服务漏洞(CVE-2016-4568)发布日期：2016-05-19更新日期：2016-05-25受影响系统：Linux kernel < 4.5.3描述：CVE(CAN) ID: CVE-2016-4568Linux Kernel是Linux操作系统的内核。Linux kernel...
V4L2调用扩展命令报“No buffer space available”错误
老吕丶的博客
05-17 573
最近在摄像头中加了一个私有化命令，通过V4L2调用一直返回失败，errno值为105（），折腾了很久。 后面排查了下代码，发现V4L2调用命令的时候，首先会获取命令的数据长度，如果执行命令得到的 数据长度和定义的数据长度不一样就会返回105错误。 还碰到一个错误返回errno56（Invalid request code），这个是因为没有实现UVC协议定义的GET_INFO请求。 ...
PCIe-DMA多通道/高性能/超低延时/超低抖动视频采集显示，V4L2驱动
04-20
基于PCI ExpressIntegrated Block，Multi-Channel PCIe QDMA Subsystem实现了使用DMA地址队列的独立...对于多路视频采集与显示子系统，在上位机可以使用标准的Linux V4L2视频驱动，实现多路视频信号的采集和显示工作。
Linux下的定时任务和延时任务的详解
09-15
主要介绍了Linux下的定时任务和延时任务，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
单片机常见延时与中断问题及解决方法（一）
08-21
延时与中断出错，是单片机新手在单片机开发应用过程中，经常会遇到的问题，本文汇总整理了包含了MCS-51系列单片机、MSP430单片机、...在内的各种单片机常见的延时与中断问题及解决方法，希望对单片机新手们，有所帮助!
Linux内核延时研究与函数代码分析
07-29
文章主要对Linux内核延时的研究与函数代码的分析，感性趣的朋友可以参考下。
happyday03-Linux内核的延时函数.docx
04-29
"Linux内核的延时函数" Linux 内核中提供了多种延时函数，用于控制程序的执行时间。这些函数可以分为两类：忙等待延时函数和休眠延时函数。 忙等待延时函数 忙等待延时函数包括 ndelay、udelay 和 mdelay。这些...
linux v4l2 卡顿,Linux下V4L2捕捉画面+H264压缩视频+帧缓冲显示视频————帧缓冲显示视频...
weixin_30894765的博客
05-25 479
帧缓冲显示主要步骤打开设备文件, 比如/dev/fb0获取framebuffer的一些信息, 比如分辨率设置参数映射framebuffer内存到用户空间写入要显示的画面/* display.h */#ifndef DISPLAY_H#define DISPLAY_Hint DisplayInit(const char* pDevName);int DisplayStart(void);int Di...
v4l2驱动文档之——controls
03-30 931
v4l2驱动编写篇第七--控制方法  刚刚完成了这一系列文章的第六部分，我们现在知道如何设置视频设备，并来回传输帧了。然而，有一个众所周知的事实，那就是用户永远也不会满意，不会满足于能从摄像头上看到视频，他们马上就会问我可不可以调参数啊？像亮度、对比度等等。这些参数可以在视频应用中调整，有时也的确会这样做，但是当硬件支持时，在 硬件中进行调整有其优势。比如说亮度调整，如果不这样做的话，可能会丢失
PCIe-DMA多通道/高性能/超低延时/超低抖动视频采集显示V4L2驱动
weixin_42144870的博客
04-20 636
视频采集与显示子系统使用高效的PCIe H2C DMA引擎读取上位机显示缓冲区的视频帧，存储到视频显示队列中，并且可以借助外部输入的硬件显示定时脉冲实时访问视频显示队列，按照显示定时脉冲输出视频帧。视频采集与显示子系统可以实时采集多路视频信号，并存储到视频采集队列中，借助高效的硬实时视频帧出入队列管理和PCIe C2H DMA引擎，将采集到的视频帧实时传递到上位机采集缓冲区。对于多路视频采集与显示子系统，在上位机可以使用标准的Linux V4L2视频驱动，实现多路视频信号的采集和显示工作。
V4L2常用命令标志符和结构体
qingkongyeyue的博客
04-08 1589
转自http://blog.csdn.net/u011425939/article/details/53671869 在进行V4L2开发中，一般会用到以下的命令标志符： VIDIOC_REQBUFS: 分配内存 VIDIOC_QUERYBUF： 把VIDIOC_REQBUFS中分配的数据缓存转换成物理地址 VIDIOC_QUERYCAP： 查询驱动功能 VIDIOC_EN
Linux下V4L2一个调试问题方法（拍照偏绿）
热门推荐
程序改变生活
08-16 1万+
一、源码 1.test.c #include #include #include #include #include #include #include #include "test.h" int fd = 0; int v4l2QueryControl(int control, struct v4l2_queryctrl *queryctrl) { int er
linux帧缓存v4l2,Linux下V4L2编程小结
weixin_28808633的博客
05-14 402
一．设置采集方式，格式 常用命令标志打开视频设备后，可以设置该视频设备的属性，例如裁剪、缩放等。这一步是可选的。在Linux编程中，一般使用ioctl函数来对设备的I/O通道进行管理：extern int ioctl (int __fd, unsigned long int __request, …)__THROW;__fd：设备的ID，例如刚才用open函数打开视频通道后返回的cameraFd；...
基于V4L2采集摄像头数据
lingyi_cai的博客
09-28 2270
基于Linux Kernel V4L2框架验证采集摄像头数据，捕获到的yuv数据在7yuv.exe进行查看，从而验证摄像头驱动到应用层的数据链路完整性。源码如下所示： #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <sys/ioctl.h> #include <linux/types.h> #in
实现Linux系统从摄像头设备拉流，每5秒拉取1帧图片形成延时摄影文件
最新发布
07-14
要实现Linux系统从摄像头设备拉流，并每5秒拉取1帧图片形成延时摄影文件，你可以使用一些开源的库，如OpenCV和v4l2。以下是一个基本的示例，使用C++和OpenCV库来实现： 1. 安装OpenCV和v4l2库：首先，确保你已经安装了OpenCV和v4l2库。你可以从官方网站下载适合你操作系统的版本，并按照说明进行安装。 2. 编写C++代码：创建一个C++源文件，并使用以下代码来实现从摄像头设备拉流并生成延时摄影文件： ```cpp #include <opencv2/opencv.hpp> #include <linux/videodev2.h> #include <fstream> int main() { cv::VideoCapture capture; // 创建视频捕获对象 capture.open("/dev/video0", cv::CAP_V4L2); // 打开摄像头设备 if (!capture.isOpened()) { // 检查设备是否成功打开 std::cerr << "Failed to open camera device!" << std::endl; return -1; } cv::Mat frame; // 存储每一帧图像的变量 int frameCount = 0; // 帧计数器 while (true) { capture >> frame; // 从摄像头设备读取一帧图像 if (frame.empty()) { // 检查是否读取到了有效的图像 std::cerr << "Failed to read frame!" << std::endl; break; } if (frameCount % 150 == 0) { // 每5秒（150帧）保存一帧图像 std::string filename = "frame_" + std::to_string(frameCount) + ".jpg"; cv::imwrite(filename, frame); // 保存图像为JPEG文件 } frameCount++; // 帧计数器增加 char key = cv::waitKey(1); // 等待按键输入 if (key == 27) { // 如果按下了Esc键，退出循环 break; } } capture.release(); // 释放摄像头设备资源 return 0; } ``` 3. 编译和运行：使用C++编译器（如g++）编译源文件，并链接OpenCV和v4l2库。 ```bash g++ your_source_file.cpp -o capture_frames `pkg-config --cflags --libs opencv` ``` 然后运行可执行文件： ```bash ./capture_frames ``` 这样，程序将从摄像头设备拉流，并每5秒保存一帧图像为延时摄影文件。每个图像文件的名称将按照帧计数器进行命名。 请注意，上述代码仅提供了基本的功能实现，你可能需要根据具体需求进行更复杂的图像处理或文件存储操作。此外，确保你有适当的权限来访问摄像头设备（例如，在Linux系统中，通常需要以root用户或有相应权限的用户运行）。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值