V4L2 官方 example

最新推荐文章于 2023-04-27 21:53:30 发布
最新推荐文章于 2023-04-27 21:53:30 发布
阅读量902 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： V4L2 文章标签： video buffer struct io null image
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hezhensong/article/details/7532931 

/*
 *  V4L2 video capture example
 *
 *  This program can be used and distributed without restrictions.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include <getopt.h> /* getopt_long() */

#include <fcntl.h> /* low-level i/o */
#include <unistd.h>
#include <errno.h>
#include <malloc.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm/types.h> /* for videodev2.h */
#include <linux/videodev2.h>

#define CLEAR(x) memset (&(x), 0, sizeof (x))

typedef enum

{
    IO_METHOD_READ,
    IO_METHOD_MMAP,
    IO_METHOD_USERPTR,
} io_method;


struct buffer
{
    void *start;
    size_t length;
};


static char *dev_name = NULL;
static io_method io = IO_METHOD_MMAP;
static int fd = -1;
struct buffer *buffers = NULL;
static unsigned int n_buffers = 0;


static void
errno_exit (const char *s)
{
    fprintf (stderr, "%s error %d, %s/n", s, errno, strerror (errno));


    exit (EXIT_FAILURE);
}


static int
xioctl (int fd, int request, void *arg)
{
    int r;


    do
r = ioctl (fd, request, arg);
    while (-1 == r && EINTR == errno);


    return r;
}


static void
process_image (const void *p)
{
    fputc ('.', stdout);
    fflush (stdout);
}


static int
read_frame (void)
{
    struct v4l2_buffer buf;
    unsigned int i;


    switch (io)
      {
      case IO_METHOD_READ:
 if (-1 == read (fd, buffers[0].start, buffers[0].length))
   {
switch (errno)
 {
 case EAGAIN:
     return 0;


 case EIO:
     /* Could ignore EIO, see spec. */


     /* fall through */


 default:
     errno_exit ("read");
 }
   }


 process_image (buffers[0].start);


 break;


      case IO_METHOD_MMAP:
 CLEAR (buf);


 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 buf.memory = V4L2_MEMORY_MMAP;


 if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf))
   {
switch (errno)
 {
 case EAGAIN:
     return 0;


 case EIO:
     /* Could ignore EIO, see spec. */


     /* fall through */


 default:
     errno_exit ("VIDIOC_DQBUF");
 }
   }


 assert (buf.index < n_buffers);


 process_image (buffers[buf.index].start);


 if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
     errno_exit ("VIDIOC_QBUF");


 break;


      case IO_METHOD_USERPTR:
 CLEAR (buf);


 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 buf.memory = V4L2_MEMORY_USERPTR;


 if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf))
   {
switch (errno)
 {
 case EAGAIN:
     return 0;


 case EIO:
     /* Could ignore EIO, see spec. */


     /* fall through */


 default:
     errno_exit ("VIDIOC_DQBUF");
 }
   }


 for (i = 0; i < n_buffers; ++i)
     if (buf.m.userptr == (unsigned long) buffers[i].start
 && buf.length == buffers[i].length)
 break;


 assert (i < n_buffers);


 process_image ((void *) buf.m.userptr);


 if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
     errno_exit ("VIDIOC_QBUF");


 break;
      }


    return 1;
}


static void
mainloop (void)
{
    unsigned int count;


    count = 100;


    while (count-- > 0)
      {
 for (;;)
   {
fd_set fds;
struct timeval tv;
int r;


FD_ZERO (&fds);
FD_SET (fd, &fds);


/* Timeout. */
tv.tv_sec = 2;
tv.tv_usec = 0;


r = select (fd + 1, &fds, NULL, NULL, &tv);


if (-1 == r)
 {
     if (EINTR == errno)
 continue;


     errno_exit ("select");
 }


if (0 == r)
 {
     fprintf (stderr, "select timeout/n");
     exit (EXIT_FAILURE);
 }


if (read_frame ())
   break;


/* EAGAIN - continue select loop. */
   }
      }
}


static void
stop_capturing (void)
{
    enum v4l2_buf_type type;


    switch (io)
      {
      case IO_METHOD_READ:
 /* Nothing to do. */
 break;


      case IO_METHOD_MMAP:
      case IO_METHOD_USERPTR:
 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;


 if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type))
     errno_exit ("VIDIOC_STREAMOFF");


 break;
      }
}


