V4L2——mplane应用层使用实例

已于 2023-09-27 14:32:32 修改
阅读量2.4k 收藏 19
点赞数 3
文章标签： linux
于 2023-09-05 14:07:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38680990/article/details/132690773
版权

前言

多数情况下，对于video设备，我们使用v4l2的时候，都是single plane的使用情景，其实v4l2 还支持mplane 的使用场景，本文将详细介绍mplane的具体使用

一、mplane 相关的结构体

1. struct v4l2_buffer

struct v4l2_buffer的定义如下图所示，其中有一个共用体m成员，在共用体中有一个struct v4l2_plane *plane成员，它就是mplane 的核心结构体

2. struct v4l2_plane

在mplane 中，struct v4l2_plane即代表其中的一个plane

3. enum v4l2_buf_type

在mplane使用场景下，对于capture设备，应该使用V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE, 同样的，对于output设备，应该使用V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE

二、mplane 应用层使用实例

1. 内存使用mmap方式

1. 使用3个plane 的场景：

#define BUFFER_NUM 4
	unsigned char *buffer1[BUFFER_NUM];
    unsigned char *buffer2[BUFFER_NUM];
	struct v4l2_capability cap;
    struct v4l2_format fmt;
    enum v4l2_buf_type type;
    int i;
    struct v4l2_buffer buf;
    struct v4l2_plane planes[VIDEO_MAX_PLANES];

    ret = ioctl(fd,VIDIOC_QUERYCAP,&cap);
    if(ret < 0)
    {
        printf("VIDIOC_QUERYCAP failed\n");
        return -1;
    }
   
    fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    ret = ioctl(fd,VIDIOC_G_FMT,&fmt);
    if(ret < 0)
    {
        printf("VIDIOC_G_GMT failed\n");
        return -1;
    }
    memset(&fmt,0,sizeof(fmt));
    fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    fmt.fmt.pix_mp.width = 1280;                             
    fmt.fmt.pix_mp.height = 720;
    fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12;         //input data format
    fmt.fmt.pix_mp.field = V4L2_FIELD_NONE;
    fmt.fmt.pix_mp.num_planes = 3;                         //plane_num
    fmt.fmt.pix_mp.plane_fmt[0].bytesperline = 1280;                   // no use
    fmt.fmt.pix_mp.plane_fmt[0].sizeimage = 1280 * 720 * 3 / 2;        // no use
    fmt.fmt.pix_mp.plane_fmt[1].bytesperline = 1280;                   //nv12 data bytesperline size
    fmt.fmt.pix_mp.plane_fmt[1].sizeimage = 1280 * 720 * 3 / 2;        //nv12 data sizeimage size
    fmt.fmt.pix_mp.plane_fmt[2].bytesperline = 1280 / 4;               // 1/16 Y data bytesperline size
    fmt.fmt.pix_mp.plane_fmt[2].sizeimage = 1280 * 720 / 16 ;          // 1/16 Y data sizeimage size
    
    ret = ioctl(fd, VIDIOC_S_FMT,&fmt);
    
    struct v4l2_requestbuffers reqbufs;
    memset(&reqbufs,0,sizeof(reqbufs));
    reqbufs.count = BUFFER_NUM;
    reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    reqbufs.memory = V4L2_MEMORY_MMAP;

    ret = ioctl(fd,VIDIOC_REQBUFS,&reqbufs);
    if(ret < 0)
    {
        printf("VIDIOC_REQBUF failed\n");
        return -1;
    }
    for(i=0;i<BUFFER_NUM;i++)
    {
        memset(&buf,0,sizeof(buf));
        memset(planes,0,sizeof(planes));
        buf.index = i;
        buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;     
        buf.memory = V4L2_MEMORY_MMAP;
        buf.length = VIDEO_MAX_PLANES;
        buf.m.planes = planes;
        buf.m.planes[0].bytesused = 0;
        buf.m.planes[1].bytesused = 0;
        bufm。planes[2].bytesused = 0;
   
        ret = ioctl(fd,VIDIOC_QUERYBUF,&buf);
        if(ret < 0)
        {
            printf("VIDIOC_QUERYBUF failed\n");
            return -1;
        }

        buffer1[i] = mmap(NULL,buf.m.planes[1].length,PROT_READ | PROT_WRITE, MAP_SHARED,fd,buf.m.planes[1].m.mem_offset);
        if(buffer[i] == MAP_FAILED)
        {
            printf("mmap failed 0 \n");
        }
        buffer2[i] = mmap(NULL,buf.m.planes[2].length,PROT_READ | PROT_WRITE,MAP_SHARED,fd,buf.m.planes[2].m.mem_offset);
        if(buffer2[i] == MAP_FAILED)
        {
            printf("mmap failed 1 \n");
        }
        printf("buffer1[i] = 0x%x \n",buffer1[i]); 
        printf("buffer2[i] = 0x%x \n",buffer2[i]);
        printf("buf.m.planes[1].length = %d, buf.m.planes[1].m.mem_offset = %d\n",buf.m.planes[1].length
        ,buf.m.planes[1].m.mem_offset);
        printf("buf.m.planes[2].length = %d, buf.m.planes[2].m.mem_offset = %d\n",buf.m.planes[2].length
        ,buf.m.planes[2].m.mem_offset);
    }
    type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   
    ret = ioctl(fd,VIDIOC_STREAMON,&type);
    if(ret < 0)
    {   
        printf("VIDIOC_STREAMON failed\n");
        return -1;
    }

