v4l2测试程序

最新推荐文章于 2023-11-26 16:16:03 发布
最新推荐文章于 2023-11-26 16:16:03 发布
阅读量2.7k 收藏 2
点赞数
分类专栏： V4L2 文章标签： 测试 video buffer null io output

/*head files:*/ 
#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 <SIGNAL.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> 
  
//declarations: 

//state reset: 

#define CLEAR(x) memset(&(x),0,sizeof(x)) 
//devices: 

#define V4L2_DEVICE "/dev/video0" 
#define FBVID_DEVICE "/dev/fb/3" 
#define OUTPUTFILE "/mnt/gjf/vidrecord.uyvy" 
  
/// 

#define SCREEN_BPP 16 
#define D1_WIDTH 352 
#define D1_HEIGHT 288 
#define D1_LINE_WIDTH (D1_WIDTH * SCREEN_BPP / 8) 
#define D1_FRAME_SIZE (D1_LINE_WIDTH * D1_HEIGHT) 
  
 

typedef enum{ 
    IO_METHOD_READ, 
    IO_METHOD_MMAP, 
    IO_METHOD_USERPTR 
}io_method; 
  
struct buffer{ 
     void* start; 
      size_t length; 
}; 
  
static char* video_device=NULL; 
static char* output_device=NULL; 
static io_method io=IO_METHOD_MMAP; 
struct buffer* buffers=NULL; 
static unsigned int n_buffers=0; 
static int videofd = -1 ; //device discription for video device; 

static int outputfd = -1 ; //device discprition for output device; 

static int captureSize = 0 ; //picture size 

static unsigned int imagewidth = 0 ; //image width 

static unsigned int imageheight = 0 ; //image height 

static unsigned int timelimit = 1 ; //capturing time 

static unsigned int totalframes = 0 ; //catpturing frames 

  
#define FRAME 0 
#define TIME 1 
static int flag = FRAME; 
  
 

typedef enum{YUYV=0,UYVY}imageType; 
static imageType format=YUYV; 
/// 

  
//command line: 

static const char short_options[]="d:pmruw:h:t:f:o:"; 
  
static const struct option long_options[] = 
{ 
     {"device",required_argument,NULL,'d'}, 
     {"help",no_argument,NULL,'p'}, 
     {"mmap",no_argument,NULL,'m'}, 
     {"read",no_argument,NULL,'r'}, 
     {"usrptr",no_argument,NULL,'u'}, 
     {"width",required_argument,NULL,'w'}, 
     {"height",required_argument,NULL,'h'}, 
     {"time",required_argument,NULL,'t'}, 
     {"frame",required_argument,NULL,'f'}, 
      {"format",required_argument,NULL,'o'}, 
      { 0 , 0 , 0 , 0 } 
}; 
  
