videobuf处理流程

最新推荐文章于 2023-06-24 16:48:25 发布
最新推荐文章于 2023-06-24 16:48:25 发布
阅读量1.7k 收藏 3
点赞数 1
分类专栏： linux 文章标签： 内核

转载自：http://blog.csdn.net/panda19881/article/details/8748934

 

videobuf是应用程序和v4l2驱动程序的一个中间层，用它来进行视频数据缓冲区的分配和管理。

它根据应用程序的需求（缓冲区的数量的大小），分配相应的视频缓冲区，这个缓冲区是在内核空间分配的，并通过mmap方法映射到用户空间，在内核空间形成一个缓冲区队列，在应用程序中有相应的缓冲区数组对应，它们指向的内存地址是一样的。在驱动程序中，根据配置的硬件参数（FIFO阈值），将vip硬件图像存储器中的数据放到缓冲区队列中的 每个缓冲区，然后等待应用程序来读取该缓冲区的数据。videobuf主要由一些特殊的数据结构和ioctl调用组成，下边对其做整体分析：

一、 初始化

初始化缓冲区队列：
1、驱动层的调用
在v4l2_vip.c文件中：

[cpp] view plain copy print ?
  1. static int vip_open(struct file *file) 
  2. { 
  3. struct vip_dev *dev = video_drvdata(file); 
  4. struct vip_fh *fh = NULL; 
  5. int retval = 0; 
  6.  
  7. 、、、、、、、、、 
  8.  
  9. /*allocate and initialize per filehandle data*/ 
  10. fh = kzalloc(sizeof(*fh), GFP_KERNEL);//此时已经把vb_vidq成员的空间分配好 
  11. if(NULL == fh){ 
  12.   dev->users--; 
  13.   retval = -ENOMEM; 
  14. } 
  15.  
  16. 、、、、、、、、、、 
  17.  
  18. fh->type    = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
  19. fh->fmt    = &formats[0]; 
  20.  
  21. 、、、、、、、、 
  22.  
  23. /*初始化videobuf缓冲区队列 vip_video_qops 是驱动层的videobuf回掉函数*/ 
  24. videobuf_queue_vmalloc_init(&fh->vb_vidq, &vip_video_qops, NULL, 
  25.      &dev->slock, fh->type,  V4L2_FIELD_INTERLACED, 
  26.      sizeof(struct vip_buffer), fh); 
  27. return 0; 
  28. }  
static int vip_open(struct file *file)
{
 struct vip_dev *dev = video_drvdata(file);
 struct vip_fh *fh = NULL;
 int retval = 0;

、、、、、、、、、

 /*allocate and initialize per filehandle data*/
 fh = kzalloc(sizeof(*fh), GFP_KERNEL);//此时已经把vb_vidq成员的空间分配好
 if(NULL == fh){
  dev->users--;
  retval = -ENOMEM;
 }

、、、、、、、、、、

 fh->type    = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 fh->fmt    = &formats[0];

、、、、、、、、

 /*初始化videobuf缓冲区队列 vip_video_qops 是驱动层的videobuf回掉函数*/
 videobuf_queue_vmalloc_init(&fh->vb_vidq, &vip_video_qops, NULL,
     &dev->slock, fh->type,  V4L2_FIELD_INTERLACED,
     sizeof(struct vip_buffer), fh);
 return 0;
}


2、videobuf层的操作
在videobuf-vmalloc.c中：

[cpp] view plain copy print ?
  1. videobuf_queue_vmalloc_init（struct videobuf_queue *q, 
  2.     struct videobuf_queue_ops *ops, 
  3.     struct device *dev, 
  4.     spinlock_t *irqlock, 
  5.     enum v4l2_buf_type type, 
  6.     enum v4l2_field field, 
  7.     unsigned int msize, 
  8.     void *priv 
  9. ） 
  10. { 
  11. videobuf_queue_core_init（q, ops, dev, irlock, type, field, msize, priv, &qops）； 
  12. } 
  13.  
  14. //上边函数多了一个qops参数，它是 videobuf层的数据操作函数集 
  15. void videobuf_queue_core_init(struct videobuf_queue *q, 
  16.     struct videobuf_queue_ops *ops, 
  17.     struct device *dev, 
  18.     spinlock_t *irqlock, 
  19.     enum v4l2_buf_type type, 
  20.     enum v4l2_field field, 
  21.     unsigned int msize, 
  22.     void *priv, 
  23.     struct videobuf_qtype_ops *int_ops) 
  24. { 
  25. BUG_ON(!q); 
  26. memset(q, 0, sizeof(*q)); 
  27. //初始化队列的一些成员 
  28. q->irqlock   = irqlock; 
  29. q->dev       = dev; 
  30. q->type      = type; 
  31. q->field     = field; 
  32. q->msize     = msize; 
  33. q->ops       = ops; 
  34. q->priv_data = priv; 
  35. q->int_ops   = int_ops; 
  36.  
  37. //检测必要的成员数据是否不为空 
  38. /* All buffer operations are mandatory */ 
  39. BUG_ON(!q->ops->buf_setup); 
  40. BUG_ON(!q->ops->buf_prepare); 
  41. BUG_ON(!q->ops->buf_queue); 
  42. BUG_ON(!q->ops->buf_release); 
  43.  
  44. /* Lock is mandatory for queue_cancel to work */ 
  45. BUG_ON(!irqlock); 
  46.  
  47. /* Having implementations for abstract methods are mandatory */ 
  48. BUG_ON(!q->int_ops); 
  49.  
  50. mutex_init(&q->vb_lock);//初始化自旋锁 
  51. init_waitqueue_head(&q->wait);//初始化videobuf队列queue中的等待队列 
  52. INIT_LIST_HEAD(&q->stream);//初始化链表 
  53. }  
videobuf_queue_vmalloc_init（struct videobuf_queue *q,
    struct videobuf_queue_ops *ops,
    struct device *dev,
    spinlock_t *irqlock,
    enum v4l2_buf_type type,
    enum v4l2_field field,
    unsigned int msize,
    void *priv
）
{
 videobuf_queue_core_init（q, ops, dev, irlock, type, field, msize, priv, &qops）；
}

//上边函数多了一个qops参数，它是 videobuf层的数据操作函数集
void videobuf_queue_core_init(struct videobuf_queue *q,
    struct videobuf_queue_ops *ops,
    struct device *dev,
    spinlock_t *irqlock,
    enum v4l2_buf_type type,
    enum v4l2_field field,
    unsigned int msize,
    void *priv,
    struct videobuf_qtype_ops *int_ops)
{
 BUG_ON(!q);
 memset(q, 0, sizeof(*q));
//初始化队列的一些成员
 q->irqlock   = irqlock;
 q->dev       = dev;
 q->type      = type;
 q->field     = field;
 q->msize     = msize;
 q->ops       = ops;
 q->priv_data = priv;
 q->int_ops   = int_ops;

//检测必要的成员数据是否不为空
 /* All buffer operations are mandatory */
 BUG_ON(!q->ops->buf_setup);
 BUG_ON(!q->ops->buf_prepare);
 BUG_ON(!q->ops->buf_queue);
 BUG_ON(!q->ops->buf_release);