2. mplane 也支持只使用一个plane的场景：

#define BUFFER_NUM 4

	unsigned char *buffer[BUFFER_NUM];
	struct v4l2_capability cap;
    struct v4l2_format fmt;
    enum v4l2_buf_type type;
    int i;
    struct v4l2_buffer buf;
    struct v4l2_plane planes[VIDEO_MAX_PLANES];
	
	memset(&fmt,0,sizeof(fmt));
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    fmt.fmt.pix_mp.width = 1280;
    fmt.fmt.pix_mp.height = 720;
    fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_H264;              //data format 
    fmt.fmt.pix_mp.field = V4L2_FIELD_NONE;
    fmt.fmt.pix_mp.num_planes = 1;                               // planes num
    fmt.fmt.pix_mp.plane_fmt[0].bytesperline = 1280;             
    fmt.fmt.pix_mp.plane_fmt[0].sizeimage = 1280 * 720 * 3 / 2;
    
    ret = ioctl(fd, VIDIOC_S_FMT,&fmt);

    if(ret < 0)
    {
        printf("VIDIOC_S_FMT failed\n");
        return -1;
    }
    struct v4l2_requestbuffers reqbufs;

    memset(&reqbufs,0,sizeof(reqbufs));
    reqbufs.count = BUFFER_NUM;
    reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    reqbufs.memory = V4L2_MEMORY_MMAP;
    ret = ioctl(fd,VIDIOC_REQBUFS,&reqbufs);
    if(ret < 0)
    {
        printf("VIDIOC_REQBUF failed\n");
        return -1;
    }
    for(i=0;i<BUFFER_NUM;i++)
    {
        memset(&buf,0,sizeof(buf));
        memset(planes,0,sizeof(planes));
        buf.index = i;
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.length = VIDEO_MAX_PLANES;
        buf.m.planes = planes;
        buf.m.planes[0].bytesused = 0;
    
        ret = ioctl(fd,VIDIOC_QUERYBUF,&buf);
        if(ret < 0)
        {
            printf("VIDIOC_QUERYBUF failed\n");
        }
        buffer[i] = mmap(NULL,buf.m.planes[0].length,PROT_READ | PROT_WRITE,MAP_SHARED,fd,buf.m.planes[0].m.mem_offset);
        if(buffer[i] == MAP_FAILED)
        {
            printf("buffer mmap failed\n");
        }
        printf("buffer[%d] = 0x%x \n",i,buffer[i]); 
        printf("buf.m.planes[0].length = %d, buf.m.planes[0].m.mem_offset = %d\n",buf.m.planes[0].length
        ,buf.m.planes[0].m.mem_offset);   
    }
    memset(&buf,0,sizeof(buf));
    memset(planes,0,sizeof(planes));
    for(i=0; i < BUFFER_NUM; i++)
    {
        buf.m.planes = planes;
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = i;
        buf.flags = 0;
        buf.length = 1;
        buf.m.planes[0].bytesused = 1280*720*3/2;
        buf.bytesused = buf.m.planes[0].bytesused;
        ret = ioctl(fd,VIDIOC_QBUF,&buf);
        if(ret < 0) 
        {
            printf("VIDIOC_QBUF failed\n");
            return -1;
        }
    }

    type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   
    ret = ioctl(fd,VIDIOC_STREAMON,&type);
    if(ret < 0)
    {   
        printf("VIDIOC_STREAMON failed\n");
        return -1;
    }

2. 内存使用dmafd方式

1. camera端导出dmafd：

#define BUFFER_NUM 4
#define CAMERA_PLANES 3
#define CAM_VIDEO "/dev/video0"