static void usage(FILE* fp,int argc,char **argv) 
{ 
  fprintf (fp,"Usage: %s [options]/n/n" 
              "Options:/n" 
              "-d | --device name Video device name [/dev/video]/n" 
              "-p | --help Print this message/n" 
              "-m | --mmap Use memory mapped buffers/n" 
              "-r | --read Use read() calls/n" 
              "-u | --userp Use application allocated buffers/n" 
              "-w | --image width/n" 
              "-h | --image height/n" 
              "-t | --capture time/n" 
              "-f | --number of frames/n" 
              "-o | --image format/n" 
                "", 
             argv[0]); 
} 
  
  
void process_command(int argc,char **argv) 
{ 
     int index ; 
     int next_option ; 
     int f = -1; 
     video_device = V4L2_DEVICE ; 
     output_device = FBVID_DEVICE ; 
     imagewidth = D1_WIDTH ; 
     imageheight = D1_HEIGHT ; 
     timelimit = 1 ; 
     totalframes = 0 ; 
     format = UYVY ; 
  
     flag = FRAME ; 
      
     do{ 
         next_option = getopt_long(argc,argv,short_options,long_options,&index) ; 
         switch(next_option) { 
             case 'd' : 
                  video_device=optarg ; 
                  break; 
             case 'p' : 
                  usage(stdout,argc,argv) ; 
                  exit(EXIT_FAILURE) ; 
             case 'm': 
                  io = IO_METHOD_MMAP ; 
                  break ; 
             case 'r': 
                  io = IO_METHOD_READ ; 
                  break ; 
             case 'u': 
                  io = IO_METHOD_USERPTR ; 
                  break ; 
             case 'w': 
                  imagewidth = atoi(optarg); 
                  break; 
             case 'h': 
                  imageheight = atoi(optarg); 
                  break; 
             case 't': 
                  flag = TIME; 
                  timelimit = atoi( optarg ) ; 
                  break; 
             case 'f': 
                  flag = FRAME; 
                  totalframes = atoi( optarg ) ; 
                  break; 
             case 'o': 
                  f = atoi(optarg); 
                  format = ( f >= YUYV && f <= UYVY )? f : UYVY; 
                  break; 
             case -1: 
                  break ; 
             default: 
                  usage(stdout,argc,argv) ; 
                  exit(EXIT_FAILURE) ; 
            
           } 
  
      }while(next_option!=-1); 
} 
  
  
///videoCapture: 

void open_device() 
{ 
     struct stat st; 
  
     if (-1 == stat (video_device, &st)) { 
         fprintf (stderr, "Cannot identify ’%s’: %d, %s/n",video_device, errno, strerror (errno)); 
         exit (EXIT_FAILURE); 
      } 
  
     if (!S_ISCHR (st.st_mode)) { 
         fprintf (stderr, "%s is no device/n", video_device); 
         exit (EXIT_FAILURE); 
      } 
  
     videofd = open (video_device, O_RDWR | O_NONBLOCK, 0); 
     if (videofd == -1) { 
         fprintf ( stderr, "Cannot open ’%s’: %d, %s/n", video_device , errno , strerror (errno) ); 
         exit (EXIT_FAILURE); 
      } 
} 
  
  
static void init_read(unsigned int bufSize) //directly read 

{ 
   buffers = calloc (1, sizeof (*buffers)); 
   if (!buffers) { 
       fprintf (stderr, "Out of memory/n"); 
       exit (EXIT_FAILURE); 
    } 
    buffers[0].length = bufSize ; 
    buffers[0].start = malloc (bufSize); 
    if (!buffers[0].start) { 
          fprintf (stderr, "Out of memory/n"); 
          exit (EXIT_FAILURE); 
    } 
} 
  
static void init_mmap() //map the driver's buffer to application buffer 

{ 
   struct v4l2_requestbuffers req; 
   CLEAR (req); 
   req.count = 4; 
   req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
   req.memory = V4L2_MEMORY_MMAP; 
   if (ioctl(videofd, VIDIOC_REQBUFS, &req) == -1) { //allocate buffer in the driver memory space 

      if (EINVAL == errno) { 
          fprintf (stderr, "%s does not support ""memory mapping/n", video_device); 
          exit (EXIT_FAILURE); 
      } else { 
          fprintf(stderr,"Failed:VIDIOC_REQBUFS"); 
          exit (EXIT_FAILURE); 
       } 
    } 
    
   if (req.count < 2) { //double buffers 

      fprintf (stderr, "Insufficient buffer memory on %s/n", video_device); 
      exit (EXIT_FAILURE); 
    } 
  
   buffers = calloc (req.count, sizeof (*buffers)); 
   if (!buffers) { 
       fprintf (stderr, "Out of memory/n"); 
       exit (EXIT_FAILURE); 
    } 
   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 (videofd, VIDIOC_QUERYBUF, &buf)) { //query the state of one of the buffers in driver space 

            fprintf(stderr,"Failed:VIDIOC_QUERYBUF "); 
            exit(EXIT_FAILURE); 
        
        } 
  
       buffers[n_buffers].length = buf.length; 
  
         
  
       buffers[n_buffers].start = mmap ( NULL /* start anywhere */, 
                            buf.length, 
                            PROT_READ | PROT_WRITE /* required */, 
                            MAP_SHARED /* recommended */, 
                            videofd, buf.m.offset); 
  
    if (buffers[n_buffers].start == MAP_FAILED ) { 
            fprintf(stderr,"Failed:when MMAP"); 
            exit(EXIT_FAILURE); 
  
         } 
     } 
  
} 
  
