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

短命女 2022-05-13 11:46 210阅读 0赞

V4L2跟V4L有较大的改动，已经称为3.0的接口标准，涵盖了大多数的视频或其它dvd和FM等驱动，都向V4L2靠拢。V4L2采用流水线的操作方式，基本遵循了打开视频设备文件、设置视频格式、处理视频数据、关闭视频设备，其中用到的函数寥寥无几，open，read，write，ioctl等来实现。

1、打开视频设备文件

在linux系统中所有的设备都被看成是一个文件，视频设备也不例外。使用open开打/dev目录下的video设备：

非阻塞模式打开:

// 用非阻塞模式打开摄像头设备
    int camfd;
    camfd = open("/dev/video0", O_RDWR | O_NONBLOCK, 0);   //在文件标志中采用非阻塞模式

阻塞模式打开:

// 如果用阻塞模式打开摄像头设备，上述代码变为：
    int camfd;
    camfd = open("/dev/video0", O_RDWR, 0);

在函数调用过程中，即使使用的是非阻塞的方式，在没有捕获到信息的情况下驱动也会将缓存中的数据返回给应用层。

2、设置视频格式--------设定属性及采集方式等

开打视频设备后，可以设置视频设备属性，如裁剪、缩放等。在linux中视频设置通过ioctl函数来对设备的I/O通道进行管理：

int ioctl (int __fd, unsigned long int __request, .../*args*/) ;

在ioctl使用中，视频常用的控制命令标识符有一下这些：

*  VIDIOC\_REQBUFS：分配内存
 *  VIDIOC\_QUERYBUF：把VIDIOC\_REQBUFS中分配的数据缓存转换成物理地址
 *  VIDIOC\_QUERYCAP：查询驱动功能
 *  VIDIOC\_ENUM\_FMT：获取当前驱动支持的视频格式
 *  VIDIOC\_S\_FMT：设置当前驱动的频捕获格式
 *  VIDIOC\_G\_FMT：读取当前驱动的频捕获格式
 *  VIDIOC\_TRY\_FMT：验证当前驱动的显示格式
 *  VIDIOC\_CROPCAP：查询驱动的修剪能力
 *  VIDIOC\_S\_CROP：设置视频信号的边框
 *  VIDIOC\_G\_CROP：读取视频信号的边框
 *  VIDIOC\_QBUF：把数据从缓存中读取出来
 *  VIDIOC\_DQBUF：把数据放回缓存队列
 *  VIDIOC\_STREAMON：开始视频显示函数
 *  VIDIOC\_STREAMOFF：结束视频显示函数
 *  VIDIOC\_QUERYSTD：检查当前视频设备支持的标准，例如PAL或NTSC。

2）、检测当前设备支持的标准

由于存在地域的差异，亚洲的标准和欧洲的视频标准存在一定的差距，亚洲一般使用PAL制式的摄像头，而欧洲一般采用NTSC，使用VIDIOC\_QUERYSTD可以检测当前摄像头所支持的标准：

v4l2_std_id std;
    do 
    {
        ret = ioctl(fd, VIDIOC_QUERYSTD, &std);
    }
        while (ret == -1 && errno == EAGAIN);
        switch (std) {
        case V4L2_STD_NTSC:
            //……
        case V4L2_STD_PAL:
            //……
    }

3）、设置视频捕获格式

检测完视频格式之后就要设置视频：

struct v4l2_format    fmt;
    memset ( &fmt, 0, sizeof(fmt) );
    fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width       = 720;
    fmt.fmt.pix.height      = 576;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
    if (ioctl(fd, VIDIOC_S_FMT, &fmt) == -1) 
    {
        return -1;
    }

4）、内存分配

为捕获的视频分配内存空间：

struct v4l2_requestbuffers  req;
    if (ioctl(fd, VIDIOC_REQBUFS, &req) == -1) 
    {
        return -1;
    }

5）、获取并记录视频缓存的物理空间

使用VIDEO\_REQBUF，可以获得count个缓存，再通过调用VIDEO\_QUERYBUF命令来取得这些缓存的地址，然后使用mmap函数转换成应用程序中的绝对地址，最后放入缓存队列。

struct v4l2_buffer buf;   //驱动中的一帧
    CLEAR (buf);
    buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory      = V4L2_MEMORY_MMAP;
    buf.index       = n_buffers;
    /*获取并记录视频缓存的物理空间*/
    ioctl (fd, VIDIOC_QUERYBUF, &buf); //映射用户空间

6）、请求数据进入队列

使用VIDIOC\_QBUF来请求数据进入队列，利用struct v4l2\_buffer buf，中buf.index来把数据放入相应的队列。

struct v4l2_buffer buf;
    CLEAR (buf);
    buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory      = V4L2_MEMORY_MMAP;
    buf.index       = i;
    ioctl (fd, VIDIOC_QBUF, &buf);//申请到的缓冲进入列队

