videobuf处理流程

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

 

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

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

一、 初始化

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

[cpp] view plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

1. static conststruct 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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

1. /* Locking: Caller holds q->vb_lock */ 
2. int __videobuf_mmap_setup(struct videobuf_queue *q, 
3.    unsigned int bcount, unsignedint 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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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_querybufInt 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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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 plaincopyprint?

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.