V4L2摄像头编程

一、FrameBuffer

Frame 是帧的意思， buffer 是缓冲的意思，所以 Framebuffer 就是帧缓冲， 这意味着 Framebuffer 就是一块内存，里面保存着一帧图像。帧缓冲（framebuffer）是 Linux 系统中的一种显示驱动接口，它将显示设备（譬如 LCD） 进行抽象、 屏蔽了不同显示设备硬件的实现，对应用层抽象为一块显示内存（显存），它允许上层应用程序直接对显示缓冲区进行读写操作，而用户不必关心物理显存的位置等具体细节，这些都由Framebuffer 设备驱动来完成。

所以在 Linux 系统中，显示设备被称为 FrameBuffer 设备（帧缓冲设备），所以 LCD 显示屏自然而言就是 FrameBuffer 设备。 FrameBuffer 设备对应的设备文件为/dev/fbX（X 为数字， 0、 1、 2、 3 等） ， Linux下可支持多个 FrameBuffer 设备，最多可达 32 个，分别为/dev/fb0 到/dev/fb31， 开发板出厂系统中， /dev/fb0设备节点便是 LCD 屏。

应用程序读写/dev/fbX 就相当于读写显示设备的显示缓冲区（显存），譬如 LCD 的分辨率是 800

480，每一个像素点的颜色用 24 位（譬如 RGB888）来表示，那么这个显示缓冲区的大小就是 800 x 480 x 24 / 8 = 1152000 个字节。 譬如执行下面这条命令将 LCD 清屏，也就是将其填充为黑色（假设 LCD 对应的设备节点是/dev/fb0，分辨率为 800

480， RGB888 格式）：dd if=/dev/zero of=/dev/fb0 bs=1024 count=1125这条命令的作用就是将 1125×1024 个字节数据全部写入到 LCD 显存中，并且这些数据都是 0x0。

二、LCD应用编程

在应用程序中，操作/dev/fbX 的一般步骤如下：

①、首先打开/dev/fbX 设备文件。

②、 使用 ioctl()函数获取到当前显示设备的参数信息，譬如屏幕的分辨率大小、像素格式，根据屏幕参数计算显示缓冲区的大小。

③、通过存储映射 I/O 方式将屏幕的显示缓冲区映射到用户空间（mmap）。

④、映射成功后就可以直接读写屏幕的显示缓冲区，进行绘图或图片显示等操作了。

⑤、完成显示后， 调用 munmap()取消映射、并调用 close()关闭设备文件。

2.1 使用ioctl()获取屏幕信息

通 过 ioctl() 函 数 来 获 取 屏 幕 参 数 信 息 ， 对 于 Framebuffer 设 备 来 说 ， 常 用 的 request 包 括FBIOGET_VSCREENINFO、 FBIOPUT_VSCREENINFO、 FBIOGET_FSCREENINFO。

FBIOGET_VSCREENINFO： 表示获取 FrameBuffer 设备的可变参数信息，可变参数信息使用

struct fb_var_screeninfo 结 构 体

来 描 述 ， 所 以 此 时 ioctl() 需 要 有 第 三 个 参 数 ， 它 是 一 个 struct fb_var_screeninfo *指针，指向 struct fb_var_screeninfo 类型对象，

调用 ioctl()会将 LCD 屏的可变参数信息保存在 struct fb_var_screeninfo 类型对象中

，如下所示：

struct fb_var_screeninfo fb_var;
ioctl(fd, FBIOGET_VSCREENINFO, &fb_var);

同理FBIOPUT_VSCREENINFO： 表示用 struct fb_var_screeninfo 对象中填充的数据设置 LCD 。

struct fb_var_screeninfo fb_var = {0};
/* 对 fb_var 进行数据填充 */
......
......
/* 设置可变参数信息 */
ioctl(fd, FBIOPUT_VSCREENINFO, &fb_var);

FBIOGET_FSCREENINFO： 表示获取 FrameBuffer 设备的固定参数信息，既然是固定参数，那就意味着应用程序不可修改。固定参数信息使用struct fb_fix_screeninfo结构体来描述，所以此时ioctl()需要有第三个参数，它是一个 struct fb_fix_screeninfo *指针，指向 struct fb_fix_screeninfo 类型对象，

调用 ioctl()会将 LCD 的固定参数信息保存在 struct fb_fix_screeninfo 对象中

，如下所示：

struct fb_fix_screeninfo fb_fix;
ioctl(fd, FBIOGET_FSCREENINFO, &fb_fix);

2.2 重要结构体

2.2.1 fb_var_screeninfo结构体(屏幕可变参数结构体)

/*
*通过 xres、 yres 获取到屏幕的水平分辨率和垂直分辨率， bits_per_pixel 表示像素深度 bpp，即每一个像
*素点使用多少个 bit 位来描述它的颜色，通过 xres * yres * bits_per_pixel / 8 计算可得到整个显示缓存区的大小。
*/
#include <linux/fb.h>
#define FBIOGET_VSCREENINFO 0x4600
#define FBIOPUT_VSCREENINFO 0x4601
#define FBIOGET_FSCREENINFO 0x4602
struct fb_var_screeninfo {
__u32 xres; /* 可视区域，一行有多少个像素点， X 分辨率 */
__u32 yres; /* 可视区域，一列有多少个像素点， Y 分辨率 */
__u32 xres_virtual; /* 虚拟区域，一行有多少个像素点 */
__u32 yres_virtual; /* 虚拟区域，一列有多少个像素点 */
__u32 xoffset; /* 虚拟到可见屏幕之间的行偏移 */
__u32 yoffset; /* 虚拟到可见屏幕之间的列偏移 */
__u32 bits_per_pixel; /* 每个像素点使用多少个 bit 来描述，也就是像素深度 bpp */
__u32 grayscale; /* =0 表示彩色, =1 表示灰度, >1 表示 FOURCC 颜色 */
/* 用于描述 R、 G、 B 三种颜色分量分别用多少位来表示以及它们各自的偏移量 */
struct fb_bitfield red; /* Red 颜色分量色域偏移 */
struct fb_bitfield green; /* Green 颜色分量色域偏移 */
struct fb_bitfield blue; /* Blue 颜色分量色域偏移 */
struct fb_bitfield transp; /* 透明度分量色域偏移 */
__u32 nonstd; /* nonstd 等于 0，表示标准像素格式；不等于 0 则表示非标准像素格式 */
__u32 activate;
__u32 height; /* 用来描述 LCD 屏显示图像的高度（以毫米为单位） */
__u32 width; /* 用来描述 LCD 屏显示图像的宽度（以毫米为单位） */
__u32 accel_flags;
/* 以下这些变量表示时序参数 */
__u32 pixclock; /* pixel clock in ps (pico seconds) */
__u32 left_margin; /* time from sync to picture */
__u32 right_margin; /* time from picture to sync */
__u32 upper_margin; /* time from sync to picture */
__u32 lower_margin;
__u32 hsync_len; /* length of horizontal sync */
__u32 vsync_len; /* length of vertical sync */
__u32 sync; /* see FB_SYNC_* */
__u32 vmode; /* see FB_VMODE_* */
__u32 rotate; /* angle we rotate counter clockwise */
__u32 colorspace; /* colorspace for FOURCC-based modes */
__u32 reserved[4]; /* Reserved for future compatibility */
};

2.2.2 fb_fix_screeninfo 结构体(屏幕固定参数结构体)

