V4L2深入理解

最新推荐文章于 2021-04-13 11:57:36 发布

波涛汹涌啊

最新推荐文章于 2021-04-13 11:57:36 发布

阅读量1.5k

点赞数

本文链接：https://blog.csdn.net/hddghhfd/article/details/86713209

版权

1. VIDIOC_REQBUFS: 请求Kernel分配Video Buffer

其申请流程如下图所示：

1.1 Kernel态相关数据结构

struct uvc_fh { struct uvc_video_chain *chain; struct uvc_streaming *stream;  //Stream---> enum uvc_handle_state state;};struct uvc_streaming { struct list_head list; struct uvc_device *dev; struct video_device *vdev; struct uvc_video_chain *chain; atomic_t active; struct usb_interface *intf; int intfnum; __u16 maxpsize; struct uvc_streaming_header header; enum v4l2_buf_type type; unsigned int nformats; struct uvc_format *format; struct uvc_streaming_control ctrl; struct uvc_format *cur_format; struct uvc_frame *cur_frame; /* Protect access to ctrl, cur_format, cur_frame and hardware video  * probe control.  */ struct mutex mutex; unsigned int frozen : 1; struct uvc_video_queue queue; // UVC Video Queue---> void (*decode) (struct urb *urb, struct uvc_streaming *video,   struct uvc_buffer *buf); /* Context data used by the bulk completion handler. */ struct {  __u8 header[256];  unsigned int header_size;  int skip_payload;  __u32 payload_size;  __u32 max_payload_size; } bulk; struct urb *urb[UVC_URBS]; char *urb_buffer[UVC_URBS]; dma_addr_t urb_dma[UVC_URBS]; unsigned int urb_size; __u32 sequence; __u8 last_fid;    struct tasklet_struct *tasklet[UVC_URBS];     /* ddl@rock-chips.com */};struct uvc_video_queue { enum v4l2_buf_type type; void *mem;             // 已经分配的连续虚拟内存的首地址 unsigned int flags; unsigned int count;    // 已分配的buffer个数 unsigned int buf_size; // 每个buffer的大小 unsigned int buf_used; struct uvc_buffer buffer[UVC_MAX_VIDEO_BUFFERS];  // UVC buffer---> struct mutex mutex; /* protects buffers and mainqueue */ spinlock_t irqlock; /* protects irqqueue */    wait_queue_head_t wait; /* wait if mainqueue is empty */ struct list_head mainqueue; struct list_head irqqueue;    };struct uvc_buffer { unsigned long vma_use_count; struct list_head stream; /* Touched by interrupt handler. */ struct v4l2_buffer buf;     // v4l2_buffer ---> struct list_head queue; wait_queue_head_t wait;     // 初始化等待队列 enum uvc_buffer_state state; unsigned int error;};struct v4l2_buffer { __u32   index;    //buffer索引 enum v4l2_buf_type      type;     //如V4L2_BUF_TYPE_VIDEO_CAPTURE __u32   bytesused; __u32   flags; enum v4l2_field  field;    // V4L2_FIELD_NONE struct timeval  timestamp;  struct v4l2_timecode timecode; __u32   sequence; /* memory location */ enum v4l2_memory        memory;   // V4L2_MEMORY_MMAP union {  __u32           offset;   //在已经分配的大块内存中的偏移量,                                          //其首地址保存在uvc_video_queue->mem中  unsigned long   userptr;  struct v4l2_plane *planes; } m; __u32   length;   //申请的内存大小 __u32   input; __u32   reserved;};

1.2 uvc_alloc_buffers实现代码

/* * Allocate the video buffers. * * Pages are reserved to make sure they will not be swapped, as they will be * filled in the URB completion handler. * * Buffers will be individually mapped, so they must all be page aligned. */int uvc_alloc_buffers(struct uvc_video_queue *queue, unsigned int nbuffers,  unsigned int buflength){ unsigned int bufsize = PAGE_ALIGN(buflength); unsigned int i; void *mem = NULL; int ret; if (nbuffers > UVC_MAX_VIDEO_BUFFERS)  nbuffers = UVC_MAX_VIDEO_BUFFERS; mutex_lock(&queue->mutex); if ((ret = __uvc_free_buffers(queue)) < 0)  goto done; /* Bail out if no buffers should be allocated. */ if (nbuffers == 0)  goto done; /* Decrement the number of buffers until allocation succeeds. */ for (; nbuffers > 0; --nbuffers) {  mem = vmalloc_32(nbuffers * bufsize);  if (mem != NULL)   break; } if (mem == NULL) {  ret = -ENOMEM;  goto done; } for (i = 0; i < nbuffers; ++i) {  memset(&queue->buffer[i], 0, sizeof queue->buffer[i]);  queue->buffer[i].buf.index = i;  queue->buffer[i].buf.m.offset = i * bufsize;  queue->buffer[i].buf.length = buflength;  queue->buffer[i].buf.type = queue->type;  queue->buffer[i].buf.field = V4L2_FIELD_NONE;  queue->buffer[i].buf.memory = V4L2_MEMORY_MMAP;  queue->buffer[i].buf.flags = 0;  init_waitqueue_head(&queue->buffer[i].wait); } queue->mem = mem; queue->count = nbuffers; queue->buf_size = bufsize; ret = nbuffers;done: mutex_unlock(&queue->mutex); return ret;}

2. VIDIOC_QUERYBUF：把Kernel分配的内存映射到用户空间

3. VIDIOC_QBUF: 把uvc_buffer放入队列中

/* * Queue a video buffer. Attempting to queue a buffer that has already been * queued will return -EINVAL. */int uvc_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *v4l2_buf){ struct uvc_buffer *buf; unsigned long flags; int ret = 0; uvc_trace(UVC_TRACE_CAPTURE, "Queuing buffer %u.\n", v4l2_buf->index); if (v4l2_buf->type != queue->type ||     v4l2_buf->memory != V4L2_MEMORY_MMAP) {  uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer type (%u) "   "and/or memory (%u).\n", v4l2_buf->type,   v4l2_buf->memory);  return -EINVAL; } mutex_lock(&queue->mutex); if (v4l2_buf->index >= queue->count) {  uvc_trace(UVC_TRACE_CAPTURE, "[E] Out of range index.\n");  ret = -EINVAL;  goto done; } buf = &queue->buffer[v4l2_buf->index]; if (buf->state != UVC_BUF_STATE_IDLE) {  uvc_trace(UVC_TRACE_CAPTURE, "[E] Invalid buffer state "   "(%u).\n", buf->state);  ret = -EINVAL;  goto done; } if (v4l2_buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&     v4l2_buf->bytesused > buf->buf.length) {  uvc_trace(UVC_TRACE_CAPTURE, "[E] Bytes used out of bounds.\n");  ret = -EINVAL;  goto done; } spin_lock_irqsave(&queue->irqlock, flags); if (queue->flags & UVC_QUEUE_DISCONNECTED) {  spin_unlock_irqrestore(&queue->irqlock, flags);  ret = -ENODEV;  goto done; } buf->state = UVC_BUF_STATE_QUEUED; if (v4l2_buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)  buf->buf.bytesused = 0; else  buf->buf.bytesused = v4l2_buf->bytesused; list_add_tail(&buf->stream, &queue->mainqueue); list_add_tail(&buf->queue, &queue->irqqueue); spin_unlock_irqrestore(&queue->irqlock, flags);done: mutex_unlock(&queue->mutex); return ret;}

4. VIDIOC_STREAMON：做好准备工作并提交URB请求

/* * Initialize bulk URBs and allocate transfer buffers. The packet size is * given by the endpoint. */static int uvc_init_video_bulk(struct uvc_streaming *stream, struct usb_host_endpoint *ep, gfp_t gfp_flags){ struct urb *urb; unsigned int npackets, pipe, i; u16 psize; u32 size;            // 获取每个包的大小 psize = le16_to_cpu(ep->desc.wMaxPacketSize) & 0x07ff;  // 一次可传输的最大负荷传输大小 size = stream->ctrl.dwMaxPayloadTransferSize; stream->bulk.max_payload_size = size;     /*    分配置urb传输buffer,返回包个数(size/psize),它指每个urb    包含多少个包; 为每个stream->urb_buffer分配DMA buffer,如下：    for (i = 0; i < UVC_URBS; ++i) {        stream->urb_size = psize * npackets; // urb_buffer的大小        //分配DMA内存，并把地址保存在urb_buffer[i]和urb_dma[i]中，        //同一块内存，不同的表示方法        //1) stream->urb_buffer[i] = offset + page->vaddr;        //2) stream->urb_dma[i] = offset + page->dma;        stream->urb_buffer[i] = usb_alloc_coherent(                     stream->dev->udev, stream->urb_size,                     gfp_flags | __GFP_NOWARN, &stream->urb_dma[i]);        if (!stream->urb_buffer[i]) {            uvc_free_urb_buffers(stream);            break;        }    }    */ npackets = uvc_alloc_urb_buffers(stream, size, psize, gfp_flags); if (npackets == 0)  return -ENOMEM; size = npackets * psize; if (usb_endpoint_dir_in(&ep->desc))  pipe = usb_rcvbulkpipe(stream->dev->udev,           ep->desc.bEndpointAddress); else  pipe = usb_sndbulkpipe(stream->dev->udev,           ep->desc.bEndpointAddress); if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)  size = 0; for (i = 0; i < UVC_URBS; ++i) {        // 创建一个 urb  urb = usb_alloc_urb(0, gfp_flags);  if (urb == NULL) {   uvc_uninit_video(stream, 1);   return -ENOMEM;  }        /* 填充urb参数  struct urb {   void *transfer_buffer; // (in) associated data buffer   dma_addr_t transfer_dma;// (in) dma addr for transfer_buffer   usb_complete_t complete;// (in) completion routine   struct usb_iso_packet_descriptor iso_frame_desc[0];               // (in) ISO ONLY  }    */  usb_fill_bulk_urb(urb, stream->dev->udev, pipe,                          stream->urb_buffer[i],  //传输buffer                          size,        //传输buffer的大小                          uvc_video_complete, //URB请求完成之后的callback                          stream);  urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;  urb->transfer_dma = stream->urb_dma[i]; //给urb->transfer_dma赋值  // 把此urb保存到stream->urb[i]中  stream->urb[i] = urb; } return 0;}

5. urb数据解析 (uvc_video_complete)

当URB请求(usb_submit_urb)完成之后，它将调用其回调函数(uvc_video_complete)，下面分析此回调函数到底做了些什么。即如何把transfer_buffer或transfer_dma中数据转换为应用程序需要的v4l2_buffer中的数据。

5.1 uvc_video_complete

static void uvc_video_complete(struct urb *urb){     struct uvc_streaming *stream = urb->context; struct uvc_video_queue *queue = &stream->queue; struct uvc_buffer *buf = NULL; unsigned long flags; int ret; switch (urb->status) { case 0:  break; default:  uvc_printk(KERN_WARNING, "Non-zero status (%d) in video "   "completion handler.\n", urb->status); case -ENOENT:  /* usb_kill_urb() called. */  if (stream->frozen)   return; case -ECONNRESET: /* usb_unlink_urb() called. */ case -ESHUTDOWN: /* The endpoint is being disabled. */  uvc_queue_cancel(queue, urb->status == -ESHUTDOWN);  return; }  spin_lock_irqsave(&queue->irqlock, flags); if (!list_empty(&queue->irqqueue))  buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,           queue);//从queue->irqqueue中取出一个空的uvc_buffer spin_unlock_irqrestore(&queue->irqlock, flags);        //把urb中的数据转换为uvc_buffer中的数据，并设置对应的状态 stream->decode(urb, stream, buf); if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {  uvc_printk(KERN_ERR, "Failed to resubmit video URB (%d).\n",   ret); }}

5.2 stream->decode是什么?

现在关键是stream->decode到底做了些什么？它也是一个回调函数，首先要搞明白它是一个什么函数，其注册过程如下图所示：

5.3 uvc_video_decode_bulk

5.4 uvc_video_decode_isoc

static void uvc_video_decode_isoc(struct urb *urb, struct uvc_streaming *stream, struct uvc_buffer *buf){ u8 *mem; int ret, i; for (i = 0; i < urb->number_of_packets; ++i) {  if (urb->iso_frame_desc[i].status < 0) {   uvc_trace(UVC_TRACE_FRAME, "USB isochronous frame "    "lost (%d).\n", urb->iso_frame_desc[i].status);     /* Mark the buffer as faulty. */   if (buf != NULL)    buf->error = 1;   continue;  }  /* Decode the payload header. */  mem = urb->transfer_buffer + urb->iso_frame_desc[i].offset;  do {   ret = uvc_video_decode_start(stream, buf, mem,    urb->iso_frame_desc[i].actual_length);   if (ret == -EAGAIN)    buf = uvc_queue_next_buffer(&stream->queue,           buf);  } while (ret == -EAGAIN);  if (ret < 0)   continue;  /* Decode the payload data. */  uvc_video_decode_data(stream, buf, mem + ret,   urb->iso_frame_desc[i].actual_length - ret);  /* Process the header again. */  uvc_video_decode_end(stream, buf, mem,   urb->iso_frame_desc[i].actual_length);  if (buf->state == UVC_BUF_STATE_READY) {   if (buf->buf.length != buf->buf.bytesused &&       !(stream->cur_format->flags &         UVC_FMT_FLAG_COMPRESSED))    buf->error = 1;   buf = uvc_queue_next_buffer(&stream->queue, buf);  } }}