V4L2视频应用程序编程架构

最新推荐文章于 2024-05-31 16:36:10 发布

明天VS依旧

最新推荐文章于 2024-05-31 16:36:10 发布

阅读量231

点赞数

分类专栏：音视频文章标签： V4L2介绍

音视频专栏收录该内容

18 篇文章

订阅专栏

参考 http://blog.youkuaiyun.com/tsuibeyond/article/details/50654823

http://www.cnblogs.com/surpassal/archive/2012/12/19/zed_webcam_lab1.html

1.打开设备fd = open(FILE_VIDEO1, O_RDWR))

2.取得设备的capability 看看设备具有什么功能比如是否具有视频输入或者音频输入输出等 VIDIOC QUERYCAP struct v4l2 capabilit

3 选择视频输入一个视频设备可以有多个视频输入 VIDIOC S INPUT struct v4l2 input

4 设置视频的制式和帧格式制式包括PAL NTSC 帧的格式个包括宽度和高度等 VIDIOC S STD VIDIOC S FMT struct v4l2 std id struct v4l2 format

5 向驱动申请帧缓冲一般不超过5个 struct v4l2 requestbuffers

6 将申请到的帧缓冲映射到用户空间这样就可以直接操作采集到的帧了而不必去复制 mmap

7 将申请到的帧缓冲全部入队列以便存放采集到的数据 VIDIOC QBUF struct v4l2 buffer

8 开始视频的采集 VIDIOC STREAMON

9 出队列以取得已采集数据的帧缓冲取得原始采集数据 VIDIOC DQBUF

10 将缓冲重新入队列尾这样可以循环采集 VIDIOC QBUF

11 停止视频的采集 VIDIOC STREAMOFF 12 关闭视频设备 close fd ;

 
   [cpp]  
   view plaincopy
#include <errno.h>  
#include <fcntl.h>  
#include <linux/videodev2.h>  
#include <stdint.h>  
#include <stdio.h>  
#include <string.h>  
#include <sys/ioctl.h>  
#include <sys/mman.h>  
#include <unistd.h>  
#include <opencv2/core/core.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <iostream>  
  
uchar *buffer;                          //buffers 指针记录缓冲帧  
  
#define IMAGEWIDTH 640  
#define IMAGEHEIGHT 480  
  
#define TRUE 1  
#define FALSE 0  
  
#define FILE_VIDEO1 "/dev/video0"  
  
static int fd;                          //设备描述符  
struct v4l2_streamparm setfps;          //结构体v4l2_streamparm来描述视频流的属性  
struct v4l2_capability cap;             //取得设备的capability，看看设备具有什么功能，比如是否具有视频输入,或者音频输入输出等  
struct v4l2_fmtdesc fmtdesc;            //枚举设备所支持的image format:  VIDIOC_ENUM_FMT  
struct v4l2_format fmt,fmtack;          //子结构体struct v4l2_pix_format设置摄像头采集视频的宽高和类型：V4L2_PIX_FMT_YYUV V4L2_PIX_FMT_YUYV  
struct v4l2_requestbuffers req;         //向驱动申请帧缓冲的请求，里面包含申请的个数  
struct v4l2_buffer buf;                 //代表驱动中的一帧  
enum   v4l2_buf_type type;              //帧类型  
  
int init_v4l2(void);                    //初始化  
int v4l2_grab(void);                    //采集  
  
  
  
int main()  
{  
        printf("first~~\n");  
        if(init_v4l2() == FALSE){      //打开摄像头  
            printf("Init fail~~\n");  
            exit(1);  
        }  
        printf("second~~\n");  
        if(v4l2_grab() == FALSE){  
            printf("grab fail~~\n");  
            exit(2);  
        }  
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;           //Stream 或者Buffer的类型。此处肯定为V4L2_BUF_TYPE_VIDEO_CAPTURE  
        buf.memory = V4L2_MEMORY_MMAP;                    //既然是Memory Mapping模式，则此处设置为：V4L2_MEMORY_MMAP  
        printf("third~~\n");  
        cvNamedWindow("one",CV_WINDOW_AUTOSIZE);  
        IplImage* img;  
        CvMat cvmat;  
        int i = 100;  
        double t;  
        while(1){  
                t = (double)cvGetTickCount();                      //调用时钟测时间  
                ioctl(fd,VIDIOC_DQBUF,&buf);  
                buf.index = 0;  
                cvmat = cvMat(IMAGEHEIGHT,IMAGEWIDTH,CV_8UC3,(void*)buffer);//CV_8UC3  
                //t = (double)cvGetTickCount();  
                img = cvDecodeImage(&cvmat,1);  
                //t=(double)cvGetTickCount()-t;  
                //printf("used time is %gms\n",(t/(cvGetTickFrequency()*1000)));  
                if(!img)    printf("No img\n");  
                cvShowImage("one",img);  
                cvReleaseImage(&img);  
                ioctl(fd,VIDIOC_QBUF,&buf);                      //在 driver 内部管理着两个 buffer queues ，一个输入队列，一个输出队列。  
                                                 //对于 capture device 来说，当输入队列中的 buffer 被塞满数据以后会自动变为输出队列，  
                                                 //等待调用 VIDIOC_DQBUF 将数据进行处理以后重新调用 VIDIOC_QBUF 将 buffer 重新放进输入队列.  
                if((cvWaitKey(1)&255) == 27)    exit(0);  
                t=(double)cvGetTickCount()-t;  
                printf("used time is %gms\n",(t/(cvGetTickFrequency()*1000)));  
        }  
  
        ioctl(fd,VIDIOC_STREAMOFF,&type);         // 停止视频采集命令，应用程序调用VIDIOC_ STREAMOFF停止视频采集命令后，视频设备驱动程序不在采集视频数据。  
        return 0;  
}  
  
