Linux 下用 QT 打开摄像头并显示

最新推荐文章于 2025-08-08 15:49:39 发布
转载 最新推荐文章于 2025-08-08 15:49:39 发布 · 3.6k 阅读 · 4

本文介绍了一个基于Qt的应用程序，该程序能够打开并显示摄像头的视频流。通过使用V4L2接口与视频设备交互，实现了视频帧的获取与RGB格式的转换，并将图像显示在一个QWidget中。

作者：叁万英尺

转自：http://www.oschina.net/code/snippet_124925_3789


打开摄像头，并显示。
标签： 摄像头 Qt Creator

代码片段(5)[全屏查看所有代码]

1. [文件] videodevice.h ~ 908B     下载(1683)    

01#ifndef VIDEODEVICE_H
02#define VIDEODEVICE_H
03 
04#include <string.h>
05#include <stdlib.h>
06#include <errno.h>
07#include <fcntl.h>
08 
09 
10#include <sys/ioctl.h>
11#include <sys/mman.h>
12 
13#include <asm/types.h>
14#include <linux/videodev2.h>
15 
16#include <QString>
17#include <QObject>
18 
19#define CLEAR(x) memset(&(x), 0, sizeof(x))
20 
21class VideoDevice :public QObject
22{
23    Q_OBJECT
24public:
25    VideoDevice(QString dev_name);
26    //VideoDevice();
27    intopen_device();
28    intclose_device();
29    intinit_device();
30    intstart_capturing();
31    intstop_capturing();
32    intuninit_device();
33    intget_frame(void **, size_t*);
34    intunget_frame();
35 
36private:
37    intinit_mmap();
38 
39    structbuffer
40    {
41        void* start;
42        size_tlength;
43    };
44    QString dev_name;
45    intfd;
46    buffer* buffers;
47    unsigned int n_buffers;
48    intindex;
49 
50signals:
51    voiddisplay_error(QString);
52 
53};
54 
55#endif // VIDEODEVICE_H

2. [文件] videodevice.cpp ~ 7KB     下载(1487)    