static void
start_capturing (void)
{
    unsigned int i;
    enum v4l2_buf_type type;


    switch (io)
      {
      case IO_METHOD_READ:
 /* Nothing to do. */
 break;


      case IO_METHOD_MMAP:
 for (i = 0; i < n_buffers; ++i)
   {
struct v4l2_buffer buf;


CLEAR (buf);


buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = i;


if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
   errno_exit ("VIDIOC_QBUF");
   }


 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;


 if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
     errno_exit ("VIDIOC_STREAMON");


 break;


      case IO_METHOD_USERPTR:
 for (i = 0; i < n_buffers; ++i)
   {
struct v4l2_buffer buf;


CLEAR (buf);


buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_USERPTR;
buf.index = i;
buf.m.userptr = (unsigned long) buffers[i].start;
buf.length = buffers[i].length;


if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
   errno_exit ("VIDIOC_QBUF");
   }


 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;


 if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
     errno_exit ("VIDIOC_STREAMON");


 break;
      }
}


static void
uninit_device (void)
{
    unsigned int i;


    switch (io)
      {
      case IO_METHOD_READ:
 free (buffers[0].start);
 break;


      case IO_METHOD_MMAP:
 for (i = 0; i < n_buffers; ++i)
     if (-1 == munmap (buffers[i].start, buffers[i].length))
 errno_exit ("munmap");
 break;


      case IO_METHOD_USERPTR:
 for (i = 0; i < n_buffers; ++i)
     free (buffers[i].start);
 break;
      }


    free (buffers);
}


static void
init_read (unsigned int buffer_size)
{
    buffers = calloc (1, sizeof (*buffers));


    if (!buffers)
      {
 fprintf (stderr, "Out of memory/n");
 exit (EXIT_FAILURE);
      }


    buffers[0].length = buffer_size;
    buffers[0].start = malloc (buffer_size);


    if (!buffers[0].start)
      {
 fprintf (stderr, "Out of memory/n");
 exit (EXIT_FAILURE);
      }
}


static void
init_mmap (void)
{
    struct v4l2_requestbuffers req;


    CLEAR (req);


    req.count = 4;
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_MMAP;


    if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req))
      {
 if (EINVAL == errno)
   {
fprintf (stderr, "%s does not support "
"memory mapping/n", dev_name);
exit (EXIT_FAILURE);
   }
 else
   {
errno_exit ("VIDIOC_REQBUFS");
   }
      }


    if (req.count < 2)
      {
 fprintf (stderr, "Insufficient buffer memory on %s/n", dev_name);
 exit (EXIT_FAILURE);
      }


    buffers = calloc (req.count, sizeof (*buffers));


    if (!buffers)
      {
 fprintf (stderr, "Out of memory/n");
 exit (EXIT_FAILURE);
      }


    for (n_buffers = 0; n_buffers < req.count; ++n_buffers)
      {
 struct v4l2_buffer buf;


 CLEAR (buf);


 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 buf.memory = V4L2_MEMORY_MMAP;
 buf.index = n_buffers;


 if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))
     errno_exit ("VIDIOC_QUERYBUF");


 buffers[n_buffers].length = buf.length;
 buffers[n_buffers].start = mmap (NULL /* start anywhere */ ,
  buf.length,
  PROT_READ | PROT_WRITE
  /* required */ ,
  MAP_SHARED /* recommended */ ,
  fd, buf.m.offset);


 if (MAP_FAILED == buffers[n_buffers].start)
     errno_exit ("mmap");
      }
}


static void
init_userp (unsigned int buffer_size)
{
    struct v4l2_requestbuffers req;
    unsigned int page_size;


    page_size = getpagesize ();
    buffer_size = (buffer_size + page_size - 1) & ~(page_size - 1);


    CLEAR (req);


    req.count = 4;
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_USERPTR;


    if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req))
      {
 if (EINVAL == errno)
   {
fprintf (stderr, "%s does not support "
"user pointer i/o/n", dev_name);
exit (EXIT_FAILURE);
   }
 else
   {
errno_exit ("VIDIOC_REQBUFS");
   }
      }


    buffers = calloc (4, sizeof (*buffers));


    if (!buffers)
      {
 fprintf (stderr, "Out of memory/n");
 exit (EXIT_FAILURE);
      }


    for (n_buffers = 0; n_buffers < 4; ++n_buffers)
      {
 buffers[n_buffers].length = buffer_size;
 buffers[n_buffers].start = memalign ( /* boundary */ page_size,
      buffer_size);


 if (!buffers[n_buffers].start)
   {
fprintf (stderr, "Out of memory/n");
exit (EXIT_FAILURE);
   }
      }
}