int init_v4l2(void){  
        if ((fd = open(FILE_VIDEO1, O_RDWR)) == -1){  
            printf("Opening video device error\n");  
            return FALSE;  
        }  
        if (ioctl(fd, VIDIOC_QUERYCAP, &cap) == -1){               // 查询视频设备的功能  
                printf("unable Querying Capabilities\n");  
                return FALSE;  
        }  
        else  
/* 
        { 
        printf( "Driver Caps:\n" 
                "  Driver: \"%s\"\n" 
                "  Card: \"%s\"\n" 
                "  Bus: \"%s\"\n" 
                "  Version: %d\n" 
                "  Capabilities: %x\n", 
                cap.driver, 
                cap.card, 
                cap.bus_info, 
                cap.version, 
                cap.capabilities); 
 
        } 
 
        if((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == V4L2_CAP_VIDEO_CAPTURE){ 
            printf("Camera device %s: support capture\n",FILE_VIDEO1); 
        } 
        if((cap.capabilities & V4L2_CAP_STREAMING) == V4L2_CAP_STREAMING){ 
            printf("Camera device %s: support streaming.\n",FILE_VIDEO1); 
        } 
*/  
        fmtdesc.index = 0;  
        fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
        printf("Support format: \n");  
        while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc) != -1){        // 获取当前视频设备支持的视频格式  
            printf("\t%d. %s\n",fmtdesc.index+1,fmtdesc.description);  
            fmtdesc.index++;  
        }  
        //set fmt  
        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
        fmt.fmt.pix.width = IMAGEWIDTH;                    
        fmt.fmt.pix.height = IMAGEHEIGHT;  
        fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG; //*************************V4L2_PIX_FMT_YUYV****************可以选择  
        fmt.fmt.pix.field = V4L2_FIELD_NONE;  
  
        if (ioctl(fd, VIDIOC_S_FMT, &fmt) == -1){    // 设置视频设备的视频数据格式，例如设置视频图像数据的长、宽，图像格式（JPEG、YUYV格式）  
            printf("Setting Pixel Format error\n");  
            return FALSE;  
        }  
        if(ioctl(fd,VIDIOC_G_FMT,&fmt) == -1){   //获取图像格式  
            printf("Unable to get format\n");  
            return FALSE;  
        }  
//        else  
  
/*        {  
            printf("fmt.type:\t%d\n",fmt.type);         //可以输出图像的格式  
            printf("pix.pixelformat:\t%c%c%c%c\n",fmt.fmt.pix.pixelformat & 0xFF,(fmt.fmt.pix.pixelformat >> 8) & 0xFF,\  
                   (fmt.fmt.pix.pixelformat >> 16) & 0xFF, (fmt.fmt.pix.pixelformat >> 24) & 0xFF);  
            printf("pix.height:\t%d\n",fmt.fmt.pix.height);  
            printf("pix.field:\t%d\n",fmt.fmt.pix.field);  
        }  
*/  
/* 
        setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
        setfps.parm.capture.timeperframe.numerator = 100; 
        setfps.parm.capture.timeperframe.denominator = 100; 
        printf("init %s is OK\n",FILE_VIDEO1); 
*/  
        return TRUE;  
}  
  
int v4l2_grab(void){  
    //struct v4l2_requestbuffers req = {0};  
    //4  request for 4 buffers  
    req.count = 1;  
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
    req.memory = V4L2_MEMORY_MMAP;  
  
    if (ioctl(fd, VIDIOC_REQBUFS, &req) == -1)        //开启内存映射或用户指针I/O  
    {  
        printf("Requesting Buffer error\n");  
        return FALSE;  
    }  
    //5 mmap for buffers  
    buffer = (uchar*)malloc(req.count * sizeof(*buffer));  
    if(!buffer){  
        printf("Out of memory\n");  
        return FALSE;  
    }  
    unsigned int n_buffers;  
    for(n_buffers = 0;n_buffers < req.count; n_buffers++){  
    //struct v4l2_buffer buf = {0};  
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
    buf.memory = V4L2_MEMORY_MMAP;  
    buf.index = n_buffers;  
    if(ioctl(fd, VIDIOC_QUERYBUF, &buf) == -1){ // 查询已经分配的V4L2的视频缓冲区的相关信息，包括视频缓冲区的使用状态、在内核空间的偏移地址、缓冲区长度等。  
        printf("Querying Buffer error\n");  
        return FALSE;  
        }  
  
    buffer = (uchar*)mmap (NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset);  
  
    if(buffer == MAP_FAILED){  
        printf("buffer map error\n");  
        return FALSE;  
        }  
    printf("Length: %d\nAddress: %p\n", buf.length, buffer);  
    printf("Image Length: %d\n", buf.bytesused);  
    }  
    //6 queue  
    for(n_buffers = 0;n_buffers <req.count;n_buffers++){  
        buf.index = n_buffers;  
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
        buf.memory = V4L2_MEMORY_MMAP;  
        if(ioctl(fd,VIDIOC_QBUF,&buf)){    // 投放一个空的视频缓冲区到视频缓冲区输入队列中   
            printf("query buffer error\n");  
            return FALSE;  
        }  
    }  
    //7 starting  
    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
    if(ioctl(fd,VIDIOC_STREAMON,&type) == -1){ //  
        printf("stream on error\n");  
        return FALSE;  
    }  
    return TRUE;  
}  