001#include "videodevice.h"
002 
003VideoDevice::VideoDevice(QString dev_name)
004{
005    this->dev_name = dev_name;
006    this->fd = -1;
007    this->buffers = NULL;
008    this->n_buffers = 0;
009    this->index = -1;
010 
011}
012 
013int VideoDevice::open_device()
014{
015    fd = open(dev_name.toStdString().c_str(), O_RDWR/*|O_NONBLOCK*/, 0);
016   // fd = open(dev_name.toStdString().c_str(), O_RDWR|O_NONBLOCK, 0);
017 
018    if(-1 == fd)
019    {
020        emit display_error(tr("open: %1").arg(QString(strerror(errno))));
021        return-1;
022    }
023    return0;
024}
025 
026int VideoDevice::close_device()
027{
028    if(-1 == close(fd))
029    {
030        emit display_error(tr("close: %1").arg(QString(strerror(errno))));
031        return-1;
032    }
033    return0;
034}
035 
036int VideoDevice::init_device()
037{
038    v4l2_capability cap;
039    v4l2_cropcap cropcap;
040    v4l2_crop crop;
041    v4l2_format fmt;
042 
043    if(-1 == ioctl(fd, VIDIOC_QUERYCAP, &cap))
044    {
045        if(EINVAL ==errno)
046        {
047            emit display_error(tr("%1 is no V4l2 device").arg(dev_name));
048        }
049        else
050        {
051            emit display_error(tr("VIDIOC_QUERYCAP: %1").arg(QString(strerror(errno))));
052        }
053        return-1;
054    }
055 
056    if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
057    {
058        emit display_error(tr("%1 is no video capture device").arg(dev_name));
059        return-1;
060    }
061 
062    if(!(cap.capabilities & V4L2_CAP_STREAMING))
063    {
064        emit display_error(tr("%1 does not support streaming i/o").arg(dev_name));
065        return-1;
066    }
067 
068    CLEAR(cropcap);
069 
070    cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
071 
072    if(0 == ioctl(fd, VIDIOC_CROPCAP, &cropcap))
073    {
074        CLEAR(crop);
075        crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
076        crop.c = cropcap.defrect;
077 
078        if(-1 == ioctl(fd, VIDIOC_S_CROP, &crop))
079        {
080            if(EINVAL ==errno)
081            {
082//                emit display_error(tr("VIDIOC_S_CROP not supported"));
083            }
084            else
085            {
086                emit display_error(tr("VIDIOC_S_CROP: %1").arg(QString(strerror(errno))));
087                return-1;
088            }
089        }
090    }
091    else
092    {
093        emit display_error(tr("VIDIOC_CROPCAP: %1").arg(QString(strerror(errno))));
094        return-1;
095    }
096 
097    CLEAR(fmt);
098 
099    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
100    fmt.fmt.pix.width = 640;
101    fmt.fmt.pix.height = 480;
102    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
103    fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
104 
105    if(-1 == ioctl(fd, VIDIOC_S_FMT, &fmt))
106    {
107        emit display_error(tr("VIDIOC_S_FMT").arg(QString(strerror(errno))));
108        return-1;
109    }
110 
111    if(-1 == init_mmap())
112    {
113        return-1;
114    }
115 
116    return0;
117}
118 
119int VideoDevice::init_mmap()
120{
121    v4l2_requestbuffers req;
122    CLEAR(req);
123 
124    req.count = 4;
125    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
126    req.memory = V4L2_MEMORY_MMAP;
127 
128    if(-1 == ioctl(fd, VIDIOC_REQBUFS, &req))
129    {
130        if(EINVAL ==errno)
131        {
132            emit display_error(tr("%1 does not support memory mapping").arg(dev_name));
133            return-1;
134        }
135        else
136        {
137            emit display_error(tr("VIDIOC_REQBUFS %1").arg(QString(strerror(errno))));
138            return-1;
139        }
140    }
141 
142    if(req.count < 2)
143    {
144        emit display_error(tr("Insufficient buffer memory on %1").arg(dev_name));
145        return-1;
146    }
147 
148    buffers = (buffer*)calloc(req.count,sizeof(*buffers));
149 
150    if(!buffers)
151    {
152        emit display_error(tr("out of memory"));
153        return-1;
154    }
155 
156    for(n_buffers = 0; n_buffers < req.count; ++n_buffers)
157    {
158        v4l2_buffer buf;
159        CLEAR(buf);
160 
161        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
162        buf.memory = V4L2_MEMORY_MMAP;
163        buf.index = n_buffers;
164 
165        if(-1 == ioctl(fd, VIDIOC_QUERYBUF, &buf))
166        {
167            emit display_error(tr("VIDIOC_QUERYBUF: %1").arg(QString(strerror(errno))));
168            return-1;
169        }
170 
171        buffers[n_buffers].length = buf.length;
172        buffers[n_buffers].start =
173                mmap(NULL,// start anywhere
174                     buf.length,
175                     PROT_READ | PROT_WRITE,
176                     MAP_SHARED,
177                     fd, buf.m.offset);
178 
179        if(MAP_FAILED == buffers[n_buffers].start)
180        {
181            emit display_error(tr("mmap %1").arg(QString(strerror(errno))));
182            return-1;
183        }
184    }
185    return0;
186 
187}
188 
189int VideoDevice::start_capturing()
190{
191    unsigned int i;
192    for(i = 0; i < n_buffers; ++i)
193    {
194        v4l2_buffer buf;
195        CLEAR(buf);
196 
197        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
198        buf.memory =V4L2_MEMORY_MMAP;
199        buf.index = i;
200//        fprintf(stderr, "n_buffers: %d\n", i);
201 
202        if(-1 == ioctl(fd, VIDIOC_QBUF, &buf))
203        {
204            emit display_error(tr("VIDIOC_QBUF: %1").arg(QString(strerror(errno))));
205            return-1;
206        }
207    }
208 
209    v4l2_buf_type type;
210    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
211 
212    if(-1 == ioctl(fd, VIDIOC_STREAMON, &type))
213    {
214        emit display_error(tr("VIDIOC_STREAMON: %1").arg(QString(strerror(errno))));
215        return-1;
216    }
217    return0;
218}
219 
220int VideoDevice::stop_capturing()
221{
222    v4l2_buf_type type;
223    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
224 
225    if(-1 == ioctl(fd, VIDIOC_STREAMOFF, &type))
226    {
227        emit display_error(tr("VIDIOC_STREAMOFF: %1").arg(QString(strerror(errno))));
228        return-1;
229    }
230    return0;
231}
232 
233int VideoDevice::uninit_device()
234{
235    unsigned int i;
236    for(i = 0; i < n_buffers; ++i)
237    {
238        if(-1 == munmap(buffers[i].start, buffers[i].length))
239        {
240            emit display_error(tr("munmap: %1").arg(QString(strerror(errno))));
241            return-1;
242        }
243 
244    }
245    free(buffers);
246    return0;
247}
248 
249int VideoDevice::get_frame(void**frame_buf, size_t* len)
250{
251    v4l2_buffer queue_buf;
252    CLEAR(queue_buf);
253 
254    queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
255    queue_buf.memory = V4L2_MEMORY_MMAP;
256 
257    if(-1 == ioctl(fd, VIDIOC_DQBUF, &queue_buf))
258    {
259        switch(errno)
260        {
261        caseEAGAIN:
262//            perror("dqbuf");
263            return-1;
264        caseEIO:
265            return-1 ;
266        default:
267            emit display_error(tr("VIDIOC_DQBUF: %1").arg(QString(strerror(errno))));
268            return-1;
269        }
270    }
271 
272    *frame_buf = buffers[queue_buf.index].start;
273    *len = buffers[queue_buf.index].length;
274    index = queue_buf.index;
275 
276    return0;
277 
278}
279 
280int VideoDevice::unget_frame()
281{
282    if(index != -1)
283    {
284        v4l2_buffer queue_buf;
285        CLEAR(queue_buf);
286 
287        queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
288        queue_buf.memory = V4L2_MEMORY_MMAP;
289        queue_buf.index = index;
290 
291        if(-1 == ioctl(fd, VIDIOC_QBUF, &queue_buf))
292        {
293            emit display_error(tr("VIDIOC_QBUF: %1").arg(QString(strerror(errno))));
294            return-1;
295        }
296        return0;
297    }
298    return-1;
299}

