linux camera application demo(一)

YUV 数据查看软件

pyuvshow_forxcr.exe

 #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 <malloc.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 <time.h>

#define CLEAR(x) memset (&(x), 0, sizeof (x))
#define ALIGN_4K(x) (((x) + (4095)) & ~(4095))
#define ALIGN_16B(x) (((x) + (15)) & ~(15))

struct size{
 int width;
 int height;
};

struct buffer {
    void * start;
    size_t length;
};

static char path_name[20] = {'\0'};
static char dev_name[20] = {'\0'};
static int      fd              = -1;
struct buffer *   buffers       = NULL;
static unsigned int   n_buffers = 0;

struct size input_size;
struct size subch_size;

unsigned int  req_frame_num = 8;
unsigned int  read_num = 20;
unsigned int  count;

int buf_size[3]={0};

static int read_frame (int mode)
{
 struct v4l2_buffer buf;
 char fdstr[30];
 void * bfstart = NULL;
 FILE *file_fd = NULL;
 int i,num;
 
 CLEAR (buf);
 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 buf.memory = V4L2_MEMORY_MMAP;

 if (-1 ==ioctl (fd, VIDIOC_DQBUF, &buf) )  
  return -1;
    
 assert (buf.index < n_buffers);

 if (count == read_num/2)
    {
  printf("file length = %d\n",buffers[buf.index].length);
  printf("file start = %x\n",buffers[buf.index].start);
       
  num = (mode > 2) ? 2 : mode;
  bfstart = buffers[buf.index].start;
    
  for (i = 0; i <= num; i++)
  { 
   printf("file %d start = %p\n", i, bfstart);
 
   sprintf(fdstr,"%s/fb%d_y%d.bin",path_name,i+1,mode);
   file_fd = fopen(fdstr,"w");
   fwrite(bfstart, buf_size[i]*2/3, 1, file_fd);
   fclose(file_fd);

   sprintf(fdstr,"%s/fb%d_u%d.bin",path_name,i+1,mode);
   file_fd = fopen(fdstr,"w");
   fwrite(bfstart + buf_size[i]*2/3, buf_size[i]/6, 1, file_fd);
   fclose(file_fd);

   sprintf(fdstr,"%s/fb%d_v%d.bin",path_name,i+1,mode);
   file_fd = fopen(fdstr,"w");
   fwrite(bfstart + buf_size[i]*2/3 + buf_size[i]/6, buf_size[i]/6, 1, file_fd);
   fclose(file_fd);

   bfstart += ALIGN_4K( buf_size[i] ); 
  }
 }
 
 if (-1 == ioctl (fd, VIDIOC_QBUF, &buf))
  return -1;
 return 0;
}

static int req_frame_buffers(void)
{
 unsigned int i;
 struct v4l2_requestbuffers req;
 
 CLEAR (req);
 req.count  = req_frame_num;
 req.type  = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 req.memory = V4L2_MEMORY_MMAP; 
 
 ioctl (fd, VIDIOC_REQBUFS, &req);

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

 for (n_buffers = 0; n_buffers < req.count; ++n_buffers)
 {
  struct v4l2_buffer buf; 
  CLEAR (buf);
  buf.type  = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  buf.memory = V4L2_MEMORY_MMAP;
  buf.index  = n_buffers;

  if (-1 == ioctl (fd, VIDIOC_QUERYBUF, &buf))
   printf ("VIDIOC_QUERYBUF error\n");

  buffers[n_buffers].length = buf.length;
  buffers[n_buffers].start  = mmap (NULL /* start anywhere */,
                 buf.length,
                 PROT_READ | PROT_WRITE /* required */,
                 MAP_SHARED /* recommended */,
                 fd, buf.m.offset);
 
  if (MAP_FAILED == buffers[n_buffers].start)
  {
   printf ("mmap failed\n");
   return -1;
  }

 }

 for (i = 0; i < n_buffers; ++i)
 {
  struct v4l2_buffer buf;
  CLEAR (buf);

  buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  buf.memory = V4L2_MEMORY_MMAP;
  buf.index = i;

  if (-1 == ioctl (fd, VIDIOC_QBUF, &buf))
  {
   printf ("VIDIOC_QBUF failed\n");
   return -1;
  }
 }
 return 0;

}