/*
*smem_start 表示显存的起始地址，这是一个物理地址，当然在应用层无法直接使用； smem_len 表示显
*存的长度，这个长度并一定等于 LCD 实际的显存大小。 line_length 表示屏幕的一行像素点有多少个字节，
*通常可以使用 line_length * yres 来得到屏幕显示缓冲区的大小。
*/
struct fb_fix_screeninfo {
char id[16]; /* 字符串形式的标识符 */
unsigned long smem_start; /* 显存的起始地址（物理地址） */
__u32 smem_len; /* 显存的长度 */
__u32 type;
__u32 type_aux;
__u32 visual;
__u16 xpanstep;
__u16 ypanstep;
__u16 ywrapstep;
__u32 line_length; /* 一行的字节数 */
unsigned long mmio_start; /* Start of Memory Mapped I/O(physical address) */
__u32 mmio_len; /* Length of Memory Mapped I/O */
__u32 accel; /* Indicate to driver which specific chip/card we have */
__u16 capabilities;
__u16 reserved[2];
};

2.2.3 编译

//交叉编译:先加上交叉编译链(以下是我的链的路径)
source /opt/stm32_sdk/environment-setup-cortexa7t2hf-neon-vfpv4-ostl-linux-gnueabi
//我的Makefile
KERNEL_DIR=/home/farsight/farsight/linux-5.4.31
CUR_DIR=$(shell pwd)
APP_NAME=lcd_test
all:
        $(CC) -o $(APP_NAME) $(APP_NAME).c
clean:
        rm -rf $(APP_NAME)

install:
        cp -raf  $(APP_NAME) /opt/rootfs/drv_module

2.2.4 例程1(获取部分可变参数)

//交叉编译后(注意不是编译)，拷贝可执行程序到开发板上就能跑了
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/fb.h>
int main(int argc, char *argv[])
{
    struct fb_fix_screeninfo fb_fix;
    struct fb_var_screeninfo fb_var;
    int fd;
    /* 打开 framebuffer 设备 */
    if (0 > (fd = open("/dev/fb0", O_WRONLY))) {
    perror("open error");
    exit(-1);
    }
    /* 获取参数信息 */
    ioctl(fd, FBIOGET_VSCREENINFO, &fb_var);
    ioctl(fd, FBIOGET_FSCREENINFO, &fb_fix);
    printf("分辨率: %d*%d\n"
    "像素深度 bpp: %d\n"
    "一行的字节数: %d\n"
    "像素格式: R<%d %d> G<%d %d> B<%d %d>\n",
    fb_var.xres, fb_var.yres, fb_var.bits_per_pixel,
    fb_fix.line_length,
    fb_var.red.offset, fb_var.red.length,
    fb_var.green.offset, fb_var.green.length,
    fb_var.blue.offset, fb_var.blue.length);
    /* 关闭设备文件退出程序 */
    close(fd);
    exit(0);
}

​  我们使用的是华清的mipi屏， 与上图打印显示的分辨率 480*854 是相符的；像素深度为 16，也就意味着一个像素点的颜色值将使用 16bit（也就是 2 个字节） 来表示；一行的字节数为 1024，一行共有 512个像素点，每个像素点使用 16bit 来描述，一共就是 512乘以16/8=1024 个字节数据，这也是没问题的。

打印出像素格式为 R<11 5> G<5 6> B<0 5>， 分别表示 R、 G、 B 三种颜色分量对应的偏移量和长度，第一个数字表示偏移量，第二个参数为长度， 从打印的结果可知， 16bit 颜色值中高 5 位表示 R 颜色通道、中间 6 位表示 G 颜色通道、低 5 位表示 B 颜色通道， 所以这是一个 RGB565 格式的显示设备。 我们可以修改设备树来使其支持RGB888格式或者ioctl修改，但如果驱动程序支持不完善改完后内核容易起不来。建议没事还是别改了。

2.2.5 使用 mmap()将显示缓冲区映射到用户空间

通过 mmap()将显示器的显示缓冲区（显存）映射到进程的地址空间中，这样应用程序便可直接对显示缓冲区进行读写操作。

为什么这里需要使用存储映射 I/O 这种方式呢？ 其实使用普通的 I/O 方式（譬如直接 read、 write）也是可以的， 只是， 当数据量比较大时，普通 I/O 方式效率较低。 假设某一显示器的分辨率为 1920 * 1080，像素格式为 ARGB8888，针对该显示器，刷一帧图像的数据量为 1920 x 1080 x 32 / 8 = 8294400 个字节（约等于 8MB），这还只是一帧的图像数据，而对于显示器来说，显示的图像往往是动态改变的，意味着图像数据会被不断更新。

在这种情况下， 数据量是比较庞大的， 使用普通 I/O 方式必然导致效率低下，所以才会采用存储映射I/O 方式。

2.2.6 例程2(LCD上画图形)

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/fb.h>
#define argb8888_to_rgb565(color) ({ \
        unsigned int temp = (color); \
        ((temp & 0xF80000UL) >> 8) | \
        ((temp & 0xFC00UL) >> 5) | \
        ((temp & 0xF8UL) >> 3); \
        })
static int width; //LCD X 分辨率
static int height; //LCD Y 分辨率
static unsigned short *screen_base = NULL; //映射后的显存基地址
/********************************************************************
* 函数名称： lcd_draw_point
* 功能描述： 打点
* 输入参数： x, y, color
* 返 回 值： 无
********************************************************************/
static void lcd_draw_point(unsigned int x, unsigned int y, unsigned int color)
{
    unsigned short rgb565_color = argb8888_to_rgb565(color);//得到 RGB565 颜色值
    /* 对传入参数的校验 */
    if (x >= width)
    x = width - 1;
    if (y >= height)
    y = height - 1;
    /* 填充颜色 */
    screen_base[y * width + x] = rgb565_color;
}
/********************************************************************
* 函数名称： lcd_draw_line
* 功能描述： 画线（水平或垂直线）
* 输入参数： x, y, dir, length, color
* 返 回 值： 无
********************************************************************/
static void lcd_draw_line(unsigned int x, unsigned int y, int dir,
unsigned int length, unsigned int color)
{
    unsigned short rgb565_color = argb8888_to_rgb565(color);//得到 RGB565 颜色值
    unsigned int end;
    unsigned long temp;
    /* 对传入参数的校验 */
    if (x >= width)
    x = width - 1;
    if (y >= height)
    y = height - 1;
    /* 填充颜色 */
    temp = y * width + x;//定位到起点
    if (dir) { //水平线
        end = x + length - 1;
        if (end >= width)
        end = width - 1;
        for ( ; x <= end; x++, temp++)
        screen_base[temp] = rgb565_color;
    }
    else { //垂直线
        end = y + length - 1;
        if (end >= height)
        end = height - 1;
        for ( ; y <= end; y++, temp += width)
        screen_base[temp] = rgb565_color;
    }
}
/********************************************************************
* 函数名称： lcd_draw_rectangle
* 功能描述： 画矩形
* 输入参数： start_x, end_x, start_y, end_y, color
* 返 回 值： 无
********************************************************************/
static void lcd_draw_rectangle(unsigned int start_x, unsigned int end_x,
unsigned int start_y, unsigned int end_y,
unsigned int color)
{
    int x_len = end_x - start_x + 1;
    int y_len = end_y - start_y - 1;
    lcd_draw_line(start_x, start_y, 1, x_len, color);//上边
    lcd_draw_line(start_x, end_y, 1, x_len, color); //下边
    lcd_draw_line(start_x, start_y + 1, 0, y_len, color);//左边
    lcd_draw_line(end_x, start_y + 1, 0, y_len, color);//右边
}
/********************************************************************
* 函数名称： lcd_fill
* 功能描述： 将一个矩形区域填充为参数 color 所指定的颜色
* 输入参数： start_x, end_x, start_y, end_y, color
* 返 回 值： 无
********************************************************************/
static void lcd_fill(unsigned int start_x, unsigned int end_x,
unsigned int start_y, unsigned int end_y,
unsigned int color)
{
    unsigned short rgb565_color = argb8888_to_rgb565(color);//得到 RGB565 颜色值
    unsigned long temp;
    unsigned int x;
    /* 对传入参数的校验 */
    if (end_x >= width)
    end_x = width - 1;
    if (end_y >= height)
    end_y = height - 1;
    /* 填充颜色 */
    temp = start_y * width; //定位到起点行首
    for ( ; start_y <= end_y; start_y++, temp+=width) {
        for (x = start_x; x <= end_x; x++)
        screen_base[temp + x] = rgb565_color;
    }
}
int main(int argc, char *argv[])
{
    struct fb_fix_screeninfo fb_fix;
    struct fb_var_screeninfo fb_var;
    unsigned int screen_size;
    int fd;
    /* 打开 framebuffer 设备 */
    if (0 > (fd = open("/dev/fb0", O_RDWR))) {
        perror("open error");
        exit(EXIT_FAILURE);
    }
    /* 获取参数信息 */
    ioctl(fd, FBIOGET_VSCREENINFO, &fb_var);
    ioctl(fd, FBIOGET_FSCREENINFO, &fb_fix);
    screen_size = fb_fix.line_length * fb_var.yres;
    width = fb_var.xres;
    height = fb_var.yres;
    /* 将显示缓冲区映射到进程地址空间 */
    screen_base = mmap(NULL, screen_size, PROT_WRITE, MAP_SHARED, fd, 0);
    if (MAP_FAILED == (void *)screen_base) {
        perror("mmap error");
        close(fd);
        exit(EXIT_FAILURE);
    }
    /* 画正方形方块 */
    int w = height * 0.25;//方块的宽度为 1/4 屏幕高度
    lcd_fill(0, width-1, 0, height-1, 0x0); //清屏（屏幕显示黑色）
    lcd_fill(0, w, 0, w, 0xFF0000); //红色方块
    lcd_fill(width-w, width-1, 0, w, 0xFF00); //绿色方块
    lcd_fill(0, w, height-w, height-1, 0xFF); //蓝色方块
    lcd_fill(width-w, width-1, height-w, height-1, 0xFFFF00);//黄色方块
    /* 画线: 十字交叉线 */
    lcd_draw_line(0, height * 0.5, 1, width, 0xFFFFFF);//白色线
    lcd_draw_line(width * 0.5, 0, 0, height, 0xFFFFFF);//白色线
    /* 画矩形 */
    unsigned int s_x, s_y, e_x, e_y;
    s_x = 0.25 * width;
    s_y = w;
    e_x = width - s_x;
    e_y = height - s_y;
    for ( ; (s_x <= e_x) && (s_y <= e_y);
    s_x+=5, s_y+=5, e_x-=5, e_y-=5)
    lcd_draw_rectangle(s_x, e_x, s_y, e_y, 0xFFFFFF);
    /* 退出 */
    munmap(screen_base, screen_size); //取消映射
    close(fd); //关闭文件
    exit(EXIT_SUCCESS); //退出进程
}

