V4L2 摄像头应用编程-I.MX6U嵌入式Linux C应用编程学习笔记基于正点原子阿尔法开发板

木木不迷茫(˵¯͒¯͒˵)

于 2024-07-29 17:13:36 发布

阅读量249

点赞数 4

分类专栏：嵌入式Linux C应用编程-提升文章标签： linux c语言学习

本文链接：https://blog.csdn.net/weixin_62434750/article/details/140775840

版权

嵌入式Linux C应用编程-提升专栏收录该内容

12 篇文章 0 订阅

订阅专栏

V4L2 摄像头应用编程

在这里插入图片描述

V4L2 简介

V4L2 是 Video for Linux Two 的简称，是 Linux 内核中的视频类设备驱动框架

V4L2 为视频类设备驱动开发和应用层提供统一的接口规范

视频类设备包括视频采集设备，如各种摄像头等

使用 V4L2 注册的设备在 Linux 系统 /dev/ 目录下生成对应的设备节点文件

设备节点名称通常为 videoX（X 是数字编号，如 0、1、2、3 等）

video 类设备节点

每一个 videoX 设备文件代表一个视频类设备

应用程序通过对 videoX 设备文件进行 I/O 操作来配置和使用这些设备

V4L2 摄像头应用程序

V4L2 设备驱动框架提供统一、标准的接口规范，供应用程序编程使用摄像头

摄像头编程模式包括

摄像头视频采集流程图
首先是打开摄像头设备
- 视频类设备对应的设备节点为 /dev/videoX，X 为数字编号，通常从 0 开始
- 摄像头应用编程的第一步是打开设备
- 使用 open 函数打开设备，得到文件描述符 fd
- 打开设备文件时，需要使用 O_RDWR 指定读写权限
- 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;
  }
查询设备的属性或功能
- 查询设备属性以确定该设备是否为视频采集类设备以及其他属性
- 使用 ioctl() 函数来查询设备属性，这是设备文件的重要系统调用
- 查询设备属性的指令为 VIDIOC_QUERYCAP，使用方法如下
  - ioctl(int fd, VIDIOC_QUERYCAP, struct v4l2_capability *cap);
- 通过 ioctl() 获取到一个 struct v4l2_capability 类型的数据
  - 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]; / 保留字段 */
    };
    - 重点关注的是 capabilities 字段，该字段描述了设备拥有的能力
      - 这些宏都是在 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;
    }
设置设备的参数，譬如像素格式、帧大小、帧率
- 摄像头支持多种像素格式，如RGB、YUYV、MJPEG等
- 摄像头支持多种视频采集分辨率，如640x480、320x240、1280x720等
- 同一分辨率下，摄像头可能支持多种视频采集帧率，如15fps、30fps
- 在进行视频采集前，需要在应用程序中设置这些参数
- 枚举出摄像头支持的所有像素格式：VIDIOC_ENUM_FMT
  - 使用 VIDIOC_ENUM_FMT 指令：
    ioctl(int fd, VIDIOC_ENUM_FMT, struct v4l2_fmtdesc *fmtdesc);
    - struct v4l2_fmtdesc 结构体
      - index 用于编号，初始值为 0，每次 ioctl 调用后加 1，直到调用失败表示枚举完成
      - description 字段是一个简单地描述性字符串，简单描述 pixelformat 像素格式
      - pixelformat 字段则是对应的像素格式编号，这是一个无符号 32 位数据，每一种像素格式都会使用一个u32 类型数据来表示
        
        可以在videodev2.h 头文件查看
      - type 字段指定获取的像素格式类型，需要在调用 ioctl() 之前设置它的值，摄像头设置为 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++;
}
- 枚举摄像头所支持的所有视频采集分辨率：VIDIOC_ENUM_FRAMESIZES
  - 使用 VIDIOC_ENUM_FRAMESIZES 指令枚举摄像头支持的所有视频采集分辨率
  - ioctl(int fd, VIDIOC_ENUM_FRAMESIZES, struct v4l2_frmsizeenum *frmsize);
    - struct v4l2_frmsizeenum 结构体描述视频帧大小信息，包含 index、pixel_format、type 和 discrete 等字段
      - struct v4l2_frmsizeenum 结构体
      - index 用于编号，初始值为 0，每次 ioctl 调用后加 1，直到调用失败表示枚举完成
      - pixel_format 字段指定像素格式，type 字段指定功能类型，摄像头设置为 V4L2_BUF_TYPE_VIDEO_CAPTURE
      - 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++;
        }