int buffer_export_mp(int fd, enum v4l2_buf_type bt, int index, int dmafd[], int n_planes)
{
    int i;
    for(i = 0; i < n_planes; i++)
    {
        struct v4l2_exportbuffer expbuf;
        memset(&expbuf, 0, sizeof(expbuf));
        expbuf.type = bt;
        expbuf.index = index;
        expbuf.plane = i;
        if(ioctl(fd, VIDIOC_EXPBUF, &expbuf) == -1) {
            printf("VIDIOC_EXPBUF failed\n");
            while(i)
                close(dmafd[--i]);
            return -1;
        }
        dmafd[i] = expbuf.fd;
        printf("dmafd[%d] = %d\n",i,dmafd[i]);
    }
    return 0;
}

	int fd;
    int i,j;
    int ret;
    int dmafd[BUFFER_NUM][CAMERA_PLANES];
    unsigned char *buffer[BUFFER_NUM];

    fd = open(CAMERA_VIDEO, O_RDWR);
    if (fd < 0)
    {
        printf("open camera video node failed\n");
        return -1;
    }

    struct v4l2_capability cap;
    struct v4l2_format fmt;
    enum v4l2_buf_type type;
    struct v4l2_buffer buf;
    struct v4l2_plane planes[VIDEO_MAX_PLANES];
    type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    ret = ioctl(fd,VIDIOC_QUERYCAP,&cap);
    if(ret < 0)
    {
        printf("VIDIOC_QUERYCAP failed\n");
        return -1;
    }
   
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    ret = ioctl(fd,VIDIOC_G_FMT,&fmt);
    if(ret < 0)
    { 
        printf("VIDIOC_G_GMT failed\n");
        return -1;
    }
    memset(&fmt,0,sizeof(fmt));
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    fmt.fmt.pix_mp.width = 1920;
    fmt.fmt.pix_mp.height = 1080;
    fmt.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12;
    fmt.fmt.pix_mp.field = V4L2_FIELD_NONE;
    fmt.fmt.pix_mp.num_planes = CAMERA_PLANES;
    ret = ioctl(fd, VIDIOC_S_FMT,&fmt);
    if(ret < 0)
    {
        printf("VIDIOC_S_FMT failed\n");
        return -1;
    }
    
    struct v4l2_requestbuffers reqbufs;

    memset(&reqbufs,0,sizeof(reqbufs));
    reqbufs.count = BUFFER_NUM;
    reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    reqbufs.memory = V4L2_MEMORY_MMAP;

    ret = ioctl(fd,VIDIOC_REQBUFS,&reqbufs);
    if(ret < 0)
    {
        printf("VIDIOC_REQBUF failed\n");
        return -1;
    }
    for(i=0;i<BUFFER_NUM;i++)
    {
        memset(&buf,0,sizeof(buf));
        memset(planes,0,sizeof(planes));
        buf.index = i;
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.length = 3;
        buf.m.planes = planes;
        buf.m.planes[0].bytesused = 0;
    
        ret = ioctl(fd,VIDIOC_QUERYBUF,&buf);
        if(ret < 0)
        {
            printf("VIDIOC_QUERYBUF failed\n");
        }

        ret = buffer_export_mp(fd,buf.type,i,dmafd[i],CAMERA_PLANES);      //export dmafd
        if(ret < 0)
        {
            printf("buffer export_mp failed\n");
            return -1;
        }
    }

2. encoder端使用camera端导出的dmafd

