Asynchronous texture upload with Qt and OpenGL - c++

Question

I'm writing a small video player using QOpenGLWidget. At the moment I'm struggling to get asynchronous texture upload working. In an earlier version of my code I wait for a "next frame" signal, upon which the frame is read from the hard drive, uploaded to the GPU and then rendered. Now I want to get this working asynchronously using a ring buffer on the GPU. I want a separate thread to upload the next N textures and the main thread to take one of this textures, display and invalidate it. As a first step I wrote a class to upload a single texture which I want to use from my QOpenGLWidget. I created shared contexts between my class and the QOpenGLWidget.
class GLWidget : public QOpenGLWidget, protected QOpenGLFunctions;
void GLWidget::paintGL() {
QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
m_program->bind();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
m_program->setUniformValue("textureSamplerRed", 0);
m_program->setUniformValue("textureSamplerGreen", 1);
m_program->setUniformValue("textureSamplerBlue", 2);
glUniformMatrix4fv(m_matMVP_Loc, 1, GL_FALSE, &m_MVP[0][0]);
m_vertice_indices_Vbo.bind();
m_vertices_Vbo.bind();
m_texture_coordinates_Vbo.bind();
glDrawElements(
GL_TRIANGLE_STRIP, // mode
m_videoFrameTriangles_indices.size(), // count
GL_UNSIGNED_INT, // type
(void*)0 // element array buffer offset
);
m_program->release();
}
I wait for the GLWidget::initializeGL() to finish, emit a signal which is connected to the initialization of my texture loading class:
class TextureLoader2 : public QObject, protected QOpenGLFunctions;
void TextureLoader2::initialize(QOpenGLContext *context)
{
// sharing the OpenGL context with GLWidget
m_context.setFormat(context->format()); // need this?
m_context.setShareContext(context);
m_context.create();
m_context.makeCurrent(context->surface());
m_surface = context->surface();
}
And here is how I load a new frame:
void TextureLoader2::loadNextFrame(const int frameIdx)
{
QElapsedTimer timer;
timer.start();
bool is_current = m_context.makeCurrent(m_surface);
// some code which reads the frame from disk and sends to the GPU.
// srcR is a pointer to the the data for red. the upload for G and B is similar
if(!m_texture_Rdata)
{
m_texture_Rdata = std::make_shared<QOpenGLTexture>(QOpenGLTexture::Target2D);
m_texture_Rdata->create();
m_texture_Rdata->setSize(m_frameWidth,m_frameHeight);
m_texture_Rdata->setFormat(QOpenGLTexture::R8_UNorm);
m_texture_Rdata->allocateStorage(QOpenGLTexture::Red,QOpenGLTexture::UInt8);
m_texture_Rdata->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt8, srcR);
// Set filtering modes for texture minification and magnification
m_texture_Rdata->setMinificationFilter(QOpenGLTexture::Nearest);
m_texture_Rdata->setMagnificationFilter(QOpenGLTexture::Linear);
m_texture_Rdata->setWrapMode(QOpenGLTexture::ClampToBorder);
}
else
{
m_texture_Rdata->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt8, srcR);
}
// these are QOpenGLTextures
m_texture_Rdata->bind(0);
m_texture_Gdata->bind(1);
m_texture_Bdata->bind(2);
emit frameUploaded();
}
My QOpenGLWidget is displaying nothing unfortunately. I don't know how to proceed.
I know that the code for reading and sending the texture to the GPU is working, since if I leave out the line
bool is_current = m_context.makeCurrent(m_surface);
my whole window (not just the frame containing the QOpenGLWidget) is overwritten, displaying the texture.
I've been searching quite a bit, but I couldn't find any simple working example code for what I want to do. Hope someone has an idea what the issue might be. I've seen people mentioning using QOffscreenSurface or a second hidden widget it similar, but different contexts. Maybe I have to use one of those?
My fragment shader:
#version 330 core
// Interpolated values from the vertex shaders
in vec2 fragmentUV;
// Ouput data
out vec4 color_0;
// Values that stay constant for the whole mesh.
uniform sampler2D textureSamplerRed;
uniform sampler2D textureSamplerGreen;
uniform sampler2D textureSamplerBlue;
void main(){
vec3 myColor;
myColor.r = texture2D( textureSamplerRed, fragmentUV ).r;
myColor.g = texture2D( textureSamplerGreen, fragmentUV ).r;
myColor.b = texture2D( textureSamplerBlue, fragmentUV ).r;
color_0 = vec4(, 1.0f);
}