Fix null pointer access and avoid nested allocations with QOpenGLTexture

CMakeLists.txt

@@ -1485,7 +1485,7 @@ else()
       src/shaders/textureshader.cpp
       src/shaders/unicolorshader.cpp
       src/shaders/vinylqualityshader.cpp
-      src/util/texture.cpp
+      src/util/opengltexture2d.cpp
       src/waveform/renderers/allshader/matrixforwidgetgeometry.cpp
       src/waveform/renderers/allshader/waveformrenderbackground.cpp
       src/waveform/renderers/allshader/waveformrenderbeat.cpp

src/util/opengltexture2d.cpp

@@ -0,0 +1,33 @@
+#include "util/opengltexture2d.h"
+
+#include <QPixmap>
+
+#include "widget/paintable.h"
+
+OpenGLTexture2D::OpenGLTexture2D()
+        : QOpenGLTexture(QOpenGLTexture::Target2D){};
+
+void OpenGLTexture2D::setData(const QImage& image) {
+    destroy();
+    if (!image.isNull()) {
+        QOpenGLTexture::setData(image);
+        setMinMagFilters(QOpenGLTexture::Linear, QOpenGLTexture::Linear);
+        setWrapMode(QOpenGLTexture::ClampToEdge);
+    }
+};
+
+void OpenGLTexture2D::setData(const QPixmap& pixmap) {
+    setData(pixmap.toImage());
+};
+
+void OpenGLTexture2D::setData(const QSharedPointer<Paintable>& pPaintable) {
+    if (pPaintable) {
+        setData(pPaintable->toImage());
+    }
+};
+
+void OpenGLTexture2D::setData(const std::shared_ptr<QImage>& pImage) {
+    if (pImage) {
+        setData(*pImage);
+    }
+};

src/util/opengltexture2d.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <QOpenGLTexture>
+#include <QSharedPointer>
+
+class Paintable;
+
+class OpenGLTexture2D : public QOpenGLTexture {
+  public:
+    OpenGLTexture2D();
+
+    void setData(const QImage& image);
+    void setData(const QPixmap& pixmap);
+    void setData(const QSharedPointer<Paintable>& pPaintable);
+    void setData(const std::shared_ptr<QImage>& pImage);
+};

src/waveform/renderers/allshader/waveformrendererpreroll.cpp

@@ -6,13 +6,13 @@
 #include <array>
 
 #include "skin/legacy/skincontext.h"
