QtConcurrent引发的崩溃

2023-02-21

使用QtConcurrent创建线程的一些问题总结

示例

在.h文件中定义了：
QFuture<int> m_iFuture;
int funcionProc();

在源文件中：
m_iFuture = QtConcurrent::run(this, &ClassName::functionProc);

int ClassName::functionProc()
{
    while(!isExit())
    {
        ...
    }
}

* 注：由于使用`QtConcurrent::run`创建的线程不能使用`m_iFuture`暂停和取消，只能查询运行状态及完成返回值，因此上面的代码，如果在外面设置`isExit()==true`时，在不同的Qt版本会崩溃

* 原因是线程执行函数一直得不到返回值, 需要在`functionProc`中添加`return`语句。
* 附打开摄像头代码

#ifndef CAMERA_H
#define CAMERA_H

#include <QDialog>
#include <QMutex>
#include <QFuture>
#include <QPixmap>
#include <QSize>
#include <QThread>

#include "opencv2/opencv.hpp"
#include "opencv2/core.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/videoio.hpp"
#include "opencv2/imgproc.hpp"

class Camera : public QObject
{
    Q_OBJECT

public:
    explicit Camera(QObject *parent = 0);
    ~Camera();

    bool open();
    void close();
    bool isAvailable();
    bool isOpened();

    cv::Mat getCurrentFrame();
private:
     bool needStopFrameProc();
     void setStopFrameProc(bool stopFlag);
     int frameProc();
     void setCurrentFrame(const cv::Mat& frame);

signals:
    void frameCaptured(QPixmap pixmap);
    void cameraStateChanged(QString);
private:
    cv::VideoCapture* m_videoCapture;

    bool m_stopFrameProc;
    QMutex m_frameProcMutex;
    QFuture<int> m_frameProcFuture;

    QMutex m_currentFrameMutex;
    cv::Mat m_currentFrame;
};

#endif // CAMERA_H

#include "Camera.h"
#include <dirent.h>
#include <libudev.h>
#include <fstream>
#include <pthread.h>
#include <time.h>
#include <vector>
#include <unistd.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/videodev2.h>//v4l2相关结构体

#include "opencv2/opencv.hpp"
#include "opencv2/core.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/videoio.hpp"
#include "opencv2/imgproc.hpp"
#include <QtMultimedia/QCameraInfo>
#include <QMessageBox>
#include <QMutexLocker>
#include <QtConcurrent>
#include <QImage>
#include <string>
#include <map>
#include <QDebug>

using std::string;

static const int CAMERA_WIDTH = 640;
static const int CAMERA_HEIGHT = 480;

#define udev_list_entry_foreach(entry, first) \
    for (entry = first; \
         entry != NULL; \
         entry = udev_list_entry_get_next(entry))

typedef struct {
    string vid;
    string pid;
} VPID;

std::map<string, string> g_pidandpath;

int v4l2_is_v4l_dev(const char *name)
{
    return !strncmp(name, "video", 5) || !strncmp(name, "radio", 5) || !strncmp(name, "vbi", 3) || !strncmp(name, "v4l-subdev", 10);
}