- 枚举摄像头所支持的所有视频采集帧率：VIDIOC_ENUM_FRAMEINTERVALS
  - 使用 VIDIOC_ENUM_FRAMEINTERVALS 指令可以枚举摄像头支持的所有视频采集帧率
  - ioctl(int fd, VIDIOC_ENUM_FRAMEINTERVALS, struct v4l2_frmivalenum *frmival);
    - 传入一个 struct v4l2_frmivalenum * 指针，ioctl() 将数据写入 frmival 指针所指向的对象
    - 结构体 struct v4l2_frmivalenum
      - index 和 type 字段与 struct v4l2_frmsizeenum 中的字段意义相同
      - width 和 height 字段用于指定视频帧大小
      - pixel_format 字段指定像素格式
      - 联合体 union
        
        当 type = V4L2_BUF_TYPE_VIDEO_CAPTURE 时，discrete 生效，这是一个 struct v4l2_fract 类型变量，描述视频帧率信息
        
        struct v4l2_fract 结构体中，numerator 表示分子，denominator 表示分母，帧率等于 denominator / numerator
    - 在调用 ioctl() 之前，需要设置 index、type、pixel_format、width 和 height 字段
  - 枚举 RGB565 像素格式下 640x480 帧大小所支持的所有视频采集帧率
    - 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++;
      }
- 查看或设置当前的格式：VIDIOC_G_FMT、VIDIOC_S_FMT
  - 指令说明
    - VIDIOC_G_FMT 用于查看设备当前的格式
    - VIDIOC_S_FMT 用于设置设备的格式
  - 查看格式
    - 使用 ioctl(int fd, VIDIOC_G_FMT, struct v4l2_format *fmt)
      - 传入 struct v4l2_format * 指针，ioctl() 将数据写入 fmt 指针所指向的对象
    - 使用 ioctl(int fd, VIDIOC_S_FMT, struct v4l2_format *fmt)
      - ioctl() 使用 fmt 所指对象的数据去设置设备的格式
    - struct v4l2_frmivalenum 结构体
      - type 字段与前面介绍的结构体中的 type 字段意义相同
      - 包含一个 union 共用体，当 type 被设置为 V4L2_BUF_TYPE_VIDEO_CAPTURE 时，pix 变量生效，它是一个 struct v4l2_pix_format 类型变量，记录视频帧格式相关的信息
        
        struct v4l2_pix_format 结构体
        
        colorspace 字段描述颜色空间，通常不需要用户指定，底层驱动会根据像素格式 pixelformat 来确定对应的 colorspace
    - 参数设置与检查
      - 使用 VIDIOC_S_FMT 设置格式时，实际设置的参数可能与指定参数不同，底层驱动可能会修改参数
        
        例子：获取当前的格式、并设置格式
        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 = 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;
        }
      - 调用 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 用于获取设备的流类型相关参数
    - VIDIOC_S_PARM 用于设置设备的流类型相关参数
  - 获取参数
    - ioctl(int fd, VIDIOC_G_PARM, struct v4l2_streamparm *streamparm);
    - 传入 struct v4l2_streamparm * 指针，ioctl() 将数据写入 streamparm 指针所指向的对象
  - 设置参数
    - ioctl(int fd, VIDIOC_S_PARM, struct v4l2_streamparm *streamparm);
    - ioctl() 使用 streamparm 所指对象的数据去设置设备的流类型相关参数
  - 结构体 struct v4l2_streamparm
    - type 字段需在调用 ioctl() 之前设置
    - 当 type = V4L2_BUF_TYPE_VIDEO_CAPTURE 时，共用体中 capture 变量生效，它是一个 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_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, “不支持帧率设置”);

申请帧缓冲、内存映射
- 读取摄像头数据的方式
  - read 方式: 直接通过 read() 系统调用读取数据
  - streaming 方式: 通过帧缓冲读取数据
- 设备能力查询
  - 使用 VIDIOC_QUERYCAP 指令查询设备属性，获取 struct v4l2_capability 类型数据
  - capabilities 字段包含 V4L2_CAP_READWRITE 表示支持 read I/O 方式
  - capabilities 字段包含 V4L2_CAP_STREAMING 表示支持 streaming I/O 方式
- 帧缓冲申请和映射
  - 使用 VIDIOC_REQBUFS 指令申请帧缓冲
  - ioctl(int fd, VIDIOC_REQBUFS, struct v4l2_requestbuffers *reqbuf);
  - 传入 struct v4l2_requestbuffers * 指针，ioctl() 根据 reqbuf 填充的信息进行申请