 /* Lock is mandatory for queue_cancel to work */
 BUG_ON(!irqlock);

 /* Having implementations for abstract methods are mandatory */
 BUG_ON(!q->int_ops);

 mutex_init(&q->vb_lock);//初始化自旋锁
 init_waitqueue_head(&q->wait);//初始化videobuf队列queue中的等待队列
 INIT_LIST_HEAD(&q->stream);//初始化链表
}


二、 videobuf的相关ioctl()操作
这些操作有三部分组成，1是应用程序通过ioctl函数调用v4l2驱动中实现的接口函数，2这些接口函数在调用videobuf层的响应函数来做出处理，3如果有的处理参数需要v4l2层来决定的话，就调用v4l2层的videobuf设置函数。

1、ioctl接口函数列表

[cpp] view plain copy print ?
  1. static const struct v4l2_ioctl_ops vip_capture_ioctl_fops = { 
  2.  
  3. 、、、、、、 
  4.  
  5. .vidioc_reqbufs  = vip_reqbufs, 
  6. .vidioc_querybuf = vip_querybuf, 
  7. .vidioc_qbuf  = vip_qbuf, 
  8. .vidioc_dqbuf  = vip_dqbuf, 
  9. .vidioc_streamon = vip_streamon, 
  10. .vidioc_streamoff = vip_streamoff, 
  11.  
  12. 、、、、、、 
  13. };  
static const struct v4l2_ioctl_ops vip_capture_ioctl_fops = {

、、、、、、

 .vidioc_reqbufs  = vip_reqbufs,
 .vidioc_querybuf = vip_querybuf,
 .vidioc_qbuf  = vip_qbuf,
 .vidioc_dqbuf  = vip_dqbuf,
 .vidioc_streamon = vip_streamon,
 .vidioc_streamoff = vip_streamoff,

、、、、、、
};


2、v4l2层设置回掉函数列表

[cpp] view plain copy print ?
  1. Static struct videobuf_queue_ops vip_video_qops = { 
  2. .buf_setup   = buffer_setbuf, 
  3. .buf_prepare  = buffer_prepare, 
  4. .buf_queue  = buffer_queue, 
  5. .buf_release  = buffer_release, 
  6. }  
Static struct videobuf_queue_ops vip_video_qops = {
 .buf_setup   = buffer_setbuf,
 .buf_prepare  = buffer_prepare,
 .buf_queue  = buffer_queue,
 .buf_release  = buffer_release,
}


三、函数调用关系分析
1、请求视频流缓冲区
/*Request video streaming buffer memory VIDIOC_REABUFS*/
v4l2_vip.c
A、vip_reqbufs

[cpp] view plain copy print ?
  1. static int vip_reqbufs(struct file *file, void *priv, 
  2.           struct v4l2_requestbuffers *p) 
  3. { 
  4. struct vip_fh *fh = priv; 
  5.  
  6. return (videobuf_reqbufs(&fh->vb_vidq, p)); 
  7. }  
static int vip_reqbufs(struct file *file, void *priv,
          struct v4l2_requestbuffers *p)
{
 struct vip_fh *fh = priv;

 return (videobuf_reqbufs(&fh->vb_vidq, p));
}


Videobuf-core.c
请求缓冲区，主要是给
B、videobuf_reqbufs

[cpp] view plain copy print ?
  1. int videobuf_reqbufs(struct videobuf_queue *q, struct v4l2_requestbuffers *req) 
  2. { 
  3. unsigned int size, count; 
  4. int retval; 
  5.  
  6. ？略过参数检测？ 
  7.   
  8. count = req->count; 
  9. if (count > VIDEO_MAX_FRAME) 
  10.   count = VIDEO_MAX_FRAME; 
  11. size = 0; 
  12. 调用v4l2驱动实现的参数这只函数buffer大小参数 
  13. q->ops->buf_setup(q, &count, &size); 
  14. size = PAGE_ALIGN(size);//和下一页对其 
  15. dprintk(1, "reqbufs: bufs=%d, size=0x%x [%d pages total]\n", 
  16.   count, size, (count*size)>>PAGE_SHIFT); 
  17. //分配缓冲区并返回实际分配的缓冲区个数 
  18. retval = __videobuf_mmap_setup(q, count, size, req->memory); 
  19. if (retval < 0) { 
  20.   dprintk(1, "reqbufs: mmap setup returned %d\n", retval); 
  21.   goto done; 
  22. } 
  23. req->count = retval; 
  24. retval = 0; 
  25. 、、、、、、 
  26. }  
int videobuf_reqbufs(struct videobuf_queue *q, struct v4l2_requestbuffers *req)
{
 unsigned int size, count;
 int retval;

 ？略过参数检测？
 
count = req->count;
 if (count > VIDEO_MAX_FRAME)
  count = VIDEO_MAX_FRAME;
 size = 0;
 调用v4l2驱动实现的参数这只函数buffer大小参数
 q->ops->buf_setup(q, &count, &size);
 size = PAGE_ALIGN(size);//和下一页对其
 dprintk(1, "reqbufs: bufs=%d, size=0x%x [%d pages total]\n",
  count, size, (count*size)>>PAGE_SHIFT);
//分配缓冲区并返回实际分配的缓冲区个数
 retval = __videobuf_mmap_setup(q, count, size, req->memory);
 if (retval < 0) {
  dprintk(1, "reqbufs: mmap setup returned %d\n", retval);
  goto done;
 }
 req->count = retval;
 retval = 0;
、、、、、、
}


C、__videobuf_mmap_setup

[cpp] view plain copy print ?
  1. /* Locking: Caller holds q->vb_lock */ 
  2. int __videobuf_mmap_setup(struct videobuf_queue *q, 
  3.    unsigned int bcount, unsigned int bsize, enum v4l2_memory memory) 
  4. { 
  5. unsigned int i; 
  6. int err; 
  7.  
  8. MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 
  9. //清空之前用的videobuf缓冲区 
  10. err = __videobuf_mmap_free(q); 
  11. if (0 != err) 
  12.   return err; 
  13.  
  14. /* Allocate and initialize buffers */ 
  15. for (i = 0; i < bcount; i++) { 
  16.   q->bufs[i] = videobuf_alloc(q);//分配bcount个struct videobuf_buffer 
  17.   if (q->bufs[i] == NULL) 
  18.    break; 
  19. //初始化基本的参数 
  20.   q->bufs[i]->i      = i; 
  21.   q->bufs[i]->input  = UNSET; 
  22.   q->bufs[i]->memory = memory; 
  23.   q->bufs[i]->bsize  = bsize; 
  24.   switch (memory) { 
  25.   case V4L2_MEMORY_MMAP: 
  26.    q->bufs[i]->boff  = bsize * i; 
  27.    break; 
  28.   case V4L2_MEMORY_USERPTR: 
  29.   case V4L2_MEMORY_OVERLAY: 
  30.    /* nothing */ 
  31.    break; 
  32.   } 
  33. } 
  34.  
  35. if (!i) 
  36.   return -ENOMEM; 
  37.  
  38. dprintk(1, "mmap setup: %d buffers, %d bytes each\n", 
  39.   i, bsize); 
  40.  
  41. return i; 
  42. }  
