platforms/windows/qwindowsopengltester.cpp

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the plugins of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qwindowsopengltester.h"
#include "qwindowscontext.h"

#include <QtCore/qvariant.h>
#include <QtCore/qdebug.h>
#include <QtCore/qtextstream.h>
#include <QtCore/qcoreapplication.h>
#include <QtCore/qfile.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qstandardpaths.h>
#include <QtCore/qlibraryinfo.h>
#include <QtCore/qhash.h>

#ifndef QT_NO_OPENGL
#include <private/qopengl_p.h>
#endif

#include <QtCore/qt_windows.h>
#include <private/qsystemlibrary_p.h>
#include <d3d9.h>

QT_BEGIN_NAMESPACE

static const DWORD VENDOR_ID_AMD = 0x1002;

static GpuDescription adapterIdentifierToGpuDescription(const D3DADAPTER_IDENTIFIER9 &adapterIdentifier)
{
    GpuDescription result;
    result.vendorId = adapterIdentifier.VendorId;
    result.deviceId = adapterIdentifier.DeviceId;
    result.revision = adapterIdentifier.Revision;
    result.subSysId = adapterIdentifier.SubSysId;
    QVector<int> version(4, 0);
    version[0] = HIWORD(adapterIdentifier.DriverVersion.HighPart); // Product
    version[1] = LOWORD(adapterIdentifier.DriverVersion.HighPart); // Version
    version[2] = HIWORD(adapterIdentifier.DriverVersion.LowPart); // Sub version
    version[3] = LOWORD(adapterIdentifier.DriverVersion.LowPart); // build
    result.driverVersion = QVersionNumber(version);
    result.driverName = adapterIdentifier.Driver;
    result.description = adapterIdentifier.Description;
    return result;
}

class QDirect3D9Handle
{
public:
    Q_DISABLE_COPY_MOVE(QDirect3D9Handle)

    QDirect3D9Handle();
    ~QDirect3D9Handle();

    bool isValid() const { return m_direct3D9 != nullptr; }

    UINT adapterCount() const { return m_direct3D9 ? m_direct3D9->GetAdapterCount() : 0u; }
    bool retrieveAdapterIdentifier(UINT n, D3DADAPTER_IDENTIFIER9 *adapterIdentifier) const;

private:
    QSystemLibrary m_d3d9lib;
    IDirect3D9 *m_direct3D9 = nullptr;
};

QDirect3D9Handle::QDirect3D9Handle() :
    m_d3d9lib(QStringLiteral("d3d9"))
{
    using PtrDirect3DCreate9 = IDirect3D9 *(WINAPI *)(UINT);

    if (m_d3d9lib.load()) {
        if (auto direct3DCreate9 = (PtrDirect3DCreate9)m_d3d9lib.resolve("Direct3DCreate9"))
            m_direct3D9 = direct3DCreate9(D3D_SDK_VERSION);
    }
}

QDirect3D9Handle::~QDirect3D9Handle()
{
    if (m_direct3D9)
       m_direct3D9->Release();
}

bool QDirect3D9Handle::retrieveAdapterIdentifier(UINT n, D3DADAPTER_IDENTIFIER9 *adapterIdentifier) const
{
    return m_direct3D9
        && SUCCEEDED(m_direct3D9->GetAdapterIdentifier(n, 0, adapterIdentifier));
}

GpuDescription GpuDescription::detect()
{
    GpuDescription result;
    QDirect3D9Handle direct3D9;
    if (!direct3D9.isValid())
        return result;

    D3DADAPTER_IDENTIFIER9 adapterIdentifier;
    bool isAMD = false;
    // Adapter "0" is D3DADAPTER_DEFAULT which returns the default adapter. In
    // multi-GPU, multi-screen setups this is the GPU that is associated with
    // the "main display" in the Display Settings, and this is the GPU OpenGL
    // and D3D uses by default. Therefore querying any additional adapters is
    // futile and not useful for our purposes in general, except for
    // identifying a few special cases later on.
    if (direct3D9.retrieveAdapterIdentifier(0, &adapterIdentifier)) {
        result = adapterIdentifierToGpuDescription(adapterIdentifier);
        isAMD = result.vendorId == VENDOR_ID_AMD;
    }

    // Detect QTBUG-50371 (having AMD as the default adapter results in a crash
    // when starting apps on a screen connected to the Intel card) by looking
    // for a default AMD adapter and an additional non-AMD one.
    if (isAMD) {
        const UINT adapterCount = direct3D9.adapterCount();
        for (UINT adp = 1; adp < adapterCount; ++adp) {
            if (direct3D9.retrieveAdapterIdentifier(adp, &adapterIdentifier)
                && adapterIdentifier.VendorId != VENDOR_ID_AMD) {
                // Bingo. Now figure out the display for the AMD card.
                DISPLAY_DEVICE dd;
                memset(&dd, 0, sizeof(dd));
                dd.cb = sizeof(dd);
                for (int dev = 0; EnumDisplayDevices(nullptr, dev, &dd, 0); ++dev) {
                    if (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
                        // DeviceName is something like \\.\DISPLAY1 which can be used to
                        // match with the MONITORINFOEX::szDevice queried by QWindowsScreen.
                        result.gpuSuitableScreen = QString::fromWCharArray(dd.DeviceName);
                        break;
                    }
                }
                break;
            }
        }
    }

    return result;
}

