rhi_support.cpp

Go to the documentation of this file.

// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "rhi_support_p.h"
 
#include <QtMultimedia/private/qvideotexturehelper_p.h>
#include <QtMultimedia/qvideoframeformat.h>
 
#include <QtCore/qfile.h>
 
QT_BEGIN_NAMESPACE
 
namespace QtMultimediaTest {
 
using namespace Qt::Literals;
 
std::unique_ptr<QRhi> createNullRhi()
{
    QRhiNullInitParams params;
    return std::unique_ptr<QRhi>{ QRhi::create(QRhi::Null, &params) };
}
 
#if QT_CONFIG(opengl)
q23::expected<OffscreenGlRhi, QString> createOffscreenGlRhi()
{
    std::unique_ptr<QOffscreenSurface> fallbackSurface{
        QRhiGles2InitParams::newFallbackSurface(),
    };
 
    QRhiGles2InitParams glParams;
    glParams.format = QSurfaceFormat::defaultFormat();
    glParams.fallbackSurface = fallbackSurface.get();
    std::unique_ptr<QRhi> rhi{
        QRhi::create(QRhi::OpenGLES2, &glParams),
    };
    if (!rhi)
        return q23::unexpected(u"QRhi::create failed"_s);
 
    return OffscreenGlRhi{
        std::move(fallbackSurface),
        std::move(rhi),
    };
}
 
std::unique_ptr<QRhi> createGles2Rhi(QOffscreenSurface *fallbackSurface)
{
    QRhiGles2InitParams params;
    params.fallbackSurface = fallbackSurface;
    return std::unique_ptr<QRhi>{ QRhi::create(QRhi::OpenGLES2, &params) };
}
#endif
 
#if QT_CONFIG(vulkan)
q23::expected<OffscreenVulkanRhi, QString>
createOffscreenVulkanRhi(const QByteArrayList &deviceExtensions)
{
    auto vulkanInstance = std::make_unique<QVulkanInstance>();
    vulkanInstance->setApiVersion(QVersionNumber(1, 1));
    vulkanInstance->setExtensions(QRhiVulkanInitParams::preferredInstanceExtensions());
    if (!vulkanInstance->create())
        return q23::unexpected(u"QVulkanInstance::create failed"_s);
 
    QRhiVulkanInitParams params;
    params.inst = vulkanInstance.get();
    params.deviceExtensions = deviceExtensions;
    std::unique_ptr<QRhi> rhi{
        QRhi::create(QRhi::Vulkan, &params),
    };
    if (!rhi) {
        return q23::unexpected(u"QRhi::create failed"_s);
    }
    return OffscreenVulkanRhi{
        std::move(vulkanInstance),
        std::move(rhi),
    };
}
#endif
 
#if QT_CONFIG(metal)
std::unique_ptr<QRhi> createOffscreenMetalRhi()
{
    QRhiMetalInitParams metalParams;
    return std::unique_ptr<QRhi>(QRhi::create(QRhi::Metal, &metalParams));
}
#endif
 
#if defined(Q_OS_WIN)
std::unique_ptr<QRhi> createOffscreenD3D11Rhi()
{
    QRhiD3D11InitParams params;
    return std::unique_ptr<QRhi>(QRhi::create(QRhi::D3D11, &params));
}
 
std::unique_ptr<QRhi> createWarpD3D11Rhi(const QWindowsD3D11TestDeviceContext &warpDevice)
{
    QRhiD3D11NativeHandles nativeHandles;
    nativeHandles.dev = warpDevice.device.Get();
    nativeHandles.context = warpDevice.context.Get();
 
    QRhiD3D11InitParams params;
    return std::unique_ptr<QRhi>{ QRhi::create(QRhi::D3D11, &params, {}, &nativeHandles) };
}
 
std::unique_ptr<QRhi> createD3D12Rhi()
{
    QRhiD3D12InitParams params;
    return std::unique_ptr<QRhi>{ QRhi::create(QRhi::D3D12, &params) };
}
 
#endif
 
q23::expected<QByteArray, QString> readBackPlane(QRhi &rhi, quint64 handle, QSize planeSize,
                                                 QRhiTexture::Format format)
{
    std::unique_ptr<QRhiTexture> texture(
            rhi.newTexture(format, planeSize, 1, QRhiTexture::UsedAsTransferSource));
    if (!texture->createFrom(QRhiTexture::NativeTexture{ handle, 0 }))
        return q23::unexpected(u"QRhiTexture::createFrom failed"_s);
 
    QRhiResourceUpdateBatch *batch = rhi.nextResourceUpdateBatch();
    QRhiReadbackResult result;
    batch->readBackTexture(texture.get(), &result);
 
    QRhiCommandBuffer *cb = nullptr;
    if (rhi.beginOffscreenFrame(&cb) != QRhi::FrameOpSuccess || !cb)
        return q23::unexpected(u"QRhi::beginOffscreenFrame failed"_s);
    cb->resourceUpdate(batch);
    rhi.endOffscreenFrame();
 
    return result.data;
}
 
#if QT_CONFIG(opengl)
 
namespace {
 
q23::expected<QShader, QString> loadShader(const QString &path)
{
    QFile file(path);
    if (!file.open(QIODevice::ReadOnly))
        return q23::unexpected(u"Could not open shader file: "_s + path);
    QShader shader = QShader::fromSerialized(file.readAll());
    if (!shader.isValid())
        return q23::unexpected(u"Invalid/unsupported shader file: "_s + path);
    return shader;
}
 
} // namespace
 
// Unlike readBackPlane(), EXTERNAL_OES textures can't be read back directly: they're only
// consumable by a shader (samplerExternalOES). Renders the texture through a full-screen quad
// using this module's own externalsampler shader into a plain RGBA8 target, then reads that back.
q23::expected<QByteArray, QString> readBackExternalOesTexture(QRhi &rhi, quint64 handle, QSize size)
{
    std::unique_ptr<QRhiTexture> sourceTexture{
        rhi.newTexture(QRhiTexture::RGBA8, size, 1, QRhiTexture::ExternalOES),
    };
    if (!sourceTexture->createFrom(QRhiTexture::NativeTexture{ handle, 0 }))
        return q23::unexpected(u"Failed to wrap the native handle as an ExternalOES QRhiTexture"_s);
 
    std::unique_ptr<QRhiTexture> targetTexture{
        rhi.newTexture(QRhiTexture::RGBA8, size, 1,
                       QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource),
    };
    if (!targetTexture->create())
        return q23::unexpected(u"Failed to create the readback render target texture"_s);
 
    QRhiColorAttachment colorAttachment(targetTexture.get());
    std::unique_ptr<QRhiTextureRenderTarget> renderTarget{
        rhi.newTextureRenderTarget(QRhiTextureRenderTargetDescription(colorAttachment)),
    };
    std::unique_ptr<QRhiRenderPassDescriptor> renderPassDescriptor{
        renderTarget->newCompatibleRenderPassDescriptor(),
    };
    renderTarget->setRenderPassDescriptor(renderPassDescriptor.get());
    if (!renderTarget->create())
        return q23::unexpected(u"Failed to create the readback render target"_s);
 
    const QVideoFrameFormat format(size, QVideoFrameFormat::Format_SamplerExternalOES);
    auto vertexShader = loadShader(QVideoTextureHelper::vertexShaderFileName(format));
    if (!vertexShader)
        return q23::unexpected(vertexShader.error());
    auto fragmentShader = loadShader(QVideoTextureHelper::fragmentShaderFileName(format, &rhi));
    if (!fragmentShader)
        return q23::unexpected(fragmentShader.error());
 
    std::unique_ptr<QRhiSampler> sampler{
        rhi.newSampler(QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
                       QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge),
    };
    if (!sampler->create())
        return q23::unexpected(u"Failed to create the sampler"_s);
 
    std::unique_ptr<QRhiBuffer> uniformBuffer{
        rhi.newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer,
                      sizeof(QVideoTextureHelper::UniformData)),
    };
    if (!uniformBuffer->create())
        return q23::unexpected(u"Failed to create the uniform buffer"_s);
 