static void
init_device (void)
{
    struct v4l2_capability cap;
    struct v4l2_cropcap cropcap;
    struct v4l2_crop crop;
    struct v4l2_format fmt;
    unsigned int min;


    if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap))
      {
 if (EINVAL == errno)
   {
fprintf (stderr, "%s is no V4L2 device/n", dev_name);
exit (EXIT_FAILURE);
   }
 else
   {
errno_exit ("VIDIOC_QUERYCAP");
   }
      }


    if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
      {
 fprintf (stderr, "%s is no video capture device/n", dev_name);
 exit (EXIT_FAILURE);
      }


    switch (io)
      {
      case IO_METHOD_READ:
 if (!(cap.capabilities & V4L2_CAP_READWRITE))
   {
fprintf (stderr, "%s does not support read i/o/n", dev_name);
exit (EXIT_FAILURE);
   }


 break;


      case IO_METHOD_MMAP:
      case IO_METHOD_USERPTR:
 if (!(cap.capabilities & V4L2_CAP_STREAMING))
   {
fprintf (stderr, "%s does not support streaming i/o/n",
dev_name);
exit (EXIT_FAILURE);
   }


 break;
      }




    /* Select video input, video standard and tune here. */




    CLEAR (cropcap);


    cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;


    if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap))
      {
 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 crop.c = cropcap.defrect;/* reset to default */


 if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop))
   {
switch (errno)
 {
 case EINVAL:
     /* Cropping not supported. */
     break;
 default:
     /* Errors ignored. */
     break;
 }
   }
      }
    else
      {
 /* Errors ignored. */
      }




    CLEAR (fmt);


    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    fmt.fmt.pix.width = 640;
    fmt.fmt.pix.height = 480;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;


    if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
errno_exit ("VIDIOC_S_FMT");


    /* Note VIDIOC_S_FMT may change width and height. */


    /* Buggy driver paranoia. */
    min = fmt.fmt.pix.width * 2;
    if (fmt.fmt.pix.bytesperline < min)
fmt.fmt.pix.bytesperline = min;
    min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
    if (fmt.fmt.pix.sizeimage < min)
fmt.fmt.pix.sizeimage = min;


    switch (io)
      {
      case IO_METHOD_READ:
 init_read (fmt.fmt.pix.sizeimage);
 break;


      case IO_METHOD_MMAP:
 init_mmap ();
 break;


      case IO_METHOD_USERPTR:
 init_userp (fmt.fmt.pix.sizeimage);
 break;
      }
}


static void
close_device (void)
{
    if (-1 == close (fd))
errno_exit ("close");


    fd = -1;
}


static void
open_device (void)
{
    struct stat st;


    if (-1 == stat (dev_name, &st))
      {
 fprintf (stderr, "Cannot identify '%s': %d, %s/n",
  dev_name, errno, strerror (errno));
 exit (EXIT_FAILURE);
      }


    if (!S_ISCHR (st.st_mode))
      {
 fprintf (stderr, "%s is no device/n", dev_name);
 exit (EXIT_FAILURE);
      }


    fd = open (dev_name, O_RDWR /* required */  | O_NONBLOCK, 0);


    if (-1 == fd)
      {
 fprintf (stderr, "Cannot open '%s': %d, %s/n",
  dev_name, errno, strerror (errno));
 exit (EXIT_FAILURE);
      }
}


static void
usage (FILE * fp, int argc, char **argv)
{
    fprintf (fp,
    "Usage: %s [options]/n/n"
    "Options:/n"
    "-d | --device name   Video device name [/dev/video]/n"
    "-h | --help          Print this message/n"
    "-m | --mmap          Use memory mapped buffers/n"
    "-r | --read          Use read() calls/n"
    "-u | --userp         Use application allocated buffers/n"
    "", argv[0]);
}


static const char short_options[] = "d:hmru";


static const struct option long_options[] = {
    {"device", required_argument, NULL, 'd'},
    {"help", no_argument, NULL, 'h'},
    {"mmap", no_argument, NULL, 'm'},
    {"read", no_argument, NULL, 'r'},
    {"userp", no_argument, NULL, 'u'},
    {0, 0, 0, 0}
};


