Chinaunix首页 | 论坛 | 博客

everjingyuan的ChinaUnix博客

首页　| 　博文目录　| 　关于我

everjingyuan

  • 博客访问： 84666
  • 博文数量： 25
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 98
  • 用 户 组： 普通用户
  • 注册时间： 2014-10-10 00:42
文章分类

全部博文（25）

推荐博文
相关博文
【ARM+Qt+OpenCV】基于ARM的双目图像采集系统

分类： 嵌入式

2016-05-24 00:53:45

        写在最前面：这是自己的毕业，参考网上了很多大神的代码，没有你们我的毕设无法完成，谢谢你们，在此，将工程中全部代码开源出来，希望对有需要的童鞋有所帮助。

      
        系统使用ARM处理器，运行linux系统，Qt创建工程编写主程序，可以使用OpenCV进行图像处理。
       通过两个摄像头采集会图像，在LCD上进行显示，然后通过LCD上的按钮实现退出程序、保存图像、显示灰度三个功能。细节的东西就不说了，网上一抓一大把，直接上代码。。。
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>走----------------你<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

这是widget.h

点击(此处)折叠或打开

  1. #ifndef WIDGET_H
  2. #define WIDGET_H

  4. #include <QWidget>
  5. #include <QtGui>
  6. #include <QDateTime>
  7. #include <cv.h>
  8. #include <highgui.h>
  9. #include <cxcore.h>
  10. #include "camthread.h"
  11. #include "globaldata.h"

  13. namespace Ui {
  14. class Widget;
  15. }

  17. class Widget : public QWidget
  18. {
  19.     Q_OBJECT

  21. public:
  22.     explicit Widget(QWidget *parent = 0);
  23.     ~Widget();

  25. private slots:
  26.     void slotShowImage(int num, unsigned char* rgb);
  27.     void slotGrayImage();
  28.     void slotSaveImage();

  30. private:
  31.     Ui::Widget *ui;

  33.     volatile bool m_saveFlag_L;
  34.     volatile bool m_saveFlag_R;
  35.     volatile bool m_grayFlag_L;
  36.     volatile bool m_grayFlag_R;

  38.     CamThread* m_cam_L;
  39.     CamThread* m_cam_R;
  40. };

  42. #endif // WIDGET_H

这是widget.cpp