#define BUFFER_NUM 4
#define CAMERA_PLANES 3
#define ENC_VIDEO "/dev/video1"

	int fd;
    int i,j;
    int ret;
    int dmafd[BUFFER_NUM][CAMERA_PLANES];
    unsigned char *buffer[BUFFER_NUM];

    fd = open(ENC_VIDEO, O_RDWR);
    if (fd < 0)
    {
        printf("open enc video node failed\n");
        return -1;
    }

    struct v4l2_capability cap;
    struct v4l2_format fmt;
    enum v4l2_buf_type type;
    struct v4l2_buffer buf;
    struct v4l2_plane planes[VIDEO_MAX_PLANES];
    type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    ret = ioctl(fd,VIDIOC_QUERYCAP,&cap);
    if(ret < 0)
    {
        printf("VIDIOC_QUERYCAP failed\n");
        return -1;
    }
   
    fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    ret = ioctl(fd,VIDIOC_G_FMT,&fmt);
    if(ret < 0)
    { 
        printf("VIDIOC_G_GMT failed\n");
        return -1;
    }
    memset(&fmt,0,sizeof(fmt));
    fmt1.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    fmt1.fmt.pix_mp.width = 1920;
    fmt1.fmt.pix_mp.height = 1080;
    fmt1.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12;
    fmt1.fmt.pix_mp.field = V4L2_FIELD_NONE;
    fmt1.fmt.pix_mp.num_planes = CAMERA_PLANES;                  //plane num

    ret = ioctl(fd, VIDIOC_S_FMT,&fmt);
    if(ret < 0)
    {
        printf("VIDIOC_S_FMT failed\n");
        return -1;
    }
    struct v4l2_requestbuffers reqbufs;
    memset(&reqbufs,0,sizeof(reqbufs));
    reqbufs.count = BUFFER_NUM;
    reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    reqbufs.memory = V4L2_MEMORY_DMABUF;                  //DMABUF

    ret = ioctl(fd,VIDIOC_REQBUFS,&reqbufs);
    if(ret < 0)
    {
        printf("Encoder input VIDIOC_REQBUF failed\n");
        return -1;
    }
    memset(&buf1,0,sizeof(buf1));
    memset(planes1,0,sizeof(planes1));
    
    for(i=0; i < BUFFER_NUM; i++)
    {
        buf.m.planes = planes;
        buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
        buf.memory = V4L2_MEMORY_DMABUF;
        buf.index = i;
        //buf.flags = 0;
        buf.length = 3;
        //buf.m.planes[0].bytesused = 1920*1080*3/2;
        //buf.m.planes[1].bytesused = 1280*720*3/2;
        //buf.m.planes[2].bytesused = 1280*720 / 16;
        //buf.bytesused = buf.m.planes[0].bytesused + buf.m.planes[1].bytesused + buf.m.planes[2].bytesused;
        for(j=0; j < CAMERA_PLANES; j++)
        {
            buf.m.planes[j].m.fd = dmafd[i][j];
            //printf("index = %d, buf.m.planes[%d] = %d\n",i,j,buf.m.planes[j].m.fd);
        }
    }

总结

  1. mplane 也支持只使用一个plane的场景；
  2. mplane实质上就是对应多个buffer；

参考资料

  1. https://www.kernel.org/doc/html/v4.14/media/uapi/v4l/buffer.html?highlight=v4l2_buffer#c.v4l2_buffer