三、V4L2摄像头编程

3.1 基本编程步骤

1. 首先是打开摄像头设备；
2. 查询设备的属性或功能；
3. 设置设备的参数，譬如像素格式、 帧大小、 帧率；
4. 申请帧缓冲、内存映射；
5. 帧缓冲入队；
6. 开启视频采集；
7. 帧缓冲出队、对采集的数据进行处理；
8. 处理完后，再次将帧缓冲入队，往复；
9. 结束采集。
   
   

3.2 重要指令宏

//以上指令宏在 linux/videodev2.h 头文件中的具体实现 
#include <linux/videodev2.h>
#define VIDIOC_QUERYCAP _IOR('V', 0, struct v4l2_capability)
#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_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_TRY_FMT _IOWR('V', 64, struct v4l2_format)
#define VIDIOC_ENUM_FRAMESIZES _IOWR('V', 74, struct v4l2_frmsizeenum)
#define VIDIOC_ENUM_FRAMEINTERVALS _IOWR('V', 75, struct v4l2_frmivalenum)

struct v4l2_capability cap;
……
ioctl(fd, VIDIOC_QUERYCAP, &cap);

3.3 打开摄像头

int fd = -1;
/* 打开摄像头 */
fd = open("/dev/video0", O_RDWR);
if (0 > fd) {
fprintf(stderr, "open error: %s: %s\n", "/dev/video0", strerror(errno));
return -1;
}

3.4 查询设备的属性/能力/功能

查询设备的属性， 使用的指令为 VIDIOC_QUERYCAP， 如下所示：

ioctl(int fd, VIDIOC_QUERYCAP, struct v4l2_capability *cap);

3.4.1 struct v4l2_capability 结构体(枚举摄像头能力结构体)

struct v4l2_capability {
    __u8 driver[16]; /* 驱动的名字 */
    __u8 card[32]; /* 设备的名字 */
    __u8 bus_info[32]; /* 总线的名字 */
    __u32 version; /* 版本信息 */
    __u32 capabilities; /* 设备拥有的能力 */
    __u32 device_caps;
    __u32 reserved[3]; /* 保留字段 */
};

3.4.2 videodev2.h 头文件定义的能力字段

/* Values for 'capabilities' field */
#define V4L2_CAP_VIDEO_CAPTURE 0x00000001 /* Is a video capture device */
#define V4L2_CAP_VIDEO_OUTPUT 0x00000002 /* Is a video output device */
#define V4L2_CAP_VIDEO_OVERLAY 0x00000004 /* Can do video overlay */
#define V4L2_CAP_VBI_CAPTURE 0x00000010 /* Is a raw VBI capture device */
#define V4L2_CAP_VBI_OUTPUT 0x00000020 /* Is a raw VBI output device */
#define V4L2_CAP_SLICED_VBI_CAPTURE 0x00000040 /* Is a sliced VBI capture device */
#define V4L2_CAP_SLICED_VBI_OUTPUT 0x00000080 /* Is a sliced VBI output device */
#define V4L2_CAP_RDS_CAPTURE 0x00000100 /* RDS data capture */
#define V4L2_CAP_VIDEO_OUTPUT_OVERLAY 0x00000200 /* Can do video output overlay */
#define V4L2_CAP_HW_FREQ_SEEK 0x00000400 /* Can do hardware frequency seek */
#define V4L2_CAP_RDS_OUTPUT 0x00000800 /* Is an RDS encoder */
/* Is a video capture device that supports multiplanar formats */
#define V4L2_CAP_VIDEO_CAPTURE_MPLANE 0x00001000
/* Is a video output device that supports multiplanar formats */
#define V4L2_CAP_VIDEO_OUTPUT_MPLANE 0x00002000
/* Is a video mem-to-mem device that supports multiplanar formats */
#define V4L2_CAP_VIDEO_M2M_MPLANE 0x00004000
/* Is a video mem-to-mem device */
#define V4L2_CAP_VIDEO_M2M 0x00008000
#define V4L2_CAP_TUNER 0x00010000 /* has a tuner */
#define V4L2_CAP_AUDIO 0x00020000 /* has audio support */
#define V4L2_CAP_RADIO 0x00040000 /* is a radio device */
#define V4L2_CAP_MODULATOR 0x00080000 /* has a modulator */
#define V4L2_CAP_SDR_CAPTURE 0x00100000 /* Is a SDR capture device */
#define V4L2_CAP_EXT_PIX_FORMAT 0x00200000 /* Supports the extended pixel format */
#define V4L2_CAP_SDR_OUTPUT 0x00400000 /* Is a SDR output device */
#define V4L2_CAP_META_CAPTURE 0x00800000 /* Is a metadata capture device */
#define V4L2_CAP_READWRITE 0x01000000 /* read/write systemcalls */
#define V4L2_CAP_ASYNCIO 0x02000000 /* async I/O */
#define V4L2_CAP_STREAMING 0x04000000 /* streaming I/O ioctls */
#define V4L2_CAP_TOUCH 0x10000000 /* Is a touch device */
#define V4L2_CAP_DEVICE_CAPS 0x80000000 /* sets device capabilities field */