static int free_frame_buffers(void)
{
 unsigned int i;

 for (i = 0; i < n_buffers; ++i) {
  if (-1 == munmap (buffers[i].start, buffers[i].length)) {
   printf ("munmap error");
   return -1;
  }
 }
 return 0;
}

static int camera_init(int sel, int mode)
{
 struct v4l2_input inp;
 struct v4l2_streamparm parms;
 
 fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
 
 if(!fd) {
  printf("open falied\n");
  return -1; 
 }
 
 inp.index = sel; 
 if (-1 == ioctl (fd, VIDIOC_S_INPUT, &inp))
 {
  printf("VIDIOC_S_INPUT %d error!\n",sel);
  return -1;
 }
 
 //VIDIOC_S_PARM   
 parms.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 parms.parm.capture.timeperframe.numerator = 1;
 parms.parm.capture.timeperframe.denominator =30;
 parms.parm.capture.capturemode = V4L2_MODE_VIDEO; //V4L2_MODE_IMAGE
     
 if (-1 == ioctl (fd, VIDIOC_S_PARM, &parms))
 {
  printf ("VIDIOC_S_PARM error\n"); 
  return -1;
 }
   
 return 0;
   
}

static int camera_fmt_set(int subch, int angle)
{
 struct v4l2_format fmt;
 struct v4l2_pix_format subch_fmt;
 
 //VIDIOC_S_FMT
 CLEAR (fmt);
 fmt.type                 = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 fmt.fmt.pix.width        = input_size.width;  //640;
 fmt.fmt.pix.height       = input_size.height;  //480;
 fmt.fmt.pix.pixelformat  = V4L2_PIX_FMT_YUV420;  //V4L2_PIX_FMT_YUV422P;//V4L2_PIX_FMT_NV12;//V4L2_PIX_FMT_YUYV;
 fmt.fmt.pix.field        = V4L2_FIELD_NONE;   //V4L2_FIELD_INTERLACED;//V4L2_FIELD_NONE;
 fmt.fmt.pix.rot_angle     = 0;

 if (0 == subch)
  fmt.fmt.pix.subchannel = NULL; 
 else
 {
  fmt.fmt.pix.subchannel = &subch_fmt;
  subch_fmt.width   = subch_size.width;
  subch_fmt.height  = subch_size.height;
  subch_fmt.pixelformat = V4L2_PIX_FMT_YUV420;   //V4L2_PIX_FMT_YUV422P;//V4L2_PIX_FMT_NV12;//V4L2_PIX_FMT_YUYV;
  subch_fmt.field   = V4L2_FIELD_NONE;   //V4L2_FIELD_INTERLACED;//V4L2_FIELD_NONE;
  subch_fmt.rot_angle  = angle;
 }
   
 if (-1 == ioctl (fd, VIDIOC_S_FMT, &fmt))
 {
  printf("VIDIOC_S_FMT error!\n");
  return -1;
 }
 
 //Test VIDIOC_G_FMT 
 if (-1 == ioctl (fd, VIDIOC_G_FMT, &fmt))
 {
  printf("VIDIOC_G_FMT error!\n");
  return -1;
 }
 else
 {
  printf("resolution got from sensor = %d*%d\n",fmt.fmt.pix.width,fmt.fmt.pix.height);
 }
 return 0;

}

static int main_test (int sel, int mode)
{
 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

 int subch = 0 ;
 int angle = 0;
                   
 if (mode >= 1) {
  subch = 1;
  if (mode == 2)
   angle = 90;
  else
   angle = 270;
 }
 
 if (-1== camera_init(sel, mode)) //camera select
  return -1;
 if (-1 == camera_fmt_set(subch, angle))
  return -1;
 if (-1 ==req_frame_buffers())
  return -1;
 
 if (-1 == ioctl (fd, VIDIOC_STREAMON, &type))
 {  
  printf ("VIDIOC_STREAMON failed\n");
  return -1;
 }
 else
  printf ("VIDIOC_STREAMON ok\n");
            
 count = read_num;    
 while (count-->0)
 {
  for (;;)
  {
   fd_set fds;
   struct timeval tv;
   int r;
    
   FD_ZERO (&fds);
   FD_SET (fd, &fds);
  
   tv.tv_sec = 2;   /* Timeout. */
   tv.tv_usec = 0;
   
   r = select (fd + 1, &fds, NULL, NULL, &tv);
   
   if (-1 == r) {
    if (EINTR == errno)
     continue;
    printf ("select err\n");
   }
   if (0 == r) {
    fprintf (stderr, "select timeout\n");
    return -1;
   }
   
   if (!read_frame (mode))
    break;
   else
    return -1;
  }
 }

 if (-1 == ioctl (fd, VIDIOC_STREAMOFF, &type))
 {  
  printf ("VIDIOC_STREAMOFF failed\n");
  return -1;
 }
 else
  printf ("VIDIOC_STREAMOFF ok\n");

 if ( -1 == free_frame_buffers())
  return -1;

 close (fd); 
 
 return 0;
}