/* Locking: Caller holds q->vb_lock */
int __videobuf_mmap_setup(struct videobuf_queue *q,
   unsigned int bcount, unsigned int bsize, enum v4l2_memory memory)
{
 unsigned int i;
 int err;

 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
//清空之前用的videobuf缓冲区
 err = __videobuf_mmap_free(q);
 if (0 != err)
  return err;

 /* Allocate and initialize buffers */
 for (i = 0; i < bcount; i++) {
  q->bufs[i] = videobuf_alloc(q);//分配bcount个struct videobuf_buffer
  if (q->bufs[i] == NULL)
   break;
//初始化基本的参数
  q->bufs[i]->i      = i;
  q->bufs[i]->input  = UNSET;
  q->bufs[i]->memory = memory;
  q->bufs[i]->bsize  = bsize;
  switch (memory) {
  case V4L2_MEMORY_MMAP:
   q->bufs[i]->boff  = bsize * i;
   break;
  case V4L2_MEMORY_USERPTR:
  case V4L2_MEMORY_OVERLAY:
   /* nothing */
   break;
  }
 }

 if (!i)
  return -ENOMEM;

 dprintk(1, "mmap setup: %d buffers, %d bytes each\n",
  i, bsize);

 return i;
}


D、videobuf_alloc

[cpp] view plain copy print ?
  1. void *videobuf_alloc(struct videobuf_queue *q) 
  2. { 
  3. struct videobuf_buffer *vb; 
  4.  
  5. BUG_ON(q->msize < sizeof(*vb)); 
  6.  
  7. if (!q->int_ops || !q->int_ops->alloc) { 
  8.   printk(KERN_ERR "No specific ops defined!\n"); 
  9.   BUG(); 
  10. } 
  11. vb = q->int_ops->alloc(q->msize); 
  12. if (NULL != vb) { 
  13.   init_waitqueue_head(&vb->done);//初始化videobuf缓冲区中的等待队列 
  14.   vb->magic     = MAGIC_BUFFER; 
  15. } 
  16.  
  17. return vb; 
  18. } 
  19.  
  20. 在videobuf-vmalloc.c中 
  21. /* ---------------------------------------------------------------------
  22. * vmalloc handlers for the generic methods
  23. /* Allocated area consists on 3 parts:
  24. struct video_buffer
  25. struct <driver>_buffer (cx88_buffer, saa7134_buf, ...)
  26. struct videobuf_dma_sg_memory
  27. */ 
  28.  
  29.    
void *videobuf_alloc(struct videobuf_queue *q)
{
 struct videobuf_buffer *vb;

 BUG_ON(q->msize < sizeof(*vb));

 if (!q->int_ops || !q->int_ops->alloc) {
  printk(KERN_ERR "No specific ops defined!\n");
  BUG();
 }
 vb = q->int_ops->alloc(q->msize);
 if (NULL != vb) {
  init_waitqueue_head(&vb->done);//初始化videobuf缓冲区中的等待队列
  vb->magic     = MAGIC_BUFFER;
 }

 return vb;
}

在videobuf-vmalloc.c中
/* ---------------------------------------------------------------------
 * vmalloc handlers for the generic methods
/* Allocated area consists on 3 parts:
 struct video_buffer
 struct <driver>_buffer (cx88_buffer, saa7134_buf, ...)
 struct videobuf_dma_sg_memory
 */


E、__videobuf_alloc
分配缓冲区的内存空间

[cpp] view plain copy print ?
  1. static void *__videobuf_alloc(size_t size) 
  2. { 
  3. struct videobuf_vmalloc_memory *mem; 
  4. struct videobuf_buffer *vb; 
  5. //给上边两个数据结构分配空间，size是在open()函数中初始化videobuf时传进来的最顶层的包含videobuf_buffer的设备数据结构体的大小，所以该设备结构体的第一个成员就要是videobuf_buffer。 
  6. vb = kzalloc(size+sizeof(*mem),GFP_KERNEL); 
  7.  
  8. //注意vb->priv是硬件视频数据到用户空间的中转缓冲区 
  9. mem = vb->priv = ((char *)vb)+size; 
  10. mem->magic=MAGIC_VMAL_MEM; 
  11.  
  12. dprintk(1,"%s: allocated at %p(%ld+%ld) & %p(%ld)\n", 
  13.   __func__,vb,(long)sizeof(*vb),(long)size-sizeof(*vb), mem,(long)sizeof(*mem)); 
  14.  
  15. //返回分配的struct videobuf_buffer结构体指针 
  16. return vb; 
  17. }  
static void *__videobuf_alloc(size_t size)
{
 struct videobuf_vmalloc_memory *mem;
 struct videobuf_buffer *vb;
//给上边两个数据结构分配空间，size是在open()函数中初始化videobuf时传进来的最顶层的包含videobuf_buffer的设备数据结构体的大小，所以该设备结构体的第一个成员就要是videobuf_buffer。
 vb = kzalloc(size+sizeof(*mem),GFP_KERNEL);

//注意vb->priv是硬件视频数据到用户空间的中转缓冲区
 mem = vb->priv = ((char *)vb)+size;
 mem->magic=MAGIC_VMAL_MEM;

 dprintk(1,"%s: allocated at %p(%ld+%ld) & %p(%ld)\n",
  __func__,vb,(long)sizeof(*vb),(long)size-sizeof(*vb), mem,(long)sizeof(*mem));

//返回分配的struct videobuf_buffer结构体指针
 return vb;
}


2、获取指定缓冲区的属性
应用程序通过VIDIOC_QUERYBUF ioctl()命令获取上边分配的缓冲区的一些属性，一边将其mmap到用户空间。
A、vip_querybuf

[cpp] view plain copy print ?
  1. static int vip_querybuf(struct file *file, void *priv, struct v4l2_buffer *p) 
  2. { 
  3. struct vip_fh *fh = priv; 
  4.  
  5. return (videobuf_querybuf(&fh->vb_vidq, p)); 
  6. } 
  7.  
  8. B、videobuf_querybuf 
  9. Int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b) 
  10. { 
  11. int ret = -EINVAL; 
  12.  
  13. mutex_lock(&q->vb_lock); 
  14. //参数检测 
  15. 、、、、、 
  16.  
  17. //获取指定videobuf_buffer的一些信息，b->index是应用程序传过来的 
  18. videobuf_status(q, b, q->bufs[b->index], q->type); 
  19.  
  20. ret = 0; 
  21. done: 
  22. mutex_unlock(&q->vb_lock); 
  23. return ret; 
  24. }  