weixin_38680990
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
V4L2框架中的vb2_buffer
bai915290475的博客
05-13 232
vb2_buffer是V4L2框架中videobuf2库的核心数据结构，代表了一个视频缓冲区。它的作用是管理视频数据缓冲区的生命周期，包括缓冲区的分配、准备、排队、处理、完成和清理等。vb2_buffer通常与vb2_queue一起使用，后者管理着一个或多个vb2_buffer实例，形成了一个缓冲区队列。以下是vb2_buffer：在vb2_queue的回调中，根据用户空间的请求分配一定数量的vb2_buffer实例。：在回调中，对每个vb2_buffer进行必要的初始化，以供后续使用。：通过。
深入理解linux内核v4l2框架之videobuf
热门推荐
Qiang的专栏
12-27 2万+
Videobuf 下面来介绍以下videobuffer相关的一些东西。 V4L2核心api提供了一套标准的方法来处理视频缓冲，这些方法允许驱动实现read(),mmap(), overlay()等操作。同样也有方法支持DMA的scatter/gather操作，并且支持vmallocbuffer(这个大多用在USB驱动上)。 videobuf层功能是一种在v4l2驱动和用户空间当中的依
V4L2捕获摄像头图片
06-20
整合网上的资源写的一个V4L2捕获摄像头图片的测试代码，自己备份用的。
V4L2 多平面格式采集(Video Capture Multiplanar)
08-09
在使用V4L2时，有的video设备 Capabilities为Video Capture Multiplanar。此时和Video Capture 格式设备采集所用的应用程序接口有些不同。
mplane方式v4l2应用分析 -- 完整代码
szembed的博客
04-11 407
【代码】mplane方式v4l2应用分析 -- 完整代码。
基于V4L2采集摄像头数据
lingyi_cai的博客
09-28 2292
基于Linux Kernel V4L2框架验证采集摄像头数据，捕获到的yuv数据在7yuv.exe进行查看，从而验证摄像头驱动到应用层的数据链路完整性。源码如下所示： #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <sys/ioctl.h> #include <linux/types.h> #in
mplane方式v4l2应用分析 -- VIDIOC_S_FMT(设置图像格式)
szembed的博客
04-11 747
以上面对代码为例，传入的是2400x1920，但是实际sensor是1280x1024，那么最终打印的也是1280x1024，也就是说S_FMT的ioctl会根据实际sensor进行修改。上面的代码删除了计算imagesize部分的代码，这里不影响分析。
V4L2学习笔记
weixin_43360707的博客
07-19 1820
在其内部有media文件夹，里面含有v4l2有关的内核函数。
V4L2之buffer分配和映射
cqxcool66的博客
11-05 3717
数据结构
树莓派--V4L2编程入门1
qq_53154054的博客
07-25 591
ioctl函数主要用于控制设备。
v4l2 buffer
jgdu1981的专栏
05-03 2481
vivi.c static int vidioc_reqbufs(struct file *file, void *priv,               struct v4l2_requestbuffers *p) --> videobuf_reqbufs(&dev->vb_vidq, p); ------->q->ops->buf_setup(q, &count, &size);
V4L2-struct.rar_v4l2
09-20
8. **v4l2_pix_format_mplane** 对于多平面的格式，如YUV420，这个结构体提供了对各个平面的独立控制。 9. **v4l2_plane** 用于多平面缓冲，每个plane代表一个单独的数据平面，如Y、U、V分量。 10. **v4l2_event...
针对multi plane dmabuf v4l2的资料
09-17
这个是针对multi plane dmabufv4l2的资料，亲...需要参考v4l2+drm+dmabuf实现零拷贝视频环回功能的，到：https://download.csdn.net/download/kfor9/23362361 刚好在做音视频相关的工作，其他资源会在这段时间上传吧。
mplane_http_transport:mplane_http_transport
06-06
所有交易都可以使用受信任的证书进行保护。 #REST API 该实现具有一组有限的消息集。 特别是，对于任何 mPlane 信息元素，都可以在 mPlane 组件之间创建和读取它们。 ##REGISTER register 关键字是元素的创建消息。...
mplane方式v4l2应用分析 -- VIDIOC_REQBUFS(申请缓冲区)
szembed的博客
04-11 230
和之前的vivi中对比，其实差距并不大，这里先关注。是通用的，这里只分析不同的地方。之后，就是这样的一个结构。和vivi是不一样的。
为什么要分析mplane格式的v4l2应用？
ldl617的专栏
09-26 1546
为什么要分析mplane格式的v4l2应用？ 在之前通过vivi学习v4l2的时候其实已经知道了v4l2怎么编写，这里为什么还要研究mplane格式的？ vivi中是非mplane格式的，该部分章节的内容编写的v4l2应用在实际项目中，其实只适用usb摄像头，但是现在好多平台支持的都是mplane格式的，所以实用性有限。 最近在rv1126平台上一直使用rkmedia去获取图像，大部分都是nv12格式的。直到最近要获取raw8到图像，突然发现rkmedia不支持，需要自己通过v4l2去获取。然而v4l2使
linux V4L2子系统——v4l2架构（7）之V4L2应用编程
枫潇潇
06-19 1456
V4L2子系统向上提供了很多访问Video设备的接口，应用程序可以通过系统调用访问Video设备。但由于Video设备千差万别，很少有设备驱动程序能支持所有的接口功能，因此在使用之前，需要了解设备驱动程序支持的功能。...
V4L2摄像头驱动demo
weixin_42005898的博客
03-22 446
// extra_camera.h #ifndef __ExtraCamera_H__ #define __ExtraCamera_H__ #define CAMERA_WIDTH (1280) #define CAMERA_HEIGH (720) #undef TAG #define TAG "ExtraCamera debug ---" #define DEBUG_TAG "ExtraCamera debug --- " #define DEBUGPRINT(fmt, args..
V4L2_CAP_VIDEO_CAPTURE_MPLANE
最新发布
08-29
V4L2_CAP_VIDEO_CAPTURE_MPLANE是一个视频输出设备，支持多平面格式。根据引用中的信息，我们知道它是一个视频捕获设备的功能属性之一。其中，V4L2_CAP_VIDEO_CAPTURE_MPLANE的值为0x00001000。它表示该设备支持多平面格式的视频捕获功能。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [v4l2 video设备支持功能查询](https://blog.csdn.net/liujia2100/article/details/24812687)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [获取USB摄像头的1080p的JPEG格式的图片20180608_1806.7z](https://download.csdn.net/download/wb4916/10467872)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [linux下通过V4L2驱动USB摄像头](https://blog.csdn.net/simonforfuture/article/details/78743800)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值