这些宏都是在videodev2.h头文件中所定义的，大家可以自己去看。对于摄像头设备来说，它的capabilities字段必须包含 V4L2_CAP_VIDEO_CAPTURE，表示它支持视频采集功能。所以我们可以通过判断 capabilities字段是否包含 V4L2_CAP_VIDEO_CAPTURE、 来确定它是否是一个摄像头设备，譬如：

/* 查询设备功能 */
ioctl(fd, VIDIOC_QUERYCAP, &vcap);
    /* 判断是否是视频采集设备 */
    if (!(V4L2_CAP_VIDEO_CAPTURE & vcap.capabilities)) {
        fprintf(stderr, "Error: No capture video device!\n");
        return -1;
}

3.5 设置帧格式、帧率

a)枚举出摄像头支持的所有像素格式： VIDIOC_ENUM_FMT

如果要设置像素格式，首先得知道该设备支持哪些像素格式，如何得知呢？ 使用VIDIOC_ENUM_FMT 指令：

ioctl(int fd, VIDIOC_ENUM_FMT, struct v4l2_fmtdesc *fmtdesc);

3.5.1 struct v4l2_fmtdesc (枚举摄像头支持帧格式结构体)

struct v4l2_fmtdesc {
    __u32 index; /* Format number */
    __u32 type; /* enum v4l2_buf_type */
    __u32 flags;
    __u8 description[32]; /* Description string */
    __u32 pixelformat; /* 这里的fourcc（四字符码）写什么用的就是什么帧格式 */
    __u32 reserved[4];
};

index 表示编号， 在枚举之前，需将其设置为 0，然后每次 ioctl()调用之后将其值加 1。 一次 ioctl()调用，只能得到一种像素格式的信息，如果设备支持多种像素格式， 则需要循环调用多次， 通过 index 来控制，index 从 0 开始，调用一次 ioctl()之后加 1，直到 ioctl()调用失败，表示已经将所有像素格式都枚举出来了；所以 index 就是一个编号，获取 index 编号指定的像素格式。description 字段是一个简单地描述性字符串，简单描述 pixelformat 像素格式。pixelformat 字段则是对应的像素格式编号，这是一个无符号 32 位数据，每一种像素格式都会使用一个u32 类型数据来表示

3.5.2 videodev2.h 头文件定义的帧格式字段

/* RGB formats */
#define V4L2_PIX_FMT_RGB332 v4l2_fourcc('R', 'G', 'B', '1') /* 8 RGB-3-3-2 */
#define V4L2_PIX_FMT_RGB444 v4l2_fourcc('R', '4', '4', '4') /* 16 xxxxrrrr ggggbbbb */
#define V4L2_PIX_FMT_ARGB444 v4l2_fourcc('A', 'R', '1', '2') /* 16 aaaarrrr ggggbbbb */
#define V4L2_PIX_FMT_XRGB444 v4l2_fourcc('X', 'R', '1', '2') /* 16 xxxxrrrr ggggbbbb */
#define V4L2_PIX_FMT_RGB555 v4l2_fourcc('R', 'G', 'B', 'O') /* 16 RGB-5-5-5 */
#define V4L2_PIX_FMT_ARGB555 v4l2_fourcc('A', 'R', '1', '5') /* 16 ARGB-1-5-5-5 */
#define V4L2_PIX_FMT_XRGB555 v4l2_fourcc('X', 'R', '1', '5') /* 16 XRGB-1-5-5-5 */
#define V4L2_PIX_FMT_RGB565 v4l2_fourcc('R', 'G', 'B', 'P') /* 16 RGB-5-6-5 */
.........
/* Grey formats */
#define V4L2_PIX_FMT_GREY v4l2_fourcc('G', 'R', 'E', 'Y') /* 8 Greyscale */
#define V4L2_PIX_FMT_Y4 v4l2_fourcc('Y', '0', '4', ' ') /* 4 Greyscale */
#define V4L2_PIX_FMT_Y6 v4l2_fourcc('Y', '0', '6', ' ') /* 6 Greyscale */
#define V4L2_PIX_FMT_Y10 v4l2_fourcc('Y', '1', '0', ' ') /* 10 Greyscale */
......
/* Luminance+Chrominance formats */亮度+色度模式
#define V4L2_PIX_FMT_YUYV v4l2_fourcc('Y', 'U', 'Y', 'V') /* 16 YUV 4:2:2 */
#define V4L2_PIX_FMT_YYUV v4l2_fourcc('Y', 'Y', 'U', 'V') /* 16 YUV 4:2:2 */
#define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16 YVU 4:2:2 */
#define V4L2_PIX_FMT_UYVY v4l2_fourcc('U', 'Y', 'V', 'Y') /* 16 YUV 4:2:2 */
......
/* compressed formats */压缩格式
#define V4L2_PIX_FMT_MJPEG v4l2_fourcc('M', 'J', 'P', 'G') /* Motion-JPEG */
#define V4L2_PIX_FMT_JPEG v4l2_fourcc('J', 'P', 'E', 'G') /* JFIF JPEG */
#define V4L2_PIX_FMT_DV v4l2_fourcc('d', 'v', 's', 'd') /* 1394 */
#define V4L2_PIX_FMT_MPEG v4l2_fourcc('M', 'P', 'E', 'G') /* MPEG-1/2/4 Multiplexed */

3.5.3 videodev2.h 头文件定义的可使用的功能字段

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,
    V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
    V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9,
    V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE = 10,
    V4L2_BUF_TYPE_SDR_CAPTURE = 11,
    V4L2_BUF_TYPE_SDR_OUTPUT = 12,
    V4L2_BUF_TYPE_META_CAPTURE = 13,
    /* Deprecated, do not use */
    V4L2_BUF_TYPE_PRIVATE = 0x80,
};

type 字 段 需 要 在 调 用 ioctl() 之 前 设 置 它 的 值 ， 对 于 摄 像 头 ， 需 要 将 type 字 段 设 置 为V4L2_BUF_TYPE_VIDEO_CAPTURE，指定我们将要获取的是视频采集的像素格式,使用示例如下所示 :

struct v4l2_fmtdesc fmtdesc;
/* 枚举出摄像头所支持的所有像素格式以及描述信息 */
fmtdesc.index = 0;
fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
while (0 == ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc)) {
    printf("fmt: %s <0x%x>\n", fmtdesc.description, fmtdesc.pixelformat);
    fmtdesc.index++;
}

b)枚举摄像头所支持的所有视频采集分辨率： VIDIOC_ENUM_FRAMESIZES

使用 VIDIOC_ENUM_FRAMESIZES 指令可以枚举出设备所支持的所有视频采集分辨率，用法如下所示：

ioctl(int fd, VIDIOC_ENUM_FRAMESIZES, struct v4l2_frmsizeenum *frmsize);

3.5.4 struct v4l2_frmsizeenum (枚举摄像头视频采集格式结构体)

struct v4l2_frmsizeenum {
    __u32 index; /* Frame size number */
    __u32 pixel_format; /* 像素格式 */
    __u32 type; /* type */
union { /* Frame size */
    struct v4l2_frmsize_discrete discrete;
    struct v4l2_frmsize_stepwise stepwise;
};
__u32 reserved[2]; /* Reserved space for future use */
};
struct v4l2_frmsize_discrete {
    __u32 width; /* Frame width [pixel] */
    __u32 height; /* Frame height [pixel] */
};

index 字段与 struct v4l2_fmtdesc 结构体的 index 字段意义相同，一个摄像头通常支持多种不同的视频采集分辨率， 一次 ioctl()调用只能得到一种视频帧大小信息，如果设备支持多种视频帧大小， 则需要循环调用多次， 通过 index 来控制。

pixel_format 字段指定像素格式，而 type 字段与 struct v4l2_fmtdesc 结构体的 type 字段意义相同；在调用 ioctl()之前，需要先设置 type 字段与 pixel_format 字段，确定我们将要枚举的是：设备的哪种功能、哪种像素格式支持的视频帧大小。