static int vip_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
{
 struct vip_fh *fh = priv;

 return (videobuf_querybuf(&fh->vb_vidq, p));
}

B、videobuf_querybuf
Int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b)
{
 int ret = -EINVAL;

 mutex_lock(&q->vb_lock);
//参数检测
、、、、、

//获取指定videobuf_buffer的一些信息，b->index是应用程序传过来的
 videobuf_status(q, b, q->bufs[b->index], q->type);

 ret = 0;
done:
 mutex_unlock(&q->vb_lock);
 return ret;
}


C、videobuf_status
把videobuf_buffer数据成员拷贝到v4l2_buffer的数据中

[cpp] view plain copy print ?
  1. /* Locking: Caller holds q->vb_lock */ 
  2. static void videobuf_status(struct videobuf_queue *q, struct v4l2_buffer *b, 
  3.        struct videobuf_buffer *vb, enum v4l2_buf_type type) 
  4. { 
  5. MAGIC_CHECK(vb->magic, MAGIC_BUFFER); 
  6. MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 
  7.  
  8. b->index    = vb->i; 
  9. b->type     = type; 
  10.  
  11. b->memory   = vb->memory; 
  12. switch (b->memory) { 
  13. case V4L2_MEMORY_MMAP: 
  14.   b->m.offset  = vb->boff; 
  15.   b->length    = vb->bsize; 
  16.   break; 
  17. case V4L2_MEMORY_USERPTR: 
  18.   b->m.userptr = vb->baddr; 
  19.   b->length    = vb->bsize; 
  20.   break; 
  21. case V4L2_MEMORY_OVERLAY: 
  22.   b->m.offset  = vb->boff; 
  23.   break; 
  24. } 
  25.  
  26. b->flags    = 0; 
  27. if (vb->map) 
  28.   b->flags |= V4L2_BUF_FLAG_MAPPED; 
  29.  
  30. switch (vb->state) { 
  31. case VIDEOBUF_PREPARED: 
  32. case VIDEOBUF_QUEUED: 
  33. case VIDEOBUF_ACTIVE: 
  34.   b->flags |= V4L2_BUF_FLAG_QUEUED; 
  35.   break; 
  36. case VIDEOBUF_DONE: 
  37. case VIDEOBUF_ERROR: 
  38.   b->flags |= V4L2_BUF_FLAG_DONE; 
  39.   break; 
  40. case VIDEOBUF_NEEDS_INIT: 
  41. case VIDEOBUF_IDLE: 
  42.   /* nothing */ 
  43.   break; 
  44. } 
  45.  
  46. if (vb->input != UNSET) { 
  47.   b->flags |= V4L2_BUF_FLAG_INPUT; 
  48.   b->input  = vb->input; 
  49. } 
  50.  
  51. b->field     = vb->field; 
  52. b->timestamp = vb->ts; 
  53. b->bytesused = vb->size; 
  54. b->sequence  = vb->field_count >> 1; 
  55. }  
/* Locking: Caller holds q->vb_lock */
static void videobuf_status(struct videobuf_queue *q, struct v4l2_buffer *b,
       struct videobuf_buffer *vb, enum v4l2_buf_type type)
{
 MAGIC_CHECK(vb->magic, MAGIC_BUFFER);
 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);

 b->index    = vb->i;
 b->type     = type;

 b->memory   = vb->memory;
 switch (b->memory) {
 case V4L2_MEMORY_MMAP:
  b->m.offset  = vb->boff;
  b->length    = vb->bsize;
  break;
 case V4L2_MEMORY_USERPTR:
  b->m.userptr = vb->baddr;
  b->length    = vb->bsize;
  break;
 case V4L2_MEMORY_OVERLAY:
  b->m.offset  = vb->boff;
  break;
 }

 b->flags    = 0;
 if (vb->map)
  b->flags |= V4L2_BUF_FLAG_MAPPED;

 switch (vb->state) {
 case VIDEOBUF_PREPARED:
 case VIDEOBUF_QUEUED:
 case VIDEOBUF_ACTIVE:
  b->flags |= V4L2_BUF_FLAG_QUEUED;
  break;
 case VIDEOBUF_DONE:
 case VIDEOBUF_ERROR:
  b->flags |= V4L2_BUF_FLAG_DONE;
  break;
 case VIDEOBUF_NEEDS_INIT:
 case VIDEOBUF_IDLE:
  /* nothing */
  break;
 }

 if (vb->input != UNSET) {
  b->flags |= V4L2_BUF_FLAG_INPUT;
  b->input  = vb->input;
 }

 b->field     = vb->field;
 b->timestamp = vb->ts;
 b->bytesused = vb->size;
 b->sequence  = vb->field_count >> 1;
}


上边函数是应用程序调用获取之前分配video buffer的长度和偏移量，用来应用程序映射该buffer到用户空间

3、将申请的缓冲区放到视频采集输入/输出队列
A、vip_qbuf

[cpp] view plain copy print ?
  1. /* Queue video memory buffer VIDIOC_QBUF*/ 
  2. static int vip_qbuf(struct file *file, viod *priv, struct v4l2_buffer *p) 
  3. { 
  4. struct vip_fh *fh = priv; 
  5. return (videobuf_qbuf(&fh->vb_vidq, p)); 
  6. }  
/* Queue video memory buffer VIDIOC_QBUF*/
static int vip_qbuf(struct file *file, viod *priv, struct v4l2_buffer *p)
{
 struct vip_fh *fh = priv;
 return (videobuf_qbuf(&fh->vb_vidq, p));
}


B、videobuf_qbuf
//每一个分配的缓冲区都要执行这个函数

