USB摄像头视频监控项目学习笔记

一个摄像头监控应用程序的系统调用如下所示:

/* open
 * VIDIOC_QUERYCAP 确定它是否视频捕捉设备,支持哪种接口(streaming/read,write)
 * VIDIOC_ENUM_FMT 查询支持哪种格式
 * VIDIOC_S_FMT    设置摄像头使用哪种格式
 * VIDIOC_REQBUFS  申请buffer
 对于 streaming:
 * VIDIOC_QUERYBUF 确定每一个buffer的信息 并且 mmap
 * VIDIOC_QBUF     放入队列
 * VIDIOC_STREAMON 启动设备
 * poll            等待有数据
 * VIDIOC_DQBUF    从队列中取出
 * 处理....
 * VIDIOC_QBUF     放入队列
 * ....
 * VIDIOC_STREAMOFF 停止设备
 *
 */

本文是作者之前做的一个摄像头监控项目的笔记,主要目的就是记录学习的过程,方便以后用到时复习使用,我们结合uvc摄像头的应用程序和驱动程序来分析uvc摄像头从硬件产生数据到上层应用程序获取数据的过程。

一:VIDIOC_QUERYCAP

VIDIOC_QUERYCAP函数主要是设置APP传入的v4l2_capability结构体变量tV4l2Cap(通过指针传入,本文涉及的基本都是通过指针传入,为了叙述时的方便,简单说成传入变量),然后APP根据设置的值再判断它是不是一个视频设备、是不是一个流(stream)设备等等...

APP程序:

struct v4l2_capability tV4l2Cap;
memset(&tV4l2Cap, 0, sizeof(struct v4l2_capability));
iError = ioctl(iFd, VIDIOC_QUERYCAP, &tV4l2Cap);
if (iError) {
    DBG_PRINTF("Error opening device %s: unable to query device.\n", strDevName);
    goto err_exit;
}