可 以 看 到 struct v4l2_frmsizeenum 结 构 体 中 有 一 个 union 共 用 体 ，type=V4L2_BUF_TYPE_VIDEO_CAPTURE 情况下， discrete 生效，这是一个 struct v4l2_frmsize_discrete 类型变量，描述了视频帧大小信息（包括视频帧的宽度和高度），也就是视频采集分辨率大小。譬如我们要枚举出摄像头 RGB565 像素格式所支持的所有视频帧大小：

struct v4l2_frmsizeenum frmsize;
frmsize.index = 0;
frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
frmsize.pixel_format = V4L2_PIX_FMT_RGB565;
while (0 == ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize)) {
    printf("frame_size<%d*%d>\n", frmsize.discrete.width, frmsize.discrete.height);
    frmsize.index++;
}

c)枚举摄像头所支持的所有视频采集帧率：VIDIOC_ENUM_FRAMEINTERVALS

​ 同一种视频帧大小，摄像头可能会支持多种不同的视频采集帧率，譬如常见的 15fps、 30fps、 45fps 以及 60fps 等；使用 VIDIOC_ENUM_FRAMEINTERVALS 指令可以枚举出设备所支持的所有帧率，使用方式如下:

ioctl(int fd, VIDIOC_ENUM_FRAMEINTERVALS, struct v4l2_frmivalenum *frmival);

3.5.5 structv4l2_frmivalenum 结构体（枚举摄像头采集帧率结构体）

struct v4l2_frmivalenum {
    __u32 index; /* Frame format index */
    __u32 pixel_format;/* Pixel format */
    __u32 width; /* Frame width */
    __u32 height; /* Frame height */
    __u32 type; /* type */
union { /* Frame interval */
    struct v4l2_fract discrete;
    struct v4l2_frmival_stepwise stepwise;
};
__u32 reserved[2]; /* Reserved space for future use */
};
struct v4l2_fract {
    __u32 numerator; //分子
    __u32 denominator; //分母
};

index、 type 字段与 struct v4l2_frmsizeenum 结构体的index、 type 字段意义相同。width、 height 字段用于指定视频帧大小， pixel_format 字段指定像素格式。以上这些字段都是需要在调用 ioctl()之前设置它的值。可 以 看 到 struct v4l2_frmivalenum 结 构 体 也 有 一 个 union 共 用 体 ， 当type=V4L2_BUF_TYPE_VIDEO_CAPTURE 时， discrete 生效，这是一个 struct v4l2_fract 类型变量，描述了视频帧率信息（一秒钟采集图像的次数）； struct v4l2_fract 结构体中， numerator 表示分子、 denominator 表示分母，使用 numerator / denominator 来表示图像采集的周期（采集一幅图像需要多少秒），所以视频帧率便等于 denominator / numerator。

使用示例，譬如，我们要枚举出 RGB565 像素格式下 640*480 帧大小所支持的所有视频采集帧率：struct v4l2_frmivalenum frmival;

struct v4l2_frmivalenum frmival;
frmival.index = 0;
frmival.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
frmival.pixel_format = V4L2_PIX_FMT_RGB565;
frmival.width = 640;
frmival.height = 480;
while (0 == ioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival)) {
    printf("Frame interval<%ffps> ", frmival.discrete.denominator / frmival.discrete.numerator);
    frmival.index++;
}

d)查看或设置当前的格式： VIDIOC_G_FMT、 VIDIOC_S_FMT前面介绍的指令只是枚举设备支持的像素格式、视频帧大小以及视频采集帧率等这些信息，将下来我们将介绍如何设置这些参数。

首先可以使用 VIDIOC_G_FMT 指令查看设备当期的格式，用法如下所示

int ioctl(int fd, VIDIOC_G_FMT, struct v4l2_format *fmt);

调用 ioctl()需要传入一个 struct v4l2_format *指针， ioctl()会将获取到的数据写入到 fmt 指针所指向的对象中， struct v4l2_format 结构体描述了格式相关的信息。

使用 VIDIOC_S_FMT 指令设置设备的格式，用法如下所示：

int ioctl(int fd, VIDIOC_S_FMT, struct v4l2_format *fmt);

3.5.6 v4l2_format 结构体的定义(

设置

像素格式、视频帧大小、视屏采集帧信息)

struct v4l2_format {
    __u32 type;
    union {
        struct v4l2_pix_format pix; /* V4L2_BUF_TYPE_VIDEO_CAPTURE */
        struct v4l2_pix_format_mplane pix_mp; /* V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE */
        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 */
        struct v4l2_sdr_format sdr; /* V4L2_BUF_TYPE_SDR_CAPTURE */
        struct v4l2_meta_format meta; /* V4L2_BUF_TYPE_META_CAPTURE */
        __u8 raw_data[200]; /* user-defined */
    } fmt;
};

type 字段依然与前面介绍的结构体中的 type 字段意义相同，不管是获取格式、还是设置格式都需要在调用 ioctl()函数之前设置它的值。

接下来是一个 union 共用体，当 type 被设置为 V4L2_BUF_TYPE_VIDEO_CAPTURE 时， pix 变量生效，它是一个 struct v4l2_pix_format 类型变量，记录了视频帧格式相关的信息，如下所示：

struct v4l2_pix_format {
    __u32 width; //视频帧的宽度（单位：像素）
    __u32 height; //视频帧的高度（单位：像素）
    __u32 pixelformat; //像素格式
    __u32 field; /* enum v4l2_field */
    __u32 bytesperline; /* for padding, zero if unused */
    __u32 sizeimage;
    __u32 colorspace; /* enum v4l2_colorspace */
    __u32 priv; /* private data, depends on pixelformat */
    __u32 flags; /* format flags (V4L2_PIX_FMT_FLAG_*) */
    union {
        /* enum v4l2_ycbcr_encoding */
        __u32 ycbcr_enc;
        /* enum v4l2_hsv_encoding */
        __u32 hsv_enc;
    };
    __u32 quantization; /* enum v4l2_quantization */
    __u32 xfer_func; /* enum v4l2_xfer_func */
};

colorspace 字段描述的是一个颜色空间， 可取值如下：

enum v4l2_colorspace {
    /*
    * Default colorspace, i.e. let the driver figure it out.
    * Can only be used with video capture.
    */
    V4L2_COLORSPACE_DEFAULT = 0,
    /* SMPTE 170M: used for broadcast NTSC/PAL SDTV */
    V4L2_COLORSPACE_SMPTE170M = 1,
    /* Obsolete pre-1998 SMPTE 240M HDTV standard, superseded by Rec 709 */
    V4L2_COLORSPACE_SMPTE240M = 2,
    /* Rec.709: used for HDTV */
    V4L2_COLORSPACE_REC709 = 3,
    /*
    * Deprecated, do not use. No driver will ever return this. This was
    * based on a misunderstanding of the bt878 datasheet.
    */
    V4L2_COLORSPACE_BT878 = 4,
    /*
    * NTSC 1953 colorspace. This only makes sense when dealing with
    * really, really old NTSC recordings. Superseded by SMPTE 170M.
    */
    V4L2_COLORSPACE_470_SYSTEM_M = 5,
    /*
    * EBU Tech 3213 PAL/SECAM colorspace. This only makes sense when
    * dealing with really old PAL/SECAM recordings. Superseded by
    * SMPTE 170M.
    */
    V4L2_COLORSPACE_470_SYSTEM_BG = 6,
    /*
    * Effectively shorthand for V4L2_COLORSPACE_SRGB, V4L2_YCBCR_ENC_601
    * and V4L2_QUANTIZATION_FULL_RANGE. To be used for (Motion-)JPEG.
    */
    V4L2_COLORSPACE_JPEG = 7,
    /* For RGB colorspaces such as produces by most webcams. */
    V4L2_COLORSPACE_SRGB = 8,
    /* AdobeRGB colorspace */
    V4L2_COLORSPACE_ADOBERGB = 9,
    /* BT.2020 colorspace, used for UHDTV. */
    V4L2_COLORSPACE_BT2020 = 10,
    /* Raw colorspace: for RAW unprocessed images */
    V4L2_COLORSPACE_RAW = 11,
    /* DCI-P3 colorspace, used by cinema projectors */
    V4L2_COLORSPACE_DCI_P3 = 12,
};