static void init_usrptr(unsigned int bufSize) // 

{ 
   struct v4l2_requestbuffers req; 
   CLEAR (req); 
   req.count = 4; 
   req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
   req.memory = V4L2_MEMORY_USERPTR; 
   if (-1 == ioctl (videofd, VIDIOC_REQBUFS, &req)) { 
       if (EINVAL == errno) { 
            fprintf (stderr, "%s does not support ""user pointer i/o/n", video_device); 
            exit (EXIT_FAILURE); 
        } 
       else { 
            fprintf(stderr,"Failed:VIDIOC_REQBUFS/n"); 
        } 
    } 
   buffers = calloc (4, sizeof (*buffers)); 
   if (!buffers) { 
       fprintf (stderr, "Out of memory/n"); 
       exit (EXIT_FAILURE); 
    } 
   for (n_buffers = 0; n_buffers < 4; ++n_buffers) { 
       buffers[n_buffers].length = bufSize; 
       buffers[n_buffers].start = malloc (bufSize); //allocate buffers in user space 

       if (!buffers[n_buffers].start) { 
            fprintf (stderr, "Out of memory/n"); 
            exit (EXIT_FAILURE); 
        } 
    } 
   
} 
  
static int xioctl( int fd,int request,void * arg) 
{ 
    int r; 
    do{ 
         r = ioctl (fd, request, arg); 
     } 
    while (-1 == r && EINTR == errno); 
    return r; 
} 
  