QVector<GpuDescription> GpuDescription::detectAll()
{
    QVector<GpuDescription> result;
    QDirect3D9Handle direct3D9;
    if (const UINT adapterCount = direct3D9.adapterCount()) {
        for (UINT adp = 0; adp < adapterCount; ++adp) {
            D3DADAPTER_IDENTIFIER9 adapterIdentifier;
            if (direct3D9.retrieveAdapterIdentifier(adp, &adapterIdentifier))
                result.append(adapterIdentifierToGpuDescription(adapterIdentifier));
        }
    }
    return result;
}

#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug d, const GpuDescription &gd)
{
    QDebugStateSaver s(d);
    d.nospace();
    d << Qt::hex << Qt::showbase << "GpuDescription(vendorId=" << gd.vendorId
      << ", deviceId=" << gd.deviceId << ", subSysId=" << gd.subSysId
      << Qt::dec << Qt::noshowbase << ", revision=" << gd.revision
      << ", driver: " << gd.driverName
      << ", version=" << gd.driverVersion << ", " << gd.description
      << gd.gpuSuitableScreen << ')';
    return d;
}
#endif // !QT_NO_DEBUG_STREAM

// Return printable string formatted like the output of the dxdiag tool.
QString GpuDescription::toString() const
{
    QString result;
    QTextStream str(&result);
    str <<   "         Card name         : " << description
        << "\n       Driver Name         : " << driverName
        << "\n    Driver Version         : " << driverVersion.toString()
        << "\n         Vendor ID         : 0x" << qSetPadChar(u'0')
        << Qt::uppercasedigits << Qt::hex << qSetFieldWidth(4) << vendorId
        << "\n         Device ID         : 0x" << qSetFieldWidth(4) << deviceId
        << "\n         SubSys ID         : 0x" << qSetFieldWidth(8) << subSysId
        << "\n       Revision ID         : 0x" << qSetFieldWidth(4) << revision
        << Qt::dec;
    if (!gpuSuitableScreen.isEmpty())
        str << "\nGL windows forced to screen: " << gpuSuitableScreen;
    return result;
}

QVariant GpuDescription::toVariant() const
{
    QVariantMap result;
    result.insert(QStringLiteral("vendorId"), QVariant(vendorId));
    result.insert(QStringLiteral("deviceId"), QVariant(deviceId));
    result.insert(QStringLiteral("subSysId"),QVariant(subSysId));
    result.insert(QStringLiteral("revision"), QVariant(revision));
    result.insert(QStringLiteral("driver"), QVariant(QLatin1String(driverName)));
    result.insert(QStringLiteral("driverProduct"), QVariant(driverVersion.segmentAt(0)));
    result.insert(QStringLiteral("driverVersion"), QVariant(driverVersion.segmentAt(1)));
    result.insert(QStringLiteral("driverSubVersion"), QVariant(driverVersion.segmentAt(2)));
    result.insert(QStringLiteral("driverBuild"), QVariant(driverVersion.segmentAt(3)));
    result.insert(QStringLiteral("driverVersionString"), driverVersion.toString());
    result.insert(QStringLiteral("description"), QVariant(QLatin1String(description)));
    result.insert(QStringLiteral("printable"), QVariant(toString()));
    return result;
}