int
main (int argc, char *argv[])
{
    dev_name = "/dev/video0";


    for (;;)
      {
 int index;
 int c;


 c = getopt_long (argc, argv, short_options, long_options, &index);
 if (-1 == c)
   {
break;
   }
 switch (c)
   {
   case 0: /* getopt_long() flag */
break;


   case 'd':
dev_name = optarg;
break;


   case 'h':
usage (stdout, argc, argv);
exit (EXIT_SUCCESS);


   case 'm':
io = IO_METHOD_MMAP;
break;


   case 'r':
io = IO_METHOD_READ;
break;


   case 'u':
io = IO_METHOD_USERPTR;
break;


   default:
usage (stderr, argc, argv);
exit (EXIT_FAILURE);
   }
      }


    open_device ();
    return 0;
    init_device ();
    start_capturing ();
    mainloop ();
    stop_capturing ();
    uninit_device ();
    close_device ();
    exit (EXIT_SUCCESS);


    return 0;
}
 











                

        

    

    
  



    



                



	

		

			

				
					
V4L2官方例程

				
			

			

				

					wuyuwei45的专栏
				

				

					05-13
					
					3796
					
				

			

		

		

			
				
V4l2的官网例程代码：

/*
 *  V4L2 video capture example
 *
 *  This program can be used and distributed without restrictions.
 */

#include 
#include 
#include 
#include 

#include              /* getopt_lo

			
		

	



                

            
              



	

		

			

				
					
linux V4L2子系统——v4l2的结构体（3）之v4l2_subdev-my write

				
			

			

				

					小硕算法工程师
				

				

					07-31
					
					719
					
				

			

		

		

			
				
子设备，负责实现具体的功能。可将其抽象为具体的某一摄像头传感器，如OV7740、OV7251、OV5640等。每一个子设备驱动都必须有一个结构体，这个结构体可以作为独立的简单子设备存在，也可以嵌入到更大的结构体（自定义的子设备结构体）里面。通常会有一个由内核设置的低层次结构体（i2c_client，也就是上面说的 i2c 设备），它包含了一些设备数据，要调用来设置子设备私有数据指针指向它，这样的话就可以很方便的从 subdev 找到相关的 I2C 设备数据（这个要编程实现的时候才能够了解它的用意）。

			
		

	



              


  
              

                


	

		

			

				
					
V4L2官方实例

				
			

			

				

					Bop to the top!
				

				

					09-25
					
					2481
					
				

			

		

		

			
				
/* *  V4L2 video capture example * *  This program can be used and distributed without restrictions. */#include #include #include #include #include              /* getopt_long() 

			
		

	





	

		

			

				
					
V4L2 video capture 例子程序

				
			

			

				

					10-25
				

			

		

		

			
				
V4L2 video capture example
This program is provided with the V4L2 API

			
		

	



		

			
		



	

		

			

				
					
3 v4l2例程代码及流程图

				
			

			

				

					u012906122的专栏
				

				

					04-27
					
					637
					
				

			

		

		

			
				
1 v4l2例程代码及流程图。图1 v4l2流程图。

			
		

	





	

		

			

				
					
Camera V4L2 应用程序例程

				
			

			

				

					02-01
				

			

		

		

			
				
基于linux系统，Camera V4L2 应用程序例程，已调试能正常运行

			
		

	





	

		

			

				
					
V4L2_video_capture_example.rar_Capture_V4L 视频_v4l_v4l2视频驱动

				
			

			

				

					09-14
				

			

		

		

			
				
这个“V4L2_video_capture_example.rar”压缩包提供了关于如何使用V4L2 API进行视频捕获的示例和指导。在这个案例中，我们将深入探讨V4L2框架、视频驱动原理，以及如何编写程序来实现视频捕获。  V4L2是V4L（Video ...

			
		

	





	

		

			

				
					
camset:v4l2-ctl的GUI

				
			

			

				

					05-25
				

			

		

		

			
				
 example_ioctl文件夹包含使用v4l2 Python绑定库读取和设置V4L值（等效于v4l2-ctl --list-formats-ext ， v4l2-ctl -L和v4l2-ctl -c ）的直接ioctl调用的一些示例。 对该库进行了少许修改，以使其与最新的Python版本...

			
		

	





	

		

			

				
					
V4L2_video_capture_example.rar_linux v4l_linux 视频采集_v4l_v4l2_v4l

				
			

			

				

					09-20
				

			

		

		

			
				