[cpp] view plain copy print ?
  1. int videobuf_qbuf(struct videobuf_queue *q, 
  2.        struct v4l2_buffer *b) 
  3. { 
  4. struct videobuf_buffer *buf; 
  5. enum v4l2_field field; 
  6. unsigned long flags = 0; 
  7. int retval; 
  8.  
  9. MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 
  10. //略过加锁，参数以及运行状态检测 
  11. 、、、、、、、、、、、、、、、、、 
  12. buf = q->bufs[b->index];//index由应用程序指定 
  13.   
  14. switch (b->memory) { 
  15. case V4L2_MEMORY_MMAP: 
  16.   if (0 == buf->baddr) { 
  17.    dprintk(1, "qbuf: mmap requested " 
  18.        "but buffer addr is zero!\n"); 
  19.    goto done; 
  20.   } 
  21.   break; 
  22. case V4L2_MEMORY_USERPTR: 
  23.   if (b->length < buf->bsize) { 
  24.    dprintk(1, "qbuf: buffer length is not enough\n"); 
  25.    goto done; 
  26.   } 
  27.   if (VIDEOBUF_NEEDS_INIT != buf->state && 
  28.       buf->baddr != b->m.userptr) 
  29.    q->ops->buf_release(q, buf); 
  30.   buf->baddr = b->m.userptr; 
  31.   break; 
  32. case V4L2_MEMORY_OVERLAY: 
  33.   buf->boff = b->m.offset; 
  34.   break; 
  35. default: 
  36.   dprintk(1, "qbuf: wrong memory type\n"); 
  37.   goto done; 
  38. } 
  39.  
  40. dprintk(1, "qbuf: requesting next field\n"); 
  41. field = videobuf_next_field(q);//根据当前的场，得到下一个场域 
  42. retval = q->ops->buf_prepare(q, buf, field);//设置缓冲区的参数 
  43. if (0 != retval) { 
  44.   dprintk(1, "qbuf: buffer_prepare returned %d\n", retval); 
  45.   goto done; 
  46. } 
  47.  
  48. list_add_tail(&buf->stream, &q->stream);//将该缓冲区添加到输出队列中 
  49. if (q->streaming) { 
  50.   spin_lock_irqsave(q->irqlock, flags); 
  51.   q->ops->buf_queue(q, buf); 
  52.   spin_unlock_irqrestore(q->irqlock, flags); 
  53. } 
  54. dprintk(1, "qbuf: succeded\n"); 
  55. retval = 0; 
  56. wake_up_interruptible_sync(&q->wait); 
  57.  
  58. done: 
  59. mutex_unlock(&q->vb_lock); 
  60.  
  61. if (b->memory == V4L2_MEMORY_MMAP) 
  62.   up_read(¤t->mm->mmap_sem); 
  63.  
  64. return retval; 
  65. }  
int videobuf_qbuf(struct videobuf_queue *q,
       struct v4l2_buffer *b)
{
 struct videobuf_buffer *buf;
 enum v4l2_field field;
 unsigned long flags = 0;
 int retval;

 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
//略过加锁，参数以及运行状态检测
、、、、、、、、、、、、、、、、、
 buf = q->bufs[b->index];//index由应用程序指定
 
 switch (b->memory) {
 case V4L2_MEMORY_MMAP:
  if (0 == buf->baddr) {
   dprintk(1, "qbuf: mmap requested "
       "but buffer addr is zero!\n");
   goto done;
  }
  break;
 case V4L2_MEMORY_USERPTR:
  if (b->length < buf->bsize) {
   dprintk(1, "qbuf: buffer length is not enough\n");
   goto done;
  }
  if (VIDEOBUF_NEEDS_INIT != buf->state &&
      buf->baddr != b->m.userptr)
   q->ops->buf_release(q, buf);
  buf->baddr = b->m.userptr;
  break;
 case V4L2_MEMORY_OVERLAY:
  buf->boff = b->m.offset;
  break;
 default:
  dprintk(1, "qbuf: wrong memory type\n");
  goto done;
 }

 dprintk(1, "qbuf: requesting next field\n");
 field = videobuf_next_field(q);//根据当前的场，得到下一个场域
 retval = q->ops->buf_prepare(q, buf, field);//设置缓冲区的参数
 if (0 != retval) {
  dprintk(1, "qbuf: buffer_prepare returned %d\n", retval);
  goto done;
 }

 list_add_tail(&buf->stream, &q->stream);//将该缓冲区添加到输出队列中
 if (q->streaming) {
  spin_lock_irqsave(q->irqlock, flags);
  q->ops->buf_queue(q, buf);
  spin_unlock_irqrestore(q->irqlock, flags);
 }
 dprintk(1, "qbuf: succeded\n");
 retval = 0;
 wake_up_interruptible_sync(&q->wait);

 done:
 mutex_unlock(&q->vb_lock);

 if (b->memory == V4L2_MEMORY_MMAP)
  up_read(¤t->mm->mmap_sem);

 return retval;
}


4、从输出队列取出已含有采集数据的帧缓冲区
A、vip_dqbuf

[cpp] view plain copy print ?
  1. /*Transfer buffers beween incoming and outgoing queue VIDIOC_DQBUF*/ 
  2. static int vip_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p) 
  3. { 
  4. struct vip_fh *fh = priv; 
  5. return (videobuf_dqbuf(&fh->vb_vidq, p, file->f_flags & O_NONBLOCK)); 
  6. }  
/*Transfer buffers beween incoming and outgoing queue VIDIOC_DQBUF*/
static int vip_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
{
 struct vip_fh *fh = priv;
 return (videobuf_dqbuf(&fh->vb_vidq, p, file->f_flags & O_NONBLOCK));
}


B、videobuf_dqbuf

[cpp] view plain copy print ?
  1. int videobuf_dqbuf(struct videobuf_queue *q, 
  2.         struct v4l2_buffer *b, int nonblocking) 
  3. { 
  4. struct videobuf_buffer *buf = NULL; 
  5. int retval; 
  6.  
  7. MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 
  8.  
  9. mutex_lock(&q->vb_lock); 
  10.  
  11. //获取下一个已近填充视频数据的缓冲区 
  12. retval = stream_next_buffer(q, &buf, nonblocking); 
  13. if (retval < 0) { 
  14.   dprintk(1, "dqbuf: next_buffer error: %i\n", retval); 
  15.   goto done; 
  16. } 
  17. //略过buf->state处理 
  18. 、、、、、、 
  19. } 
  20. list_del(&buf->stream);//将该缓冲区从链表中删除，使其处于用户状态 
  21. memset(b, 0, sizeof(*b)); 
  22. videobuf_status(q, b, buf, q->type); 
  23.  
  24. done: 
  25. mutex_unlock(&q->vb_lock); 
  26. return retval; 
  27. }  
int videobuf_dqbuf(struct videobuf_queue *q,
        struct v4l2_buffer *b, int nonblocking)
{
 struct videobuf_buffer *buf = NULL;
 int retval;

 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);

 mutex_lock(&q->vb_lock);

//获取下一个已近填充视频数据的缓冲区
 retval = stream_next_buffer(q, &buf, nonblocking);
 if (retval < 0) {
  dprintk(1, "dqbuf: next_buffer error: %i\n", retval);
  goto done;
 }
//略过buf->state处理
、、、、、、
 }
 list_del(&buf->stream);//将该缓冲区从链表中删除，使其处于用户状态
 memset(b, 0, sizeof(*b));
 videobuf_status(q, b, buf, q->type);

 done:
 mutex_unlock(&q->vb_lock);
 return retval;
}


C、stream_next_buffer
如果输出队列中有视频数据的缓冲区，并且缓冲区的状态正常，那么就返回该缓冲区

