カメラ監視アプリケーションのシステムコールは以下の通りです。
/ *オープン
* VIDIOC_QUERYCAPは、それがビデオキャプチャデバイスであるかどうかを決定します。このインターフェイスは、サポートする（ストリーミング/読み取り、書き込み）
*サポートされる形式を表すVIDIOC_ENUM_FMTクエリ
*カメラが使用する形式を設定する
VIDIOC_S_FMT *
ストリーミング用のVIDIOC_REQBUFSアプリケーションバッファ：
* VIDIOC_QUERYBUFは、それぞれを決定しますバッファ情報とmmap
* VIDIOC_QBUFがキューに入れられます
* VIDIOC_STREAMONがデバイスを開始します
*データ待ちのポーリング
* VIDIOC_DQBUFがキューから取り出されます
*処理
*。* VIDIOC_QBUFがキューに入れられます
* ....
* VIDIOC_STREAMOFFデバイスを停止します
*
* /
この記事は、著者が以前に作成したカメラ監視プロジェクトのメモです。主な目的は、学習プロセスを記録することです。これは、後で確認するのに便利です。uvcカメラのアプリケーションとドライバーを組み合わせて、ハードウェアから上位アプリケーションまでのuvcカメラによって生成されたデータを分析しますプログラムがデータを取得するプロセス。
1つ：VIDIOC_QUERYCAP
VIDIOC_QUERYCAP関数は、主にAPPによって渡されるv4l2_capability構造体変数tV4l2Capを設定することです（ポインターによって渡されるため、この記事に含まれる基本は基本的にポインターによって渡されます。説明の便宜上、単に入力変数としてそれを言います）。その後、設定に従ってAPP値は、それがビデオデバイスであるか、ストリームデバイスであるかなどを決定します...
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;
}Q：基になるドライバーは、どのような基準で、渡した変数を設定しますか？
回答：デバイス記述子。
Q：デバイス記述子はどこから来ますか？
A：私たちのuvcカメラを開発ボードに接続すると、USBバスドライバーがusb_device構造を生成し、それをUSBバスドライバーのキューにぶら下げます。このusb_device構造には、ハードウェア情報が含まれています。これは記述子です。
2つ：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;
}
3：VIDIOC_S_FMT
まずAPPでLCD解像度とtVideoDevice-> iPixelFormat（YUYV、MJPEGなど）を取得し、それをv4l2_format構造体変数tV4l2Fmtを介してドライバーに渡します。渡された値は、実際にはハードウェアで設定されていません。一時的に保存されるだけで、ストリーミング時に実際にハードウェアに送信されます。
Q：なぜ最初にアプリでLCDの解像度を取得してから、それをドライバーに渡す必要があるのですか？
A：私たちのプロジェクトは、カメラが収集したデータを取得して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;
4：VIDIOC_REQBUFS
VIDIOC_REQBUFSは、最初にAPPにいくつかの値（適用するバッファーの数など）を設定し、次に構造体変数tV4l2ReqBuffs（タイプv4l2_requestbuffers）を介してドライバーに渡されます。ドライバーは着信数と3番目のステップdwMaxVideoFrameSize（sizeimage）に応じてバッファーを適用し、キュー内のバッファーに関する情報（各バッファーの数やオフセットなど）を設定し、最後に実際に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（照会するバッファー情報を示します（どの情報？オフセット値とページサイズ（サイズ画像）など））次にtV4l2Bufをドライバーに渡し、ドライバーはキューに対応するバッファー情報をtV4l2Buf.indexに従ってtV4l2Bufにコピーし、APPに戻ります。APPはtV4l2Buf.lengthをtVideoDevice-> iVideoBufMaxLenに保存します。
次に、mmapを呼び出してtV4l2Buf.length、tV4l2Buf.m.offsetをドライバーに渡し、いくつかの比較の後、ドライバーはmmapであるバッファー（4番目の手順で適用されたバッファー）を見つけ、バッファーの最初のアドレスを渡します戻り値は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
}
最初に、5番目のステップの変数tV4l2Bufをクリアし、tV4l2Buf.indexをドライバーに渡すように設定します。ドライバーは、tV4l2Buf.indexに従って各バッファーのバッファーを見つけます（コードを見て、実際にはバッファーの情報が含まれています。データが実際に格納される場所は、 queme-> mem）、それらのストリームとキューをメインキューとキューのirqqueueに掛けて、2つのキューを形成します。
実際、これは二重にリンクされたリストです上記の図は、理解を容易にするためのものです。
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;
}
セブン：ストリーモン
このステップの作業は、主に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に配置することです）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);
8：VIDIOC_DQBUF
アプリケーションが起動すると、VIDIOC_DQBUFが呼び出され、APPはタイプv4l2_bufferの構造変数tV4l2Bufをドライバーに転送します。ドライバーは、メインキューキューの最初のノードのデータをtV4l2Bufにコピーします（主にtV4l2Buf.indexを使用します） 、そしてこのノードをメインキューのキューから削除します。
このtV4l2Buf.indexを使用すると、APPは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を呼び出して、2つのキューから削除されたノードを挿入する必要があります。
tV4l2Buf.index = ptVideoDevice-> iVideoBufCurIndex（8番目のステップで記録されたtV4l2Buf.indexを実行）を実行し、最後にキューから削除されたバッファーを取得してから、キューに再度挿入し、次のデータフレームを待つ来る。
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;
};