int main(int argc,char *argv[])
{
 int i,test_cnt = 1;
 int sel = 0;
 int width = 640;
 int height = 480;
    int mode = 1;
 
// ./app_basic 0 0 1920 1080  
 
 CLEAR (dev_name);
    CLEAR (path_name);
    if( argc == 1 ) {
  sprintf(dev_name,"/dev/video0");
        sprintf(path_name,"/mnt/extsd");
    }
    else if( argc == 3 ) {
  sel = atoi(argv[1]);
  sprintf(dev_name,"/dev/video%d",sel);
  sel = atoi(argv[2]);
        sprintf(path_name,"/mnt/extsd");
    }
    else if( argc == 5 ) {
  sel = atoi(argv[1]);
  sprintf(dev_name,"/dev/video%d",sel);
  sel = atoi(argv[2]);
  width = atoi(argv[3]);
  height = atoi(argv[4]);
        sprintf(path_name,"/mnt/extsd");
    }
    else if( argc == 6 ) {
  sel = atoi(argv[1]);
  sprintf(dev_name,"/dev/video%d",sel);
  sel = atoi(argv[2]);
  width = atoi(argv[3]);
  height = atoi(argv[4]);
        sprintf(path_name,"%s",argv[5]);
    }
    else if( argc == 7 ) {
  sel = atoi(argv[1]);
  sprintf(dev_name,"/dev/video%d",sel);
  sel = atoi(argv[2]);
  width = atoi(argv[3]);
  height = atoi(argv[4]);
        sprintf(path_name,"%s",argv[5]);
        mode = atoi(argv[6]);
 }
 else if( argc == 8 ) {
  sel = atoi(argv[1]);
  sprintf(dev_name,"/dev/video%d",sel);
  sel = atoi(argv[2]);
  width = atoi(argv[3]);
  height = atoi(argv[4]);
        sprintf(path_name,"%s",argv[5]);
        mode = atoi(argv[6]);
  test_cnt = atoi(argv[7]);
 }
 else{
  printf("please select the video device: 0-video0 1-video1 ......\n");  //select the video device
  scanf("%d", &sel);
  sprintf(dev_name,"/dev/video%d",sel);
   
  printf("please select the camera: 0-dev0 1-dev1 ......\n");  //select the camera
  scanf("%d", &sel);
  
  printf("please input the resolution: width height......\n");  //input the resolution
  scanf("%d %d", &width, &height);

        printf("please input the frame saving path......\n");  //input the frame saving path
  scanf("%15s", path_name);

        printf("please input the test mode: 1~4......\n");  //input the test mode
  scanf("%d", &mode);

  printf("please input the test_cnt: >=1......\n");  //input the test count
  scanf("%d", &test_cnt);
 }
 
 input_size.width = width;
 input_size.height = height;
 
 subch_size.width = input_size.width >> 1;
 subch_size.height = input_size.height >> 1;
 
 buf_size[0] = ALIGN_16B(input_size.width)*input_size.height*3/2;
 buf_size[1] = ALIGN_16B(subch_size.width)*subch_size.height*3/2;
 buf_size[2] = ALIGN_16B(subch_size.height)*subch_size.width*3/2;

 for(i = 0; i < test_cnt; i++)
 {
  if (0 == main_test(sel, 0))
   printf("*************************mode %d test done at the %d time!!\n", mode, i);
  else
   printf("*************************mode %d test failed at the %d time!!\n", mode, i);
 }
 return 0;
}

makefile

 

CC := arm-none-linux-gnueabi-gcc
LINUX_DIR = ../../../../../include
#ASM_DIR =  ../../../../../arch/arm/include/asm
CFLAGS := -I $(LINUX_DIR)
TARGET := app_basic

.PHONY: all clean

all: $(TARGET)

app_basic:app_basic.c
 $(CC) $(CFLAGS) -static  $^  -o  $@

clean:
 rm -rf $(TARGET)