标题中的"V4L2_video_capture_example.rar"表明这是一个关于V4L2视频采集的示例程序，可能包含源代码和编译指南。V4L2是Linux系统中进行视频采集的核心接口，它允许开发者直接与视频捕获设备进行通信，获取视频流...

			
		

	





	

		

			

				
					
USBCamera+v4l2+rkisp+rkmpp+opencv.rar

				
			

			

				

					09-17
				

			

		

		

			
				
在压缩包中的源代码文件，如`example.cpp`、`v4l2_camera.cpp`、`rockchip_mpp.cpp`、`rockchip_rga.cpp`等，分别对应于这些技术的实现细节。`v4l2_camera.cpp`和`v4l2_camera.hpp`包含了V4L2接口的实现，`rockchip_...

			
		

	





	

		

			

				
					
V4L2 SAMPLE CODE

				
			

			

				

					05-26
				

			

		

		

			
				
V4L2 CAMERA 示例代码 简单实现

			
		

	





	

		

			

				
					
v4l2 官方capture 测试程序

				
			

			

				

					09-18
				

			

		

		

			
				
v4l2官方测试程序，有三种capture方式，read，mmap和用户指针模式

			
		

	





	

		

			

				
					
linux-v4l2完整源代码

				
			

			

				

					04-16
				

			

		

		

			
				
linux-v4l2完整源代码，包含图像采集到处理的每个过程，学习v4l2很好的代码，且稍作改动即可使用！

			
		

	





	

		

			

				
					
论文研究-基于Zynq-7000的V4L2双帧缓存驱动设计 .pdf

				
			

			

				

					08-15
				

			

		

		

			
				
基于Zynq-7000的V4L2双帧缓存驱动设计，王宇，胡若澜，V4L2是Linux2.6版本的一大特点，它主要为视频驱动程序的开发提供了相关的协议标准。Zynq-7000处理器结合了ARM架构和FPGA的特点，其软硬件��

			
		

	





	

		

			

				
					
V4L2驱动程序的实现

				
			

			

				

					09-12
				

			

		

		

			
				
基于V4L2的linux的摄像头驱动程序的实现

			
		

	





	

		

			

				
					
Video for linux 2 example (v4l2 demo)

				
			

			

				

					MetalSeed
				

				

					10-03
					
					6110
					
				

			

		

		

			
				
1. 定义
V4L2(Video For Linux Two) 是内核提供给应用程序访问音、视频驱动的统一接口。
2. 工作流程：
打开设备－> 检查和设置设备属性－> 设置帧格式－> 设置一种输入输出方法（缓冲 区管理）－> 循环获取数据－> 关闭设备。
3. 设备的打开和关闭：

#include 

int open(const char *device_name, int fl

			
		

	





	

		

			

				
					
arm板上最简单的使用v4l2使用USB摄像头捕获图像的例子

				
			

			

				

					qq_21036905的博客
				

				

					08-03
					
					5742
					
				

			

		

		

			
				
首先我使用的linux系统是字符界面的，很想找一个最简单的USB摄像头程序进行摄像头测试。可是找了半天不是不能用就是太复杂，不方便测试也不方便入门学习。国外的要收费，国内的好不容易找到一个，还有BUG，又用不了。
找到了L4V2 api官方测试程序，弄了半天总算有点明白了。稍微做了改动。
这个程序是使用YUV格式保存，并且通过stdio输出，这样做的目的是方便重定向到下一个转换程序。但是对于着

			
		

	





	

		

			

				
					
v4l2视频采集程序

				
			

			

				

					L_yangliu的专栏
				

				

					11-15
					
					6917
					
				

			

		

		

			
				
/* 
 *  V4L2 video capture example 
 * 
 *  This program can be used and distributed without restrictions. 
 */ 
 
#include  
#include  
#include  
#include  
 
#include              /* get

			
		

	





	

		

			

				
					
v4l2 videobuf

					
最新发布

				
			

			

				

					03-20
				

			

		

		

			
				
### v4l2 videobuf 技术细节及使用方法

#### 1. v4l2 videobuf 的核心概念
v4l2 videobuf 是 Linux 内核中的一个重要模块，用于管理视频设备的缓冲区操作。它通过 `videobuf2` 提供了一套统一的 API 来处理不同类型的记忆体分配方式[^1]。

主要涉及的核心组件包括：
- **videobuf2-core.c**: 实现了 videobuf2 的核心逻辑。
- **videobuf2-dma-contig.c 和 videobuf2-dma-sg.c**: 处理 DMA 缓冲区的相关功能。
- **videobuf2-vmalloc.c**: 支持虚拟内存分配。
- **include/uapi/linux/videobuf2.h**: 定义了与用户空间交互的数据结构和枚举类型。

其中，`enum v4l2_memory` 枚举定义了几种常见的缓冲区类型[^2]:
- `V4L2_MEMORY_MMAP`: 使用内存映射的方式共享数据。
- `V4L2_MEMORY_USERPTR`: 用户指针模式，允许应用程序指定自己的缓冲区地址。
- `V4L2_MEMORY_OVERLAY`: 过时的覆盖显示模式。
- `V4L2_MEMORY_DMABUF`: 基于 DMA buffer 的跨进程资源共享机制。

#### 2. v4l2 videobuf 的典型工作流程
以下是基于 `VIDIOC_REQBUFS`, `VIDIOC_QUERYBUF`, 和其他 ioctl 调用的工作流：

##### 请求缓存 (`VIDIOC_REQBUFS`)
在实际应用中，通常会先调用 `ioctl(VIDIOC_REQBUFS)` 接口来请求一定数量的缓冲区资源。例如，在下面的例子中，程序申请了 4 个 MMAP 类型的捕获缓冲区[^4]:

```c
#define NB_BUFFER 4
struct v4l2_requestbuffers reqBufs;
memset(&reqBufs, 0, sizeof(struct v4l2_requestbuffers));
reqBufs.count = NB_BUFFER;
reqBufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
reqBufs.memory = V4L2_MEMORY_MMAP;