if (!(tV4l2Cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
{
    DBG_PRINTF("%s is not a video capture device\n", strDevName);
    goto err_exit;
}

if (tV4l2Cap.capabilities & V4L2_CAP_STREAMING) {
	DBG_PRINTF("%s supports streaming i/o\n", strDevName);
}
    
if (tV4l2Cap.capabilities & V4L2_CAP_READWRITE) {
	DBG_PRINTF("%s supports read i/o\n", strDevName);
}

驱动程序:

case VIDIOC_QUERYCAP:        
	{
		struct v4l2_capability *cap = arg;    //获取APP传入的指针

		memset(cap, 0, sizeof *cap);
		strlcpy(cap->driver, "uvcvideo", sizeof cap->driver);
		strlcpy(cap->card, vdev->name, sizeof cap->card);
		usb_make_path(stream->dev->udev,
			      cap->bus_info, sizeof(cap->bus_info));
		cap->version = DRIVER_VERSION_NUMBER;        
		if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)    //如果插入的设备是摄像头
			cap->capabilities = V4L2_CAP_VIDEO_CAPTURE      //设置传入的结构体变量的信息 
					  | V4L2_CAP_STREAMING;
		else
			cap->capabilities = V4L2_CAP_VIDEO_OUTPUT
					  | V4L2_CAP_STREAMING;
		break;
	}

问:底层驱动是根据什么来设置我们传入的变量的?

答:设备描述符。

问:设备描述符从哪来呢?

答:我们的uvc摄像头刚插上开发板时,USB总线驱动程序会生成一个usb_device结构体并把它挂到USB总线驱动程序的队列中,这个usb_device结构体里面就包含有我们的硬件信息,也就是所说的描述符。

二:VIDIOC_ENUM_FMT

VIDIOC_ENUM_FMT函数主要是设置APP传入的v4l2_fmtdesc结构体变量tFmtDesc,然后APP判断是否支持这种pixelformat,若是支持便把它赋给APP的tVideoDevice(ptVideoDevice是它的指针)->iPixelFormat,无法支持则结束程序。

APP程序:

        struct v4l2_fmtdesc tFmtDesc;
    memset(&tFmtDesc, 0, sizeof(tFmtDesc));
	tFmtDesc.index = 0;
	tFmtDesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    //枚举摄像头硬件支持的各种格式,若我们的应用程序支持这种格式则跳出循环
	while ((iError = ioctl(iFd, VIDIOC_ENUM_FMT, &tFmtDesc)) == 0) {
        if (isSupportThisFormat(tFmtDesc.pixelformat))//这个函数在下面定义了
        {
            ptVideoDevice->iPixelFormat = tFmtDesc.pixelformat;
            break;
        }
		tFmtDesc.index++;//index++再传入驱动即可查看硬件所支持的下一种格式
	}

    if (!ptVideoDevice->iPixelFormat)//无法支持
    {
    	DBG_PRINTF("can not support the format of this device\n");
        goto err_exit;        
    }

驱动程序:

	case VIDIOC_ENUM_FMT:
	{
		struct v4l2_fmtdesc *fmt = arg;    //获取APP传入的指针
		struct uvc_format *format;
		enum v4l2_buf_type type = fmt->type;
		__u32 index = fmt->index;

        //检查APP传入的数据
		if (fmt->type != stream->type ||
		    fmt->index >= stream->nformats)    //类型不对或者超过硬件支持的种数了
			return -EINVAL;

		memset(fmt, 0, sizeof(*fmt));
		fmt->index = index;
		fmt->type = type;

        //根据硬件的信息设置APP传入的变量
		format = &stream->format[fmt->index];
		fmt->flags = 0;
		if (format->flags & UVC_FMT_FLAG_COMPRESSED)
			fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
		strlcpy(fmt->description, format->name,
			sizeof fmt->description);
		fmt->description[sizeof fmt->description - 1] = 0;
		fmt->pixelformat = format->fcc;        //设置pixelformat,如YUYV、RGB、MJPEG等等...
		break;
	}

三:VIDIOC_S_FMT

我们先在APP获取LCD的分辨率和tVideoDevice->iPixelFormat(如YUYV、MJPEG等),然后通过v4l2_format结构体变量tV4l2Fmt传入到驱动程序里,传入的这些值其实还没真正设置到硬件上,只是暂时保存起来,等streamon的时候才真正发给硬件。

问:为什么要先在APP获取LCD的分辨率,然后传入驱动呢

答:我们这个项目是获取摄像头采集的数据然后在LCD上显示,为了增强显示效果,我们通过传入的参数设置摄像头采集的图片的分辨率和我们的LCD一致(如果摄像头不支持这种分辨率,那么驱动程序会找到和我们设置的值相近的分辨率)。

    int iLcdWidth;
    int iLcdHeigt;
    int iLcdBpp;
    struct v4l2_format  tV4l2Fmt;

    /* set format in */
    GetDispResolution(&iLcdWidth, &iLcdHeigt, &iLcdBpp);//获取LCD分辨率
    memset(&tV4l2Fmt, 0, sizeof(struct v4l2_format));
    tV4l2Fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    tV4l2Fmt.fmt.pix.pixelformat = ptVideoDevice->iPixelFormat;
    tV4l2Fmt.fmt.pix.width       = iLcdWidth;
    tV4l2Fmt.fmt.pix.height      = iLcdHeigt;
    tV4l2Fmt.fmt.pix.field       = V4L2_FIELD_ANY;

    /* 如果驱动程序发现无法某些参数(比如分辨率),
     * 它会调整这些参数, 并且返回给应用程序
     */
    iError = ioctl(iFd, VIDIOC_S_FMT, &tV4l2Fmt); 
    if (iError) 
    {
    	DBG_PRINTF("Unable to set format\n");
        goto err_exit;        
    }
	/* 读出调整后的参数 */
    ptVideoDevice->iWidth  = tV4l2Fmt.fmt.pix.width;
    ptVideoDevice->iHeight = tV4l2Fmt.fmt.pix.height;

驱动程序:

	/* Find the closest image size. The distance between image sizes is
	 * the size in pixels of the non-overlapping regions between the
	 * requested size and the frame-specified size.
	 */
        //找到和我们传入的值最接近的分辨率(fmt是我们在APP里传入的那个变量)
	rw = fmt->fmt.pix.width;
	rh = fmt->fmt.pix.height;
	maxd = (unsigned int)-1;

	for (i = 0; i < format->nframes; ++i) {
		__u16 w = format->frame[i].wWidth;
		__u16 h = format->frame[i].wHeight;

		d = min(w, rw) * min(h, rh);
		d = w*h + rw*rh - 2*d;
		if (d < maxd) {
			maxd = d;
			frame = &format->frame[i];
		}

		if (maxd == 0)
			break;
	}            //此处代码没贴全(因为太长了)
        ...
        ...

        
	fmt->fmt.pix.width = frame->wWidth;
	fmt->fmt.pix.height = frame->wHeight;
	fmt->fmt.pix.field = V4L2_FIELD_NONE;
	fmt->fmt.pix.bytesperline = format->bpp * frame->wWidth / 8;
	fmt->fmt.pix.sizeimage = probe->dwMaxVideoFrameSize;
	fmt->fmt.pix.colorspace = format->colorspace;
	fmt->fmt.pix.priv = 0;

四:VIDIOC_REQBUFS

VIDIOC_REQBUFS先在APP设置一些值,例如要申请的缓冲区个数,然后通过v4l2_requestbuffers类型的结构体变量tV4l2ReqBuffs传入到驱动中,驱动程序根据传入的个数和前面第三步的dwMaxVideoFrameSize(sizeimage)来申请缓冲区,然后设置队列queue里关于缓冲区的信息(如:各个缓冲区的号数和偏移量),最后得到真正申请到的缓冲区个数回到APP,我们把它保存到ptVideoDevice->iVideoBufCnt中(ptVideoDevice->iVideoBufCnt = tV4l2ReqBuffs.count;)

APP程序:

    struct v4l2_requestbuffers tV4l2ReqBuffs;
    /* request buffers */
    memset(&tV4l2ReqBuffs, 0, sizeof(struct v4l2_requestbuffers));
    tV4l2ReqBuffs.count = NB_BUFFER;
    tV4l2ReqBuffs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    tV4l2ReqBuffs.memory = V4L2_MEMORY_MMAP;

    iError = ioctl(iFd, VIDIOC_REQBUFS, &tV4l2ReqBuffs);
    if (iError) 
    {
    	DBG_PRINTF("Unable to allocate buffers.\n");
        goto err_exit;        
    }
    /* 申请buffer不一定能成功,真正申请到的buffer个数记录在tV4l2ReqBuffs.count */
    ptVideoDevice->iVideoBufCnt = tV4l2ReqBuffs.count;

驱动程序

struct v4l2_requestbuffers *rb = arg;
ret = uvc_alloc_buffers(&stream->queue, rb->count,stream->ctrl.dwMaxVideoFrameSize);

uvc_alloc_buffers的部分代码如下所示: 

/* 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;
	}

//设置队列queue里各个缓冲区的信息,例如偏移量,号数index等等...
	for (i = 0; i < nbuffers; ++i) {
		memset(&queue->buffer[i], 0, sizeof queue->buffer[i]);
		queue->buffer[i].buf.= 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;        //真正存放图片数据的地址在这里,队列里面的buffer数组只是记录各个缓冲区的偏移量之类的信息
	queue->count = nbuffers;
	queue->buf_size = bufsize;
	ret = nbuffers;

done:
	mutex_unlock(&queue->mutex);
	return ret;

五、for(i = 0; i < ptVideoDevice->iVideoBufCnt; i++){

VIDIOC_QUERYBUF 和 mmap

}

VIDIOC_QUERYBUF 和 mmap,先在APP设置一些值到v4l2_buffer结构体变量tV4l2Buf中,例如:tV4l2Buf.index(表示我们要查询哪个缓冲区的信息(什么信息?偏移值和页大小(sizeimage)等)),然后把tV4l2Buf传入驱动,驱动程序根据传入的tV4l2Buf.index拷贝队列queue对应的缓冲区信息到tV4l2Buf,返回到APP,APP把tV4l2Buf.length保存到tVideoDevice->iVideoBufMaxLen中。

然后调用mmap把tV4l2Buf.length,tV4l2Buf.m.offset传入驱动,驱动程序进行某种对比后找出要mmap的缓冲区(第四步申请的那些缓冲区),把该缓冲区的首地址通过返回值的形式赋给了ptVideoDevice->pucVideBuf[i],一个循环下来,ptVideoDevice->pucVideBuf数组便指向了各个缓冲区的首地址。

APP程序:

        	memset(&tV4l2Buf, 0, sizeof(struct v4l2_buffer));
        	tV4l2Buf.index = i;
        	tV4l2Buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        	tV4l2Buf.memory = V4L2_MEMORY_MMAP;
        	iError = ioctl(iFd, VIDIOC_QUERYBUF, &tV4l2Buf);
        	if (iError) 
            {
        	    DBG_PRINTF("Unable to query buffer.\n");
        	    goto err_exit;
        	}

            ptVideoDevice->iVideoBufMaxLen = tV4l2Buf.length;
        	ptVideoDevice->pucVideBuf[i] = mmap(0 /* start anywhere */ ,tV4l2Buf.length, PROT_READ, MAP_SHARED, iFd,tV4l2Buf.m.offset);
        	if (ptVideoDevice->pucVideBuf[i] == MAP_FAILED) 
            {
        	    DBG_PRINTF("Unable to map buffer\n");
        	    goto err_exit;
        	}