QWindowsOpenGLTester::Renderer QWindowsOpenGLTester::requestedGlesRenderer()
{
    const char platformVar[] = "QT_ANGLE_PLATFORM";
    if (qEnvironmentVariableIsSet(platformVar)) {
        const QByteArray anglePlatform = qgetenv(platformVar);
        if (anglePlatform == "d3d11")
            return QWindowsOpenGLTester::AngleRendererD3d11;
        if (anglePlatform == "d3d9")
            return QWindowsOpenGLTester::AngleRendererD3d9;
        if (anglePlatform == "warp")
            return QWindowsOpenGLTester::AngleRendererD3d11Warp;
        qCWarning(lcQpaGl) << "Invalid value set for " << platformVar << ": " << anglePlatform;
    }
    return QWindowsOpenGLTester::InvalidRenderer;
}

QWindowsOpenGLTester::Renderer QWindowsOpenGLTester::requestedRenderer()
{
    const char openGlVar[] = "QT_OPENGL";
    if (QCoreApplication::testAttribute(Qt::AA_UseOpenGLES)) {
        const Renderer glesRenderer = QWindowsOpenGLTester::requestedGlesRenderer();
        return glesRenderer != InvalidRenderer ? glesRenderer : Gles;
    }
    if (QCoreApplication::testAttribute(Qt::AA_UseDesktopOpenGL))
        return QWindowsOpenGLTester::DesktopGl;
    if (QCoreApplication::testAttribute(Qt::AA_UseSoftwareOpenGL))
        return QWindowsOpenGLTester::SoftwareRasterizer;
    if (qEnvironmentVariableIsSet(openGlVar)) {
        const QByteArray requested = qgetenv(openGlVar);
        if (requested == "angle") {
            const Renderer glesRenderer = QWindowsOpenGLTester::requestedGlesRenderer();
            return glesRenderer != InvalidRenderer ? glesRenderer : Gles;
        }
        if (requested == "desktop")
            return QWindowsOpenGLTester::DesktopGl;
        if (requested == "software")
            return QWindowsOpenGLTester::SoftwareRasterizer;
        qCWarning(lcQpaGl) << "Invalid value set for " << openGlVar << ": " << requested;
    }
    return QWindowsOpenGLTester::InvalidRenderer;
}

static inline QString resolveBugListFile(const QString &fileName)
{
    if (QFileInfo(fileName).isAbsolute())
        return fileName;
    // Try QLibraryInfo::SettingsPath which is typically empty unless specified in qt.conf,
    // then resolve via QStandardPaths::ConfigLocation.
    const QString settingsPath = QLibraryInfo::location(QLibraryInfo::SettingsPath);
    if (!settingsPath.isEmpty()) { // SettingsPath is empty unless specified in qt.conf.
        const QFileInfo fi(settingsPath + u'/' + fileName);
        if (fi.isFile())
            return fi.absoluteFilePath();
    }
    return QStandardPaths::locate(QStandardPaths::ConfigLocation, fileName);
}

#ifndef QT_NO_OPENGL
typedef QHash<QOpenGLConfig::Gpu, QWindowsOpenGLTester::Renderers> SupportedRenderersCache;
Q_GLOBAL_STATIC(SupportedRenderersCache, supportedRenderersCache)
#endif