7）、从队列取出采集到的数据

使用VIDIOC\_DQBUF来将buf中的数据取出。

struct v4l2_buffer buf;
    CLEAR (buf);
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    ioctl (fd, VIDIOC_DQBUF, &buf); //出列采集的帧缓冲

8）、开始视频图像捕捉

使用VIDIOC\_STREAMON来开始视频图像的采集。

type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    /*开始捕获数据*/
    if (-1 == ioctl (fd, VIDIOC_STREAMON, &type)) //开始捕捉图像数据
       	printf ("VIDIOC_STREAMON failed\n");

9）、关闭视频图像捕捉

使用VIDIOC\_STREAMOFF用法同VIDIOC\_STREAMON。

使用mmap程序：

#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>
    
    #define CLEAR(x) memset (&(x), 0, sizeof (x))
    
    struct buffer {
            void *                  start;
            size_t                  length;
    };
    
    static char *           dev_name        = "/dev/video0";//摄像头设备名
    static int              fd              = -1;
    struct buffer *         buffers         = NULL;
    static unsigned int     n_buffers       = 0;
    
    FILE *file_fd;
    static unsigned long file_length;
    static unsigned char *file_name;
    //
    //获取一帧数据
    //
    static int read_frame (void)
    {
    	struct v4l2_buffer buf;
    	unsigned int i;   	
       	
       	CLEAR (buf);
    	buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    	buf.memory = V4L2_MEMORY_MMAP;
    
    	ioctl (fd, VIDIOC_DQBUF, &buf); //出列采集的帧缓冲
    
    	assert (buf.index < n_buffers);
       	printf ("buf.index dq is %d,\n",buf.index);
    
    	fwrite(buffers[buf.index].start, buffers[buf.index].length, 1, file_fd); //将其写入文件中
     
    	ioctl(fd, VIDIOC_QBUF, &buf); //再将其入列
    
    	return 1;
    }
    
    int main (int argc,char ** argv)
    {
    	struct v4l2_capability cap;
    	struct v4l2_format fmt;
    	unsigned int i;
    	enum v4l2_buf_type type;
    
    	file_fd = fopen("test-mmap.jpg", "w");//图片文件名
    	/* 1.打开视频设备*/
    	fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);//打开设备
    
    	/*获取摄像头驱动参数*/
    	if (ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) 
    	{    
            	perror("VIDIOC_QUERYCAP failed ");    
            	return 0;    
        	} 
        	printf("driver:   %s\n", cap.driver);
    	/*设置摄像头参数*/
    	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;
    	fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
    	ioctl(fd, VIDIOC_S_FMT, &fmt); //设置图像格式
    
    	file_length = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height; //计算图片大小
    
    	/*分配视频内存空间*/
    	struct v4l2_requestbuffers req;
    	CLEAR (req);
    	req.count               = 4;
    	req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    	req.memory              = V4L2_MEMORY_MMAP;
    
    	ioctl (fd, VIDIOC_REQBUFS, &req); //申请缓冲，count是申请的数量
    
    	if (req.count < 2)
       		printf("Insufficient buffer memory\n");
    	
    	/*分配内存并初始化为都为0*/
    	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 */,    //通过mmap建立映射关系
        		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");
            }
    	/*请求数据入队列*/
    	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");
    	}
                   
    	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    	/*开始捕获数据*/
    	if (-1 == ioctl (fd, VIDIOC_STREAMON, &type)) //开始捕捉图像数据
       	printf ("VIDIOC_STREAMON failed\n");
    	sleep(5);
    	for (;;) //这一段涉及到异步IO
    	{
       		fd_set fds;
       		struct timeval tv;
       		int r;
    
       		FD_ZERO (&fds);//将指定的文件描述符集清空
       		FD_SET (fd, &fds);//在文件描述符集合中增加一个新的文件描述符
    
       		/* Timeout. */
    		tv.tv_sec = 10;
    		tv.tv_usec = 0;
    		
       		r = select (fd + 1, &fds, NULL, NULL, &tv);//判断是否可读（即摄像头是否准备好），tv是定时
    		/*以上采用异步IO等待数据到来，该打开方式未非阻塞型*/
       		if (-1 == r) 
       		{
        			if (EINTR == errno)
         			continue;
        			printf ("select err\n");
                    }
       		if (0 == r) 
       		{
        			fprintf (stderr, "select timeout\n");
        			exit (EXIT_FAILURE);
                 	}
    
       		if (read_frame ())//如果可读，执行read_frame ()函数，并跳出循环
       			break;
    	}
    
    unmap:
    	for (i = 0; i < n_buffers; ++i)
       		if (-1 == munmap (buffers[i].start, buffers[i].length))
        			printf ("munmap error");
    	close (fd);
    	fclose (file_fd);
    	exit (EXIT_SUCCESS);
    	return 0;
    }

read读取方式：