#define VPFE_STD_AUTO ((v4l2_std_id)(0x1000000000000000ULL)) 
  
  
void init_device() 
{ 
    struct v4l2_capability cap; 
    struct v4l2_cropcap cropCap; 
    struct v4l2_crop crop; 
    struct v4l2_format fmt; 
     unsigned int min; 
     //get the capture device's capabilities 

    if (ioctl(videofd, VIDIOC_QUERYCAP, &cap) == -1) { 
       if (errno == EINVAL) { 
            fprintf ( stderr, "%s is no V4L2 device/n",video_device); 
            exit(EXIT_FAILURE); 
        } 
       fprintf(stderr,"Failed VIDIOC_QUERYCAP on %s (%s)/n", video_device,strerror(errno)); 
       exit(EXIT_FAILURE); 
    } 
  
   if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { 
       fprintf(stderr,"%s is no video capture device/n", video_device); 
       exit(EXIT_FAILURE); 
    } 
                  
   switch (io) { 
      case IO_METHOD_READ: 
           if (!(cap.capabilities & V4L2_CAP_READWRITE)) { 
              fprintf (stderr, "%s does not support read i/o/n",video_device); 
              exit (EXIT_FAILURE); 
            } 
       break; 
      case IO_METHOD_MMAP: 
      case IO_METHOD_USERPTR: 
       if (!(cap.capabilities & V4L2_CAP_STREAMING)) { 
            fprintf (stderr, "%s does not support streaming i/o/n",video_device); 
            exit (EXIT_FAILURE); 
            } 
    } 
  
    //set croping and scaling attribure 

    CLEAR(cropCap); 
    cropCap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    if (0 == ioctl (videofd, VIDIOC_CROPCAP, &cropCap)) { 
         crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
         crop.c = cropCap.defrect; /* reset to default */ 
         if (-1 == ioctl (videofd, VIDIOC_S_CROP, &crop)) { 
              switch (errno) { 
                 case EINVAL: 
                    fprintf(stderr,"Cropping not supported/n"); 
                    //exit (EXIT_FAILURE); 

                 default: 
                    fprintf(stderr, "Failed:VIDIOC_S_CROP"); 
                   // exit (EXIT_FAILURE); 

                 } 
           } 
     } 
    else { 
         fprintf(stderr,"Failed:VIDIOC_CROPCAP"); 
         //exit(EXIT_FAILURE); 

    } 
  
  
  
     //set picture format 

    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    fmt.fmt.pix.width = D1_WIDTH; //720 

    fmt.fmt.pix.height = D1_HEIGHT; //480 

     
    switch(format) { 
        case YUYV : 
             fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 
             break; 
        case UYVY : 
             fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY; 
             break; 
        default : 
             fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY; 
    } 
  
    //fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; 

    fmt.fmt.pix.field = V4L2_FIELD_INTERLACED; 
  
    if (-1 == ioctl (videofd, VIDIOC_S_FMT, &fmt)){ 
       fprintf(stderr,"Failed: VIDIOC_S_FMT"); 
       exit(EXIT_FAILURE); 
     } 
  
    captureSize = fmt.fmt.pix.sizeimage; 
/* 
   min = fmt.fmt.pix.width * 2; 
   if (fmt.fmt.pix.bytesperline < min) 
      fmt.fmt.pix.bytesperline = min; 
   min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height; 
   if (fmt.fmt.pix.sizeimage < min) 
       fmt.fmt.pix.sizeimage=min; 
   fprintf(stderr,"fmt size : %u /n",fmt.fmt.pix.sizeimage); 
  
*/ 
  
 // printf("%width:%u,height:%u,sizeimage:%u/n",fmt.fmt.pix.width,fmt.fmt.pix.height,fmt.fmt.pix.sizeimage); 

   //allocate buffer: 

   switch(io){ 
        case IO_METHOD_READ: 
             init_read(fmt.fmt.pix.sizeimage); 
             break; 
        case IO_METHOD_MMAP: 
             init_mmap(); 
             break; 
        case IO_METHOD_USERPTR: 
             init_usrptr(fmt.fmt.pix.sizeimage); 
             break; 
        default: 
              fprintf(stderr,"IO_METHOD : No such method/n"); 
             break; 
  
     } 
  
} 
  
  
void startCapturing(void) 
{ 
    unsigned int i; 
    enum v4l2_buf_type type; 
    switch (io) { 
        case IO_METHOD_READ: 
             /* Nothing to do. */ 
             break; 
        case IO_METHOD_MMAP: 
             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 == xioctl (videofd, VIDIOC_QBUF, &buf)) { //enqueue an empty capturing buffer allocated in 

                                                                   //driver space 

                      fprintf(stderr,"Failed(MMAP):VIDIOC_QBUF/n"); 
                      exit(EXIT_FAILURE); 
                } 
              } 
  
              type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
              if (-1 == ioctl (videofd, VIDIOC_STREAMON, &type)){ //start capturing 

                       fprintf(stderr,"Failed(MMAP):VIDIOC_STREAMON/n"); 
                       exit(EXIT_FAILURE); 
              } 
              break; 
        case IO_METHOD_USERPTR: 
             for (i = 0; i < n_buffers; ++i) { 
                 struct v4l2_buffer buf; 
                 CLEAR (buf); 
                 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
                 buf.memory = V4L2_MEMORY_USERPTR; 
                 buf.m.userptr = (unsigned long) buffers[i].start; 
                 buf.length = buffers[i].length; 
  
                 if (-1 == ioctl (videofd, VIDIOC_QBUF, &buf)) { //encode an empty buffer allocated in usr space 

                                                                   // in the capturing queue 

                     fprintf(stderr,"Failed(USERPTR):VIDIOC_QBUF/n"); 
                     exit(EXIT_FAILURE); 
                 } 
              } 
  
              type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
              if (-1 == ioctl (videofd, VIDIOC_STREAMON, &type)) { //start capturing 

                     fprintf(stderr,"Failed(USERPTR):VIDIOC_STREAMON/n"); 
                     exit(EXIT_FAILURE); 
              } 
     } 
  
} 
  