点击(此处)折叠或打开

  1. #include "widget.h"
  2. #include "ui_widget.h"

  4. Widget::Widget(QWidget *parent) :
  5.     QWidget(parent),
  6.     ui(new Ui::Widget)
  7. {
  8.     ui->setupUi(this);

  10.     //flag set
  11.     m_saveFlag_L = 0;
  12.     m_saveFlag_R = 0;
  13.     m_grayFlag_L = 0;
  14.     m_grayFlag_R = 0;
  15.     //camera setup
  16.     m_cam_L = new CamThread("/dev/video1", LEFT_CAM);
  17.     if(m_cam_L->initCam() == -1)
  18.         printf("open %s error\n", m_cam_L->m_devName.toStdString().c_str());
  19.     connect(m_cam_L, SIGNAL(sigGotImage(int, unsigned char*)), this, SLOT(slotShowImage(int, unsigned char*)));

  21.     m_cam_R = new CamThread("/dev/video2", RIGHT_CAM);
  22.     if(m_cam_R->initCam() == -1)
  23.         printf("open %s error\n", m_cam_L->m_devName.toStdString().c_str());
  24.     connect(m_cam_R, SIGNAL(sigGotImage(int, unsigned char*)), this, SLOT(slotShowImage(int, unsigned char*)));

  26.     m_cam_L->start();
  27.     m_cam_R->start();
  28.     printf("thread start\n");

  30.     connect(ui->saveButton, SIGNAL(clicked()), this, SLOT(slotSaveImage()));
  31.     connect(ui->grayButton, SIGNAL(clicked()), this, SLOT(slotGrayImage()));
  32.     connect(ui->quitButton, SIGNAL(clicked()), qApp, SLOT(quit()));
  33. }

  35. Widget::~Widget()
  36. {
  37.     delete ui;

  39.     free(m_cam_L);
  40.     free(m_cam_R);
  41. }

  43. void Widget::slotShowImage(int num, unsigned char* rgb)
  44. {
  45.     ///////////////left////////////////////////
  46.     if(num == LEFT_CAM)
  47.     {
  48.         cv::Mat mat_src_L(IMG_HEIGHT, IMG_WIDTH, CV_8UC3, rgb);
  49.         QImage qimage_L;

  51.         if(m_grayFlag_L == 1)
  52.         { //gray
  53.             cv::Mat mat_gray_L(IMG_WIDTH, IMG_HEIGHT, CV_8UC1);
  54.             cv::cvtColor(mat_src_L, mat_gray_L, CV_BGR2GRAY);

  56.             qimage_L = QImage(mat_gray_L.cols, mat_gray_L.rows, QImage::Format_Indexed8); //Format_Indexed8
  57.             qimage_L.setColorCount(256);
  58.             for(int i = 0; i < 256; i++)
  59.             {
  60.                 qimage_L.setColor(i, qRgb(i, i, i));
  61.             }
  62.             unsigned char* pSrc = mat_gray_L.data;
  63.             for(int row = 0; row < mat_gray_L.rows; row++)
  64.             {
  65.                 unsigned char* pDest = qimage_L.scanLine(row);
  66.                 memcpy(pDest, pSrc, mat_gray_L.cols);
  67.                 pSrc += mat_gray_L.step;
  68.             }
  69.         }
  70.         else
  71.         {
  72.             qimage_L = QImage(mat_src_L.data, mat_src_L.cols, mat_src_L.rows, QImage::Format_RGB888);
  73.         }
  74.        ui->imgLabel_L->setPixmap(QPixmap::fromImage(qimage_L, Qt::AutoColor));

  76.         if(m_saveFlag_L == 1)
  77.         { //save
  78.             QDateTime date_time_L = QDateTime::currentDateTime();
  79.             QString imgName_L = QString("/cam/%1-%2_%3:%4:%5_L.bmp")
  80.                                                 .arg(date_time_L.date().month(), 2, 10, QChar('0'))
  81.                                                 .arg(date_time_L.date().day(), 2, 10, QChar('0'))
  82.                                                 .arg(date_time_L.time().hour(), 2, 10, QChar('0'))
  83.                                                 .arg(date_time_L.time().minute(), 2, 10, QChar('0'))
  84.                                                 .arg(date_time_L.time().second(), 2, 10, QChar('0'));
  85.             qimage_L.save(imgName_L);
  86.             imgName_L = imgName_L + " saved.";
  87.             ui->stateLabel_L->setText(imgName_L );
  88.             m_saveFlag_L = 0;
  89.         }
  90.     }

  92.     ///////////////right////////////////////////
  93.     if(num == RIGHT_CAM)
  94.     {
  95.         cv::Mat mat_src_R(IMG_HEIGHT, IMG_WIDTH, CV_8UC3, rgb);
  96.         QImage qimage_R;

  98.         if(m_grayFlag_R == 1)
  99.         { //gray
  100.             cv::Mat mat_gray_R(IMG_WIDTH, IMG_HEIGHT, CV_8UC1);
  101.             cv::cvtColor(mat_src_R, mat_gray_R, CV_BGR2GRAY);

  103.             qimage_R = QImage(mat_gray_R.cols, mat_gray_R.rows, QImage::Format_Indexed8); //Format_Indexed8
  104.             qimage_R.setColorCount(256);
  105.             for(int i = 0; i < 256; i++)
  106.             {
  107.                 qimage_R.setColor(i, qRgb(i, i, i));
  108.             }
  109.             unsigned char* pSrc = mat_gray_R.data;
  110.             for(int row = 0; row < mat_gray_R.rows; row++)
  111.             {
  112.                 unsigned char* pDest = qimage_R.scanLine(row);
  113.                 memcpy(pDest, pSrc, mat_gray_R.cols);
  114.                 pSrc += mat_gray_R.step;
  115.             }
  116.         }
  117.         else
  118.         {
  119.             qimage_R = QImage(mat_src_R.data, mat_src_R.cols, mat_src_R.rows, QImage::Format_RGB888);
  120.         }
  121.        ui->imgLabel_R->setPixmap(QPixmap::fromImage(qimage_R, Qt::AutoColor));

  123.         if(m_saveFlag_R == 1)
  124.         { //save
  125.             QDateTime date_time_R = QDateTime::currentDateTime();
  126.             QString imgName_R = QString("/cam/%1-%2_%3:%4:%5_R.bmp")
  127.                                                 .arg(date_time_R.date().month(), 2, 10, QChar('0'))
  128.                                                 .arg(date_time_R.date().day(), 2, 10, QChar('0'))
  129.                                                 .arg(date_time_R.time().hour(), 2, 10, QChar('0'))
  130.                                                 .arg(date_time_R.time().minute(), 2, 10, QChar('0'))
  131.                                                 .arg(date_time_R.time().second(), 2, 10, QChar('0'));
  132.             qimage_R.save(imgName_R);
  133.             imgName_R = imgName_R + " saved.";
  134.             ui->stateLabel_R->setText(imgName_R);
  135.             m_saveFlag_R = 0;
  136.         }
  137.     }
  138. }

  140. void Widget::slotSaveImage()
  141. {
  142.     m_saveFlag_L = 1;
  143.     m_saveFlag_R = 1;
  144. }

  146. void Widget::slotGrayImage()
  147. {
  148.     if(m_grayFlag_L == 0)
  149.     {
  150.         //change state
  151.         ui->garyLabel->setText("gray");
  152.         m_grayFlag_L =1;
  153.         m_grayFlag_R =1;
  154.         return;
  155.     }

  157.     if(m_grayFlag_L == 1)
  158.     {
  159.         //change state
  160.         ui->garyLabel->setText("orig");
  161.         m_grayFlag_L = 0;
  162.         m_grayFlag_R = 0;
  163.         return;
  164.     }
  165. }
