基于linux视频架构V4L2分析-----video for linux（一）

怼烎@ 2022-05-13 09:06 287阅读 0赞

在linux内核版本中，2.6.38可谓是一个分水岭，在这之前linux视频架构采用v4l的架构，在2.6.38内核中去除了v4l采用全新的v4l2，v4l2架构不再兼容v4l。全新的API接口使用起来相当的方便。linux视频架构再次体现了linux驱动分层思想的优越性。

废话不讲，直接进入主题.

在linux中视频设备被当作一个文件设备来对待，视频设备存放在/dev下,，全路径为/dev/videoN（N为video编号，操作系统中可能存在不止一个视频设备哦）。

视频采集步骤基本如下：

1、打开视频设备文件。

2、设置视频设备参数（数据格式和采集方式等等）。

3、获取视频设备视频数据和处理数据。

4、关闭视频设备文件。

1、打开视频设备

视频设备被当作一个文件来看待，因此打开视频设备跟打开一个文件方式一样-------open一个文件，视频文件打开有两个方式，一种是阻塞型打开方式，一种是非阻塞型打开方式。不同的打开方式也使得编程上存在差异。

1）、阻塞方式打开：

int camfd;

camfd = open("/dev/video0", O\_RDWR);

2）、非阻塞方式打开：

int camfd;

camfd = open("/dev/video0",O\_RDWR | O\_NONBLOCK);

关于阻塞和非阻塞打开的区别在于，当视频设备未捕获到一帧数据信息时，在非阻塞模式下会将DQBUF中的数据传递给应用层，在阻塞模式下不会将DQBUF中的数据传递给应用层直道捕获完一帧数据才传递给应用层。

2、设置视频参数

设置视频参数通过ioctl来配置，ioctl有三个参数，分别是fd,、cmd和parameter，分别表示设备描述符、控制命令和控制命令参数。

常用控制字如下：

#define VIDIOC_QUERYCAP		 _IOR('V',  0, struct v4l2_capability)          
    #define VIDIOC_RESERVED		  _IO('V',  1)
    #define VIDIOC_ENUM_FMT         _IOWR('V',  2, struct v4l2_fmtdesc)
    #define VIDIOC_G_FMT		_IOWR('V',  4, struct v4l2_format)
    #define VIDIOC_S_FMT		_IOWR('V',  5, struct v4l2_format)
    #define VIDIOC_REQBUFS		_IOWR('V',  8, struct v4l2_requestbuffers)
    #define VIDIOC_QUERYBUF		_IOWR('V',  9, struct v4l2_buffer)
    #define VIDIOC_G_FBUF		 _IOR('V', 10, struct v4l2_framebuffer)
    #define VIDIOC_S_FBUF		 _IOW('V', 11, struct v4l2_framebuffer)
    #define VIDIOC_OVERLAY		 _IOW('V', 14, int)
    #define VIDIOC_QBUF		_IOWR('V', 15, struct v4l2_buffer)
    #define VIDIOC_DQBUF		_IOWR('V', 17, struct v4l2_buffer)
    #define VIDIOC_STREAMON		 _IOW('V', 18, int)
    #define VIDIOC_STREAMOFF	 _IOW('V', 19, int)
    #define VIDIOC_G_PARM		_IOWR('V', 21, struct v4l2_streamparm)
    #define VIDIOC_S_PARM		_IOWR('V', 22, struct v4l2_streamparm)
    #define VIDIOC_G_STD		 _IOR('V', 23, v4l2_std_id)
    #define VIDIOC_S_STD		 _IOW('V', 24, v4l2_std_id)
    #define VIDIOC_ENUMSTD		_IOWR('V', 25, struct v4l2_standard)
    #define VIDIOC_ENUMINPUT	_IOWR('V', 26, struct v4l2_input)
    #define VIDIOC_G_CTRL		_IOWR('V', 27, struct v4l2_control)
    #define VIDIOC_S_CTRL		_IOWR('V', 28, struct v4l2_control)

1）、控制命令 VIDIOC\_ENUM\_FMT

功能：获取当前驱动支持的视频格式

参数说明：参数类型为V4L2的视频格式描述符类型 struct v4l2\_fmtdesc

struct v4l2_fmtdesc {
    	__u32		    index;             /* Format number      */
    	enum v4l2_buf_type  type;              /* buffer type        */
    	__u32               flags;
    	__u8		    description[32];   /* Description string */
    	__u32		    pixelformat;       /* Format fourcc      */
    	__u32		    reserved[4];
    };

返回值说明： 执行成功时，函数返回值为 0；struct v4l2\_fmtdesc 结构体中的pixelformat和description 成员返回当前视频设备所支持的视频格式