驱动程序:

int uvc_query_buffer(struct uvc_video_queue *queue,
		struct v4l2_buffer *v4l2_buf)
{
	int ret = 0;

	mutex_lock(&queue->mutex);
	if (v4l2_buf->index >= queue->count) {
		ret = -EINVAL;
		goto done;
	}

        //根据传入的v4l2_buf->index决定要查询哪个缓冲区的信息
	__uvc_query_buffer(&queue->buffer[v4l2_buf->index], v4l2_buf);//函数定义在下面

done:
	mutex_unlock(&queue->mutex);
	return ret;
}
static void __uvc_query_buffer(struct uvc_buffer *buf,
		struct v4l2_buffer *v4l2_buf)
{
        //把内核里面缓冲区的信息拷贝到APP传进来的地址
	memcpy(v4l2_buf, &buf->buf, sizeof *v4l2_buf);

	if (buf->vma_use_count)
		v4l2_buf->flags |= V4L2_BUF_FLAG_MAPPED;

        //设置flag
	switch (buf->state) {
	case UVC_BUF_STATE_ERROR:
	case UVC_BUF_STATE_DONE:
		v4l2_buf->flags |= V4L2_BUF_FLAG_DONE;
		break;
	case UVC_BUF_STATE_QUEUED:
	case UVC_BUF_STATE_ACTIVE:
	case UVC_BUF_STATE_READY:
		v4l2_buf->flags |= V4L2_BUF_FLAG_QUEUED;
		break;
	case UVC_BUF_STATE_IDLE:
	default:
		break;
	}
}

