RK3568平台（camera篇）V4L2摄像头应用编程

一.V4L2简介

V4L2 (Video4Linux2)是Linux内核中的一个框架，提供了一套用于视频设备驱动程序开发的API。它是一个开放的、通用的、模块化的视频设备驱动程序框架，允许Linux操作系统和应用程序与各种视频设备（如摄像头、视频采集卡等）进行交互。

V4L2提供了一个通用的API，使应用程序能够访问和控制视频设备，包括获取设备信息、设置设备参数、采集视频数据、控制设备状态等。V4L2还提供了一个统一的视频数据格式，允许应用程序在处理视频数据时无需考虑设备的具体格式。

二.V4L2采集原理

当启动视频采集后，驱动程序开始采集一帧图像数据，会把采集的图像数据放入视频采集输入队

列的第一个帧缓冲区，一阵图像数据就算采集完成了。第一个帧缓冲区存满一帧图像数据后，驱

动程序将该帧缓冲区移至视频采集输出队列，等待应用程序从输出队列取出，应用程序取出图像

数据可以对图像数据进行处理或存储操作，然后将帧该缓冲区放入视频采集输入队列的尾部。驱

动程序接下来采集下一帧数据，放入第二个缓冲区，同样的帧缓冲区存满一帧数据后，驱动程序

将该缓冲区移至视频采集输出队列，应用程序将该帧缓冲区的图像数据取出后又将该帧缓冲区放

入视频输入队列尾部，这样循环往复就实现了循环采集。

三.V4L2采集流程

使用 V4L2 进行视频采集，一般分为 5 个步骤：
（1） 打开设备，进行初始化参数设置，通过 V4L2 接口设置视频图像的采集
窗口、采集的点阵大小和格式；
（2） 申请图像帧缓冲，并进行内存映射，将这些帧缓冲区从内核空间映射
到用户空间，便于应用程序读取、处理图像数据；
（3） 将帧缓冲进行入队操作，启动视频采集；
（4） 驱动开始视频数据的采集，应用程序从视频采集输出队列取出帧缓冲
区，处理完后，将帧缓冲区重新放入视频采集输入队列，循环往复采集连续的视
频数据；
（5） 释放资源，停止采集工作。

四.V4L2应用编程

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/videodev2.h>
#include <linux/fb.h>

typedef struct camera_format {
 unsigned char description[32]; //字符串描述信息
 unsigned int pixelformat; //像素格式
} cam_fmt;

static cam_fmt cam_fmts[2]; 

int lcdfd = 0; //LCD设备文件描述符
int *lcdptr = NULL; //LCD映射到内存的指针
int lcd_w=800, lcd_h=1280 ; //LCD屏幕的分辨率
int video_width = 640, video_height= 360; //摄像头采集数据的分辨率

static int fb_dev_init(void) 
{
	//打开LCD设备文件
	lcdfd = open("/dev/fb0", O_RDWR);
	if (lcdfd < 0) 
	{
		perror("LCD open failed:");
	}
	/*获取LCD信息*/
	struct fb_var_screeninfo info;
	int lret = ioctl(lcdfd, FBIOGET_VSCREENINFO, &info);
	if (lret < 0) 
	{
		perror("get info failed:");
	}

	//获取LCD的分辨率
	lcd_w = info.xres;
	lcd_h = info.yres;
	//映射LCD到内存
	lcdptr = (int *)mmap(NULL, lcd_w*lcd_h*4,PROT_READ | PROT_WRITE, MAP_SHARED, lcdfd, 0);
	if (lcdptr == NULL) 
	{
		perror("lcd mmap failed:");
	}

	//清空LCD屏幕并填充白色背景
	memset(lcdptr, 0xFF, lcd_w*lcd_h*4);
	return 0;
}