static int process_image(const void *p) 
{ 
       
         
  
  
     return 0; 
} 
  
static int read_frame (void) 
{ 
    struct v4l2_buffer buf; 
    unsigned int i; 
    switch (io) { 
        case IO_METHOD_READ: 
           if (-1 == read (videofd, buffers[0].start, buffers[0].length)) { //read data into the usr buffer, 

                                                                             //note there is only one buffer 

              switch (errno) { 
                 case EAGAIN: 
                    return 0; 
                 case EIO: 
                   /* Could ignore EIO, see spec. */ 
                   /* fall through */ 
                 default: 
                    { 
                    fprintf(stderr,"Failed : read"); 
                    exit(EXIT_FAILURE); 
                    } 
                } 
             } 
  
  
       // if (write(outputfd, buffers[buf.index].start , captureSize ) == -1) //write to the output file 

        // fprintf(stderr,"Error writing the data to output file/n"); 

  
           process_image (buffers[0].start); //process this buffer 

           break; 
       case IO_METHOD_MMAP: 
           CLEAR (buf); 
           buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
           buf.memory = V4L2_MEMORY_MMAP; 
           if (-1 == xioctl (videofd, VIDIOC_DQBUF, &buf)) { //dequeue a buffer 

               switch (errno) { 
                   case EAGAIN: 
                        return 0; 
                   case EIO: 
                   /* Could ignore EIO, see spec. */ 
                   /* fall through */ 
                   default: 
                      { 
                       fprintf(stderr,"Failed : VIDIOC_DQBUF"); 
                       exit(EXIT_FAILURE); 
                      } 
                } 
            } 
           assert (buf.index < n_buffers); 
            
  
  
      // if (write(outputfd, buffers[buf.index].start , captureSize ) == -1); 

  
           process_image (buffers[buf.index].start); //process this buffer 

           if (-1 == xioctl (videofd, VIDIOC_QBUF, &buf)) { //enqueue this buffer in order to reuse it 

                   fprintf(stderr,"Failed : VIDIOC_QBUF/n"); 
                   exit(EXIT_FAILURE); 
           } 
           break; 
        case IO_METHOD_USERPTR: 
           CLEAR (buf); 
           buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
           buf.memory = V4L2_MEMORY_USERPTR; 
           if (-1 == xioctl (videofd, VIDIOC_DQBUF, &buf)) { 
               switch (errno) { 
                  case EAGAIN: 
                     return 0; 
                  case EIO: 
                  /* Could ignore EIO, see spec. */ 
                  /* fall through */ 
                  default: 
                     { 
                      fprintf(stderr,"Failed : VIDIOC_DQBUF"); 
                      exit(EXIT_FAILURE); 
                     } 
                 } 
              } 
            for (i = 0; i < n_buffers; ++i) //find the dequeued buffer in usr space 

               if (buf.m.userptr == (unsigned long) buffers[i].start && buf.length == buffers[i].length) 
                    break; 
            assert (i < n_buffers); 
  
  // if (write(outputfd, buffers[i].start , captureSize ) == -1) //write to the output file 

   // fprintf(stderr,"Error writing the data to output file/n"); 

  
            process_image ((void *) buf.m.userptr); 
            if (-1 == xioctl (videofd, VIDIOC_QBUF, &buf)) { //reuse 

                  fprintf(stderr,"Failed : VIDIOC_QBUF"); 
                  exit(EXIT_FAILURE); 
              } 
            break; 
    } 
   return 0; 
} 
  
  
  
/// 

void timehandle(int signo) 
{ 
   fprintf(stderr,"EXIT : time over !--->%u/n",timelimit); 
   exit(0); 
} 
  