static int video_fmtdesc(int fd)  
    {  
        /***********Format Enumeration************/  
        int ret = 0;  
        struct v4l2_fmtdesc fmtdes;  
        CLEAR(fmtdes);  
        fmtdes.index = 0;  
        fmtdes.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
        printf("\n**********vidioc enumeration stream format informations:****\n");  
        while (1) {  
              
            ret = ioctl(fd, VIDIOC_ENUM_FMT, &fmtdes);  
            if (ret < 0)   
                break;  
              
             printf("{ pixelformat = %c%c%c%c, description = %s }\n",  
                    (fmtdes.pixelformat & 0xFF),  
                    (fmtdes.pixelformat >> 8) & 0xFF,  
                    (fmtdes.pixelformat >> 16) & 0xFF,   
                    (fmtdes.pixelformat >> 24) & 0xFF,  
                    fmtdes.description);  
              
            if (fmtdes.type == V4L2_BUF_TYPE_VIDEO_CAPTURE)  
                printf("video capture type:\n");  
            if (fmtdes.pixelformat == V4L2_PIX_FMT_YUYV)  
                printf("V4L2_PIX_FMT_YUYV\n");  
            fmtdes.index++;  
        }  
        return 0;  
    }

2）、控制命令VIDIOC\_QUERYCAP  
        功能：查询驱动功能

参数说明：参数类型为V4L2的能力描述类型struct v4l2\_capability

struct v4l2_capability {
    	__u8	driver[16];	/* i.e. "bttv" */
    	__u8	card[32];	/* i.e. "Hauppauge WinTV" */
    	__u8	bus_info[32];	/* "PCI:" + pci_name(pci_dev) */
    	__u32   version;        /* should use KERNEL_VERSION() */
    	__u32	capabilities;	/* Device capabilities */
    	__u32	reserved[4];
    };

返回值说明： 执行成功时，函数返回值为 0；函数执行成功后，struct v4l2\_capability 结构体变量中的返回当前视频设备所支持的功能；例如支持视频捕获功能V4L2\_CAP\_VIDEO\_CAPTURE、V4L2\_CAP\_STREAMING等。

static int video_capability(int fd)  
    {  
        int ret = 0;  
        /***********get the device capability********/  
        struct v4l2_capability cap;  
        ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);  
        if (ret < 0) {  
            perror("VIDIOC_QUERYCAP failed ");  
            return ret;  
        }  
          
        printf("\n****Capability informations****\n");  
        printf("driver:   %s\n", cap.driver);  
          
        if (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)  
            printf("Capture capability is supported\n");  
      
        if (cap.capabilities & V4L2_CAP_STREAMING)   
            printf("Streaming capability is supported\n");  
              
        if (cap.capabilities & V4L2_CAP_VIDEO_OVERLAY)   
            printf("Overlay capability is supported\n");  
          
        return 0;  
    }

3）、控制命令VIDIOC\_S\_FMT

功能：设置当前驱动的频捕获格式（例如设置视频的长宽和数据格式）

参数说明：参数类型为V4L2的视频数据格式类型struct v4l2\_format

struct v4l2_format {
    	enum v4l2_buf_type type;
    	union {
    		struct v4l2_pix_format		pix;     /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
    		struct v4l2_window		win;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
    		struct v4l2_vbi_format		vbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */
    		struct v4l2_sliced_vbi_format	sliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
    		__u8	raw_data[200];                   /* user-defined */
    	} fmt;
    };

返回值说明： 执行成功时，函数返回值为 0

static int video_setfmt(int fd)  
    {  
        /***********set Stream data format********/  
        int ret = 0;  
        struct v4l2_format fmt;  
        CLEAR(fmt);  
        fmt.type            =   V4L2_BUF_TYPE_VIDEO_CAPTURE;  
        fmt.fmt.pix.width   =   640;  
        fmt.fmt.pix.height  =   480;  
        fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;//for PAL   
        fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;  
          
        ret = ioctl(fd, VIDIOC_S_FMT, &fmt);  
        if (ret < 0) {  
            perror("VIDIOC_S_FMT");  
            return ret;  
        }  
          
        return 0;  
    }

4）、控制命令VIDIOC\_REQBUFS

功能：分配内存，V4L2的视频设备位于内核空间，因此通过该控制命令申请的是位于内核的内存空间，应用程序不能直接访问，需要通过mmap内存映射函数把内核内存映射到用户空间，这样应用程序可以通过访问用户空间地址来访问内核空间。

参数说明：参数类型为V4L2的申请缓冲区数据结构体类型struct v4l2\_requestbuffers

struct v4l2_requestbuffers {
    	__u32			count;
    	enum v4l2_buf_type      type;
    	enum v4l2_memory        memory;
    	__u32			reserved[2];
    };

返回值说明： 执行成功时，函数返回值为 0；V4L2驱动层分配好了视频缓冲区；

5）、控制命令VIDIOC\_QUERYBUF

功能：查询已经分配的V4L2的视频缓冲区的相关信息，包括视频缓冲区的使用状态、在内核空间的偏移地址、缓冲区长度等。应用程序设计中通过调VIDIOC\_QUERYBUF来获取内核空间的视频缓冲区信息，然后调用函数mmap把内核空间地址映射到用户空间，这样应用程序才能够访问位于内核空间的视频缓冲区。

参数说明：参数类型为V4L2缓冲区数据结构类型    struct v4l2\_buffer