上面这的代码中使用了一个自定义的CamThread类，这是为了实现对两个摄像头进行多线操作而创建的类。
        值得注意的是在connect(m_cam_X, SIGNAL(sigGotImage(int, unsigned char*)), this, SLOT(slotShowImage(int, unsigned char*)));中，子线程中图像数据是如何被传入主线程中的，这里实验了很久才成功。
       还有将OpenCV中的图像数据进行灰度转化时，长x宽 和 宽x长 似乎有变化，这里感谢佩佩童鞋帮我找出了这个问题。

这是camthread.h

点击(此处)折叠或打开

  1. /* 相机线程类
  2.  * 完成对相机的所用的操作，包括控制，采集
  3.  * 最后发送数据到主线程
  4.  */
  5. #ifndef CAMTHREAD_H
  6. #define CAMTHREAD_H

  8. #include <string.h>
  9. #include <stdlib.h>
  10. #include <errno.h>
  11. #include <fcntl.h>
  12. #include <unistd.h>
  13. #include <sys/ioctl.h>
  14. #include <sys/mman.h>
  15. #include <asm/types.h>
  16. #include <linux/videodev2.h>
  17. #include <QString>
  18. #include <QObject>
  19. #include <QThread>
  20. #include <QFile>
  21. #include <QtGui>
  22. #include <stdio.h>
  23. #include "globaldata.h"

  25. #define PIXE_FORMAT V4L2_PIX_FMT_YUYV//V4L2_PIX_FMT_MJPEG
  26. #define CLEAR(x) memset(&(x), 0, sizeof(x))

  28. class CamThread : public QThread
  29. {
  30.     Q_OBJECT

  32. public:
  33.     CamThread(QString devName, int num);
  34.     ~CamThread();

  36.     int initCam(); //初始化设备

  38. private:
  39.     int openDevice();
  40.     int initDevice();
  41.     int startCapturing();
  42.     //int getFrame(void** frameBuf, size_t* len);
  43.     int getFrame();
  44.     int ungetFrame();
  45.     int stopCapturing();
  46.     int uninitDevice();
  47.     int closeDevice();

  49.     int initMmap();

  51.     //MJPEG
  52.     //int is_huffman(unsigned char *buf);

  54.     //YUYV
  55.     int convertYUVtoRGBpixel(int y, int u, int v);
  56.     int convertYUVtoRGBbuffer(unsigned char* yuv, unsigned char* rgb, unsigned int w, unsigned int h);

  58. protected:
  59.     void run();

  61. signals:
  62.     //void sigGotImage(int num, unsigned char* &rgb);
  63.     void sigGotImage(int num, unsigned char* rgb);

  65. public:
  66.     struct camBuffer //定义一个结构体来映射每个缓存帧
  67.     {
  68.         void* start;
  69.         size_t length;
  70.     };

  72.     QString m_devName; //设备文件名
  73.     int m_camNum; //用于区别左右摄像头
  74.     int m_fd; //文件描述符
  75.     camBuffer* m_buffers; //数据缓存
  76.     unsigned int m_nbuffers; //记录分配内存数量
  77.     int m_index;

  79.     unsigned char* m_yuv;
  80.     unsigned char* m_rgb;

  82. };

  84. #endif // CAMTHREAD_H