void init_sigaction(void) 
{ 
  struct sigaction act; 
  act.sa_handler=timehandle; 
  act.sa_flags=0; 
  sigemptyset(&act.sa_mask); 
  sigaction(SIGPROF,&act,NULL); 
} 
  
void init_time() 
{ 
  struct itimerval value; 
  value.it_value.tv_sec= 1; 
  value.it_value.tv_usec=0; 
  value.it_interval=value.it_value; 
  setitimer(ITIMER_PROF,&value,NULL); 
} 
  
  
/// 

  
void mainloop (void) 
{ 
   static int framecount=0; 
   
     
   outputfd = open(OUTPUTFILE , O_WRONLY | O_CREAT | O_TRUNC, 00644); 
   if (outputfd == -1) { 
        fprintf(stderr,"Failed to open %s for writing/n", OUTPUTFILE); 
        exit(EXIT_FAILURE); 
    } 
     
    if(flag == TIME) 
     { 
       //init_sigaction( ) ; 

       //init_time( ) ; 

       while( 1 ){ 
          fd_set fds; 
          struct timeval tv; 
          int r; 
          FD_ZERO (&fds); 
          FD_SET (videofd, &fds); 
          /* Timeout. */ 
          tv.tv_sec = 2; 
          tv.tv_usec = 0; 
          r = select (videofd + 1, &fds, NULL, NULL, &tv); //wait for a new frame 

          if (-1 == r) { 
             if (EINTR == errno) 
                 continue; 
             fprintf(stderr,"select"); 
             exit(EXIT_FAILURE); 
           } 
          if (0 == r) { 
             fprintf (stderr, "select timeout/n"); 
             exit (EXIT_FAILURE); 
           } 
  
          if (read_frame ()) 
             break; 
          printf("capturing frame %d /n",framecount); 
          framecount++; 
  
          /* EAGAIN - continue select loop. */ 
        } 
    } 
   else 
       while( framecount < totalframes ){ 
          fd_set fds; 
          struct timeval tv; 
          int r; 
          FD_ZERO (&fds); 
          FD_SET (videofd, &fds); 
          /* Timeout. */ 
          tv.tv_sec = 2; 
          tv.tv_usec = 0; 
         // fprintf(stderr,"wait for a new frame/n"); 

          r = select (videofd + 1, &fds, NULL, NULL, &tv); //wait for a new frame 

          if (-1 == r) { 
             if (EINTR == errno) 
                 continue; 
             fprintf(stderr,"select"); 
             exit(EXIT_FAILURE); 
           } 
          if (0 == r) { 
             fprintf (stderr, "select timeout/n"); 
             exit (EXIT_FAILURE); 
           } 
  
          //fprintf(stderr,"Read next frame :/n"); 

          if (read_frame ()) 
             break; 
          printf("capturing frame %d /n",framecount); 
          framecount++; 
  
          /* EAGAIN - continue select loop. */ 
       } 
   if( outputfd != -1 ) 
      close(outputfd); 
} 
  
  
//--------------------------------------------- 

void stop_capturing (void) //stop catpureing pictures 

{ 
  enum v4l2_buf_type type; 
  switch (io) { 
     case IO_METHOD_READ: 
      /* Nothing to do. */ 
           break; 
     case IO_METHOD_MMAP: 
     case IO_METHOD_USERPTR: 
         type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
         if (-1 == xioctl (videofd, VIDIOC_STREAMOFF, &type)){ 
             fprintf (stderr,"VIDIOC_STREAMOFF"); 
             exit(EXIT_FAILURE); 
          } 
         break; 
} 
  
void uninit(void) 
{ 
     unsigned int i; 
     switch (io) { 
        case IO_METHOD_READ: 
           free (buffers[0].start); 
           break; 
        case IO_METHOD_MMAP: 
           for (i = 0; i < n_buffers; ++i) 
               if (-1 == munmap (buffers[i].start, buffers[i].length)){ 
                  fprintf(stderr,"munmap"); 
                  exit(EXIT_FAILURE); 
                 } 
           break; 
        case IO_METHOD_USERPTR: 
           for (i = 0; i < n_buffers; ++i) 
               free (buffers[i].start); 
           break; 
          } 
        free (buffers); 
     } 
} 
  