QWindowsOpenGLTester::Renderers QWindowsOpenGLTester::detectSupportedRenderers(const GpuDescription &gpu,
                                                                               Renderer requested)
{
#if defined(QT_NO_OPENGL)
    Q_UNUSED(gpu)
    Q_UNUSED(requested)
    return 0;
#else
    QOpenGLConfig::Gpu qgpu = QOpenGLConfig::Gpu::fromDevice(gpu.vendorId, gpu.deviceId, gpu.driverVersion, gpu.description);
    SupportedRenderersCache *srCache = supportedRenderersCache();
    SupportedRenderersCache::const_iterator it = srCache->constFind(qgpu);
    if (it != srCache->cend())
        return *it;

    QWindowsOpenGLTester::Renderers result(QWindowsOpenGLTester::AngleRendererD3d11
        | QWindowsOpenGLTester::AngleRendererD3d9
        | QWindowsOpenGLTester::AngleRendererD3d11Warp
        | QWindowsOpenGLTester::SoftwareRasterizer);

    // Don't test for GL if explicitly requested or GLES only is requested
    if (requested == DesktopGl
        || ((requested & GlesMask) == 0 && testDesktopGL())) {
            result |= QWindowsOpenGLTester::DesktopGl;
    }

    QSet<QString> features; // empty by default -> nothing gets disabled
    if (!qEnvironmentVariableIsSet("QT_NO_OPENGL_BUGLIST")) {
        const char bugListFileVar[] = "QT_OPENGL_BUGLIST";
        QString buglistFileName = QStringLiteral(":/qt-project.org/windows/openglblacklists/default.json");
        if (qEnvironmentVariableIsSet(bugListFileVar)) {
            const QString fileName = resolveBugListFile(QFile::decodeName(qgetenv(bugListFileVar)));
            if (!fileName.isEmpty())
                buglistFileName = fileName;
        }
        features = QOpenGLConfig::gpuFeatures(qgpu, buglistFileName);
    }
    qCDebug(lcQpaGl) << "GPU features:" << features;

    if (features.contains(QStringLiteral("disable_desktopgl"))) { // Qt-specific
        qCDebug(lcQpaGl) << "Disabling Desktop GL: " << gpu;
        result &= ~QWindowsOpenGLTester::DesktopGl;
    }
    if (features.contains(QStringLiteral("disable_angle"))) { // Qt-specific keyword
        qCDebug(lcQpaGl) << "Disabling ANGLE: " << gpu;
        result &= ~QWindowsOpenGLTester::GlesMask;
    } else {
        if (features.contains(QStringLiteral("disable_d3d11"))) { // standard keyword
            qCDebug(lcQpaGl) << "Disabling D3D11: " << gpu;
            result &= ~QWindowsOpenGLTester::AngleRendererD3d11;
        }
        if (features.contains(QStringLiteral("disable_d3d9"))) { // Qt-specific
            qCDebug(lcQpaGl) << "Disabling D3D9: " << gpu;
            result &= ~QWindowsOpenGLTester::AngleRendererD3d9;
        }
    }
    if (features.contains(QStringLiteral("disable_rotation"))) {
        qCDebug(lcQpaGl) << "Disabling rotation: " << gpu;
        result |= DisableRotationFlag;
    }
    if (features.contains(QStringLiteral("disable_program_cache"))) {
        qCDebug(lcQpaGl) << "Disabling program cache: " << gpu;
        result |= DisableProgramCacheFlag;
    }
    srCache->insert(qgpu, result);
    return result;
#endif // !QT_NO_OPENGL
}

QWindowsOpenGLTester::Renderers QWindowsOpenGLTester::supportedRenderers(Renderer requested)
{
    const GpuDescription gpu = GpuDescription::detect();
    const QWindowsOpenGLTester::Renderers result = detectSupportedRenderers(gpu, requested);
    qCDebug(lcQpaGl) << __FUNCTION__ << gpu << requested << "renderer: " << result;
    return result;
}

