基于V4L2摄像头采集图片程序设计

#ifndef __COMMON_H
#define __COMMON_H
//该头文件定义的是摄像头在屏幕上显示的宽度和高度
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include <stdint.h>

typedef unsigned char U8;
typedef unsigned int U32;
typedef unsigned short U16;

#define WIDTH  800
#define HEIGHT 600

#endif	//__COMMON_H

#ifndef __VIDEOCAPTURE_H
#define __VIDEOCAPTURE_H

#include"common.h"
#include<sys/mman.h>
#include<fcntl.h>
#include<linux/videodev2.h>

#define VIDEODEVNAME ("/dev/video0")
#define COUNT  4
//需要调用的摄像头相关的接口，包括初始化，开始，结束，采取一帧的数据并保存
int initCamera();
void unInitCamera();
int startCamera();
int stopCamera();
int getOneFrame(U8* pcYuvBuffer);

#endif	//__VIDEOCAPTURE_H

#include"videoCapture.h"

static U8* pcYuv[COUNT]={NULL};
static int vidDevFd = -1;
static int nLength = 0;
static struct v4l2_buffer dequeBuffer;
static struct v4l2_buffer queueBuffer;

//初始化摄像头程序
int initCamera()
{
//open /dev/video*
//open video device
vidDevFd = open(VIDEODEVNAME, O_RDONLY);
if (vidDevFd < 0)
{
fprintf(stderr, "open %s failed %s\n",VIDEODEVNAME, strerror(errno));
return -1;
}

//printf("vidDevFd = %d!\n", vidDevFd);

//设置视频格式
//set video device format
struct v4l2_format vidDevFmt;
vidDevFmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
vidDevFmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
vidDevFmt.fmt.pix.width = WIDTH;
vidDevFmt.fmt.pix.height = HEIGHT;

if (0 != ioctl(vidDevFd, VIDIOC_S_FMT, &vidDevFmt))
{
fprintf(stderr, "VIDIOC_S_FMT failed %s\n", strerror(errno));
unInitCamera();
return -1;
}

//request buffers
//max count need to be considered
struct v4l2_requestbuffers reqBuffer;
reqBuffer.count = COUNT;
reqBuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqBuffer.memory = V4L2_MEMORY_MMAP;

if (0 != ioctl(vidDevFd, VIDIOC_REQBUFS, &reqBuffer))
{
fprintf(stderr, "VIDIOC_REQBUFS failed %s\n", strerror(errno));
unInitCamera();
return -1;
}

//query buffers
int i = 0;
struct v4l2_buffer qryBuffer;
qryBuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
qryBuffer.memory = V4L2_MEMORY_MMAP;

for (i = 0; i < COUNT; i++)
{
qryBuffer.index = i;

if (0 != ioctl(vidDevFd, VIDIOC_QUERYBUF, &qryBuffer))
{
fprintf(stderr, "VIDIOC_QUERYBUF failed %s\n", strerror(errno));
unInitCamera();
return -1;
}

printf("qryBuffer.m.offset=%d, qryBuffer.lenght=%d\n", qryBuffer.m.offset, qryBuffer.length);
//mmap video device memory allocated by VIDIOC_REQBUFS
pcYuv[i] = mmap(NULL, qryBuffer.length, PROT_READ, MAP_SHARED, vidDevFd, qryBuffer.m.offset);
nLength = qryBuffer.length;

//queue buffers
struct v4l2_buffer queBuffer;
queBuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
queBuffer.memory = V4L2_MEMORY_MMAP;
queBuffer.index = qryBuffer.index;
if (0 != ioctl(vidDevFd, VIDIOC_QBUF, &queBuffer))
{
fprintf(stderr, "init VIDIOC_QBUF failed %s\n", strerror(errno));
unInitCamera();
return -1;
}

}

dequeBuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
dequeBuffer.memory = V4L2_MEMORY_MMAP;
queueBuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
queueBuffer.memory = V4L2_MEMORY_MMAP;

return 0;
}

//取消摄像头
void unInitCamera()
{
int i = 0;

for (i = 0; i < COUNT; i++)
{
if (NULL != pcYuv[i])
{
if (-1 == munmap(pcYuv[i], nLength));
{
//fprintf(stderr,"munmap error:%s!\n",strerror(errno));
}
pcYuv[i] = NULL;
}
}

if (vidDevFd >= 0)
close(vidDevFd);
}
//摄像头开始
int startCamera()
{
//start camera

int nArg = 1;
if (0 != ioctl(vidDevFd, VIDIOC_STREAMON, &nArg))
{
fprintf(stderr, "VIDIOC_STREAMON failed %s\n", strerror(errno));
unInitCamera();
return -1;
}

return 0;
}

//停止摄像头
int stopCamera()
{
//stop camera

int nArg = 1;
if (0 != ioctl(vidDevFd, VIDIOC_STREAMOFF, &nArg))
{
fprintf(stderr, "VIDIOC_STREAMOFF failed %s\n", strerror(errno));
unInitCamera();
return -1;
}

return 0;
}

//获取Frame
int getOneFrame(unsigned char* pcYuyvBuffer)
{
if (0 != ioctl(vidDevFd, VIDIOC_DQBUF, &dequeBuffer))
{
fprintf(stderr, "VIDIOC_DQBUF failed %s\n", strerror(errno));
unInitCamera();
return -1;
}

//get frame
memcpy(pcYuyvBuffer, pcYuv[dequeBuffer.index], dequeBuffer.length);
printf("len=%d\n",dequeBuffer.length);

//queue
queueBuffer.index = dequeBuffer.index;
if (0 != ioctl(vidDevFd, VIDIOC_QBUF, &queueBuffer))
{
fprintf(stderr, "VIDIOC_QBUF failed %s\n", strerror(errno));
unInitCamera();
return -1;
}
return 0;
}

#include"videoCapture.h"

int main(void )
{
int nRet = 0;
//char yuyv[WIDTH*HEIGHT*2];
char* pcYuvBuffer = NULL;

if(-1 == initCamera())
{
printf("initCamera failed!\n");
goto ERR;
}

if (-1 == startCamera())
{
printf("startCamera failed!\n");
goto ERR;
}

pcYuvBuffer = (char*)malloc((WIDTH*HEIGHT*2)*sizeof(char));
if (NULL == pcYuvBuffer)
{
printf("malloc YUYV buffer failed!\n");
goto ERR;
}

int nDstFd = open("mytest.yuv", O_CREAT|O_EXCL|O_RDWR|O_TRUNC, 0777);
if (nDstFd == -1)
{
fprintf(stderr, "open mytest.yuv failed:%s\n", strerror(errno));
}

int nFrameNum = 0;

while(1)
{
if (20 == nFrameNum)
break;

memset(pcYuvBuffer, 0, WIDTH*HEIGHT*2);

//if (-1 == getOneFrame(yuyv))
if (-1 == getOneFrame(pcYuvBuffer))
{
printf("getOneFrame error!\n");
goto ERR;
}

//if (-1 == write(nDstFd, yuyv, WIDTH*HEIGHT*2))
if (-1 == write(nDstFd, pcYuvBuffer, WIDTH*HEIGHT*2))
{
fprintf(stderr, "write error:%s\n", strerror(errno));
goto ERR;
}

nFrameNum++;
}

if (-1 == stopCamera())
{
printf("stopCamera error!\n");
}

ERR:
if (NULL != pcYuvBuffer)
{
free(pcYuvBuffer);
pcYuvBuffer = NULL;
}

unInitCamera();

close(nDstFd);
nDstFd = -1;

return 0;
}