void close_device (void) 
{ 
    if (-1 == close (videofd)) 
     { 
       fprintf(stderr,"close"); 
       exit(EXIT_FAILURE); 
     } 
    videofd = -1; 
} 
  
///entry: 

  
int main(int argc,char **argv) 
{ 
  process_command(argc,argv); 
  open_device(); 
  fprintf(stderr,"SUCCESS : open_device /n"); 
  init_device(); 
  fprintf(stderr,"SUCCESS : Init_device /n"); 
  startCapturing(); 
  fprintf(stderr,"SUCCESS : startCapturing/n"); 
   
  mainloop(); 
  fprintf(stderr,"SUCCESS : stopCapturing/n"); 
  stop_capturing() ; 
  fprintf(stderr,"SUCCUSS : closeDevice/n"); 
  close_device(); 
   
  return 0; 
}

evilcode
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
V4l2应用程序实验
weixin_51332399的博客
06-10 62
3.检测内核中是否添加了摄像头的设备树，在发fsmp1a-linux-5.4.31/arch/arm/boot/dts目录下如下两个文件为。7.由于图片中没有添加头和尾部信息，所有得到的图片只有数据信息，可以通过YUVviewPlus.exe来显示图片信息。在实验过程中的"$"后的操作在主机上，"#"后的操作在开发板上。4.接上摄像头设备，启动linux内核，检测是否存在摄像头节点。5.将摄像头的应用程序交叉编译后拷贝到rootfs目录执行。1.将内核中的虚拟摄像头驱动从内核中选配掉，默认是选中的。
嵌入式平台v4l2测试程序
11-09
《嵌入式平台v4l2测试程序：深入解析与应用》 在现代电子设备中，嵌入式系统扮演着至关重要的角色，特别是在多媒体设备、物联网(IoT)和智能硬件领域。对于这些设备，视频输入/输出(V4L2)接口是实现高质量图像和视频...
v4l2 官方capture 测试程序
09-18
v4l2官方测试程序，有三种capture方式，read，mmap和用户指针模式
linux的命令行解析参数之getopt_long函数使用
yuchunhai321的博客
05-08 253
命令行参数更加清晰： #include <stdio.h> #include <stdlib.h> #include <string.h> #include <getopt.h> static char* dev_name; static int number; static void usage(FILE *fp, int argc, c...
Linux V4L2之camera
weixin_34111790的博客
04-24 765
一、硬件知识 1. 摄像头硬件结构和工作原理，如图1&图2　 　　 　　外部光线穿过lens镜头，经过红外滤光片后光学图像投射到传感器上，然后光学图像被转换成电信号，电信号再经过模数转换变为数字信号，数字信号经过DSP加工处理， 再被送到接收端进行处理，最终转换成屏幕上能够看到的图像。其中： 1）滤光片作用： 　　a. 滤除红外线，滤除对可见光有干扰的红外光，使成像效果...
V4L2测试程序
pengjin1985的专栏
05-08 2641
#include #include #include #include #include #include #include int fd;/*设备号*/ /*设备文件*/ #define CAMERA_DEVICE "/dev/video0" int main() {     int i, ret;     // Open Devi
qcarcam v4l2 camera hal测试程序
最新发布
04-22
《Qcarcam V4L2 Camera HAL测试程序详解》 在深入探讨Qcarcam V4L2 Camera HAL测试程序之前，我们首先需要了解几个关键概念。Android系统在处理摄像头硬件时，采用了一种称为硬件抽象层（HAL）的机制，它使得上层...
android camera v4l2测试代码
01-22
在这个“android camera v4l2测试代码”中，我们主要探讨的是如何在HAL（Hardware Abstraction Layer，硬件抽象层）上利用V4L2进行相机驱动的测试，以及这对于理解Android相机数据流Buffer的工作原理的价值。...
全志T7 v4l2开发测试代码
04-22
`v4l2.h`是V4L2的头文件，包含了所有必要的结构体定义、枚举类型和函数原型，使得用户空间程序可以正确地使用V4L2 API。这个头文件定义了如`struct v4l2_format`（用于设置视频格式）、`struct v4l2_buffer`（用于...
基于V4l2框架实现的camera测试程序
07-30
本教程将围绕基于V4l2框架实现的camera测试程序进行深入探讨，帮助开发者了解如何利用该框架进行相机功能的开发和测试。 首先，我们需要理解V4l2的核心概念。V4l2提供了一组内核驱动程序和用户空间接口，包括控制、...
v4l2的一个测试程序
05-25
v4l2的一个测试程序，能够测试摄像头的实际fps值V4L2_FPS
v4l2linux视频测试程序
08-26
v4l2 linux 视频， 从硬件缓冲区获取数据 加工转化
camera的v4l2测试代码
04-01
在android的camera中间件，需要确认驱动，此时可以用测试代码去测试
基于linux v4l2视频采集测试代码
07-30
v4l2的一个开源测试程序，能够测试摄像头的实际fps值V4L2_FPS\V4L2_FPS。 在linux下交叉编译，在目标板ARM上调试通过。
v4l2 preview capture 测试程序
╰☆╮EvilCode的专栏╭☆╯
04-21 3538
<br />#ifdef __cplusplus<br />extern "C"{<br />#endif<br /><br />/*=======================================================================<br />                                        INCLUDE FILES<br />=====================================================
Linux摄像头（v4l2应用）——获取摄像头一帧图像
qq_41007891的博客
11-26 3315
V4L2（Video for Linux 2）：Linux内核中视频设备中的驱动框架，对于应用层它提供了一系列的API接口，同时对于硬件层，它适配大部分的视频设备，因此通过调用V4L2的接口函数可以适配大部分的视频设备。
测试V4L2的摄像头c语言程序
Cox__W的专栏
06-30 678
有的时候接到项目,无非就是想快点的测试手里的驱动到底能不能用,尤其是没有调试过的驱动,现写测试程序,如果不着急还行.最好是能找到能用的,最好就是纯c的,这样简单,又方便调试驱动. 我这里遇到的是v4l2的驱动,想要知到好不好用,就要测试,最简单就是先找一个usb的摄像头来尝试,uvc的驱动大部分bsp都是支持的,插上后,发现有/dev/video0节点产生.接着就是测试,找了好多,也试着自己写,最后还是找到一个能用的,以下代码转载: https://blog.csdn.net/sanmaoljh/art
v4l2使用技巧
laviolette的专栏
09-20 1132
V4L2 较 V4L 有较大的改动，并已成为 2.6 的标准接口，函盖 video/ dvb /FM… ，多数驱动都在向 V4l2 迁移 。V4L2 采用流水线的方式，操作更简单直观。 一般来说，需要用到的函数就是 open() ， close() 和 ioctl () 。
V4L2编程模型简介（一）
pengrui18的专栏
10-18 1293
博客源地址：http://www.embedu.org/Column/Column514.htm 简介：本文所附代码是根据v4l2官方文档以及demo(capture.c)修改而来，纯粹为学习交流之用，请勿使用在商用场合。 地址：由于官方网的域名有敏感词汇，所以请google一下。 一 、操作流程简单看 二、 模块概要分析 以下是所附代码所涉及到的全局变量，摆出来只是参考...
写一个v4l2接口的测试程序
05-22
以下是一个简单的v4l2接口的测试程序，可以获取摄像头的视频流并显示在屏幕上： ```c #include #include #include #include #include #include #include #include #include #define BUFFER_COUNT 4 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值