使用 VIDIOC_S_FMT 指令设置格式时， 通常不需要用户指定 colorspace，底层驱动会根据像素格式pixelformat 来确定对应的 colorspace。例子：获取当前的格式、并设置格式

struct v4l2_format fmt;
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 > ioctl(fd, VIDIOC_G_FMT, &fmt)) { //获取格式信息
    perror("ioctl error");
    return -1;
}
printf("width:%d, height:%d format:%d\n", fmt.fmt.pix.width, fmt.fmt.pix.height, fmt.fmt.pix.pixelformat);
fmt.fmt.pix.width = 854;
fmt.fmt.pix.height = 480;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;
if (0 > ioctl(fd, VIDIOC_S_FMT, &fmt)) { //设置格式
    perror("ioctl error");
    return -1;
}

使用指令 VIDIOC_S_FMT 设置格式时，实际设置的参数并不一定等于我们指定的参数，譬如上面我们指定视频帧宽度为 800、高度为 480，但这个摄像头不一定支持这种视频帧大小，或者摄像头不支持V4L2_PIX_FMT_RGB565 这种像素格式； 通常在这种情况下， 底层驱动程序并不会按照我们指定的参数进行设置， 它会对这些参数进行修改，譬如，如果摄像头不支持 800480， 那么底层驱动可能会将其修改为640乘以480（假设摄像头支持这种分辨率）；所以，当 ioctl()调用返回后，我们还需要检查返回的 struct v4l2_format类型变量，以确定我们指定的参数是否已经生效：

struct v4l2_format fmt;
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.width = 800;
fmt.fmt.pix.height = 480;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;
if (0 > ioctl(fd, VIDIOC_S_FMT, &fmt)) { //设置格式
    perror("ioctl error");
    return -1;
}
if (800 != fmt.fmt.pix.width ||
480 != fmt.fmt.pix.height){
    do_something();
}
if (V4L2_PIX_FMT_RGB565 != fmt.fmt.pix.pixelformat) {
    do_something();
}

e)设置或获取当前的流类型相关参数： VIDIOC_G_PARM、 VIDIOC_S_PARM使用 VIDIOC_G_PARM 指令可以获取设备的流类型相关参数（Stream type-dependent parameters），使用方式如下：

ioctl(int fd, VIDIOC_G_PARM, struct v4l2_streamparm *streamparm);

调用 ioctl()需要传入一个 struct v4l2_streamparm *指针， ioctl()会将获取到的数据写入到 streamparm 指针所指向的对象中， struct v4l2_streamparm 结构体描述了流类型相关的信息，具体的内容等会在介绍。使用 VIDIOC_S_PARM 指令设置设备的流类型相关参数，用法如下所示：

ioctl(int fd, VIDIOC_S_PARM, struct v4l2_streamparm *streamparm);

3.5.7 v4l2_streamparm结构体(流类型结构体)

struct v4l2_streamparm {
__u32 type; /* enum v4l2_buf_type */
    union {
        struct v4l2_captureparm capture;
        struct v4l2_outputparm output;
        __u8 raw_data[200]; /* user-defined */
    } parm;
};
struct v4l2_captureparm {
    __u32 capability; /* Supported modes */
    __u32 capturemode; /* Current mode */
    struct v4l2_fract timeperframe; /* Time per frame in seconds */
    __u32 extendedmode; /* Driver-specific extensions */
    __u32 readbuffers; /* # of buffers for read */
    __u32 reserved[4];
};
struct v4l2_fract {
    __u32 numerator; /* 分子 */
    __u32 denominator; /* 分母 */
};

当 type= V4L2_BUF_TYPE_VIDEO_CAPTURE 时， union 共用体中 capture 变量生效，它是一个 structv4l2_captureparm 类型变量， struct v4l2_captureparm 结构体描述了摄像头采集相关的一些参数，譬如视频采集帧率，上面已经给出了该结构体的定义。

struct v4l2_captureparm 结构体中， capability 字段表示设备支持的模式有哪些，可取值如下（以下任意一个或多个的位或关系）：

/* Flags for 'capability' and 'capturemode' fields */
#define V4L2_MODE_HIGHQUALITY 0x0001 /* High quality imaging mode 高品质成像模式 */
#define V4L2_CAP_TIMEPERFRAME 0x1000 /* timeperframe field is supported 支持设置 timeperframe字段

capturemode 则表示当前的模式，与 capability 字段的取值相同。

​  timeperframe 字段是一个 struct v4l2_fract 结构体类型变量，描述了设备视频采集的周期，前面已经给大家介绍过。使用 VIDIOC_S_PARM 可以设置视频采集的周期，也就是视频采集帧率，但是很多设备并不支 持应用层设置 timeperframe 字段，只有当 capability 字段包含 V4L2_CAP_TIMEPERFRAME 时才表示设备支持 timeperframe 字段，这样应用层才可以去设置设备的视频采集帧率。所以，在设置之前，先通过 VIDIOC_G_PARM 命令获取到设备的流类型相关参数，判断 capability 字段是否包含V4L2_CAP_TIMEPERFRAME，如下所示：

struct v4l2_streamparm streamparm;
streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ioctl(v4l2_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(v4l2_fd, VIDIOC_S_PARM, &streamparm)) {//设置参数
        fprintf(stderr, "ioctl error: VIDIOC_S_PARM: %s\n", strerror(errno));
        return -1;
    }
}
else
fprintf(stderr, "不支持帧率设置");

3.6 申请帧缓冲、内存映射

​  读取摄像头数据的方式有两种，一种是 read 方式，也就是直接通过 read()系统调用读取摄像头采集到的数据；另一种则是 streaming 方式； 25.2.2 小节中介绍了使用 VIDIOC_QUERYCAP 指令查询设备的属性、得到一个 struct v4l2_capability 类型数据， 其中 capabilities 字段记录了设备拥有的能力，当该字段包含V4L2_CAP_READWRITE 时，表示设备支持 read I/O 方式读取数据；当该字段包含 V4L2_CAP_STREAMING时，表示设备支持 streaming I/O 方式；事实上，

绝大部分设备都支持 streaming I/O 方式读取数据，使用streaming I/O 方式，我们需要向设备申请帧缓冲，并将帧缓冲映射到应用程序进程地址空间中。


​  当完成对设备的配置之后，接下来就可以去申请帧缓冲了，帧缓冲顾名思义就是用于存储一帧图像数据的缓冲区， 使用 VIDIOC_REQBUFS 指令可申请帧缓冲，使用方式如下所示：

ioctl(int fd, VIDIOC_REQBUFS, struct v4l2_requestbuffers *reqbuf);

3.6.1 struct v4l2_requestbuffers(申请帧缓冲结构体)

struct v4l2_requestbuffers {
    __u32 count; //申请帧缓冲的数量
    __u32 type; /* enum v4l2_buf_type */
    __u32 memory; /* enum v4l2_memory */
    __u32 reserved[2];
};

通常将 memory 设置为 V4L2_MEMORY_MMAP 即可！ 使用示例如下：

struct v4l2_requestbuffers reqbuf;
reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqbuf.count = 3; // 申请 3 个帧缓冲
reqbuf.memory = V4L2_MEMORY_MMAP;
if (0 > ioctl(fd, VIDIOC_REQBUFS, &reqbuf)) {
    fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
    return -1;
}