3. [文件] processImage.h ~ 677B     下载(1412)    

01#ifndef PROCESSIMAGE_H
02#define PROCESSIMAGE_H
03 
04#include <QtGui>
05#include "videodevice.h"
06 
07class ProcessImage :public QWidget
08{
09    Q_OBJECT
10public:
11    ProcessImage(QWidget *parent=0);
12    ~ProcessImage();
13 
14private:
15    QPainter *painter;
16    QLabel *label;
17    QImage *frame;
18    //QPixmap *frame;
19    QTimer *timer;
20    intrs;
21    uchar *pp;
22    uchar * p;
23    unsigned int len;
24    intconvert_yuv_to_rgb_pixel(inty, int u, int v);
25    intconvert_yuv_to_rgb_buffer(unsigned char*yuv, unsigned char *rgb, unsigned int width, unsignedint height);
26    VideoDevice *vd;
27 
28private slots:
29    voidpaintEvent(QPaintEvent *);
30    voiddisplay_error(QString err);
31 
32 
33};
34 
35#endif

4. [文件] processImage.cpp ~ 4KB     下载(1422)    

001#include <QtGui>
002#include "processImage.h"
003#include "videodevice.h"
004extern "C"
005{
006#include <stdio.h>
007#include <stdlib.h>
008}
009ProcessImage::ProcessImage(QWidget *parent):QWidget(parent)
010{
011    pp = (unsignedchar *)malloc(640 * 480/*QWidget::width()*QWidget::height()*/* 3 *sizeof(char));
012    painter =new QPainter(this);
013    frame = new QImage(pp,640,480,QImage::Format_RGB888);
014   // frame = new QPixmap(640,320);
015    label = new QLabel();
016    vd = new VideoDevice(tr("/dev/video0"));
017 
018    connect(vd, SIGNAL(display_error(QString)),this,SLOT(display_error(QString)));
019    rs = vd->open_device();
020    if(-1==rs)
021    {
022        QMessageBox::warning(this,tr("error"),tr("open /dev/dsp error"),QMessageBox::Yes);
023        vd->close_device();
024    }
025 
026    rs = vd->init_device();
027    if(-1==rs)
028    {
029        QMessageBox::warning(this,tr("error"),tr("init failed"),QMessageBox::Yes);
030        vd->close_device();
031    }
032 
033    rs = vd->start_capturing();
034    if(-1==rs)
035    {
036        QMessageBox::warning(this,tr("error"),tr("start capture failed"),QMessageBox::Yes);
037        vd->close_device();
038    }
039 
040    if(-1==rs)
041    {
042        QMessageBox::warning(this,tr("error"),tr("get frame failed"),QMessageBox::Yes);
043        vd->stop_capturing();
044    }
045 
046    timer = new QTimer(this);
047    connect(timer,SIGNAL(timeout()),this,SLOT(update()));
048    timer->start(30);
049 
050    QHBoxLayout *hLayout =new QHBoxLayout();
051    hLayout->addWidget(label);
052    setLayout(hLayout);
053    setWindowTitle(tr("Capture"));
054}
055 
056ProcessImage::~ProcessImage()
057{
058    rs = vd->stop_capturing();
059    rs = vd->uninit_device();
060    rs = vd->close_device();
061}
062 
063void ProcessImage::paintEvent(QPaintEvent *)
064{
065    rs = vd->get_frame((void**)&p,&len);
066    convert_yuv_to_rgb_buffer(p,pp,640,480/*QWidget::width(),QWidget::height()*/);
067    frame->loadFromData((uchar *)pp,/*len*/640 * 480 * 3 *sizeof(char));
068 
069//    painter->begin(this);
070//    painter->drawImage(0,0,*frame);
071//    painter->end();
072//    rs = vd->unget_frame();
073   // frame->load("./img3.jpg");
074 
075    label->setPixmap(QPixmap::fromImage(*frame,Qt::AutoColor));
076   // label->show();
077    rs = vd->unget_frame();
078   // label->drawFrame();
079 
080    //    QPixmap *pixImage = new QPixmap();
081//    pixImage->loadFromData((uchar *)pp,sizeof(pp),0,Qt::AutoColor);
082//    QPainter painter(this);
083//    painter.begin(this);
084//    painter.drawPixmap(0,0,QWidget::width(),QWidget::height(),*pixImage);
085//    painter.end();
086}
087 
088void ProcessImage::display_error(QString err)
089{
090    QMessageBox::warning(this,tr("error"), err,QMessageBox::Yes);
091}
092 
093/*yuv格式转换为rgb格式*/
094int ProcessImage::convert_yuv_to_rgb_buffer(unsignedchar *yuv, unsigned char *rgb, unsigned intwidth, unsigned int height)
095{
096 unsigned int in, out = 0;
097 unsigned int pixel_16;
098 unsigned char pixel_24[3];
099 unsigned int pixel32;
100 inty0, u, y1, v;
101 for(in = 0; in < width * height * 2; in += 4) {
102  pixel_16 =
103   yuv[in + 3] << 24 |
104   yuv[in + 2] << 16 |
105   yuv[in + 1] <<  8 |
106   yuv[in + 0];
107  y0 = (pixel_16 & 0x000000ff);
108  u  = (pixel_16 & 0x0000ff00) >>  8;
109  y1 = (pixel_16 & 0x00ff0000) >> 16;
110  v  = (pixel_16 & 0xff000000) >> 24;
111  pixel32 = convert_yuv_to_rgb_pixel(y0, u, v);
112  pixel_24[0] = (pixel32 & 0x000000ff);
113  pixel_24[1] = (pixel32 & 0x0000ff00) >> 8;
114  pixel_24[2] = (pixel32 & 0x00ff0000) >> 16;
115  rgb[out++] = pixel_24[0];
116  rgb[out++] = pixel_24[1];
117  rgb[out++] = pixel_24[2];
118  pixel32 = convert_yuv_to_rgb_pixel(y1, u, v);
119  pixel_24[0] = (pixel32 & 0x000000ff);
120  pixel_24[1] = (pixel32 & 0x0000ff00) >> 8;
121  pixel_24[2] = (pixel32 & 0x00ff0000) >> 16;
122  rgb[out++] = pixel_24[0];
123  rgb[out++] = pixel_24[1];
124  rgb[out++] = pixel_24[2];
125 }
126 return0;
127}
128 
129int ProcessImage::convert_yuv_to_rgb_pixel(inty, int u, int v)
130{
131 unsigned int pixel32 = 0;
132 unsigned char *pixel = (unsigned char *)&pixel32;
133 intr, g, b;
134 r = y + (1.370705 * (v-128));
135 g = y - (0.698001 * (v-128)) - (0.337633 * (u-128));
136 b = y + (1.732446 * (u-128));
137 if(r > 255) r = 255;
138 if(g > 255) g = 255;
139 if(b > 255) b = 255;
140 if(r < 0) r = 0;
141 if(g < 0) g = 0;
142 if(b < 0) b = 0;
143 pixel[0] = r * 220 / 256;
144 pixel[1] = g * 220 / 256;
145 pixel[2] = b * 220 / 256;
146 returnpixel32;
147}
148/*yuv格式转换为rgb格式*/