struct v4l2_buffer {
    	__u32			index;
    	enum v4l2_buf_type      type;
    	__u32			bytesused;
    	__u32			flags;
    	enum v4l2_field		field;
    	struct timeval		timestamp;
    	struct v4l2_timecode	timecode;
    	__u32			sequence;
    
    	/* memory location */
    	enum v4l2_memory        memory;
    	union {
    		__u32           offset;
    		unsigned long   userptr;
    	} m;
    	__u32			length;
    	__u32			input;
    	__u32			reserved;
    };

返回值说明： 执行成功时，函数返回值为 0；struct v4l2\_buffer结构体变量中保存了指令的缓冲区的相关信息

6）、控制命令VIDIOC\_QBUF

功能：把数据放回缓存队列

参数说明：参数类型为V4L2缓冲区数据结构类型    struct v4l2\_buffer

返回值说明： 执行成功时，函数返回值为 0；函数执行成功后，指令(指定)的视频缓冲区进入视频输入队列，在启动视频设备拍摄图像时，相应的视频数据被保存到视频输入队列相应的视频缓冲区中。

static int video_mmap(int fd)  
    {  
        /*******第一步分配内核内存空间*******/  
        int ret = 0;  
        struct v4l2_requestbuffers req;  
        CLEAR(req);  
        req.count    = 4;  
        req.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
        req.memory   = V4L2_MEMORY_MMAP;  
          
        ret = ioctl(fd, VIDIOC_REQBUFS, &req);  
        if (ret < 0) {  
            perror("VIDIOC_REQBUFS");  
            return ret;  
        }  
          
        if (req.count < 2)  
            printf("insufficient buffer memory\n");  
            printf("Number of buffers allocated = %d\n", req.count);  
              
        /*******第二步获得物理页地址*******/  
        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;  
              
            ret = ioctl(fd, VIDIOC_QUERYBUF, &buf);  
            if (ret < 0) {  
                perror("VIDIOC_QUERYBUF");  
                return ret;  
            }  
              
        /*******第三步映射内核空间到用户空间*******/  
            buffers[n_buffers].length = buf.length;  
            buffers[n_buffers].start =   
            mmap(NULL,  
                buf.length,  
                PROT_READ | PROT_WRITE,  
                MAP_SHARED,  
                fd,  
                buf.m.offset);  
                  
            //if (MAP_FAILED == buffers[n_buffers].start)   
            //perror("mmap failed \n");   
        }  
          
        /************数据放入缓存队列***********/  
        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;  
              
            ret = ioctl(fd, VIDIOC_QBUF, &buf);//申请的缓冲进入队列   
            if (ret < 0) {  
                perror("VIDIOC_QBUF");  
                return ret;  
            }     
        }  
          
        return 0;  
    }

7）、控制命令VIDIOC\_STREAMON

功能：开始视频显示函数  
        参数说明：参数类型为V4L2的视频缓冲区类型 enum v4l2\_buf\_type

enum v4l2_buf_type {
    	V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,
    	V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,
    	V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,
    	V4L2_BUF_TYPE_VBI_CAPTURE          = 4,
    	V4L2_BUF_TYPE_VBI_OUTPUT           = 5,
    	V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,
    	V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,
    #if 1
    	/* Experimental */
    	V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
    #endif
    	V4L2_BUF_TYPE_PRIVATE              = 0x80,
    };

返回值说明： 执行成功时，函数返回值为 0；函数执行成功后，视频设备驱动程序开始采集视频数据，此时应用程序一般通过调用select函数来判断一帧视频数据是否采集完成，当视频设备驱动完成一帧视频数据采集并保存到视频缓冲区中时，select函数返回，应用程序接着可以读取视频数据；否则select函数阻塞直到视频数据采集完成。

static int video_streamon(int fd)  
    {  
        int ret = 0;  
          
        /************start stream on***********/  
      
        enum v4l2_buf_type types;//开始捕捉图像数据   
        types = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
        ret = ioctl(fd, VIDIOC_STREAMON, &types);  
        if (ret < 0) {  
            perror("VIDIOC_STREAMON");  
            return ret;  
        }  
      
        return 0;  
    }

8）、控制命令VIDIOC\_STREAMOFF

功能：停止视频采集命令，应用程序调用VIDIOC\_ STREAMOFF停止视频采集命令后，视频设备驱动程序不在采集视频数据。

参数说明：参数类型为V4L2的视频缓冲区类型 enum v4l2\_buf\_type ；

返回值说明： 执行成功时，函数返回值为 0；函数执行成功后，视频设备停止采集视频数据。

static int video_streamoff(int fd)  
    {  
        int ret = 0;  
          
        /************start stream off***********/  
      
        enum v4l2_buf_type types;//开始捕捉图像数据   
        types = V4L2_BUF_TYPE_VIDEO_CAPTURE;  
        ret = ioctl(fd, VIDIOC_STREAMOFF, &types);  
        if (ret < 0) {  
            perror("VIDIOC_STREAMOFF");  
            return ret;  
        }  
      
        return 0;  
    }