- 结构体 struct v4l2_requestbuffers
  - /*

M E M O R Y - M A P P I N G B U F F E R S
/
struct v4l2_requestbuffers {
__u32 count; //申请帧缓冲的数量
__u32 type; / enum v4l2_buf_type /
__u32 memory; / enum v4l2_memory */
__u32 reserved[2];
}；
```
 - type 字段需在调用 ioctl() 之前设置，表示缓冲区类型

 - count 字段指定申请的帧缓冲数量

 - memory 字段表示内存类型，常用 V4L2_MEMORY_MMAP
```
- 帧缓冲申请示例
  - 通常将 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);
    - 传入 struct v4l2_buffer * 指针，ioctl() 将数据写入 buf 指针所指的对象
  - 结构体 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 开始
    - type 字段需在调用 ioctl() 之前设置，表示缓冲区类型
    - memory 字段需在调用 ioctl() 之前设置，表示内存类型
    - length 字段表示帧缓冲的长度
    - offset 字段表示帧缓冲的偏移量，对应内核申请的内存空间的某一段
  - 内存映射
    - 使用 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 个帧缓冲并将其映射到用户空间
    - 将每个帧缓冲对应的映射区的起始地址保存在 frm_base 数组中
  - 读取数据
    - 映射完成后，应用程序可以直接读取映射区的数据，即内核维护的帧缓冲中的数据

帧缓冲入队
- 入队操作
  - 使用 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;
}
}

- 步骤简述

	- 设置缓冲区类型和内存类型

		- buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

buf.memory = V4L2_MEMORY_MMAP;

	- 循环入队

		- 对每个缓冲区设置 index，从 0 开始依次递增

		- 使用 ioctl(fd, VIDIOC_QBUF, &buf) 进行入队操作

		- 错误处理: 如果 ioctl() 返回小于 0 的值，表示入队操作失败，打印错误信息并返回 -1

开启视频采集
- 开启视频采集
  - 使用 VIDIOC_STREAMON 指令开启视频采集
  - ioctl(int fd, VIDIOC_STREAMON, int *type); //开启视频采集
  - 传入一个 enum v4l2_buf_type 类型指针，通常设置为 V4L2_BUF_TYPE_VIDEO_CAPTURE
- 停止视频采集
  - 使用 VIDIOC_STREAMOFF 指令停止视频采集
  - 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;
}

帧缓冲出队、对采集的数据进行处理
- 开启视频采集后，可以读取用户空间映射区的数据，获取摄像头采集的图像数据
- 帧缓冲出队操作
  - 在读取数据之前，需要将帧缓冲从内核的帧缓冲队列中取出，称为帧缓冲出队
  - 使用 VIDIOC_DQBUF 指令执行出队操作
  - ioctl(int fd, VIDIOC_DQBUF, struct v4l2_buffer *buf);
- 读取和处理数据:
  - 帧缓冲出队后，可以读取数据并进行处理
  - 例如，将摄像头采集的图像显示到 LCD 屏上
处理完后，再次将帧缓冲入队，往复
- 帧缓冲入队操作
  - 数据处理完成后，将帧缓冲重新入队，准备读取下一帧数据
  - 使用 VIDIOC_QBUF 指令执行入队操作
  - ioctl(int fd, VIDIOC_QBUF, struct v4l2_buffer *buf)
- 循环处理
  - 不断进行帧缓冲出队、读取数据、处理数据、帧缓冲入队的循环操作
- 示例代码
  - 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);
}

}

结束采集
- 如果要结束视频采集，使用 VIDIOC_STREAMOFF 指令
- 使用示例
  - enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

if (0 > ioctl(fd, VIDIOC_STREAMOFF, &type)) {
perror(“ioctl error”);
return -1;
}

摄像头操作主要通过 ioctl() 函数完成，使用不同的 V4L2 指令请求不同操作

这些指令定义在头文件 linux/videodev2.h 中
在摄像头应用程序代码中，需要包含头文件 linux/videodev2.h
头文件中定义了多种 ioctl() 指令，以宏定义形式提供（VIDIOC_XXX）

每个指令宏表示向设备请求不同操作，通常携带一个 struct 数据结构体作为 ioctl() 的第三个参数

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

实际编程中，并非所有指令都会用到，针对视频采集设备有一些常用指令

