qwindowsd3d11videoprocessor.cpp

Go to the documentation of this file.

// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qwindowsd3d11videoprocessor_p.h"
 
#include <QtCore/qloggingcategory.h>
#include <QtCore/private/qsystemerror_p.h>
 
#include <dxgi1_2.h>
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(lcD3D11VideoProcessor, "qt.multimedia.windows.d3d11videoprocessor");
 
namespace QtMultimediaPrivate {
 
namespace {
 
DXGI_COLOR_SPACE_TYPE toDxgiColorSpace(QVideoFrameFormat::ColorSpace colorSpace,
                                       QVideoFrameFormat::ColorRange colorRange,
                                       QVideoFrameFormat::ColorTransfer colorTransfer)
{
    const bool fullRange = colorRange == QVideoFrameFormat::ColorRange_Full;
 
    switch (colorSpace) {
    case QVideoFrameFormat::ColorSpace_BT2020:
        switch (colorTransfer) {
        case QVideoFrameFormat::ColorTransfer_ST2084:
            // DXGI defines no full-range YCbCr/PQ/2020 space; HDR10 input is always
            // studio-range, tone-mapped to the SDR output space by the processor.
            return DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020;
        case QVideoFrameFormat::ColorTransfer_STD_B67:
            return fullRange ? DXGI_COLOR_SPACE_YCBCR_FULL_GHLG_TOPLEFT_P2020
                             : DXGI_COLOR_SPACE_YCBCR_STUDIO_GHLG_TOPLEFT_P2020;
        case QVideoFrameFormat::ColorTransfer_Unknown:
        case QVideoFrameFormat::ColorTransfer_BT709:
        case QVideoFrameFormat::ColorTransfer_BT601:
        case QVideoFrameFormat::ColorTransfer_Linear:
        case QVideoFrameFormat::ColorTransfer_Gamma22:
        case QVideoFrameFormat::ColorTransfer_Gamma28:
            // BT.2020 primaries with a gamma transfer are wide-gamut SDR, not HDR.
            return fullRange ? DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020
                             : DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020;
        }
        Q_UNREACHABLE_RETURN(DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020);
    case QVideoFrameFormat::ColorSpace_BT601:
        return fullRange ? DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601
                         : DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601;
    case QVideoFrameFormat::ColorSpace_BT709:
    case QVideoFrameFormat::ColorSpace_AdobeRgb:
    case QVideoFrameFormat::ColorSpace_Undefined:
        // Fallback for color spaces with no DXGI equivalent (e.g. AdobeRgb).
        return fullRange ? DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709
                         : DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709;
    }
    Q_UNREACHABLE_RETURN(DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709);
}
 
} // namespace
 
QWindowsD3D11VideoProcessor::QWindowsD3D11VideoProcessor() = default;
QWindowsD3D11VideoProcessor::~QWindowsD3D11VideoProcessor() = default;
 
bool QWindowsD3D11VideoProcessor::isPixelFormatSupported(QVideoFrameFormat::PixelFormat pixelFormat)
{
    // Matches the D3D11VA surface formats in FFmpeg's hwcontext_d3d11va supported_formats[].
    switch (pixelFormat) {
    case QVideoFrameFormat::Format_NV12:
    case QVideoFrameFormat::Format_P010:
        return true;
    default:
        return false;
    }
}
 
bool QWindowsD3D11VideoProcessor::ensureVideoProcessor(ID3D11Device *device, const QSize &frameSize)
{
    if (m_videoProcessor && m_processorSize == frameSize)
        return true;
 
    m_videoProcessor.Reset();
    m_enumerator.Reset();
    m_processorSize = {};
 
    if (!m_videoDevice) {
        if (FAILED(device->QueryInterface(IID_PPV_ARGS(&m_videoDevice))))
            return false;
    }
 
    if (!m_videoContext) {
        ComPtr<ID3D11DeviceContext> ctx;
        device->GetImmediateContext(&ctx);
        if (FAILED(ctx.As(&m_videoContext)))
            return false;
    }
 
    D3D11_VIDEO_PROCESSOR_CONTENT_DESC contentDesc{};
    contentDesc.InputFrameFormat = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
    contentDesc.InputWidth = static_cast<UINT>(frameSize.width());
    contentDesc.InputHeight = static_cast<UINT>(frameSize.height());
    contentDesc.OutputWidth = static_cast<UINT>(frameSize.width());
    contentDesc.OutputHeight = static_cast<UINT>(frameSize.height());
    contentDesc.Usage = D3D11_VIDEO_USAGE_PLAYBACK_NORMAL;
 
    HRESULT hr = m_videoDevice->CreateVideoProcessorEnumerator(&contentDesc, &m_enumerator);
    if (FAILED(hr)) {
        qCWarning(lcD3D11VideoProcessor)
                << "CreateVideoProcessorEnumerator:" << QSystemError::windowsComString(hr);
        return false;
    }
 
    hr = m_videoDevice->CreateVideoProcessor(m_enumerator.Get(), 0, &m_videoProcessor);
    if (FAILED(hr)) {
        qCWarning(lcD3D11VideoProcessor)
                << "CreateVideoProcessor:" << QSystemError::windowsComString(hr);
        m_enumerator.Reset();
        return false;
    }
 
    m_processorSize = frameSize;
    return true;
}
 
bool QWindowsD3D11VideoProcessor::ensureOutputTexture(ID3D11Device *device, const QSize &frameSize)
{
    if (m_outputTex) {
        D3D11_TEXTURE2D_DESC desc{};
        m_outputTex->GetDesc(&desc);
        if (desc.Width == static_cast<UINT>(frameSize.width())
            && desc.Height == static_cast<UINT>(frameSize.height()))
            return true;
    }
 
    m_outputView.Reset();
    m_outputTex.Reset();
 
    D3D11_TEXTURE2D_DESC desc{};
    desc.Width = static_cast<UINT>(frameSize.width());
    desc.Height = static_cast<UINT>(frameSize.height());
    desc.MipLevels = 1;
    desc.ArraySize = 1;
    desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    desc.SampleDesc = { 1, 0 };
    desc.Usage = D3D11_USAGE_DEFAULT;
    desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
 
    if (FAILED(device->CreateTexture2D(&desc, nullptr, &m_outputTex)))
        return false;
 
    D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC outputViewDesc{};
    outputViewDesc.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D;
    outputViewDesc.Texture2D.MipSlice = 0;
 
    HRESULT hr = m_videoDevice->CreateVideoProcessorOutputView(
            m_outputTex.Get(), m_enumerator.Get(), &outputViewDesc, &m_outputView);
    if (FAILED(hr)) {
        qCWarning(lcD3D11VideoProcessor)
                << "CreateVideoProcessorOutputView:" << QSystemError::windowsComString(hr);
        m_outputTex.Reset();
        return false;
    }
 
    return true;
}
 
ComPtr<ID3D11Texture2D> QWindowsD3D11VideoProcessor::convertToBGRA(
        ID3D11Device *device, ID3D11DeviceContext *context, const ComPtr<ID3D11Texture2D> &texture,
        const QSize &frameSize, QVideoFrameFormat::ColorSpace colorSpace,
        QVideoFrameFormat::ColorRange colorRange, QVideoFrameFormat::ColorTransfer colorTransfer,
        UINT subresourceIndex)
{
    Q_ASSERT(device);
    Q_ASSERT(context);
    Q_ASSERT(texture);
 
    if (frameSize.isEmpty())
        return nullptr;
 
    if (!ensureVideoProcessor(device, frameSize))
        return nullptr;
 
    if (!ensureOutputTexture(device, frameSize))
        return nullptr;
 
    D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC inputViewDesc{};
    inputViewDesc.FourCC = 0;
    inputViewDesc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
    inputViewDesc.Texture2D.MipSlice = 0;
    inputViewDesc.Texture2D.ArraySlice = subresourceIndex;
 
    ComPtr<ID3D11VideoProcessorInputView> inputView;
    HRESULT hr = m_videoDevice->CreateVideoProcessorInputView(texture.Get(), m_enumerator.Get(),
                                                              &inputViewDesc, &inputView);
    if (FAILED(hr)) {
        qCWarning(lcD3D11VideoProcessor)
                << "CreateVideoProcessorInputView:" << QSystemError::windowsComString(hr);
        return nullptr;
    }
 
    m_videoContext->VideoProcessorSetStreamColorSpace1(
            m_videoProcessor.Get(), 0, toDxgiColorSpace(colorSpace, colorRange, colorTransfer));
    m_videoContext->VideoProcessorSetOutputColorSpace1(m_videoProcessor.Get(),
                                                       DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709);
 
    D3D11_VIDEO_PROCESSOR_STREAM stream{};
    stream.Enable = TRUE;
    stream.pInputSurface = inputView.Get();
 
    // ID3D11VideoContext is not thread-safe; the caller must hold the D3D11 device lock.
    hr = m_videoContext->VideoProcessorBlt(m_videoProcessor.Get(), m_outputView.Get(), 0, 1,
                                           &stream);
    if (FAILED(hr)) {
        qCWarning(lcD3D11VideoProcessor)
                << "VideoProcessorBlt:" << QSystemError::windowsComString(hr);
        return nullptr;
    }
 
    context->Flush();
 
    return m_outputTex;
}
 
} // namespace QtMultimediaPrivate
 
QT_END_NAMESPACE