[cpp] view plain copy print ?
  1. /* Locking: Caller holds q->vb_lock */ 
  2. static int stream_next_buffer(struct videobuf_queue *q, 
  3.    struct videobuf_buffer **vb, int nonblocking) 
  4. { 
  5. int retval; 
  6. struct videobuf_buffer *buf = NULL; 
  7.  
  8. retval = stream_next_buffer_check_queue(q, nonblocking); 
  9. if (retval) 
  10.   goto done; 
  11.   
  12. //得到输出队列中第一个有视频数据的缓冲区 
  13. buf = list_entry(q->stream.next, struct videobuf_buffer, stream); 
  14. retval = videobuf_waiton(buf, nonblocking, 1); 
  15. if (retval < 0) 
  16.   goto done; 
  17.  
  18. *vb = buf;//正常返回该缓冲区 
  19. done: 
  20. return retval; 
  21. }  
/* Locking: Caller holds q->vb_lock */
static int stream_next_buffer(struct videobuf_queue *q,
   struct videobuf_buffer **vb, int nonblocking)
{
 int retval;
 struct videobuf_buffer *buf = NULL;

 retval = stream_next_buffer_check_queue(q, nonblocking);
 if (retval)
  goto done;
 
//得到输出队列中第一个有视频数据的缓冲区
 buf = list_entry(q->stream.next, struct videobuf_buffer, stream);
 retval = videobuf_waiton(buf, nonblocking, 1);
 if (retval < 0)
  goto done;

 *vb = buf;//正常返回该缓冲区
done:
 return retval;
}


D、stream_next_buffer_check_queue
这个函数的功能就是检测是否开始队列中视频数据流的传输（q->streaming），如果没有，就返回负的错误吗。如果开始传输，再判断输出队列中是否有缓冲区，有的话正常返回0，否则根据阻塞标志看是返回错误码还是阻塞等待输出队列缓冲区。

[cpp] view plain copy print ?
  1. /* Locking: Caller holds q->vb_lock */ 
  2. static int stream_next_buffer_check_queue(struct videobuf_queue *q, int noblock) 
  3. { 
  4. int retval; 
  5.  
  6. checks: 
  7. if (!q->streaming) {//在stream on中置位1，意味着开始流数据传输 
  8.   dprintk(1, "next_buffer: Not streaming\n"); 
  9.   retval = -EINVAL; 
  10.   goto done; 
  11. } 
  12.  
  13. if (list_empty(&q->stream)) {//如果输出队列为空，则根据传入的阻塞标志看是否要等待 
  14.   if (noblock) {//如果是非阻塞的流处理，则直接返回 
  15.    retval = -EAGAIN; 
  16.    dprintk(2, "next_buffer: no buffers to dequeue\n"); 
  17.    goto done; 
  18.   } else {//如果是阻塞流处理，则是当前读取数据进程进入等待状态，当输出队列有缓冲区时唤醒该进程。 
  19.    dprintk(2, "next_buffer: waiting on buffer\n"); 
  20.  
  21.    /* Drop lock to avoid deadlock with qbuf */ 
  22.    mutex_unlock(&q->vb_lock); 
  23.  
  24. /* Checking list_empty and streaming is safe without locks because we goto checks to validate while  holding locks before proceeding */ 
  25. retval= 
  26. wait_event_interruptible(q->wait,!list_empty(&q->stream)|| !q->streaming); 
  27.    mutex_lock(&q->vb_lock); 
  28.  
  29.    if (retval) 
  30.     goto done; 
  31.  
  32.    goto checks; 
  33.   } 
  34. } 
  35. retval = 0; 
  36. done: 
  37. return retval; 
  38. }  
/* Locking: Caller holds q->vb_lock */
static int stream_next_buffer_check_queue(struct videobuf_queue *q, int noblock)
{
 int retval;

checks:
 if (!q->streaming) {//在stream on中置位1，意味着开始流数据传输
  dprintk(1, "next_buffer: Not streaming\n");
  retval = -EINVAL;
  goto done;
 }

 if (list_empty(&q->stream)) {//如果输出队列为空，则根据传入的阻塞标志看是否要等待
  if (noblock) {//如果是非阻塞的流处理，则直接返回
   retval = -EAGAIN;
   dprintk(2, "next_buffer: no buffers to dequeue\n");
   goto done;
  } else {//如果是阻塞流处理，则是当前读取数据进程进入等待状态，当输出队列有缓冲区时唤醒该进程。
   dprintk(2, "next_buffer: waiting on buffer\n");

   /* Drop lock to avoid deadlock with qbuf */
   mutex_unlock(&q->vb_lock);

/* Checking list_empty and streaming is safe without locks because we goto checks to validate while  holding locks before proceeding */
retval=
wait_event_interruptible(q->wait,!list_empty(&q->stream)|| !q->streaming);
   mutex_lock(&q->vb_lock);

   if (retval)
    goto done;

   goto checks;
  }
 }
 retval = 0;
done:
 return retval;
}



该函数用来判断视频缓冲区的状态是否在队列和激活，否则等待
E、videobuf_waiton

[cpp] view plain copy print ?
  1. #define WAITON_CONDITION (vb->state != VIDEOBUF_ACTIVE && vb->state != VIDEOBUF_QUEUED) 
  2. int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr) 
  3. { 
  4. MAGIC_CHECK(vb->magic, MAGIC_BUFFER); 
  5.  
  6. if (non_blocking) {//如果是非阻塞流操作操作 
  7.   if (WAITON_CONDITION)//并且等待条件满足 
  8.    return 0;//则正常返回 
  9.   else 
  10.    return -EAGAIN;//否则返回错误码 
  11. } 
  12. //如果是阻塞流操作，那么就会使该进程进入等待队列 
  13. if (intr) 
  14.   return wait_event_interruptible(vb->done, WAITON_CONDITION); 
  15. else 
  16.   wait_event(vb->done, WAITON_CONDITION); 
  17.  
  18. return 0; 
  19. }  
#define WAITON_CONDITION (vb->state != VIDEOBUF_ACTIVE && vb->state != VIDEOBUF_QUEUED)
int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr)
{
 MAGIC_CHECK(vb->magic, MAGIC_BUFFER);

 if (non_blocking) {//如果是非阻塞流操作操作
  if (WAITON_CONDITION)//并且等待条件满足
   return 0;//则正常返回
  else
   return -EAGAIN;//否则返回错误码
 }
//如果是阻塞流操作，那么就会使该进程进入等待队列
 if (intr)
  return wait_event_interruptible(vb->done, WAITON_CONDITION);
 else
  wait_event(vb->done, WAITON_CONDITION);

 return 0;
}



四、V4L2 层缓冲区参数设置：
1、buffer_setup

[cpp] view plain copy print ?
  1. static int buffer_setup(struct video_queue *vp, unsigned *count, 
  2.             unsigned int *size) 
  3. { 
  4. struct vip_fh    *fh = vq->priv_data; 
  5. struct vip_dev  *dev = fh->dev; 
  6.  
  7. *size = fh->width*fh->height*2;//两场odd/even 
  8.  
  9. if(0 == *count) 
  10.   *count = 32; 
  11. while(*size * *count > vid_limit * 1024 *1024);//最大缓冲区限制 
  12.   (*count)--; 
  13.  
  14. dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__, *count, *size); 
  15. return 0; 
  16. }  