​  streaming I/O 方式会在内核空间中维护一个帧缓冲队列， 驱动程序会将从摄像头读取的一帧数据写入到队列中的一个帧缓冲，接着将下一帧数据写入到队列中的下一个帧缓冲；当应用程序需要读取一帧数据时，需要从队列中取出一个装满一帧数据的帧缓冲，这个取出过程就叫做出队；当应用程序处理完这一帧数据后，需要再把这个帧缓冲加入到内核的帧缓冲队列中，这个过程叫做入队！

使用 VIDIOC_REQBUFS 指令申请帧缓冲， 该缓冲区实质上是由内核所维护的，应用程序不能直接读取该缓冲区的数据，我们需要将其映射到用户空间中，这样，应用程序读取映射区的数据实际上就是读取内核维护的帧缓冲中的数据。

​  在映射之前，需要查询帧缓冲的信息，譬如帧缓冲的长度、偏移量等信息，使用 VIDIOC_QUERYBUF指令查询，使用方式如下所示：

ioctl(int fd, VIDIOC_QUERYBUF, struct v4l2_buffer *buf);

3.6.2 struct v4l2_buffer(帧缓冲属性结构体)

struct v4l2_buffer {
    __u32 index; //buffer 的编号
    __u32 type; //type
    __u32 bytesused;
    __u32 flags;
    __u32 field;
    struct timeval timestamp;
    struct v4l2_timecode timecode;
    __u32 sequence;
    /* memory location */
    __u32 memory;
    union {
        __u32 offset; //偏移量
        unsigned long userptr;
        struct v4l2_plane *planes;
        __s32 fd;
    } m;
    __u32 length; //buffer 的长度
    __u32 reserved2;
    __u32 reserved;
};

​  index 字段表示一个编号， 申请的多个帧缓冲、 每一个帧缓冲都有一个编号，从 0 开始。

一次 ioctl()调用只能获取指定编号对应的帧缓冲的信息，所以要获取多个帧缓冲的信息，需要重复调用多次，每调用一次ioctl()、 index 加 1，指向下一个帧缓冲。


​  type 字段与前面所提及到的 type 字段意义相同，不再介绍，在调用 ioctl()之前需先设置它的值。memory 字段与 struct v4l2_requestbuffers 结构体的 memory 字段意义相同，需要在调用 ioctl()之前设置它的值。

​  length 字段表示帧缓冲的长度，而共同体中的 offset 则表示帧缓冲的偏移量，如何理解这个偏移量？因为应用程序通过 VIDIOC_REQBUFS 指令申请帧缓冲时，

内核会向操作系统申请一块内存空间作为帧缓冲区，这块内存空间的大小就等于申请的帧缓冲数量 * 每一个帧缓冲的大小，每一个帧缓冲对应到这一块内存空间的某一段，所以它们都有一个地址偏移量。


​  帧缓冲的数量不要太多了，尤其是在一些内存比较吃紧的嵌入式系统中，帧缓冲的数量太多，势必会占用太多的系统内存。

使用示例，申请帧缓冲后、调用 mmap()将帧缓冲映射到用户地址空间：

struct v4l2_requestbuffers reqbuf;
struct v4l2_buffer buf;
void *frm_base[3];//从内核映射到应用层的映射区
reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqbuf.count = 3; // 申请 3 个帧缓冲
reqbuf.memory = V4L2_MEMORY_MMAP;
/* 申请 3 个帧缓冲 */
if (0 > ioctl(fd, VIDIOC_REQBUFS, &reqbuf)) {
    fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
    return -1;
}
/* 建立内存映射 */
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
for (buf.index = 0; buf.index < 3; buf.index++) {
    ioctl(fd, VIDIOC_QUERYBUF, &buf);
    frm_base[buf.index] = mmap(NULL, buf.length,
    PROT_READ | PROT_WRITE, MAP_SHARED,
    fd, buf.m.offset);
    if (MAP_FAILED == frm_base[buf.index]) {
        perror("mmap error");
        return -1;
    }
}

后面读取摄像头采集的数据时，直接读取映射区即可。

3.7 入队

​  使用 VIDIOC_QBUF 指令将帧缓冲放入到内核的帧缓冲队列中，使用方式如下：

ioctl(int fd, VIDIOC_QBUF, struct v4l2_buffer *buf);

调用 ioctl()之前，需要设置 struct v4l2_buffer 类型对象的 memory、 type 字段，使用示例如下所示, 将三个帧缓冲放入内核的帧缓冲队列（入队操作）中：

struct v4l2_buffer buf;
/* 入队操作 */
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
for (buf.index = 0; buf.index < 3; buf.index++) {
    if (0 > ioctl(fd, VIDIOC_QBUF, &buf)) {
        perror("ioctl error");
        return -1;
    }
}

3.8 开启视频采集

​  将三个帧缓冲放入到队列中之后，接着便可以打开摄像头、开启图像采集了，使用 VIDIOC_DQBUF 指令开启视频采集，使用方式如下所示：

ioctl(int fd, VIDIOC_STREAMON, int *type); //开启视频采集
ioctl(int fd, VIDIOC_STREAMOFF, int *type); //停止视频采集

type 其实一个 enum v4l2_buf_type *指针，通常用法如下：

enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 > ioctl(fd, VIDIOC_STREAMON, &type)) {
    perror("ioctl error");
    return -1;
}

3.9 读取数据、对数据进行处理

开启视频采集后，直接读取每一个帧缓冲的在用户空间的映射区即可读取到摄像头采集的每一帧图像数据。在读取数据之前，需要将帧缓冲从内核的帧缓冲队列中取出，这个操作叫做帧缓冲出队（有入队自然就有出队）。

ioctl(int fd, VIDIOC_DQBUF, struct v4l2_buffer *buf);

帧缓冲出队之后，接下来便可读取数据了，然后对数据进行处理，譬如将摄像头采集的图像显示到 LCD屏上；数据处理完成之后，再将帧缓冲入队，将队列中的下一个帧缓冲出队，然后读取数据、处理，这样往复操作。 例如：

struct v4l2_buffer buf;
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
for ( ; ; ) {
    for(buf.index = 0; buf.index < 3; buf.index++) {
        ioctl(fd, VIDIOC_DQBUF, &buf); //出队
        // 读取帧缓冲的映射区、获取一帧数据
        // 处理这一帧数据
        do_something();
        // 数据处理完之后、将当前帧缓冲入队、接着读取下一帧数据
        ioctl(fd, VIDIOC_QBUF, &buf);
    }
}

3.10 结束视频采集

enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (0 > ioctl(fd, VIDIOC_STREAMOFF, &type)) {
    perror("ioctl error");
    return -1;
}

3.11 视频显示例程

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

#define FB_DEV              "/dev/fb0"      //LCD设备节点
#define FRAMEBUFFER_COUNT   3               //帧缓冲数量

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

/*** 描述一个帧缓冲的信息 ***/
typedef struct cam_buf_info {
    unsigned short *start;      //帧缓冲起始地址
    unsigned long length;       //帧缓冲长度
} cam_buf_info;

static int width;                       //LCD宽度
static int height;                      //LCD高度
static int line_length;
static unsigned short *screen_base = NULL;//LCD显存基地址
static int fb_fd = -1;                  //LCD设备文件描述符
static int v4l2_fd = -1;                //摄像头设备文件描述符
static cam_buf_info buf_infos[FRAMEBUFFER_COUNT];
static cam_fmt cam_fmts[10];
static int frm_width, frm_height;   //视频帧宽度和高度