//将YUYV格式的数据转换为RGB格式
void yuyv_to_rgb(unsigned char *yuyvdata, unsigned char * rgbdata, int w, int h)
{
	int r1, g1, b1;
	int r2, g2, b2;
	for (int i = 0; i < w*h/2; i++) 
	{
		char data[4];
		memcpy(data, yuyvdata + i*4, 4);
		unsigned char Y0 = data[0];
		unsigned char U0 = data[1];
		unsigned char Y1 = data[2];
		unsigned char V1 = data[3];
		r1 = Y0 + 1.4075*(V1 - 128);
		if (r1 > 255)
			r1 = 255;
		if (r1 < 0)
			r1 = 0;
		g1 = Y0 - 0.3455*(U0 - 128) - 0.7169*(V1 - 128);
		if (g1 > 255)
			g1 = 255;
		if (g1 < 0)
			g1 = 0;
		b1 = Y0 + 1.779*(U0 - 128);
		if (b1 > 255)
			b1 = 255;
		if (b1 < 0)
			b1 = 0;

		r2 = Y1 + 1.4075*(V1 - 128);
		if (r2 > 255)
			r2 = 255;
		if (r2 < 0)
			r2 = 0;
		g2 = Y1 - 0.3455*(U0 - 128) - 0.7169*(V1 - 128);
		if (g2 > 255)
			g2 = 255;
		if (g2 < 0)
			g2 = 0;
		b2 = Y1 + 1.779*(U0 - 128);
		if (b2 > 255)
			b2 = 255;
		if (b2 < 0)
			b2 = 0;

		rgbdata[i*6 + 0] = r1;
		rgbdata[i*6 + 1] = g1;
		rgbdata[i*6 + 2] = b1;
		rgbdata[i*6 + 3] = r2;
		rgbdata[i*6 + 4] = g2;
		rgbdata[i*6 + 5] = b2;
	}
}



void lcd_show_rgb(unsigned char *rgbdata, int w, int h)
{
	unsigned int *ptr = lcdptr;
	for (int i = 0; i < h; i++) 
	{
		for (int j = 0; j < w; j++) 
		{
			memcpy(ptr + j, rgbdata + j*3, 3);
		}
		ptr += lcd_w;//偏移一行
		rgbdata += w*3;//偏移一行
	}
}