/*
 * Memory-map a video buffer.
 *
 * This function implements video buffers memory mapping and is intended to be
 * used by the device mmap handler.
 */
int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
{
	struct uvc_buffer *uninitialized_var(buffer);
	struct page *page;
	unsigned long addr, start, size;
	unsigned int i;
	int ret = 0;

	start = vma->vm_start;
	size = vma->vm_end - vma->vm_start;

	mutex_lock(&queue->mutex);

        
    /* 应用程序调用mmap函数时, 会传入offset参数
     * 根据这个offset找出指定的缓冲区
     */
	for (i = 0; i < queue->count; ++i) {
		buffer = &queue->buffer[i];
		if ((buffer->buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)//把内核里的缓冲区信息和传进来的参数进行某种对比,如果符合则证明就是要mmap这个缓冲区
			break;
	}

	if (i == queue->count || PAGE_ALIGN(size) != queue->buf_size) {
		ret = -EINVAL;
		goto done;
	}

	/*
	 * VM_IO marks the area as being an mmaped region for I/O to a
	 * device. It also prevents the region from being core dumped.
	 */
	vma->vm_flags |= VM_IO;

    /* 根据虚拟地址找到缓冲区对应的page构体 */
	addr = (unsigned long)queue->mem + buffer->buf.m.offset;
#ifdef CONFIG_MMU
	while (size > 0) {
		page = vmalloc_to_page((void *)addr);

        /* 把page和APP传入的虚拟地址挂构 */
		if ((ret = vm_insert_page(vma, start, page)) < 0)
			goto done;

		start += PAGE_SIZE;
		addr += PAGE_SIZE;
		size -= PAGE_SIZE;
	}
#endif

	vma->vm_ops = &uvc_vm_ops;
	vma->vm_private_data = buffer;
	uvc_vm_open(vma);

done:
	mutex_unlock(&queue->mutex);
	return ret;
}

六、for(i = 0; i < ptVideoDevice->iVideoBufCnt; i++){

VIDIOC_QBUF

}

首先清空第五步的变量tV4l2Buf,并设置tV4l2Buf.index传入驱动,驱动根据tV4l2Buf.index找到各个缓冲区的buffer(看代码感觉其实里面包含的是缓冲区的信息而已,真正存数据的地方是queme->mem),把它们的stream和queue分别挂到队列queue的mainqueue和irqqueue形成两条队列。

其实是双向链表,上面的图只是为了容易理解而已。 

APP程序:

        	memset(&tV4l2Buf, 0, sizeof(struct v4l2_buffer));
        	tV4l2Buf.index = i;
        	tV4l2Buf.type  = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        	tV4l2Buf.memory = V4L2_MEMORY_MMAP;
        	iError = ioctl(iFd, VIDIOC_QBUF, &tV4l2Buf);
        	if (iError)
            {
        	    DBG_PRINTF("Unable to queue buffer.\n");
        	    goto err_exit;
        	}

驱动程序: 


/*
 * 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;
	}

        //找到对应的buffer
	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;

        //把buffer的stream和queue分别挂到队列queue的mainqueue和irqqueue
	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;
}

七:streamon

这一步的工作主要是初始化URB和启动摄像头,我们在内核代码中搜索urb->complete可在Uvc_video.c里找到uvc_video_complete函数,当硬件产生一帧数据给URB之后,便回进入uvc_video_complete函数

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);
        //如果irqqueue队列不为空,则让buf指向它第一个节点,准备把数据从URB拷贝到第一个节点
	if (!list_empty(&queue->irqqueue))
		buf = list_first_entry(&queue->irqqueue, struct uvc_buffer,queue);
	spin_unlock_irqrestore(&queue->irqlock, flags);

        //decode是解码的意思,其实内部就是拷贝URB上的数据到irqqueue队列的第一个节点
	stream->decode(urb, stream, buf);

        //重新提交URB
	if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
		uvc_printk(KERN_ERR, "Failed to resubmit video URB (%d).\n",
			ret);
	}
}

在内核源码搜索stream->decode,我们会找到stream->decode = uvc_video_decode_isoc;分析uvc_video_decode_isoc函数的源码我们看到下面的这一部分,这部分代码的作用就是把URB上的数据(也就是下面代码的data)拷贝到irqqueue队列第一个节点对应的缓冲区,因为调用的过程比较繁琐,这里长话短说,详细分析得看源代码。

	/* Copy the video data to the buffer. */
	maxlen = buf->buf.length - buf->buf.bytesused;
	mem = queue->mem + buf->buf.m.offset + buf->buf.bytesused;
	nbytes = min((unsigned int)len, maxlen);
	memcpy(mem, data, nbytes);
	buf->buf.bytesused += nbytes;

然后把irqqueue队列的这个节点删除掉并唤醒APP进程(等数据时进入休眠)

list_del(&buf->queue);
wake_up(&buf->wait);

八:VIDIOC_DQBUF

当应用程序被唤醒后,会调用VIDIOC_DQBUF,APP把v4l2_buffer类型的结构体变量tV4l2Buf传入到驱动程序,驱动程序把mainqueue队列的第一个节点的数据拷贝到tV4l2Buf(我们主要用到tV4l2Buf.index),然后把这个节点从mainqueue队列中删去。

APP有了这个tV4l2Buf.index便知道了ptVideoDevice->pucVideBuf[i]有数据,把它地址赋给ptVideoBuf->tPixelDatas.aucPixelDatas(用来指向每次有图片数据的那块缓存)。到此我们便从硬件得到一帧图片到APP了。

APP程序: 

    /* VIDIOC_DQBUF */
    memset(&tV4l2Buf, 0, sizeof(struct v4l2_buffer));
    tV4l2Buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    tV4l2Buf.memory = V4L2_MEMORY_MMAP;
    iRet = ioctl(ptVideoDevice->iFd, VIDIOC_DQBUF, &tV4l2Buf);
    if (iRet < 0) 
    {
    	DBG_PRINTF("Unable to dequeue buffer.\n");
    	return -1;
    }
    ptVideoDevice->iVideoBufCurIndex = tV4l2Buf.index;

    ptVideoBuf->iPixelFormat        = ptVideoDevice->iPixelFormat;
    ptVideoBuf->tPixelDatas.iWidth  = ptVideoDevice->iWidth;
    ptVideoBuf->tPixelDatas.iHeight = ptVideoDevice->iHeight;
    ptVideoBuf->tPixelDatas.iBpp    = (ptVideoDevice->iPixelFormat == V4L2_PIX_FMT_YUYV) ? 16 : \
                                        (ptVideoDevice->iPixelFormat == V4L2_PIX_FMT_MJPEG) ? 0 :  \
                                        (ptVideoDevice->iPixelFormat == V4L2_PIX_FMT_RGB565) ? 16 :  \
                                        0;
    ptVideoBuf->tPixelDatas.iLineBytes    = ptVideoDevice->iWidth * ptVideoBuf->tPixelDatas.iBpp / 8;
    ptVideoBuf->tPixelDatas.iTotalBytes   = tV4l2Buf.bytesused;
        //获取图片缓存的地址
    ptVideoBuf->tPixelDatas.aucPixelDatas = ptVideoDevice->pucVideBuf[tV4l2Buf.index];  

部分驱动程序:

        //取出mainqueue队列的第一个节点
	buf = list_first_entry(&queue->mainqueue, struct uvc_buffer, stream);
        //把这个节点从mainqueue队列中删除
	list_del(&buf->stream);
        //和第五步的VIDIOC_QUERYBUF一样,它的作用其实就是把buf(也就是mainqueue队列第一个节点)的数据拷贝到v4l2_buf(我们主要用到v4l2_buf.index)
	__uvc_query_buffer(buf, v4l2_buf);

九:再次VIDIOC_QBUF,为了能够循环得到图片,我们还得调用VIDIOC_QBUF把前面从两个队列删除的那个节点插回去。

执行tV4l2Buf.index  = ptVideoDevice->iVideoBufCurIndex(在第八步记录了tV4l2Buf.index);找回上次从队列中删掉的是哪个buffer,然后把它重新插到队列上去,然后等待下一帧数据的到来。

    struct v4l2_buffer tV4l2Buf;
    int iError;
    
	memset(&tV4l2Buf, 0, sizeof(struct v4l2_buffer));
	tV4l2Buf.index  = ptVideoDevice->iVideoBufCurIndex;
	tV4l2Buf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	tV4l2Buf.memory = V4L2_MEMORY_MMAP;
	iError = ioctl(ptVideoDevice->iFd, VIDIOC_QBUF, &tV4l2Buf);
	if (iError) 
    {
	    DBG_PRINTF("Unable to queue buffer.\n");
	    return -1;
	}
    return 0;

/*
 * 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;
	}

        //找到对应的buffer
	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;

        //把buffer的stream和queue分别挂到队列queue的mainqueue和irqqueue
	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;
}

最后再贴几个上面用到的结构体,方便查看

1.T_VideoBuf

typedef struct VideoBuf {
    T_PixelDatas tPixelDatas;
    int iPixelFormat;
}T_VideoBuf, *PT_VideoBuf;



/* 图片的象素数据 */
typedef struct PixelDatas {
	int iWidth;   /* 宽度: 一行有多少个象素 */
	int iHeight;  /* 高度: 一列有多少个象素 */
	int iBpp;     /* 一个象素用多少位来表示 */
	int iLineBytes;  /* 一行数据有多少字节 */
	int iTotalBytes; /* 所有字节数 */ 
	unsigned char *aucPixelDatas;  /* 象素数据存储的地方,每次都是指向有新数据的缓冲区 */
}T_PixelDatas, *PT_PixelDatas;

2.

struct VideoDevice {
    int iFd;
    int iPixelFormat;
    int iWidth;
    int iHeight;

    int iVideoBufCnt;
    int iVideoBufMaxLen;
    int iVideoBufCurIndex;    
    unsigned char *pucVideBuf[NB_BUFFER];    //通过mmap函数映射,该数组的每个变量都指向了缓冲区的地址(比如 men + 1 * offset 、men + 2 * offset)

    /* 函数 */
    PT_VideoOpr ptOPr;
};

3.uvc_video_queue 

struct uvc_video_queue {
	enum v4l2_buf_type type;

	void *mem;            //正真存放图片数据的地方
	unsigned int flags;

	unsigned int count;
	unsigned int buf_size;
	unsigned int buf_used;
	struct uvc_buffer buffer[UVC_MAX_VIDEO_BUFFERS];    //n个buffer,里面记录了每个缓冲区的偏移值和号数index等信息
	struct mutex mutex;	/* protects buffers and mainqueue */
	spinlock_t irqlock;	/* protects irqqueue */

	struct list_head mainqueue;    //供APP使用的队列(头节点)
	struct list_head irqqueue;    //供驱动使用的队列(头节点)
};

 4.uvc_buffer 

struct uvc_buffer {
	unsigned long vma_use_count;
	struct list_head stream;    //供APP使用的队列(普通节点)

	/* Touched by interrupt handler. */
	struct v4l2_buffer buf;
	struct list_head queue;    //供驱动使用的队列(普通节点)
	wait_queue_head_t wait;
	enum uvc_buffer_state state;
	unsigned int error;
};

5.v4l2_buffer  

struct v4l2_buffer {
	__u32			index;    //记录buffer的号数
	enum v4l2_buf_type      type;
	__u32			bytesused;
	__u32			flags;
	enum v4l2_field		field;
	struct timeval		timestamp;
	struct v4l2_timecode	timecode;
	__u32			sequence;

	/* memory location */
	enum v4l2_memory        memory;
	union {
		__u32           offset;    //记录各个缓冲区的偏移值,正真的图片数据在mem + n * offset
		unsigned long   userptr;
		struct v4l2_plane *planes;
	} m;
	__u32			length;
	__u32			input;
	__u32			reserved;
};
发布了42 篇原创文章 · 获赞 10 · 访问量 1万+

猜你喜欢

转载自blog.csdn.net/qq_37659294/article/details/104326223