    std::unique_ptr<QRhiShaderResourceBindings> srb(rhi.newShaderResourceBindings());
    srb->setBindings({
            QRhiShaderResourceBinding::uniformBuffer(
                    0,
                    QRhiShaderResourceBinding::VertexStage
                            | QRhiShaderResourceBinding::FragmentStage,
                    uniformBuffer.get()),
            QRhiShaderResourceBinding::sampledTexture(1, QRhiShaderResourceBinding::FragmentStage,
                                                      sourceTexture.get(), sampler.get()),
    });
    if (!srb->create())
        return q23::unexpected(u"Failed to create the shader resource bindings"_s);
 
    // A single full-screen quad (vertexPosition: vec4, vertexTexCoord: vec2, interleaved),
    // matching the vertex layout every one of this module's video shaders expects.
    static constexpr float vertexData[] = {
        // x,    y,   z,   w,   u,   v
        -1.f, -1.f, 0.f, 1.f, 0.f, 0.f, //
        1.f,  -1.f, 0.f, 1.f, 1.f, 0.f, //
        -1.f, 1.f,  0.f, 1.f, 0.f, 1.f, //
        1.f,  1.f,  0.f, 1.f, 1.f, 1.f,
    };
    std::unique_ptr<QRhiBuffer> vertexBuffer{
        rhi.newBuffer(QRhiBuffer::Immutable, QRhiBuffer::VertexBuffer, sizeof(vertexData)),
    };
    if (!vertexBuffer->create())
        return q23::unexpected(u"Failed to create the vertex buffer"_s);
 