int main(int argc,char *argv[])
{
    int ret,i;
	int fd;
    unsigned short *base;
    unsigned short *start;
    int min_w, min_h;
    int j;


    fb_dev_init();
     /* 步骤一，打开视频设备 */
    fd = open(argv[1], O_RDWR);
    if (fd < 0) 
	{
        printf("file open error\n");
        return -1;
    }
    /* 步骤二，查询设备能力 */
	//查询设备的基本信息
	struct v4l2_capability cap; // 定义一个v4l2_capability结构体的变量cap
	// 使用ioctl函数发送VIDIOC_QUERYCAP命令来获取视频设备的基本信息，并将结果保存到cap变量中 
	if (ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) 
	{ 
		perror("VIDIOC_QUERYCAP"); 
		return -1; 
	} 
	//查看支持的图像格式、分辨率、帧率
	struct v4l2_fmtdesc fmtdesc = {0};//定义支持的像素格式结构体
	struct v4l2_frmsizeenum frmsize = {0};//定义支持的分辨率结构体
	struct v4l2_frmivalenum frmival = {0};//定义支持的帧率结构体
	fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//设置视频采集类型为 V4L2_BUF_TYPE_VIDEO_CAPTURE
	fmtdesc.index = 0;
	while (!ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc))//获取支持的像素格式
	{
		strcpy(cam_fmts[fmtdesc.index].description, fmtdesc.description);
		cam_fmts[fmtdesc.index].pixelformat = fmtdesc.pixelformat;
		fmtdesc.index++;
	}
	frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	frmival.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	for(i=0;i<fmtdesc.index;i++)//枚举每一种像素格式
	{
		printf("description:%s\npixelformat:0x%x\n", cam_fmts[i].description,cam_fmts[i].pixelformat );
		frmsize.index = 0;
		frmsize.pixel_format = cam_fmts[i].pixelformat;
		frmival.pixel_format = cam_fmts[i].pixelformat;
		// 2.枚举出摄像头所支持的所有视频采集分辨率
		while (0 == ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) 
		{
			printf("size<%d*%d> ",frmsize.discrete.width,frmsize.discrete.height);
			frmsize.index++;
			frmival.index = 0;
			frmival.width = frmsize.discrete.width;
			frmival.height = frmsize.discrete.height;
			// 3. 获取摄像头视频采集帧率
			while (0 == ioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival)) 
			{
				printf("<%dfps>", frmival.discrete.denominator/frmival.discrete.numerator);
				frmival.index++;
			}
			printf("\n");
		}
		printf("\n");
	}
    /*步骤三，设置采集参数，视频帧宽度、高度、格式、视频帧率等信息*/
    struct v4l2_format fmt = {0};
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type 类型
    fmt.fmt.pix.width = video_width; //设置视频帧宽度
    fmt.fmt.pix.height = video_height;//设置视频帧高度
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; //设置像素格式 
    if (ioctl(fd, VIDIOC_S_FMT, &fmt) < 0) 
	{
        printf("ioctl error: VIDIOC_S_FMT\n");
        return -1;
    }

    struct v4l2_streamparm streamparm = {0};
    streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    ioctl(fd, VIDIOC_G_PARM, &streamparm);
    if (V4L2_CAP_TIMEPERFRAME & streamparm.parm.capture.capability) 
	{
        streamparm.parm.capture.timeperframe.numerator = 1;
        streamparm.parm.capture.timeperframe.denominator = 30;//30fps
        if (0 > ioctl(fd, VIDIOC_S_PARM, &streamparm)) 
		{
            printf("ioctl error: VIDIOC_S_PARM");
            return -1;
        }
    }
    /*步骤四，请求帧缓冲*/
	struct v4l2_requestbuffers reqbuffer;
	reqbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	reqbuffer.count = 4;//缓存数量
	reqbuffer.memory = V4L2_MEMORY_MMAP;//映射方式
	ret = ioctl(fd, VIDIOC_REQBUFS, &reqbuffer);
	if (ret < 0) 
	{
		printf("Request Queue space failed \n");
		return -1;
	}
	/*步骤五，映射帧缓冲*/
	struct v4l2_buffer mapbuffer;
	unsigned char *mptr[4];
	unsigned int size[4];//存储大小，方便释放
	mapbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	for (i = 0; i < 4; i++) 
	{
		mapbuffer.index = i;
		ret = ioctl(fd, VIDIOC_QUERYBUF, &mapbuffer);
		if (ret < 0) 
		{
			printf("Kernel space queue failed\n");
			return -1;
		}
		mptr[i] = (unsigned char *)mmap(NULL, mapbuffer.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mapbuffer.m.offset);
		size[i] = mapbuffer.length;
		//使用完毕,入队
		ret = ioctl(fd, VIDIOC_QBUF, &mapbuffer);
		if (ret < 0) 
		{
			printf("ioctl error: VIDIOC_QBUF \n");
			return -1;
		}
	}

	/*步骤六，开启视频采集*/
	int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	ret = ioctl(fd, VIDIOC_STREAMON, &type);
	if (ret < 0)
	{
		printf("ioctl error: VIDIOC_STREAMON \n");
		return -1;
	}
	//步骤七，读取数据、对数据进行处理
	unsigned char rgbdata[video_width*video_height*3];
	while (1) 
	{
		struct v4l2_buffer readbuffer;
		//出队列
		readbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		ret = ioctl(fd, VIDIOC_DQBUF, &readbuffer);
		if (ret < 0) 
		{
			printf("ioctl error:VIDIOC_DQBUF \n");
		}
		//显示在LCD上
		yuyv_to_rgb(mptr[readbuffer.index], rgbdata, video_width, video_height);
		lcd_show_rgb(rgbdata, video_width, video_height);
		//通知内核已经使用完毕，入队列
		ret = ioctl(fd, VIDIOC_QBUF, &readbuffer);
		if (ret < 0) 
		{
			printf("ioctl error:VIDIOC_QBUF \n");
		}
	}
	//步骤八，停止视频采集和释放资源
	ret = ioctl(fd, VIDIOC_STREAMOFF, &type);
	if (ret < 0) 
	{
		printf("ioctl error:VIDIOC_STREAMOFF \n");
		return -1;
	}

	//释放映射空间
	for (i = 0; i < 4; i++) 
	{
		munmap(mptr[i], size[i]);
	}
	close(fd);
	return 0;
}