bool read_vpid(string dev_path, VPID& vpid)
{
    bool success = false;

    auto udev = udev_new();
    if (!udev) {
        return false;
    }

    struct stat statbuf;
    if (stat(dev_path.c_str(), &statbuf) < 0) {
        return false;
    }

    auto type =  S_ISBLK(statbuf.st_mode) ? 'b' : S_ISCHR(statbuf.st_mode) ? 'c' : 0;

    auto opened_dev = udev_device_new_from_devnum(udev, type, statbuf.st_rdev);
    auto dev = opened_dev;

    struct udev_list_entry *list_entry;
    udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(dev))
    {
        success = true;
        if(strcmp(udev_list_entry_get_name(list_entry), "ID_VENDOR_ID") == 0)
            vpid.vid = udev_device_get_property_value(dev, udev_list_entry_get_name(list_entry));

        if(strcmp(udev_list_entry_get_name(list_entry), "ID_MODEL_ID") == 0)
            vpid.pid = udev_device_get_property_value(dev, udev_list_entry_get_name(list_entry));

        //printf("==== vid: %s\n pid: %s\n", vpid.vid.c_str(), vpid.pid.c_str());
        /*printf("%s=%s\n", udev_list_entry_get_name(list_entry), udev_list_entry_get_value(list_entry));*/
    }

    /*while (dev != nullptr) {
        auto serial = udev_device_get_sysattr_value(dev, "serial");
        if (nullptr == serial) {
            dev = udev_device_get_parent(dev);
        } else {
            success = true;
            vpid.vid = udev_device_get_sysattr_value(dev, "idVendor");
            vpid.pid = udev_device_get_sysattr_value(dev, "idProduct");
            printf("==== vid: %s\n pid: %s\n", vpid.vid.c_str(), vpid.pid.c_str());
            break;
        }
    }*/
    if (opened_dev) {
        udev_device_unref(opened_dev);
    }
    udev_unref(udev);

    return success;
}

bool get_camera_path(string &camera_path)
{
    bool success = false;

    const char* dir_name = "/dev";
    DIR* dir = opendir(dir_name);
    if (!dir) {
        fprintf(stderr, "Error: couldn't open the directory: %s\n", dir_name);
        return false;
    }

    struct dirent* entry = nullptr;
    int fd;

    while ((entry = readdir(dir))) {
        if (!v4l2_is_v4l_dev(entry->d_name))
            continue;

        char device_name[256];
        snprintf(device_name, sizeof(device_name), "/dev/%s", entry->d_name);
        
        if ((fd = open(device_name, O_RDWR | O_NONBLOCK)) < 0) {
            continue;
        }

        struct v4l2_capability cap;
        if (ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {
            fprintf(stderr, "Error: cam_info: can't open device: %s\n", device_name);
            close(fd);
            break;
        } else {            
            if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) || !(cap.capabilities & V4L2_CAP_STREAMING)) {                
                close(fd);
                continue;
            } else {
                //printf("Driver Name:%s\n Card Name:%s\n Bus info:%s\n version:%d\n capabilities:%x\n \n ", cap.driver, cap.card, cap.bus_info,cap.version,cap.capabilities);
                camera_path = device_name;
                VPID vid;
                if(read_vpid(device_name, vid))
                {
                    g_pidandpath[vid.pid] = device_name;
                }
                close(fd);
                success = true;
//                break;
            }
        }
    }

    closedir(dir);
    return success;
}


Camera::Camera(QObject *parent)
{
    m_stopFrameProc = false;
    m_videoCapture = new cv::VideoCapture;
}

Camera::~Camera()
{
    delete m_videoCapture;
}

bool Camera::open()
{
    if(m_frameProcFuture.isRunning()) {
        return true;
    } else {
        setStopFrameProc(false);
    }

    string cameraPath;
    if(!::get_camera_path(cameraPath)){
        printf("can not find vis path!\n");
        return false;
    }

    bool cameraOpened;
    for(std::map<string, string>::iterator it = g_pidandpath.begin(); it != g_pidandpath.end(); it++)
    {
        if(strncmp(it->first.c_str(), "ae01", 4) == 0)
        {
            cameraOpened = m_videoCapture->open(it->second);
            //printf("====== %s, cameraOpened: %d\n", it->second.c_str(), cameraOpened);
        }
    }

    //bool cameraOpened = m_videoCapture->open(cameraPath);
    //printf("====== %s, cameraOpened: %d\n", cameraPath.c_str(), cameraOpened);
    if(cameraOpened) {
        m_videoCapture->set(CV_CAP_PROP_FPS, 15);
        m_videoCapture->set(CV_CAP_PROP_FRAME_WIDTH, CAMERA_WIDTH);
        m_videoCapture->set(CV_CAP_PROP_FRAME_HEIGHT, CAMERA_HEIGHT);
        m_videoCapture->set(CV_CAP_PROP_FOURCC, CV_FOURCC('M', 'J', 'P', 'G'));

        m_frameProcFuture = QtConcurrent::run(this, &Camera::frameProc);
    }

    return cameraOpened;
}

