Android(安卓)S5PV210 camera驱动测试程序

分类：AndroidSamsung S5PV210 2012-07-04 13:47 480人阅读评论(13) 收藏举报

最近在调试S5PV210上的camera驱动，因为对Android的samsung camera hal 不太了解，自己写了个测试程序方便调试

因为camera驱动都是遵守V4L2标准，所以测试程序是通用的，在MX51平台也能工作。

[html] view plain copy

#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<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>
#include<linux/fb.h>
#defineCLEAR(x)memset(&(x),0,sizeof(x))
intPAL_WIDTH=720;
intPAL_HEIGHT=576;
enum{
RGB565,
RGB888,
RGB32,
};
structbuffer{
void*start;
size_tlength;
};
staticchar*dev_name=NULL;
staticintfd=-1;
staticunsignedintn_buffers=0;
staticintg_width;
staticintg_height;
staticunsignedg_pixelformat;
staticstructfb_var_screeninfovinfo;
staticstructfb_fix_screeninfofinfo;
structbuffer*buffers=NULL;
staticintfile_index=1;
staticintg_count=9;
staticvoiderrno_exit(constchar*s)
{
fprintf(stderr,"%serror%d,%s\n",s,errno,strerror(errno));
exit(EXIT_FAILURE);
}
staticintxioctl(intfd,intrequest,void*arg)
{
intr;
dor=ioctl(fd,request,arg);
while(-1==r&&EINTR==errno);
returnr;
}
staticvoidwrite_yuv(constvoid*p,intindex)
{
intwrite_fd=0;
intret;
intlength;
chartmp[20];
sprintf(tmp,"/data/file/yuvfile%d",index);
write_fd=open(tmp,O_RDWR|O_CREAT);
if(write_fd==-1){
printf("%s:openyuvfilefailed,errno(%d)\n",__func__,errno);
}
length=g_width*g_height*2;
ret=write(write_fd,p,length);
if(ret!=length){
printf("%s:writeyuvfilefailed,ret(%d),errno(%d)\n",__func__,ret,errno);
}
}
staticvoidprocess_image(constvoid*p)
{
if(file_index<g_count){
write_yuv(p,file_index);
file_index=file_index+1;
}
}
staticintread_frame(void)
{
intret=0;
structtimevaltimer;
structv4l2_bufferbuf;
CLEAR(buf);
buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory=V4L2_MEMORY_MMAP;
if(-1==xioctl(fd,VIDIOC_DQBUF,&buf)){
switch(errno){
caseEAGAIN:
printf("VIDIOC_DQBUFreturnEAGAIN\n");
return0;
default:
printf("VIDIOC_DQBUFfailed,errno(%d):\n",errno,strerror(errno));
ret=-errno;
returnret;
}
}
assert(buf.index<n_buffers);
printf("%s:buf.bytesused(%d),buf.index(%d)\n",
__func__,buf.index);
process_image(buffers[buf.index].start);
if(-1==xioctl(fd,VIDIOC_QBUF,&buf)){
printf("VIDIOC_BUFfailed,errno(%d)\n",errno);
ret=-errno;
}
gettimeofday(&timer,NULL);
printf("(%d)thcapture,tv_sec(%d),tv_usec\n",
file_index,timer.tv_sec,timer.tv_usec);
returnret;
}
staticvoidrun(void)
{
intret;
printf("%s:enter\n",__func__);
while(1){
fd_setfds;
structtimevaltv;
FD_ZERO(&fds);
FD_SET(fd,&fds);
if(file_index==g_count){
break;
}
tv.tv_sec=5;
tv.tv_usec=0;
ret=select(fd+1,&fds,NULL,NULL,&tv);
if(-1==ret){
if(EINTR==errno){
printf("errno==EINTR\n");
continue;
}
errno_exit("select");
}
if(0==ret){
printf("selecttimeout\n");
exit(EXIT_FAILURE);
}
if(read_frame())
continue;
sleep(1);
}
printf("%s:endrun\n",__func__);
}
staticvoidstop_capturing(void)
{
enumv4l2_buf_typetype;
printf("%s:enter\n",__func__);
type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
if(-1==xioctl(fd,VIDIOC_STREAMOFF,&type))
errno_exit("VIDIOC_STREAMOFF");
}
staticvoidstart_capturing(void)
{
unsignedinti;
enumv4l2_buf_typetype;
printf("%s:enter\n",__func__);
for(i=0;i<n_buffers;++i){
structv4l2_bufferbuf;
CLEAR(buf);
buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory=V4L2_MEMORY_MMAP;
buf.index=i;
if(-1==xioctl(fd,VIDIOC_QBUF,&buf))
errno_exit("VIDIOC_QBUF");
}
type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
if(-1==xioctl(fd,VIDIOC_STREAMON,&type))
errno_exit("VIDIOC_STREAMON");
}
staticvoiduninit_device(void)
{
unsignedinti;
for(i=0;i<n_buffers;++i)
if(-1==munmap(buffers[i].start,buffers[i].length))
errno_exit("munmap");
free(buffers);
}
staticvoidinit_mmap(void)
{
structv4l2_requestbuffersreq;
CLEAR(req);
req.count=4;
req.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory=V4L2_MEMORY_MMAP;
if(-1==xioctl(fd,VIDIOC_REQBUFS,&req)){
if(EINVAL==errno){
fprintf(stderr,"%sdoesnotsupportmemorymapping\n",dev_name);
exit(EXIT_FAILURE);
}else{
errno_exit("VIDIOC_REQBUFS");
}
}
if(req.count<2){//if(req.count<2)
fprintf(stderr,"Insufficientbuffermemoryon%s\n",dev_name);
exit(EXIT_FAILURE);
}
buffers=calloc(req.count,sizeof(*buffers));
if(!buffers){
fprintf(stderr,"Outofmemory\n");
exit(EXIT_FAILURE);
}
printf("requestbuffercount(%d)\n",req.count);
for(n_buffers=0;n_buffers<req.count;++n_buffers){
structv4l2_bufferbuf;
CLEAR(buf);
buf.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory=V4L2_MEMORY_MMAP;
buf.index=n_buffers;
if(-1==xioctl(fd,VIDIOC_QUERYBUF,&buf))
errno_exit("VIDIOC_QUERYBUF");
buffers[n_buffers].length=buf.length;
buffers[n_buffers].start=mmap(NULL,buf.length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,buf.m.offset);
printf("buf.start(%p),buf.length(%d)\n",buffers[n_buffers].start,buf.length);
if(MAP_FAILED==buffers[n_buffers].start)
errno_exit("mmap");
}
}
staticvoidinit_device(void)
{
structv4l2_capabilitycap;
structv4l2_cropcapcropcap;
structv4l2_cropcrop;
structv4l2_formatfmt;
if(-1==xioctl(fd,VIDIOC_QUERYCAP,&cap)){
printf("%s:VIDIOC_QUERYCAP\n",__func__,errno);
exit(EXIT_FAILURE);
}
printf("supportoverlaycap.capabilities(0x%x)\n",cap.capabilities);
if(!(cap.capabilities&V4L2_CAP_VIDEO_CAPTURE)){
fprintf(stderr,"%sisnovideocapturedevice\n",dev_name);
exit(EXIT_FAILURE);
}
if(!(cap.capabilities&V4L2_CAP_STREAMING)){
fprintf(stderr,"%sdoesnotsupportstreamingi/o\n",dev_name);
exit(EXIT_FAILURE);
}
CLEAR(cropcap);
cropcap.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
if(0==xioctl(fd,VIDIOC_CROPCAP,&cropcap)){
crop.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
crop.c=cropcap.defrect;
if(-1==xioctl(fd,VIDIOC_S_CROP,&crop)){
printf("VIDIOC_S_CROPfailed(%d),%s\n",errno,strerror(errno));
}
}
CLEAR(fmt);
fmt.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width=PAL_WIDTH;
fmt.fmt.pix.height=PAL_HEIGHT;
fmt.fmt.pix.pixelformat=V4L2_PIX_FMT_YUYV;
fmt.fmt.pix.field=V4L2_FIELD_NONE;
if(-1==xioctl(fd,VIDIOC_S_FMT,&fmt)){
errno_exit("VIDIOC_S_FMT");
}
printf("width(%d),height(%d),pixelformat(0x%x),field(%d)\n",
fmt.fmt.pix.width,fmt.fmt.pix.height,fmt.fmt.pix.pixelformat,
fmt.fmt.pix.field);
g_width=fmt.fmt.pix.width;
g_height=fmt.fmt.pix.height;
init_mmap();
}
staticvoidclose_device(void)
{
close(fd);
}
staticvoidopen_device(void)
{
structstatst;
fd=open(dev_name,O_RDWR|O_NONBLOCK,0);
if(-1==fd){
fprintf(stderr,"Cannotopen'%s':%d,%s\n",
dev_name,errno,strerror(errno));
exit(EXIT_FAILURE);
}
}
staticvoidusage(FILE*fp,intargc,char**argv)
{
fprintf(fp,
"Usage:%s[options]\n\n"
"Options:\n"
"-d|--devicenameVideodevicename[/dev/video]\n"
"-h|--helpPrintthismessage\n"
"-t|--howlongwilldisplayinseconds\n"
"",
argv[0]);
}
staticconstcharshort_options[]="d:w:h:f:p:c:";
staticconststructoptionlong_options[]={
{"device",required_argument,NULL,'d'},
{"help",no_argument,NULL,'h'},
{"time",no_argument,NULL,'t'},
{0,0,0,0}
};
intselect_input(intinput)
{
intret;
ret=xioctl(fd,VIDIOC_S_INPUT,&input);
if(ret){
printf("xioctlVIDIOC_S_INPUTfailederrno(%d)\n",errno);
}
returnret;
}
intmain(intargc,char**argv)
{
dev_name="/dev/video0";
for(;;){
intindex;
intc;
inttmp;
c=getopt_long(argc,argv,short_options,long_options,&index);
if(-1==c)
break;
switch(c){
case0:
break;
case'd':
dev_name=optarg;
break;
case'c':
g_count=strtol(optarg,NULL,10);
break;
case'p':
tmp=strtol(optarg,NULL,10);
if(tmp==0){
g_pixelformat=V4L2_PIX_FMT_UYVY;
}
elseif(tmp==1){
g_pixelformat=V4L2_PIX_FMT_YUYV;
}
break;
case'w':
PAL_WIDTH=strtol(optarg,NULL,10);
printf("PAL_WIDTH(%d)\n",PAL_WIDTH);
break;
case'h':
PAL_HEIGHT=strtol(optarg,NULL,10);
printf("PAL_HEIGHT(%d)\n",PAL_HEIGHT);
break;
default:
usage(stderr,argc,argv);
exit(EXIT_FAILURE);
}
}
open_device();
select_input(0);
init_device();
start_capturing();
run();
stop_capturing();
uninit_device();
close_device();
return0;
}

更多相关文章

随机推荐