这是camthread.cpp

点击(此处)折叠或打开

  1. #include "camthread.h"

  3. CamThread::CamThread(QString devName, int num)
  4. {
  5.     m_devName = devName; //设备文件名
  6.     m_camNum = num; //用于区别左右摄像头
  7.     m_fd = -1; //文件描述符
  8.     m_buffers = NULL; //数据缓存
  9.     m_nbuffers = 0; //记录分配内存数量

  11.     m_yuv = NULL;
  12.     m_rgb = NULL;
  13.     //m_qimage = NULL;
  14. }

  16. CamThread::~CamThread()
  17. {

  19. }


  22. //////////////////////////图像获取///////////////////////////////////////////////////
  23. int CamThread::initCam()
  24. {
  25.     if(openDevice() == -1)
  26.     {
  27.         printf("open %s error\n", m_devName.toStdString().c_str());
  28.         closeDevice();
  29.         return -1;
  30.     }
  31.     if(initDevice() == -1)
  32.     {
  33.         printf("init %s error\n", m_devName.toStdString().c_str());
  34.         closeDevice();
  35.         return -1;
  36.     }
  37.     if(startCapturing() == -1)
  38.     {
  39.         printf("startCapturing %s error\n", m_devName.toStdString().c_str());
  40.         closeDevice();
  41.         return -1;
  42.     }

  44.     return 0;
  45. }

  47. void CamThread::run()
  48. {
  49.     while(1)
  50.     {
  51.             getFrame();
  52.             //printf("getFrame()\n");
  53.             convertYUVtoRGBbuffer(m_yuv, m_rgb, IMG_WIDTH, IMG_HEIGHT);
  54.             //printf("YUV2RGB\n");
  55.             emit sigGotImage(m_camNum, m_rgb);
  56.             //printf("emit signal\n");
  57.             ungetFrame();
  58.             msleep(30);
  59.     }
  60. }

  62. ////////////////////////摄像头具体操作/////////////////////////////////////////////////////
  63. int CamThread::openDevice()
  64. {
  65.     m_fd = open(m_devName.toStdString().c_str(), O_RDWR, 0);
  66.     if(m_fd == -1)
  67.     {
  68.         printf("open: %s\n", strerror(errno));
  69.         return -1;
  70.     }

  72.     return 0;
  73. }

  75. int CamThread::initDevice()
  76. {
  77.     //查询设备属性
  78.     v4l2_capability cap;
  79.     if(ioctl(m_fd, VIDIOC_QUERYCAP, &cap) == -1)
  80.     {
  81.         if(EINVAL == errno)
  82.             printf("%s is no v4l2 device\n", (char*)&m_devName);
  83.         else
  84.             printf("VIDIOC_QUERYCAP: %s\n", strerror(errno));
  85.         return -1;
  86.     }
  87.     if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
  88.     {
  89.         printf("%s is not video capture device\n", (char*)&m_devName);
  90.         return -1;
  91.     }
  92.     if(!(cap.capabilities & V4L2_CAP_STREAMING))
  93.     {
  94.         printf("%s dose not support streaming\n", (char*)&m_devName);
  95.         return -1;
  96.     }
  97.     if(!(cap.capabilities & V4L2_CAP_READWRITE))
  98.     {
  99.         printf("%s dose not support read.write\n", m_devName.toStdString().c_str());
  100.         //return -1;
  101.     }

  103.     //图像的缩放
  104.     v4l2_cropcap cropcap;
  105.     v4l2_crop crop;
  106.     CLEAR(cropcap);
  107.     cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  108.     if(ioctl(m_fd, VIDIOC_CROPCAP, &cropcap) == 0)
  109.     {
  110.         CLEAR(crop);
  111.         crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  112.         crop.c = cropcap.defrect;
  113.         if(ioctl(m_fd, VIDIOC_S_CROP, &crop) == -1)
  114.         {
  115.             if(EINVAL == errno)
  116.             {
  117.                 printf("VIDIOC_S_CROP not supported\n");
  118.             }
  119.             else
  120.             {
  121.                 printf("VIDIOC_S_CROP: %s\n", strerror(errno));
  122.                 return -1;
  123.             }
  124.         }
  125.     }
  126.     else
  127.     {
  128.         printf("VIDIOC_CROPCAP: %s\n", strerror(errno));
  129.         return -1;
  130.     }

  132. //查询所有支持格式
  133.     v4l2_fmtdesc fmtdesc;
  134.      CLEAR(fmtdesc);
  135.      fmtdesc.index = 0;
  136.      fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  137.      printf("support format:\n");
  138.      while(ioctl(m_fd, VIDIOC_ENUM_FMT, &fmtdesc) != -1)
  139.      {
  140.          printf("\t%d.%s\n", fmtdesc.index+1, fmtdesc.description);
  141.          fmtdesc.index++;
  142.      }

  144.     //设置格式
  145.     v4l2_format fmt;
  146.     CLEAR(fmt);
  147.     fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  148.     fmt.fmt.pix.width = IMG_WIDTH;
  149.     fmt.fmt.pix.height = IMG_HEIGHT;
  150.     fmt.fmt.pix.pixelformat = PIXE_FORMAT;
  151.     fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
  152.     if(ioctl(m_fd, VIDIOC_S_FMT, &fmt) == -1)
  153.     {
  154.         printf("VIDIOC_S_FMT: %s\n", strerror(errno));
  155.         return -1;
  156.     }

  158.     //mmap
  159.     if(initMmap() == -1)
  160.     {
  161.         printf("init mmap error \n");
  162.         return -1;
  163.     }

  165.     //m_rgb m_qimage
  166.     m_yuv = (unsigned char*)malloc(IMG_WIDTH*IMG_HEIGHT*3*sizeof(char));
  167.     m_rgb = (unsigned char*)malloc(IMG_WIDTH*IMG_HEIGHT*3*sizeof(char));

  169.     return 0;
  170. }

  172. int CamThread::startCapturing()
  173. {
  174.     //把四个缓冲帧放入队列，并启动数据流
  175.     for(unsigned int i = 0; i < m_nbuffers; ++i)
  176.     {
  177.         v4l2_buffer buf;
  178.         CLEAR(buf);
  179.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  180.         buf.memory = V4L2_MEMORY_MMAP;
  181.         buf.index = i;
  182.         if(ioctl(m_fd, VIDIOC_QBUF, &buf) == -1) //缓冲帧放入队列
  183.         {
  184.             printf("VIDIOC_QBUF %s\n",strerror(errno));
  185.             return -1;
  186.         }
  187.     }

  189.     v4l2_buf_type type;
  190.     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  191.     if(ioctl(m_fd, VIDIOC_STREAMON, &type) == -1)
  192.     {
  193.         printf("VIDIOC_STREAMON %s\n", strerror(errno));
  194.         return -1;
  195.     }

  197.     return 0;
  198. }

  200. //int CamThread::getFrame(void** frameBuf, size_t* len)
  201. int CamThread::getFrame()
  202. {
  203.     //从缓冲区取出一帧，并保存
  204.     v4l2_buffer queue_buf;
  205.     CLEAR(queue_buf);
  206.     queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  207.     queue_buf.memory = V4L2_MEMORY_MMAP;
  208.     if(ioctl(m_fd, VIDIOC_DQBUF, &queue_buf) == -1)
  209.     {
  210.         switch(errno)
  211.         {
  212.             case EAGAIN:
  213.                 return -1;
  214.             case EIO:
  215.                 return -1;
  216.             default:
  217.                 printf("VIDIOC_DQUBUF: %s\n", strerror(errno));
  218.                 return -1;
  219.         }
  220.     }
  221.     //printf("DQBUF done\n");
  222.     //*frameBuf = m_buffers[queue_buf.index].start;
  223.     //*len = m_buffers[queue_buf.index].length; //queue_buf.bytesused;
  224.     m_index = queue_buf.index; //buffer的序号

  226.     //YUYV
  227.     memcpy(m_yuv, m_buffers[queue_buf.index].start, m_buffers[queue_buf.index].length);
  228.     //printf("memcpy done\n");

  230. /*
  231.     //MJPEG
  232.     memcpy(m_tmpBuffer, m_buffers[queue_buf.index].start, queue_buf.bytesused );

  234.     m_fileFd = fopen("cam.jpg", "wb");
  235.     unsigned char *ptdeb, *ptcur = m_tmpBuffer;
  236.     int sizein;
  237.     if(!is_huffman(m_tmpBuffer))
  238.     {
  239.         ptdeb = ptcur = m_tmpBuffer;
  240.         while (((ptcur[0] << 8) | ptcur[1]) != 0xffc0)
  241.             ptcur++;
  242.         sizein = ptcur - ptdeb;
  243.         fwrite(m_tmpBuffer, sizein, 1, m_fileFd);
  244.         fwrite(dht_data, DHT_SIZE, 1, m_fileFd);
  245.         fwrite(ptcur, queue_buf.bytesused-sizein, 1, m_fileFd);
  246.     }
  247.     else
  248.     {
  249.         fwrite(ptcur, queue_buf.bytesused, 1, m_fileFd);
  250.     }
  251.     fclose(m_fileFd);
  252. */

  254.     return 0;
  255. }

  257. int CamThread::ungetFrame()
  258. {
  259.     if(m_index != -1)
  260.     {
  261.         //将取出的帧放回缓冲区(队列)
  262.         v4l2_buffer queue_buf;
  263.         CLEAR(queue_buf);
  264.         queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  265.         queue_buf.memory = V4L2_MEMORY_MMAP;
  266.         queue_buf.index = m_index;
  267.         if(ioctl(m_fd, VIDIOC_QBUF, &queue_buf) == -1)
  268.         {
  269.             printf("VIDIOC_QBUF: %s\n", strerror(errno));
  270.             return -1;
  271.         }

  273.         return 0;
  274.     }
  275.     printf("m_index = -1\n");
  276.     return -1;
  277. }

  279. int CamThread::stopCapturing()
  280. {
  281.     v4l2_buf_type type;
  282.     type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  283.     if(ioctl(m_fd, VIDIOC_STREAMOFF, &type) == -1)
  284.     {
  285.         printf("VIDIOC_STREAMOFF %s\n", strerror(errno));
  286.         return -1;
  287.     }

  289.     return 0;
  290. }

  292. int CamThread::uninitDevice()
  293. {
  294.     for(unsigned int i = 0; i < m_nbuffers; ++i)
  295.     {
  296.         if(munmap(m_buffers[i].start, m_buffers[i].length))
  297.         {
  298.             printf("munmap %s\n", strerror(errno));
  299.             return -1;
  300.         }
  301.     }
  302.     free(m_buffers);
  303.     free(m_yuv);
  304.     free(m_rgb);

  306.     return 0;
  307. }

  309. int CamThread::closeDevice()
  310. {
  311.     if(close(m_fd) == -1)
  312.     {
  313.         printf("close: %s", strerror(errno));
  314.         return -1;
  315.     }

  317.     return 0;
  318. }

  320. int CamThread::initMmap()
  321. {
  322.     //申请缓冲区 ?申请设备中的缓存帧
  323.     v4l2_requestbuffers reqbuf;
  324.     CLEAR(reqbuf);
  325.     reqbuf.count = 4; //缓冲区内缓冲帧数目
  326.     reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; //缓存帧数据格式
  327.     reqbuf.memory = V4L2_MEMORY_MMAP; //I/O方式，内存映射的方式
  328.     if(ioctl(m_fd, VIDIOC_REQBUFS, &reqbuf) == -1)
  329.     {
  330.         if(EINVAL == errno)
  331.             printf("%s does not support memory mapping\n", (char*)&m_devName);
  332.         else
  333.             printf("VIDIOC_REQUBUF %s\n", strerror(errno));
  334.         return -1;
  335.     }
  336.     if(reqbuf.count < 2)
  337.     {
  338.         printf("insufficient buffer memory on %s\n", (char*)&m_devName);
  339.         return -1;
  340.     }

  342.     //映射缓存区帧
  343.     m_buffers = (camBuffer*)calloc(reqbuf.count, sizeof(*m_buffers));
  344.     if(!m_buffers)
  345.     {
  346.         printf("out of memory\n");
  347.         return -1;
  348.     }
  349.     for(m_nbuffers = 0; m_nbuffers < reqbuf.count; ++m_nbuffers)
  350.     {
  351.         v4l2_buffer buf; //缓存帧
  352.         CLEAR(buf);
  353.         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  354.         buf.memory = V4L2_MEMORY_MMAP;
  355.         buf.index = m_nbuffers; //buffer的序号
  356.         // 查询序号为n_buffers 的缓冲区，得到其起始物理地址和大小
  357.         if(ioctl(m_fd, VIDIOC_QUERYBUF, &buf) == -1) //获取(查询)这些缓存帧的地址、长度
  358.         {
  359.             printf("VIDIOC_QUERYBUF: %s\n", strerror(errno));
  360.             return -1;
  361.         }
  362.         m_buffers[m_nbuffers].length = buf.length; //设置
  363.         //将申请到的缓存帧映射到应用程序，用m_buffers指针记录
  364.         m_buffers[m_nbuffers].start = mmap(NULL,
  365.                                                                         buf.length,
  366.                                                                         PROT_READ | PROT_WRITE,
  367.                                                                         MAP_SHARED,
  368.                                                                         m_fd,
  369.                                                                         buf.m.offset);
  370.         if(m_buffers[m_nbuffers].start == MAP_FAILED)
  371.         {
  372.             printf("mmap %s\n", strerror(errno));
  373.             return -1;
  374.         }
  375.     }

  377.     return 0;
  378. }

  380. //////////////////////MJPEG/////////////////////////////////
  381. /*
  382. int CamThread::is_huffman(unsigned char *buf)
  383. {
  384.     unsigned char *ptbuf;
  385.     int i = 0;
  386.     ptbuf = buf;
  387.     while (((ptbuf[0] << 8) | ptbuf[1]) != 0xffda)
  388.     {
  389.             if(i++ > 2048)
  390.                     return 0;
  391.             if(((ptbuf[0] << 8) | ptbuf[1]) == 0xffc4)
  392.                     return 1;
  393.             ptbuf++;
  394.     }
  395.     return 0;
  396. }
  397. */

  399. //////////////////////YUYV图像转换////////////////////////////////////////
  400. int CamThread::convertYUVtoRGBpixel(int y, int u, int v)
  401. {
  402.     unsigned int pixel_32 = 0;
  403.     unsigned char *pixel = (unsigned char *)&pixel_32;
  404.     int r, g, b;
  405.     r = y + (1.370705 * (v-128));
  406.     g = y - (0.698001 * (v-128)) - (0.337633 * (u-128));
  407.     b = y + (1.732446 * (u-128));
  408.     if(r > 255)
  409.         r = 255;
  410.     if(g > 255)
  411.         g = 255;
  412.     if(b > 255)
  413.         b = 255;
  414.     if(r < 0)
  415.         r = 0;
  416.     if(g < 0)
  417.         g = 0;
  418.     if(b < 0)
  419.         b = 0;
  420.     pixel[0] = r*220/256;
  421.     pixel[1] = g*220/256;
  422.     pixel[2] = b*220/256;

  424.     return pixel_32;
  425. }

  427. int CamThread::convertYUVtoRGBbuffer(unsigned char* yuv, unsigned char* rgb, unsigned int w, unsigned int h)
  428. {
  429.     unsigned int in, out = 0;
  430.     unsigned int pixel_16;
  431.     unsigned char pixel_24[3];
  432.     unsigned int pixel_32;
  433.     int y0, u, y1, v;

  435.     for(in = 0; in < w*h*2; in+=4)
  436.     {
  437.         pixel_16 = yuv[in+3]<<24 |
  438.                           yuv[in+2]<<16 |
  439.                           yuv[in+1]<<8 |
  440.                           yuv[in+0];
  441.         y0 = (pixel_16 & 0x000000ff);
  442.         u = (pixel_16 & 0x0000ff00) >> 8;
  443.         y1 = (pixel_16 & 0x00ff0000) >> 16;
  444.         v = (pixel_16 & 0xff000000) >> 24;

  446.         pixel_32 = convertYUVtoRGBpixel(y0, u, v);
  447.         pixel_24[0] = (pixel_32 & 0x000000ff);
  448.         pixel_24[1] = (pixel_32 & 0x0000ff00) >> 8;
  449.         pixel_24[2] = (pixel_32 & 0x00ff0000) >> 16;
  450.         rgb[out++] = pixel_24[0];
  451.         rgb[out++] = pixel_24[1];
  452.         rgb[out++] = pixel_24[2];

  454.         pixel_32 = convertYUVtoRGBpixel(y1, u, v);
  455.         pixel_24[0] = (pixel_32 & 0x000000ff);
  456.         pixel_24[1] = (pixel_32 & 0x0000ff00) >> 8;
  457.         pixel_24[2] = (pixel_32 & 0x00ff0000) >> 16;
  458.         rgb[out++] = pixel_24[0];
  459.         rgb[out++] = pixel_24[1];
  460.         rgb[out++] = pixel_24[2];
  461.     }

  463.     return 0;
  464. }

CamThread类是通过V4L2来实现对摄像头的操作，从摄像头中获取到YUV格式的数据后，还要将其转换为RGB格式的，这里看了关于YUV与RGB颜色空间之间关系的论文，他俩之间是可以相互转换的，最后参考了网上一位大神的代码，时间久远查找不便，不能给出出处请见谅。发现论文中的参数和大神代码中的参数是有些微不同的，但大神的代码运行良好而且参数差值很小，因此没有修改。

至于main.cpp就不用在赘述了。。。

附上运行图


个人水平有限难免有错误之处，希望不吝敕教
未能详尽解说，之后会再进行补充

阅读(3026) | 评论(0) | 转发(0) |
0

上一篇：ubuntu下安装adb驱动

下一篇：关于Qt下的qdbus -- 在一个ObjectPath下生成多个Interface

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6