bool QWindowsOpenGLTester::testDesktopGL()
{
#if !defined(QT_NO_OPENGL)
    typedef HGLRC (WINAPI *CreateContextType)(HDC);
    typedef BOOL (WINAPI *DeleteContextType)(HGLRC);
    typedef BOOL (WINAPI *MakeCurrentType)(HDC, HGLRC);
    typedef PROC (WINAPI *WglGetProcAddressType)(LPCSTR);

    HMODULE lib = nullptr;
    HWND wnd = nullptr;
    HDC dc = nullptr;
    HGLRC context = nullptr;
    LPCTSTR className = L"qtopengltest";

    CreateContextType CreateContext = nullptr;
    DeleteContextType DeleteContext = nullptr;
    MakeCurrentType MakeCurrent = nullptr;
    WglGetProcAddressType WGL_GetProcAddress = nullptr;

    bool result = false;

    // Test #1: Load opengl32.dll and try to resolve an OpenGL 2 function.
    // This will typically fail on systems that do not have a real OpenGL driver.
    lib = LoadLibraryA("opengl32.dll");
    if (lib) {
        CreateContext = reinterpret_cast<CreateContextType>(
            reinterpret_cast<QFunctionPointer>(::GetProcAddress(lib, "wglCreateContext")));
        if (!CreateContext)
            goto cleanup;
        DeleteContext = reinterpret_cast<DeleteContextType>(
            reinterpret_cast<QFunctionPointer>(::GetProcAddress(lib, "wglDeleteContext")));
        if (!DeleteContext)
            goto cleanup;
        MakeCurrent = reinterpret_cast<MakeCurrentType>(
            reinterpret_cast<QFunctionPointer>(::GetProcAddress(lib, "wglMakeCurrent")));
        if (!MakeCurrent)
            goto cleanup;
        WGL_GetProcAddress = reinterpret_cast<WglGetProcAddressType>(
            reinterpret_cast<QFunctionPointer>(::GetProcAddress(lib, "wglGetProcAddress")));
        if (!WGL_GetProcAddress)
            goto cleanup;

        WNDCLASS wclass;
        wclass.cbClsExtra = 0;
        wclass.cbWndExtra = 0;
        wclass.hInstance = static_cast<HINSTANCE>(GetModuleHandle(nullptr));
        wclass.hIcon = nullptr;
        wclass.hCursor = nullptr;
        wclass.hbrBackground = HBRUSH(COLOR_BACKGROUND);
        wclass.lpszMenuName = nullptr;
        wclass.lpfnWndProc = DefWindowProc;
        wclass.lpszClassName = className;
        wclass.style = CS_OWNDC;
        if (!RegisterClass(&wclass))
            goto cleanup;
        wnd = CreateWindow(className, L"qtopenglproxytest", WS_OVERLAPPED,
                           0, 0, 640, 480, nullptr, nullptr, wclass.hInstance, nullptr);
        if (!wnd)
            goto cleanup;
        dc = GetDC(wnd);
        if (!dc)
            goto cleanup;

        PIXELFORMATDESCRIPTOR pfd;
        memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
        pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
        pfd.nVersion = 1;
        pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_GENERIC_FORMAT;
        pfd.iPixelType = PFD_TYPE_RGBA;
        // Use the GDI functions. Under the hood this will call the wgl variants in opengl32.dll.
        int pixelFormat = ChoosePixelFormat(dc, &pfd);
        if (!pixelFormat)
            goto cleanup;
        if (!SetPixelFormat(dc, pixelFormat, &pfd))
            goto cleanup;
        context = CreateContext(dc);
        if (!context)
            goto cleanup;
        if (!MakeCurrent(dc, context))
            goto cleanup;

        // Now that there is finally a context current, try doing something useful.

        // Check the version. If we got 1.x then it's all hopeless and we can stop right here.
        typedef const GLubyte * (APIENTRY * GetString_t)(GLenum name);
        auto GetString = reinterpret_cast<GetString_t>(
            reinterpret_cast<QFunctionPointer>(::GetProcAddress(lib, "glGetString")));
        if (GetString) {
            if (const char *versionStr = reinterpret_cast<const char *>(GetString(GL_VERSION))) {
                const QByteArray version(versionStr);
                const int majorDot = version.indexOf('.');
                if (majorDot != -1) {
                    int minorDot = version.indexOf('.', majorDot + 1);
                    if (minorDot == -1)
                        minorDot = version.size();
                    const int major = version.mid(0, majorDot).toInt();
                    const int minor = version.mid(majorDot + 1, minorDot - majorDot - 1).toInt();
                    qCDebug(lcQpaGl, "Basic wglCreateContext gives version %d.%d", major, minor);
                    // Try to be as lenient as possible. Missing version, bogus values and
                    // such are all accepted. The driver may still be functional. Only
                    // check for known-bad cases, like versions "1.4.0 ...".
                    if (major == 1) {
                        result = false;
                        qCDebug(lcQpaGl, "OpenGL version too low");
                    }
                }
            }
        } else {
            result = false;
            qCDebug(lcQpaGl, "OpenGL 1.x entry points not found");
        }

        // Check for a shader-specific function.
        if (WGL_GetProcAddress("glCreateShader")) {
            result = true;
            qCDebug(lcQpaGl, "OpenGL 2.0 entry points available");
        } else {
            qCDebug(lcQpaGl, "OpenGL 2.0 entry points not found");
        }
    } else {
        qCDebug(lcQpaGl, "Failed to load opengl32.dll");
    }

cleanup:
    if (MakeCurrent)
        MakeCurrent(nullptr, nullptr);
    if (context)
        DeleteContext(context);
    if (dc && wnd)
        ReleaseDC(wnd, dc);
    if (wnd) {
        DestroyWindow(wnd);
        UnregisterClass(className, GetModuleHandle(nullptr));
    }
    // No FreeLibrary. Some implementations, Mesa in particular, deadlock when trying to unload.

    return result;
#else
    return false;
#endif // !QT_NO_OPENGL
}

QT_END_NAMESPACE