升级qt后QOpenGL程序崩溃

Question

我有一个程序可以从设备中提取输入。 将我的主板上的qt从4.7升级到5.11后，我遇到了段错误。 如果我在执行QOpenGLTexture :: allocateStorages（）的行中注释掉，那么它不会崩溃，但是窗口中没有图像，只是黑色。 但是，该程序可以在具有较旧版本qt的电路板上使用。 我不知道为什么会崩溃。 一般来说，我对opengl和qt还是陌生的，感谢您的帮助。 这是显示代码

#include <QOpenGLWidget>
#include <QOpenGLShaderProgram>
#include <QOpenGLBuffer>
#include <QImage>
#include <memory>
#include "FanGeometryEngine.h"

class WindowDisplay : public QOpenGLWidget, public QOpenGLFunctions
{
Q_OBJECT

public:
    WindowDisplay(QWidget* parent = nullptr);
    ~WindowDisplay() override;
    void nextPalette();

protected:
    void initializeGL() override;
    void resizeGL(int w, int h) override;
    void paintGL() override;
    QMatrix4x4 projection;

private:
    QOpenGLShaderProgram fanImageProgram;
    QOpenGLTexture palettes;
    QOpenGLTexture intensities;
    int currentRotation {0};
    float paletteIndex {1.0f / 12.0f};

    FanGeometryEngine geometryEngine;

    void initFanImageShaders();
    void initPalettes();
    void initIntensities(uint16_t width, uint16_t height, uint8_t* data);

public slots:
    void newDataReceived(
        uint16_t width,
        uint16_t height,
        Device::Frequency frequency,
        double range,
        double gain,
        int16_t* bearings,
        uint8_t* data
    );
};

WindowDisplay.cpp

#include "WindowDisplay.h"

WindowDisplay::WindowDisplay(QWidget* parent) :
    QOpenGLWidget(parent),
    palettes(QOpenGLTexture::Target2D),
    intensities(QOpenGLTexture::Target2D)
{
    this->projection.setToIdentity();
    this->projection.translate(0.0f, -1.0f);
    this->projection.scale(2.0f, 2.0f);
}

WindowDisplay::~WindowDisplay()
{
    this->makeCurrent();
    this->palettes.destroy();
    this->intensities.destroy();
    this->doneCurrent();
}

void WindowDisplay::initializeGL()
{
    this->initializeOpenGLFunctions();
    this->glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    this->setFont(QFont("Verdana", 14), "white");

    this->initFanImageShaders();
    this->initPalettes();

    uint8_t intensityData[256 * 396];
    for (int i = 0; i < 256 * 396; i++) {
        intensityData[i] = static_cast<uint8_t>(i);
    }
    this->initIntensities(256, 396, intensityData);

    this->fanImageProgram.release();
}

void WindowDisplay::initFanImageShaders()
{
    if (! this->fanImageProgram.addShaderFromSourceFile(
        QOpenGLShader::Vertex,
        ":/Graphics/Shaders/FanImage/VertexShader.glsl"
    )) {
        this->close();
    }

    if (! this->fanImageProgram.addShaderFromSourceFile(
        QOpenGLShader::Fragment,
        ":/Graphics/Shaders/FanImage/FragmentShader.glsl"
    )) {
        this->close();
    }

    this->fanImageProgram.bindAttributeLocation("aPosition", 0);
    this->fanImageProgram.bindAttributeLocation("aTextureCoords", 1);

    if (! this->fanImageProgram.link()) {
        this->close();
    }

    if (! this->fanImageProgram.bind()) {
        this->close();
    }
}

void WindowDisplay::initPalettes()
{
    QImage image(":/Graphics/TextureImages/palettes.bmp");
    image.rgbSwapped();

    this->palettes.setData(image.mirrored(), QOpenGLTexture::DontGenerateMipMaps);
    this->palettes.setMinificationFilter(QOpenGLTexture::Nearest);
    this->palettes.setMagnificationFilter(QOpenGLTexture::Linear);
    this->palettes.setWrapMode(QOpenGLTexture::WrapMode::ClampToEdge);
}

void WindowDisplay::initIntensities(uint16_t width, uint16_t height, uint8_t* data)
{
    this->makeCurrent();
    this->intensities.destroy();
    this->intensities.create();
    this->intensities.setSize(width, height);
    this->intensities.setFormat(QOpenGLTexture::R8_UNorm);
    this->intensities.allocateStorage();        // <===========  If I comment out this line 
                                                // then it doesn't crash
    this->intensities.setData(
        QOpenGLTexture::Red,
        QOpenGLTexture::UInt8,
        data
    );
    this->intensities.setMinificationFilter(QOpenGLTexture::Nearest);
    this->intensities.setMagnificationFilter(QOpenGLTexture::Linear);
}

void WindowDisplay::resizeGL(int w, int h)
{

    const float max = 1.99f;

    const float labelWidth =  70.0f;
    float multiplier = (static_cast<float>(w) / h) /
        (this->geometryEngine.getAspectRatio() + ((2.0f / w) * labelWidth));
    multiplier = multiplier > 1.0f ? 1.0f : multiplier;

    this->projection(0, 0) = max * (static_cast<float>(h) / w) * multiplier;
    this->projection(1, 1) = multiplier * max;
    this->projection(1, 3) = -1.0f + ((max - (multiplier * max)) / max);
}

void WindowDisplay::paintGL()
{
    this->glClear(GL_COLOR_BUFFER_BIT);

    this->fanImageProgram.bind();
    this->palettes.bind(0);
    this->fanImageProgram.setUniformValue(
        this->fanImageProgram.uniformLocation("palettes"),
        0
    );
    this->intensities.bind(1);
    this->fanImageProgram.setUniformValue(
        this->fanImageProgram.uniformLocation("intensities"),
        1
    );
    this->fanImageProgram.setUniformValue("chosenPalette", this->paletteIndex);
    this->fanImageProgram.setUniformValue("projection", this->projection);
    this->geometryEngine.drawFanImage(&this->fanImageProgram);
    this->intensities.release();
    this->palettes.release();
    this->fanImageProgram.release();
}

void WindowDisplay::newDataReceived(
    uint16_t width,
    uint16_t height,
    Device::Frequency frequency,
    double line,
    double gain,
    int16_t *bearings,
    uint8_t *data
)
{
    this->geometryEngine.updateParams(
        frequency,
        line,
        gain,
        bearings,
        width
    );
    delete bearings;
    this->geometryEngine.setConnectionText("Connected");
    this->initIntensities(width, height, data);
    delete data;
    this->update();
}


void WindowDisplay::nextPalette()
{
    float yShift = 1.0f / 6.0f;
    this->paletteIndex += yShift;
    // reset to first palette after last one
    if (this->paletteIndex > 1.0f) {
        this->paletteIndex = 1.0f / 12.0f;
    }
}