v4l2 摄像头常用的 ioctl 指令

V4L2 摄像头应用编程实战

采用RGB565格式进行显示

#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 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;

    /* 内存映射 */
    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 += width;  //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);
}

初始化LCD设备
- 打开LCD设备并获取其屏幕信息
- 映射LCD显存到用户空间
- 将LCD背景刷白
初始化摄像头设备
- 打开摄像头设备文件
- 查询设备功能，确保它是一个视频采集设备
枚举摄像头支持的像素格式
- 使用 VIDIOC_ENUM_FMT 枚举摄像头支持的所有像素格式及其描述信息，并保存到数组中
打印摄像头支持的分辨率和帧率
- 枚举摄像头支持的所有分辨率和帧率信息，将其打印出来
设置摄像头格式和帧率
- 设置视频采集的帧格式为RGB565
- 设置采集帧率为30fps
初始化帧缓冲
- 申请帧缓冲
- 建立内存映射
- 初始化队列，将帧缓冲放入队列中
开启视频采集
- 启动摄像头，开始采集视频数据
读取视频数据并显示到LCD
- 在一个无限循环中，从摄像头读取视频数据
- 逐行复制采集到的RGB565数据到LCD显存中
- 数据处理完后，将缓冲区重新放回队列中，重复上述过程

实现UVC USB 摄像头在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 <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 char *start;      //帧缓冲起始地址
    unsigned long length;       //帧缓冲长度
} cam_buf_info;

static int width;                       //LCD宽度
static int height;                      //LCD高度
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;   //视频帧宽度和高度

//将 YUYV 转换为 RGB565
static inline unsigned short yuyv_to_rgb565(unsigned char y, unsigned char u, unsigned char v) {
    int r = y + (1.4075 * (v - 128));
    int g = y - (0.3455 * (u - 128)) - (0.7169 * (v - 128));
    int b = y + (1.7790 * (u - 128));

    r = r < 0 ? 0 : (r > 255 ? 255 : r);
    g = g < 0 ? 0 : (g > 255 ? 255 : g);
    b = b < 0 ? 0 : (b > 255 ? 255 : b);

    return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
}

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;

    /* 内存映射 */
    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_YUYV;  //像素格式
    if (0 > ioctl(v4l2_fd, VIDIOC_S_FMT, &fmt)) {
        fprintf(stderr, "ioctl error: VIDIOC_S_FMT: %s\n", strerror(errno));
        return -1;
    }

    /*** 判断是否已经设置为我们要求的YUYV像素格式
    如果没有设置成功表示该设备不支持YUYV像素格式 */
    if (V4L2_PIX_FMT_YUYV != fmt.fmt.pix.pixelformat) {
        fprintf(stderr, "Error: the device does not support YUYV 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 char *start;
    int min_w, min_h;
    int j, i;

    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);  //出队
            start = (unsigned char *)buf_infos[buf.index].start;
            base = screen_base;

            for (j = 0; j < min_h; j++) {
                for (i = 0; i < min_w; i += 2) {
                    unsigned char y0 = start[2 * i];
                    unsigned char u = start[2 * i + 1];
                    unsigned char y1 = start[2 * i + 2];
                    unsigned char v = start[2 * i + 3];

                    base[i] = yuyv_to_rgb565(y0, u, v);
                    base[i + 1] = yuyv_to_rgb565(y1, u, v);
                }
                base += width;
                start += frm_width * 2;
            }

            // 数据处理完之后、再入队、往复
            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);
}

YUYV 到 RGB565 转换: 添加 yuyv_to_rgb565 函数用于像素格式转换
v4l2_read_data 函数: 修改了数据处理部分，将 YUYV 数据转换为 RGB565 数据然后显示到 LCD 屏幕

木木不迷茫(˵¯͒¯͒˵)

关注

4
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
V4L2 摄像头应用编程-I.MX6U嵌入式Linux C应用编程学习笔记基于正点原子阿尔法开发板

V4L2（Video for Linux Two）是Linux内核中的视频设备驱动框架，为视频类设备（如摄像头）提供统一接口规范。V4L2注册的设备在系统的/dev/目录下生成设备节点文件，通常命名为videoX。应用程序通过对这些设备节点进行I/O操作来配置和使用设备。摄像头应用编程的步骤包括：打开设备：使用open函数打开摄像头设备文件。查询设备属性：使用ioctl()函数查询设备功能，确保其支持视频采集功能。......
复制链接

扫一扫