QT应用处理大图像时无报错意外崩溃问题求助

核心症状 #

• 每半秒接收82次3072x64的32位原始数据，拼接为3072×5248（64×82）的大图，每秒完成处理与显示
• 处理少于69张大图时运行正常，达到69张时无报错意外崩溃；注释*pixel = scaledPixelValue;语句后可正常运行
• 改用16位数据测试时，处理第140张同规格大图时崩溃

可能原因与排查方向 #

1. QImage内存重复赋值导致堆损坏 #

代码中重置image的逻辑存在隐患：

image = QImage();
image = QImage(3072, 5248, QImage::Format_Grayscale16);

image = QImage()会触发旧QImage的析构，但如果此时frameProcessed信号的槽函数仍在引用旧图像内存，会导致悬空指针访问，进而破坏堆结构。这类内存损坏不会立即崩溃，积累到一定次数（69/140次）才会触发崩溃。

2. 缓冲区索引计算错误 #

代码中bufIndex按字节偏移计算，但rawPixels是uint16_t*类型，索引应按元素数而非字节数计算：

unsigned long long bufIndex = (y * width * 2 + x * 2) + ((recv_frames - 1) * width * 2 * frameHeight);

此处的*2是字节数，但rawPixels是16位指针，直接用该值作为索引会导致越界访问，破坏内存。虽然有越界检查，但计算逻辑错误导致检查失效。

3. 未同步的多线程访问 #

如果ProcessRecievedFrame在多线程中执行，currentLine、image等成员变量无线程保护，会引发竞态条件，比如在重置image的同时进行像素赋值，直接破坏内存结构。

4. 内存泄漏累积 #

若ifComplete为false时未释放images，会导致内存泄漏，积累到一定程度触发OOM崩溃，但注释像素赋值后仍正常，更倾向堆损坏而非泄漏问题。

修复方案 #

1. 修正缓冲区索引计算 #

将bufIndex改为按16位元素数计算，移除字节数的*2：

// 按uint16_t元素数计算索引，无需乘2
unsigned long long bufIndex = (y * width + x) + ((recv_frames - 1) * width * frameHeight);
// 对应的rawPixelsSize也改为元素数
size_t rawPixelsSize = width * frameHeight * recv_frames;

同步修正越界检查逻辑：

if (bufIndex >= rawPixelsSize) { // bufIndex为unsigned类型，不会小于0
    qWarning() << "bufIndex out of bounds:" << bufIndex << "rawPixelsSize:" << rawPixelsSize;
    continue;
}

2. 优化QImage重置逻辑 #

避免直接覆盖旧图像，确保信号处理完成后再重置，或使用智能指针管理图像生命周期：

if (currentLine > 5244) {
    qDebug() << "image reset" << currentLine;
    currentLine = 0;
    // 通知槽函数停止使用旧图像，避免悬空指针
    emit imageAboutToReset();
    image = QImage(3072, 5248, QImage::Format_Grayscale16);
}

也可改用QSharedPointer<QImage>管理图像，让槽函数持有智能指针，自动处理内存释放。

3. 添加线程同步保护 #

若在多线程环境中运行，对currentLine、image等成员变量添加互斥锁：

#include <QMutex>
#include <QMutexLocker>

class Display {
private:
    QMutex m_mutex;
    int currentLine = 0;
    QImage image;
    // ... 其他成员
};

void Display::ProcessRecievedFrame(bool ifComplete, uint8_t* images, int recv_frames) {
    QMutexLocker locker(&m_mutex); // 加锁保护成员变量
    // ... 原函数逻辑
}

4. 强化像素赋值的边界检查 #

确保scanLine返回的指针有效，避免悬空指针：

int targetY = y + currentLine;
if (targetY >= image.height()) {
    qWarning() << "Invalid targetY:" << targetY;
    continue;
}
uint16_t* pixelLine = reinterpret_cast<uint16_t*>(image.scanLine(targetY));
if (!pixelLine) {
    qWarning() << "Null scanLine for y:" << targetY;
    continue;
}
uint16_t* pixel = pixelLine + x;

优化后的完整代码 #

#include <QMutex>
#include <QMutexLocker>
#include <QImage>
#include <QDebug>
#include <cmath>

class Display {
private:
    QMutex m_mutex;
    int currentLine = 0;
    QImage image;
    // ... 其他成员
signals:
    void frameProcessed(const QImage& image);
    void imageAboutToReset();
};

void Display::ProcessRecievedFrame(bool ifComplete, uint8_t* images, int recv_frames) {
    QMutexLocker locker(&m_mutex);

    const int width = 3072;
    const int frameHeight = 64;
    const int totalLines = 5248;
    const int scalefactor = 15;

    if (currentLine >= totalLines) {
        qWarning("All lines have been processed");
        return;
    }

    const uint16_t* rawPixels = reinterpret_cast<const uint16_t*>(images);
    // 按uint16_t元素数计算缓冲区大小
    const size_t rawPixelsSize = static_cast<size_t>(width) * frameHeight * recv_frames;

    for (int y = 0; y < frameHeight; ++y) {
        const int targetY = y + currentLine;
        if (targetY >= image.height()) {
            qWarning() << "Invalid targetY:" << targetY;
            continue;
        }

        uint16_t* pixelLine = reinterpret_cast<uint16_t*>(image.scanLine(targetY));
        if (!pixelLine) {
            qWarning() << "Null scanLine for y:" << targetY;
            continue;
        }

        for (int x = 0; x < width; ++x) {
            // 按uint16_t元素数计算索引
            const unsigned long long bufIndex = static_cast<unsigned long long>(y) * width + x 
                + static_cast<unsigned long long>(recv_frames - 1) * width * frameHeight;

            if (bufIndex >= rawPixelsSize) {
                qWarning() << "bufIndex out of bounds:" << bufIndex << "rawPixelsSize:" << rawPixelsSize;
                continue;
            }

            const ushort pixelValue = rawPixels[bufIndex];
            uint16_t* pixel = pixelLine + x;

            if (std::isfinite(static_cast<double>(pixelValue)) && pixelValue >= 0) {
                int scaledPixelValue = static_cast<int>(pixelValue * scalefactor + 0.5);
                scaledPixelValue = qBound(0, scaledPixelValue, 65535);

                *pixel = static_cast<uint16_t>(scaledPixelValue);
            } else {
                qDebug() << "Invalid pixelValue:" << pixelValue;
            }
        }
    }

    currentLine += frameHeight;
    emit frameProcessed(image);

    if (ifComplete) {
        delete[] images;
        return;
    }

    if (currentLine > 5244) {
        qDebug() << "image reset" << currentLine;
        currentLine = 0;
        emit imageAboutToReset();
        image = QImage(width, totalLines, QImage::Format_Grayscale16);
    }
}

内容的提问来源于stack exchange，提问作者TheUser