5. [文件] main.cpp ~ 212B     下载(1410)    

01#include <QtGui>
02#include "processImage.h"
03 
04int main(intargc,char *argv[])
05{
06    QApplication app(argc,argv);
07    ProcessImage process;
08    process.resize(640,480);
09    process.show();
10 
11    returnapp.exec();
12}

使用QtCAM在Linux上开始使用网络摄像头
cumj63710的博客
06-15 1013
在本文中，我将解释如何开始使用开源Linux网络摄像头软件QtCAM。 QtCAM具有10多个图像控制设置，显示显示的帧速率，色彩空间切换和扩展设置。 凭借这些功能及其友好的用户界面，QtCAM可能是满足您Linux网络摄像头软件需求的正确选择。 在GNU通用公共许可证下，可以在GitHub上获得QtCAM源代码。 安装和启动QtCAM 在Linux上，您可以从GitHub上提供...
Qt/Linux 下的摄像头捕获（Video4Linux2）
lhembed的专栏
12-10 1393
Linux下使用各种设备是一件令人兴奋的事情。在Unix的世界里，用户与硬件打交待总是简单的。最近笔者在Linux下搞了摄像头的开发，有一点感想发于此处。Linux中操作一个设备一般都是打开（open），读取（read）和关闭（close）。使用Read的大多是一些字符型设备，然而对于显示屏或者摄像头这种字符设备而已，挨个字的读写将使得系统调用变得频繁，众所周之，系统调用对于系统而已是个不小的开销。于是有内存映射(mmap)等物，本例中将讲述在Linux下开发摄像头的一般过程以及使用Qt进行界面开发的实例。
Linux下基于QT的摄像头应用
03-13
Linux下基于QT的摄像头应用，可以打开摄像头并显示
linux下QT控制摄像头显示视频源码
08-16
Linux下使用QT控制USB摄像头显示视频图像的源码，可运行于ARM开发板。
Linux开发板（如RK3588）上打开摄像头设备并获取实时画面
最新发布
阿飞的博客
08-08 826
笔者在项目开发中遇到这样一个需求，硬件同事在 RK3588 麒麟v10系统（本质还是基于Linux系统）开发板上已经安装好了摄像头和相关驱动，现在需要软件去使用这个摄像头并使用摄像头捕捉的画面做一些开发。之前使用 OpenCV 的能打开摄像头并拿到画面帧，但 OpenCV 默认是给我们转为 BGR888 格式的帧返回的，其内部做了转码操作，其一是转码操作如果是跑的 CPU 可能性能不高，其二是需要拿到 YUV 数据使用所以不需要做额外的转码操作。所以决定使用GStreamer直接去打开摄像头设备并获取流。
linux下QT通过v4l2的方式采集摄像头并显示到界面上
05-11
linux下的qt通过v4l2方式采集摄像头数据并且显示，初学者可以学习一下。 linux下的qt通过v4l2方式采集摄像头数据并且显示，初学者可以学习一下。
Linux V4L2 摄像头视频采集
我的编程之旅
05-23 1681
<br />一，什么是 video4linux<br />Video4linux（简称V4L),是linux中关于视频设备的内核驱动,现在已有Video4linux2，还未加入linux内核，使用需自己 下载补丁。在Linux中，视频设备是设备文件，可以像访问普通文件一样对其进行读写，摄像头在/dev/videoN下，N可能为0，1，2，3... 一般0.<br />另，推荐一个用于播放从摄像头采集到的raw数据的播放器RawPlayer，只需要把采集的数据保存到文件***.yuv就OK了。<br />二，
在Linux系统下QT获取摄像头图像，显示在对应窗口
佳佳鸽的博客
12-07 4138
在Linux系统下，通过QT对multimedia、multimediawidgets库的使用，打开摄像头获取图像并显示在对应窗口，点击指定按钮时实现截图保存与显示。 界面效果如下： mycamera.h #ifndef MYCAMERA_H #define MYCAMERA_H #include <QWidget> #include <QCameraInfo> #include <QCamera> #include <QVideoWidget> #i
linux下基于V4L2/Qt的usb摄像头采集显示程序
09-09
总的来说，这个项目展示了如何在Linux环境下利用V4L2 API进行USB摄像头的视频采集，并结合Qt5.6.0库创建一个用户界面，实现摄像头图像的实时显示和参数配置。这样的程序对于开发多媒体应用、监控系统或者其他需要...
linux下基于QT和v4l2驱动的USB摄像头视频采集与显示
02-04
linux下基于QT和v4l2驱动的USB摄像头视频采集与显示例子，请参看其中README文件，本例子在ubuntu12.04LTS下编译通过，采用的通用的免驱摄像头，可以方便的移植到嵌入式linux中
Linux QT摄像头采集图像
jiang_dlut
09-07 6734
Linux下使用各种设备是一件令人兴奋的事情。在Unix的世界里，用户与硬件打交待总是简单的。最近笔者在Linux下搞了摄像头的开发，有一点感想发于此处。 Linux中操作一个设备一般都是打开（open），读取（read）和关闭（close）。使用Read的大多是一些字符型设备，然而对于显示屏或者摄 像头这种字符设备而已，挨个字的读写将使得系统调用变得频繁，众所周之，系统调用对于系统而已是个不小的开销。于是有内存映射(mmap)等物，本例中将 讲述在Linux下开发摄像头的一般过程以及使用Qt进行界面开发
嵌入式linux下QT开发 Camera摄像头采集视频源码
11-25
是基于嵌入式linux下QT开发的 Camera摄像头采集视频源码,并且源码里面最重要还有一份QT界面的控件说明文档等等,源码经测试，直接可编译使用
基于Linux的USB摄像头视频采集+编码+发送
07-17
支持x86和ARM平台的USB摄像头视频采集，根据自己的摄像头设备节点、分辨率修改代码，运行时需要一些库的支持，同时需要注意如果运行缺少某些库时需要软链接进入相应的目录中。
linux中移植Qt后，调用摄像头使用类QCamer类还是使用Linux下的v4l2
qq_57023986的博客
05-30 1407
在Linux中，一般可以使用Qt中的QCamer类或v4l2中的API来调用摄像头。具体选择哪一个工具可以根据实际需要来确定。如果你只需要基本的摄像头图像捕捉，简单地使用QCamer类并依赖Qt的其他部分可能会更加方便。QCamer类提供了许多易于使用的函数，可以轻松地创建和管理摄像头设备、设置捕捉参数、捕捉图像等等。另外，使用QCamer类还可以轻松地融入Qt的GUI应用程序中，增强用户界面的交互性。然而，如果你需要更多的控制和定制摄像头设备，那么使用v4l2库可能更好。
linux下打开摄像头拍照并保存图片+Ubuntu
ttt99908的博客
12-30 3349
linux下打开摄像头拍照并保存图片
Qt---Linux平台Qt5用V4L2读取摄像头，实现实时画面和拍照
热门推荐
sunny_hu92的博客
04-18 1万+
平台：ubuntu14.04 工具：qt5.7_opensource版本 Desktop   1. V4L2的介绍： 摘自http://www.cnblogs.com/silence-hust/p/4464291.html 大部分都一样的流程，多看几遍再结合代码就可以看懂的。   一、Video for Linux two 　　v4l2为linux下视频设备程序提供了一套接口规范...
在Linux用摄像头做简单的监控系统
heat pipe vacuum tube
09-08 1787
<br />Linuxaria 上提供了两份教程，关于如何用Linux PC 上的摄像头做简单的远程监控系统，可以用于家庭环境。注：原教程都是基于Ubuntu 10.04的。<br />第一份方案是基于 Motion 软件的。能够在特定环境下触发，如声音、特定操作等，并能用邮件、SMS远程操纵，同时支持远程调节亮度、对比度等。  原文<br />第二份方案是基于 webcam-server 的。使用更为简单，并有GUI。<br />第三份方案是基于 ZoneMinder 的。这是一个专业的商
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值