    QRhiVertexInputLayout inputLayout;
    inputLayout.setBindings({ { 6 * sizeof(float) } });
    inputLayout.setAttributes({
            { 0, 0, QRhiVertexInputAttribute::Float4, 0 },
            { 0, 1, QRhiVertexInputAttribute::Float2, 4 * sizeof(float) },
    });
 
    std::unique_ptr<QRhiGraphicsPipeline> pipeline(rhi.newGraphicsPipeline());
    pipeline->setShaderStages({
            { QRhiShaderStage::Vertex, *vertexShader },
            { QRhiShaderStage::Fragment, *fragmentShader },
    });
    pipeline->setVertexInputLayout(inputLayout);
    pipeline->setShaderResourceBindings(srb.get());
    pipeline->setRenderPassDescriptor(renderPassDescriptor.get());
    pipeline->setTopology(QRhiGraphicsPipeline::TriangleStrip);
    if (!pipeline->create())
        return q23::unexpected(u"Failed to create the graphics pipeline"_s);
 
    QRhiCommandBuffer *cb = nullptr;
    if (rhi.beginOffscreenFrame(&cb) != QRhi::FrameOpSuccess || !cb)
        return q23::unexpected(u"QRhi::beginOffscreenFrame failed"_s);
 
    QRhiResourceUpdateBatch *batch = rhi.nextResourceUpdateBatch();
    batch->uploadStaticBuffer(vertexBuffer.get(), vertexData);
 
    QVideoTextureHelper::UniformData uniformData{};
    const QMatrix4x4 identity;
    memcpy(uniformData.transformMatrix, identity.constData(), sizeof(uniformData.transformMatrix));
    memcpy(uniformData.colorMatrix, identity.constData(), sizeof(uniformData.colorMatrix));
    uniformData.opacity = 1.f;
    batch->updateDynamicBuffer(uniformBuffer.get(), 0, sizeof(uniformData), &uniformData);
 
    cb->beginPass(renderTarget.get(), Qt::black, { 1.0f, 0 }, batch);
    cb->setGraphicsPipeline(pipeline.get());
    cb->setViewport({ 0, 0, float(size.width()), float(size.height()) });
    cb->setShaderResources(srb.get());
    const QRhiCommandBuffer::VertexInput vertexBinding(vertexBuffer.get(), 0);
    cb->setVertexInput(0, 1, &vertexBinding);
    cb->draw(4);
    cb->endPass();
 
    QRhiReadbackResult result;
    QRhiResourceUpdateBatch *readbackBatch = rhi.nextResourceUpdateBatch();
    readbackBatch->readBackTexture(targetTexture.get(), &result);
    cb->resourceUpdate(readbackBatch);
 
    rhi.endOffscreenFrame();
 
    return result.data;
}
 
#endif // QT_CONFIG(opengl)
 
} // namespace QtMultimediaTest
 
QT_END_NAMESPACE