if (ioctl(fd, VIDIOC_REQBUFS, &reqBufs) < 0) {
    perror("Failed to request buffers");
    close(fd);
    exit(EXIT_FAILURE);
}
```

如果该函数执行成功，则表示已经准备好创建所需的缓冲区数目；但此时并未真正分配物理存储器——这一步将在后续阶段完成。

##### 查询并映射缓存 (`VIDIOC_QUERYBUF`)
接着可以利用 `VIDIOC_QUERYBUF` 获取每个单独缓冲区的具体信息，并将其映射到用户态进程中以便访问其内容:

```c
for(int i=0;i<NB_BUFFER;i++) {
    struct v4l2_buffer buf;
    
    memset(&buf, 0, sizeof(buf));
    buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    buf.memory      = V4L2_MEMORY_MMAP;
    buf.index       = i;

    if(ioctl(fd, VIDIOC_QUERYBUF, &buf)<0){
        perror("Query Buffer Failed!");
        break;
    }

    void* start = mmap(NULL , buf.length,
                       PROT_READ | PROT_WRITE,
                       MAP_SHARED ,
                       fd         ,
                       buf.m.offset);

    if(MAP_FAILED==start){
        perror("mmap failed");
        continue;
    }
    // Store the pointer somewhere...
}
```

上述代码片段展示了如何逐一查询已请求好的缓冲区元数据（如长度、偏移量），并通过 POSIX 函数 `mmap()` 将它们映射至当前运行环境下的可读写区域里去。

#### 3. 设备注册与管理
当一切准备就绪后，最终还需要借助 `video_device` 结构体实例化具体的媒体实体对象，并向系统提交注册请求使得外部能够发现这些新加入的服务端点[^5]:

```c
static const struct file_operations fops = {...};
struct video_device *vdev = video_device_alloc();

if (!vdev) {
    pr_err("Unable to allocate memory for video device\n");
    return -ENOMEM;
}

strscpy(vdev->name, "example_v4l2", sizeof(vdev->name));
vdev->fops           = &fops;
vdev->release        = example_release_function;
vdev->device_caps   |= V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE;
vdev->lock           = NULL;

int ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
if(ret<0){
    video_device_release(vdev);
    return ret;
}
pr_info("%s registered as /dev/video%d\n",__func__,vdev->num);
module_exit(example_cleanup_module);
```

此部分负责初始化必要的属性字段值以及绑定回调句柄等内容项，从而构建起完整的驱动框架体系架构图谱。

---

### 示范总结
综上所述，通过对以上几个关键环节的学习理解可以帮助开发者快速掌握有关于 Videobuf2 在 V4L2 子系统的具体实践技巧要点所在之处。从最基础的概念介绍再到深入剖析其实现原理直至最后给出完整可用的实际案例演示全过程均有所涉猎涵盖全面无遗漏任何重要知识点领域范围广泛适用性强值得推荐学习参考价值极高！

---

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值