void Camera::close()
{
    if(m_frameProcFuture.isRunning())
    {
        setStopFrameProc(true);
        m_frameProcFuture.waitForFinished();
    }
    
    m_videoCapture->release();
}

bool Camera::isAvailable()
{
    string cameraPath;
    if(!::get_camera_path(cameraPath)){
        printf("can not find vis path!\n");
        return false;
    }

    bool cameraOpened = m_videoCapture->open(cameraPath);
    if(cameraOpened) {
        m_videoCapture->release();
        return true;
    } else {
        return false;
    }
}

bool Camera::isOpened()
{
    return m_videoCapture->isOpened();
}

bool Camera::needStopFrameProc()
{
    QMutexLocker locker(&m_frameProcMutex);
    //qDebug() << "needStopFrameProc: " << m_stopFrameProc;
    return m_stopFrameProc;
}

void Camera::setStopFrameProc(bool stopFlag)
{
    QMutexLocker locker(&m_frameProcMutex);
    //qDebug() << "setStopFrameProc: " << stopFlag;
    m_stopFrameProc = stopFlag;
}

/*
* 通过调试发现，当摄像头断开后，每次read()虽然返回的还是true，Mat也不是empty，但是Mat的数据都是上一次的数据，
* 于是推测可以通过直接判断Mat的内容来判断摄像头是否正常。经过调试发现摄像头断开时Mat的数据的确是初始状态的。于是可以通过检测read()后的Mat来判断摄像头是否正常：
*/
bool checkMat(cv::Mat& mat)
{
	for (int i = 0; i < mat.rows; i++)
	{
		uchar* pRow = (unsigned char*)mat.ptr<uchar>(i);
		for (int j = 0; j < mat.cols * mat.channels(); j++)
		{
			if (pRow[j])
			{
				return true;
			}
		}
	}
	return false;
}
/*
* 在正常状态下，这个判断是很快的，所有这个判断可以在每一帧的后面使用。当然，这个要求Mat每次都得初始化。
*
* cv::Mat m;
* while (true)
* {
*    m.release();
*    m_v.read(m);
*    if (!checkMat(frame))
*    {
*        LOG("摄像头断开\n");
*        m_v.release();
*    }
*    ...
* }
*/

int Camera::frameProc()
{
    struct timeval timeout;
    timeout.tv_sec = 0;
    timeout.tv_usec = 1000*100;

    while(!needStopFrameProc()) {
        usleep(50*1000);

        cv::Mat rawFrame;
        *m_videoCapture >> rawFrame;
        if (!checkMat(rawFrame))
            emit cameraStateChanged("摄像头断开, 请重试");

        if(rawFrame.empty()) {
            continue;
        } else {
            setCurrentFrame(rawFrame);

            cv::Mat frame;
            //显示可见光摄像头
            cv::cvtColor(rawFrame, frame, cv::COLOR_RGB2BGR);

            const uchar* data = (const uchar*) frame.data;
            QImage image(data, frame.cols, frame.rows, frame.step, QImage::Format_RGB888);
            QPixmap pixmap = QPixmap::fromImage(image);

            emit frameCaptured(pixmap);
        }
    }

    return 0;
}

cv::Mat Camera::getCurrentFrame()
{
    QMutexLocker locker(&m_currentFrameMutex);
    return m_currentFrame.clone();
}

void Camera::setCurrentFrame(const cv::Mat &frame)
{
    QMutexLocker locker(&m_currentFrameMutex);
    m_currentFrame = frame;
}