static int fb_dev_init(void)
{
    struct fb_var_screeninfo fb_var = {0};
    struct fb_fix_screeninfo fb_fix = {0};
    unsigned long screen_size;

    /* 打开framebuffer设备 */
    fb_fd = open(FB_DEV, O_RDWR);
    if (0 > fb_fd) {
        fprintf(stderr, "open error: %s: %s\n", FB_DEV, strerror(errno));
        return -1;
    }

    /* 获取framebuffer设备信息 */
    ioctl(fb_fd, FBIOGET_VSCREENINFO, &fb_var);
    ioctl(fb_fd, FBIOGET_FSCREENINFO, &fb_fix);

    screen_size = fb_fix.line_length * fb_var.yres;
    width = fb_var.xres;
    height = fb_var.yres;
    line_length = fb_fix.line_length / (fb_var.bits_per_pixel / 8);

    /* 内存映射 */
    screen_base = mmap(NULL, screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
    if (MAP_FAILED == (void *)screen_base) {
        perror("mmap error");
        close(fb_fd);
        return -1;
    }

    /* LCD背景刷白 */
    memset(screen_base, 0xFF, screen_size);
    return 0;
}

static int v4l2_dev_init(const char *device)
{
    struct v4l2_capability cap = {0};

    /* 打开摄像头 */
    v4l2_fd = open(device, O_RDWR);
    if (0 > v4l2_fd) {
        fprintf(stderr, "open error: %s: %s\n", device, strerror(errno));
        return -1;
    }

    /* 查询设备功能 */
    ioctl(v4l2_fd, VIDIOC_QUERYCAP, &cap);

    /* 判断是否是视频采集设备 */
    if (!(V4L2_CAP_VIDEO_CAPTURE & cap.capabilities)) {
        fprintf(stderr, "Error: %s: No capture video device!\n", device);
        close(v4l2_fd);
        return -1;
    }

    return 0;
}

static void v4l2_enum_formats(void)
{
    struct v4l2_fmtdesc fmtdesc = {0};

    /* 枚举摄像头所支持的所有像素格式以及描述信息 */
    fmtdesc.index = 0;
    fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FMT, &fmtdesc)) {

        // 将枚举出来的格式以及描述信息存放在数组中
        cam_fmts[fmtdesc.index].pixelformat = fmtdesc.pixelformat;
        strcpy(cam_fmts[fmtdesc.index].description, fmtdesc.description);
        fmtdesc.index++;
    }
}

static void v4l2_print_formats(void)
{
    struct v4l2_frmsizeenum frmsize = {0};
    struct v4l2_frmivalenum frmival = {0};
    int i;

    frmsize.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    frmival.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    for (i = 0; cam_fmts[i].pixelformat; i++) {

        printf("format<0x%x>, description<%s>\n", cam_fmts[i].pixelformat,
                    cam_fmts[i].description);

        /* 枚举出摄像头所支持的所有视频采集分辨率 */
        frmsize.index = 0;
        frmsize.pixel_format = cam_fmts[i].pixelformat;
        frmival.pixel_format = cam_fmts[i].pixelformat;
        while (0 == ioctl(v4l2_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;
            while (0 == ioctl(v4l2_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival)) {
                printf("<%dfps>", frmival.discrete.denominator /
                        frmival.discrete.numerator);
                frmival.index++;
            }
            printf("\n");
        }
        printf("\n");
    }
}

static int v4l2_set_format(void)
{
    struct v4l2_format fmt = {0};
    struct v4l2_streamparm streamparm = {0};

    /* 设置帧格式 */
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;//type类型
    fmt.fmt.pix.width = width;  //视频帧宽度
    fmt.fmt.pix.height = height;//视频帧高度
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB565;  //像素格式
    if (0 > ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt)) {
        fprintf(stderr, "ioctl error: VIDIOC_S_FMT: %s\n", strerror(errno));
        return -1;
    }

    /*** 判断是否已经设置为我们要求的RGB565像素格式
    如果没有设置成功表示该设备不支持RGB565像素格式 */
    if (V4L2_PIX_FMT_RGB565 != fmt.fmt.pix.pixelformat) {
        fprintf(stderr, "Error: the device does not support RGB565 format!\n");
        return -1;
    }

    frm_width = fmt.fmt.pix.width;  //获取实际的帧宽度
    frm_height = fmt.fmt.pix.height;//获取实际的帧高度
    printf("视频帧大小<%d * %d>\n", frm_width, frm_height);

    /* 获取streamparm */
    streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    ioctl(v4l2_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(v4l2_fd, VIDIOC_S_PARM, &streamparm)) {
            fprintf(stderr, "ioctl error: VIDIOC_S_PARM: %s\n", strerror(errno));
            return -1;
        }
    }

    return 0;
}

static int v4l2_init_buffer(void)
{
    struct v4l2_requestbuffers reqbuf = {0};
    struct v4l2_buffer buf = {0};

    /* 申请帧缓冲 */
    reqbuf.count = FRAMEBUFFER_COUNT;       //帧缓冲的数量
    reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    reqbuf.memory = V4L2_MEMORY_MMAP;
    if (0 > ioctl(v4l2_fd, VIDIOC_REQBUFS, &reqbuf)) {
        fprintf(stderr, "ioctl error: VIDIOC_REQBUFS: %s\n", strerror(errno));
        return -1;
    }

    /* 建立内存映射 */
    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {

        ioctl(v4l2_fd, VIDIOC_QUERYBUF, &buf);
        buf_infos[buf.index].length = buf.length;
        buf_infos[buf.index].start = mmap(NULL, buf.length,
                PROT_READ | PROT_WRITE, MAP_SHARED,
                v4l2_fd, buf.m.offset);
        if (MAP_FAILED == buf_infos[buf.index].start) {
            perror("mmap error");
            return -1;
        }
    }

    /* 入队 */
    for (buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {

        if (0 > ioctl(v4l2_fd, VIDIOC_QBUF, &buf)) {
            fprintf(stderr, "ioctl error: VIDIOC_QBUF: %s\n", strerror(errno));
            return -1;
        }
    }

    return 0;
}

static int v4l2_stream_on(void)
{
    /* 打开摄像头、摄像头开始采集数据 */
    enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if (0 > ioctl(v4l2_fd, VIDIOC_STREAMON, &type)) {
        fprintf(stderr, "ioctl error: VIDIOC_STREAMON: %s\n", strerror(errno));
        return -1;
    }

    return 0;
}

static void v4l2_read_data(void)
{
    struct v4l2_buffer buf = {0};
    unsigned short *base;
    unsigned short *start;
    int min_w, min_h;
    int j;

    if (width > frm_width)
        min_w = frm_width;
    else
        min_w = width;
    if (height > frm_height)
        min_h = frm_height;
    else
        min_h = height;

    buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory = V4L2_MEMORY_MMAP;
    for ( ; ; ) {

        for(buf.index = 0; buf.index < FRAMEBUFFER_COUNT; buf.index++) {

            ioctl(v4l2_fd, VIDIOC_DQBUF, &buf);     //出队
            for (j = 0, base=screen_base, start=buf_infos[buf.index].start;
                        j < min_h; j++) {

                memcpy(base, start, min_w * 2); //RGB565 一个像素占2个字节
                base += line_length;  //LCD显示指向下一行
                start += frm_width;//指向下一行数据
            }

            // 数据处理完之后、再入队、往复
            ioctl(v4l2_fd, VIDIOC_QBUF, &buf);
        }
    }
}

int main(int argc, char *argv[])
{
    if (2 != argc) {
        fprintf(stderr, "Usage: %s <video_dev>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    /* 初始化LCD */
    if (fb_dev_init())
        exit(EXIT_FAILURE);

    /* 初始化摄像头 */
    if (v4l2_dev_init(argv[1]))
        exit(EXIT_FAILURE);

    /* 枚举所有格式并打印摄像头支持的分辨率及帧率 */
    v4l2_enum_formats();
    v4l2_print_formats();

    /* 设置格式 */
    if (v4l2_set_format())
        exit(EXIT_FAILURE);

    /* 初始化帧缓冲：申请、内存映射、入队 */
    if (v4l2_init_buffer())
        exit(EXIT_FAILURE);

    /* 开启视频采集 */
    if (v4l2_stream_on())
        exit(EXIT_FAILURE);

    /* 读取数据：出队 */
    v4l2_read_data();       //在函数内循环采集数据、将其显示到LCD屏

    exit(EXIT_SUCCESS);
}