static int buffer_setup(struct video_queue *vp, unsigned *count,
            unsigned int *size)
{
 struct vip_fh    *fh = vq->priv_data;
 struct vip_dev  *dev = fh->dev;

 *size = fh->width*fh->height*2;//两场odd/even

 if(0 == *count)
  *count = 32;
 while(*size * *count > vid_limit * 1024 *1024);//最大缓冲区限制
  (*count)--;

 dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__, *count, *size);
 return 0;
}


2、buffer_prepare

[cpp] view plain copy print ?
  1. static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb, 
  2.        rnum v4l2_field field) 
  3. { 
  4. struct vip_fh *fh = vq->priv_data;/*open set*/ 
  5. struct vip_dev *dev = fh->dev; 
  6. struct vip_buffer *buf = container_of(vb, struct vip_buffer, vb); 
  7. int rc; 
  8.  
  9. dprintk(dev, 1, "%s, field=%d\n", __func__, field); 
  10.  
  11. BUG_ON(NULL == fh->fmt); 
  12.  
  13. if(fh->width < NORM_MINW || fh->width > NORM_MAXW || 
  14.   fh->height < NORM_MINH || fh->height > NORM_MAXH) 
  15.    return -EINVAL; 
  16.  
  17. buf->vb.size = fh->width * fh->height * 2; 
  18. if(0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) 
  19.   return -EINVAL; 
  20.  
  21. //设置缓冲区的像素参数 
  22. buf->fmt   = fh->fmt; 
  23. buf->vb.width  = fh->width; 
  24. buf->vb.heignt  = fh->heignt; 
  25. buf->vb.filed  = fh->filed; 
  26.  
  27. //precalculate_bars(fh); 
  28.  
  29. if(VIDEOBUF_NEEDS_INIT == buf->vb.state){ 
  30.   rc = videobuf_iolock(vq, &buf->vb, NULL); 
  31.   if(rc < 0) 
  32.    goto fail; 
  33. } 
  34. buf->vb.state = VIDEOBUF_PREPARED; 
  35. return 0; 
  36.  
  37. fail: 
  38. free_buffer(vq, buf); 
  39. return rc; 
  40. }  