-#include "util/texture.h"
 #include "waveform/renderers/allshader/matrixforwidgetgeometry.h"
 #include "waveform/renderers/waveformwidgetrenderer.h"
 #include "widget/wskincolor.h"
 
 namespace {
-std::unique_ptr<QOpenGLTexture> generateTexture(float markerLength,
+void generateTexture(OpenGLTexture2D* pTexture,
+        float markerLength,
         float markerBreadth,
         float devicePixelRatio,
         QColor color) {
@@ -54,7 +54,7 @@ std::unique_ptr<QOpenGLTexture> generateTexture(float markerLength,
     painter.drawPath(path);
     painter.end();
 
-    return createTexture(image);
+    pTexture->setData(image);
 }
 } // anonymous namespace
 
@@ -120,13 +120,14 @@ void WaveformRendererPreroll::paintGL() {
         // has changed size last time.
         m_markerLength = markerLength;
         m_markerBreadth = markerBreadth;
-        m_pTexture = generateTexture(m_markerLength,
+        generateTexture(&m_texture,
+                m_markerLength,
                 m_markerBreadth,
                 m_waveformRenderer->getDevicePixelRatio(),
                 m_color);
     }
 
-    if (!m_pTexture) {
+    if (!m_texture.isStorageAllocated()) {
         return;
     }
 
@@ -146,7 +147,7 @@ void WaveformRendererPreroll::paintGL() {
     m_shader.setUniformValue(matrixLocation, matrix);
     m_shader.setUniformValue(textureLocation, 0);
 
-    m_pTexture->bind();
+    m_texture.bind();
 
     const float end = m_waveformRenderer->getLength();
 
@@ -191,7 +192,7 @@ void WaveformRendererPreroll::paintGL() {
                 (end - x) / markerLength);
     }
 
-    m_pTexture->release();
+    m_texture.release();
 
     m_shader.disableAttributeArray(positionLocation);
     m_shader.disableAttributeArray(texcoordLocation);

src/waveform/renderers/allshader/waveformrendererpreroll.h

@@ -6,6 +6,7 @@
 
 #include "shaders/patternshader.h"
 #include "util/class.h"
+#include "util/opengltexture2d.h"
 #include "waveform/renderers/allshader/vertexdata.h"
 #include "waveform/renderers/allshader/waveformrenderer.h"
 
@@ -33,7 +34,7 @@ class allshader::WaveformRendererPreroll final : public allshader::WaveformRende
     QColor m_color;
     float m_markerBreadth{};
     float m_markerLength{};
-    std::unique_ptr<QOpenGLTexture> m_pTexture;
+    OpenGLTexture2D m_texture;
 
     DISALLOW_COPY_AND_ASSIGN(WaveformRendererPreroll);
 };

src/waveform/renderers/allshader/waveformrendermark.cpp

@@ -4,7 +4,6 @@
 #include <QPainterPath>
 
 #include "util/colorcomponents.h"
-#include "util/texture.h"
 #include "waveform/renderers/allshader/matrixforwidgetgeometry.h"
 #include "waveform/renderers/allshader/rgbadata.h"
 #include "waveform/renderers/allshader/vertexdata.h"
@@ -20,15 +19,15 @@
 // then used as textures to be drawn with a GLSL shader.
 
 class TextureGraphics : public WaveformMark::Graphics {
-    std::unique_ptr<QOpenGLTexture> m_pTexture;
-
   public:
-    TextureGraphics(std::unique_ptr<QOpenGLTexture>&& pTexture)
-            : m_pTexture{std::move(pTexture)} {
-    }
-    QOpenGLTexture* texture() const {
-        return m_pTexture.get();
+    TextureGraphics() = default;
+
+    QOpenGLTexture* texture() {
+        return &m_texture;
     }
+
+  private:
+    OpenGLTexture2D m_texture;
 };
 
 // Both allshader::WaveformRenderMark and the non-GL ::WaveformRenderMark derive
@@ -225,11 +224,12 @@ void allshader::WaveformRenderMark::paintGL() {
     const float currentMarkPoint = std::floor(
             static_cast<float>(m_waveformRenderer->getPlayMarkerPosition() *
                     m_waveformRenderer->getLength()));
-    if (m_pPlayPosMarkTexture) {
-        const float markHalfWidth = m_pPlayPosMarkTexture->width() / devicePixelRatio / 2.f;
+
+    if (m_playPosMarkTexture.isStorageAllocated()) {
+        const float markHalfWidth = m_playPosMarkTexture.width() / devicePixelRatio / 2.f;
         const float drawOffset = currentMarkPoint - markHalfWidth;
 
-        drawTexture(drawOffset, 0.f, m_pPlayPosMarkTexture.get());
+        drawTexture(drawOffset, 0.f, &m_playPosMarkTexture);
     }
 }
 
@@ -297,7 +297,7 @@ void allshader::WaveformRenderMark::updatePlayPosMarkTexture() {
     }
     painter.end();
 
-    m_pPlayPosMarkTexture = createTexture(image);
+    m_playPosMarkTexture.setData(image);
 }
 
 void allshader::WaveformRenderMark::drawTriangle(QPainter* painter,
@@ -321,6 +321,8 @@ void allshader::WaveformRenderMark::resizeGL(int, int) {
 }
 
 void allshader::WaveformRenderMark::updateMarkImage(WaveformMarkPointer pMark) {
-    pMark->m_pGraphics = std::make_unique<TextureGraphics>(
-            createTexture(pMark->generateImage(m_waveformRenderer->getDevicePixelRatio())));
+    auto pTextureGraphics = std::make_unique<TextureGraphics>();
+    pTextureGraphics->texture()->setData(
+            pMark->generateImage(m_waveformRenderer->getDevicePixelRatio()));
+    pMark->m_pGraphics = std::move(pTextureGraphics);
 }

src/waveform/renderers/allshader/waveformrendermark.h

@@ -4,6 +4,7 @@
 
 #include "shaders/rgbashader.h"
 #include "shaders/textureshader.h"
+#include "util/opengltexture2d.h"
 #include "waveform/renderers/allshader/waveformrendererabstract.h"
 #include "waveform/renderers/waveformrendermarkbase.h"
 
@@ -44,12 +45,12 @@ class allshader::WaveformRenderMark : public ::WaveformRenderMarkBase,
             QPointF p2,
             QPointF p3);
 
-    mixxx::RGBAShader m_rgbaShader;
-    mixxx::TextureShader m_textureShader;
-    std::unique_ptr<QOpenGLTexture> m_pPlayPosMarkTexture;
-
     void drawMark(const QRectF& rect, QColor color);
     void drawTexture(float x, float y, QOpenGLTexture* texture);
 
+    mixxx::RGBAShader m_rgbaShader;
+    mixxx::TextureShader m_textureShader;
+    OpenGLTexture2D m_playPosMarkTexture;
+
     DISALLOW_COPY_AND_ASSIGN(WaveformRenderMark);
 };