static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
       rnum v4l2_field field)
{
 struct vip_fh *fh = vq->priv_data;/*open set*/
 struct vip_dev *dev = fh->dev;
 struct vip_buffer *buf = container_of(vb, struct vip_buffer, vb);
 int rc;

 dprintk(dev, 1, "%s, field=%d\n", __func__, field);

 BUG_ON(NULL == fh->fmt);

 if(fh->width < NORM_MINW || fh->width > NORM_MAXW ||
  fh->height < NORM_MINH || fh->height > NORM_MAXH)
   return -EINVAL;

 buf->vb.size = fh->width * fh->height * 2;
 if(0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
  return -EINVAL;

 //设置缓冲区的像素参数
 buf->fmt   = fh->fmt;
 buf->vb.width  = fh->width;
 buf->vb.heignt  = fh->heignt;
 buf->vb.filed  = fh->filed;

 //precalculate_bars(fh);

 if(VIDEOBUF_NEEDS_INIT == buf->vb.state){
  rc = videobuf_iolock(vq, &buf->vb, NULL);
  if(rc < 0)
   goto fail;
 }
 buf->vb.state = VIDEOBUF_PREPARED;
 return 0;

fail:
 free_buffer(vq, buf);
 return rc;
}


3、buffer_queue

[cpp] view plain copy print ?
  1. static void buffer_queue (struct videobuf_queue *vq, struct videobuf_buffer *vb) 
  2. { 
  3. struct vip_buffer  *buf  = container(vb, struct vip_buffer, vb); 
  4. struct vip_fh   *fh   = vq->priv_data; 
  5. struct vip_dev   *dev  = fh->dev; 
  6. struct vip_damqueue  *vdq  = &dev->vidq; 
  7.  
  8. dprintk(dev, 1, "%s\n, __func__"); 
  9.  
  10. buf->vb.state = VIDEOBUF_QUEUED; 
  11. list_add_tail(&buf->vb.queue, &vdq->active);//添加缓冲区到DMA链表 
  12. }  
static void buffer_queue (struct videobuf_queue *vq, struct videobuf_buffer *vb)
{
 struct vip_buffer  *buf  = container(vb, struct vip_buffer, vb);
 struct vip_fh   *fh   = vq->priv_data;
 struct vip_dev   *dev  = fh->dev;
 struct vip_damqueue  *vdq  = &dev->vidq;

 dprintk(dev, 1, "%s\n, __func__");

 buf->vb.state = VIDEOBUF_QUEUED;
 list_add_tail(&buf->vb.queue, &vdq->active);//添加缓冲区到DMA链表
}


[cpp] view plain copy print ?
  1. enum videobuf_state{ 
  2. VIDEOBUF_DEDDS_INIT = 0   realse_buffer() 
  3. VIDEOBUF_PREPARED  = 1   buffer_prepare() 
  4. VIDEOBUF_QUEUE  = 2   buffer_queue() 
  5. VIDEOBUF_ACTIVE  = 3 
  6. VIDEOBUF_DONE   = 4   fillbuff()->wake_up(&buf->vb.done) 
  7. VIDEOBUF_ERROR  = 5 
  8. VIDEOBUF_IDLE   = 6 
  9. } 
  10. 应用程序的调用过程： 
  11. 1、 reqbufs() -> buf_setup() 
  12.  
  13. 2、 querybuf()->videobuf_status() 
  14.  
  15. 3、 qbuf()->buf_prepare() 
  16.  
  17. 4、 streamon()->buf_queue() 
  18. wake_up_interruptible_sysc(&q->wait) 
  19.  
  20. 5、 dqbuf()->stream_next_buffer()->stream_next_buffer_check_queue() 
  21.  
  22. 6、 qbuf()->buf_prepare()->buf_queue() 
  23.  
  24.   
yingxian_Fei
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解linux内核v4l2框架之videobuf
Qiang的专栏
12-27 2万+
Videobuf 下面来介绍以下videobuffer相关的一些东西。 V4L2核心api提供了一套标准的方法来处理视频缓冲，这些方法允许驱动实现read(),mmap(), overlay()等操作。同样也有方法支持DMA的scatter/gather操作，并且支持vmallocbuffer(这个大多用在USB驱动上)。 videobuf层功能是一种在v4l2驱动和用户空间当中的依
V4L2视频采集程序框架
11-13
VIDEOBUF 部分负责视频数据的捕获和处理，而 CONTROL 部分负责视频设备的控制和管理。 2. ioctl 函数 ioctl 函数是 Linux 编程中的一种标准函数，用于对设备的 I/O 通道进行管理。在 V4L2 中，ioctl 函数用于对...
V4L2源代码之旅九：videobuf
嵌入式开发专栏
11-16 858
转自：http://www.cnblogs.com/ronnydm/p/5796928.html 　关于videobuf，即V4L2如何实现高性能的和用户空间的Buffer交互，这部分内容应该是V4L2中最难以理解的部分了。 　　看文档：kernel/Documentation/video4linux/videobuf. 　　videobuf的功能是V4L2 driver和u
v4l2 视频传输
iotplan.com 物联网技术专栏
09-23 1535
 关于Linux的视频编程(v4l2编程) 一.什么是video4linuxVideo4linux2（简称V4L2),是linux中关于视频设备的内核驱动。在Linux中，视频设备是设备文件，可以像访问普通文件一样对其进行读写，摄像头在/dev/video0下。二、一般操作流程（视频设备）：1. 打开设备文件。 int fd=open(”
linux视频驱动之videobuf
奋斗
07-01 4620
下面是Linux内核文档中的一篇---videobuf的翻译，只是大概意思的翻译，有不对的地方请指正。 欢迎转载，转载请注明出处。 An introduction to the videobuf layer Jonathan Corbet  Current as of 2.6.33 The videobuf layer functions as a sort of glue
2.2.14 Videobuf Framework
u012906122的专栏
06-24 143
典型的驱动程序`read()`实现将启动捕获引擎，在调用上述函数之前，然后在返回之前停止引擎（尽管更智能的实现可能会预期在不久的将来发生另一个`read()`调用，并保持引擎运行一段时间）。例如，对于`VIDIOC_REQBUFS`调用，将转换为对驱动程序的`vidioc_reqbufs()`回调函数的调用，该回调通常只需要找到正确的`struct videobuf_queue`指针并将其传递给`videobuf_reqbufs()`函数。第一步是在`open()`函数中初始化`videobuf`队列。
V4L2框架-videobuf2
热门推荐
YellowMax
07-15 1万+
阅读原文 本文介绍在 v4l2 框架之下的数据流交互的实现与使用，主要目的是实现一个能够进行用户空间与内核空间进行数据交互、数据流格式设置、数据流 buffer 申请与释放、数据流开启与关闭的 video 设备驱动。 02 - V4L2框架-media-device 01 - V4L2框架-v4l2 device 00 - V4L2框架概述 简介 videobuf2 用于连...
videobuf-vmalloc.rar_Capture
09-23
- Videobuf包括一系列的宏和函数，比如`videobuf_queue_dma_buf`、`videobuf_to_vmalloc`等，这些工具帮助驱动开发者高效地处理video buffer。 4. **videobuf-vmalloc.c和videobuf-vmalloc.h**： - `videobuf-...
V4L2-struct.rar_v4l2
09-20
此枚举类型定义了缓冲区的类型，如VIDEOBUF_TYPE_GRABBER表示图像采集，VIDEOBUF_TYPE_OUTPUT表示视频输出。 4. **v4l2_format** 这个结构体定义了视频流的格式，包括像素格式（如YUV、RGB等）、宽度、高度、帧率...
V4L2源代码之旅十：videobuf主要结构体
嵌入式开发专栏
11-16 938
转自：http://www.cnblogs.com/ronnydm/p/5815977.html 1. vb2_mem_ops /** * struct vb2_mem_ops - memory handling/memory allocator operations * @alloc: allocate video memory and, optionally, a
基于Linux的v4l2视频架构驱动编写(三)
eilianlau
12-24 2771
基于Linux的v4l2视频架构驱动编写，控制命令VIDIOC_QUERYBUF，功能： 查询已经分配的V4L2的视频缓冲区的相关信息，包括视频缓冲区的使用状态、在内核空间的偏移地址、缓冲区长度等。在应用程序设计中通过调VIDIOC_QUERYBUF来获取内核空间的视频缓冲区信息 5. 控制命令VIDIOC_QUERYBUF 功能： 查询已经分配的V4L2的视频缓冲区的相关信息，包括视频缓
摄像头V4L2编程应用开发
weixin_46571142的博客
01-16 1785
1.V4L2简介 Video for Linux two(Video4Linux2)简称V4L2，是V4L的改进版。V4L2是linux系统操作系统下一套用于采集图片、视频、和音视频数据的通用API接口，配合适当的视频采集设备和相应的驱动程序，可以实现图片、视频、音频等的采集。 在linux中，一切皆文件，所有外设都被看做是一种特殊的文件，成为“设备文件”。视频设备可以看做是设备文件，可以像访问普通文件一样对其进行读写。 V4L2驱动的摄像头的设备文件一般是/dev/videoX(X为任意数字，要与自己的设
v4l2 vivi驱动分析
River的专栏
12-26 1037
v4l2驱动框架相对还是挺复杂的, 最好的参考例子有 v4l2-pci-skeleton.c 和 vivi (Virtual Video) 其中vivi在最新的Linux 4.xx版本也变得非常复杂。 所以采用Linux-3.16.74版本作为学习... 1. 该版本没有使用platform_driver框架, 故模块初始化入口函数vivi_init直接进行video设备的注册...
摄像头驱动--V4L2框架
qq_42230338的博客
08-06 1113
简单的字符设备驱动的框架 复杂的字符设备驱动程序框架 采用分层的思想，例如前面学习的LCD驱动程序，内核已经将构造file_operation结构体，注册字符设备驱动register_chrdevd， 入口函数、出口函数这些有共性的部分都已经抽离出来了，形成的fbmem.c这样的文件，也就是核心层的代码部分，所有的frambuffer设备都可以在此基础上完成驱动的设计。这样一来对于LCD驱动就...
从vivi学习V4L2架构(七):申请的缓冲帧从内核空间映射到用户空间
11-21 631
从vivi学习V4L2架构(七):申请的缓冲帧从内核空间映射到用户空间，对应驱动层的调用流程
videobuf2_v4l2
最新发布
07-28
videobuf2_v4l2是一个Linux内核驱动程序，用于视频缓冲区管理和视频设备的V4L2（Video for Linux 2）子系统之间的交互。它提供了一种机制，使用户空间应用程序能够通过V4L2 API与视频设备进行通信，并在内核中管理视频帧的缓冲区。 videobuf2_v4l2通过定义结构体和函数来实现视频缓冲区的管理。它使用V4L2框架中的队列和缓冲区分配器来处理视频帧的传输和处理。该驱动程序还提供了一些函数，用于在用户空间和内核空间之间进行缓冲区的传输和管理。 使用videobuf2_v4l2，开发人员可以轻松地实现视频采集、视频编码、视频解码等功能，并将其集成到他们的应用程序中。 总之，videobuf2_v4l2是一个用于视频缓冲区管理和V4L2子系统交互的Linux内核驱动程序。它为开发人员提供了一种方便的方式来处理视频帧的传输和管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值