summaryrefslogtreecommitdiff
path: root/vcl/inc/opengl/win/WinDeviceInfo.hxx
blob: 0c60b35f274e864836be27210a31fa5fe354e0a2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#ifndef INCLUDED_VCL_OPENGL_WIN_WINDEVICEINFO_HXX
#define INCLUDED_VCL_OPENGL_WIN_WINDEVICEINFO_HXX

#include "opengl/DeviceInfo.hxx"
#include <rtl/ustring.hxx>
#include <vector>
#include <cstdint>

namespace wgl {

enum OperatingSystem {
    DRIVER_OS_UNKNOWN = 0,
    DRIVER_OS_WINDOWS_XP,
    DRIVER_OS_WINDOWS_SERVER_2003,
    DRIVER_OS_WINDOWS_VISTA,
    DRIVER_OS_WINDOWS_7,
    DRIVER_OS_WINDOWS_8,
    DRIVER_OS_WINDOWS_8_1,
    DRIVER_OS_LINUX,
    DRIVER_OS_OS_X_10_5,
    DRIVER_OS_OS_X_10_6,
    DRIVER_OS_OS_X_10_7,
    DRIVER_OS_OS_X_10_8,
    DRIVER_OS_ANDROID,
    DRIVER_OS_ALL
};

enum VersionComparisonOp {
    DRIVER_LESS_THAN,             // driver <  version
    DRIVER_LESS_THAN_OR_EQUAL,    // driver <= version
    DRIVER_GREATER_THAN,          // driver >  version
    DRIVER_GREATER_THAN_OR_EQUAL, // driver >= version
    DRIVER_EQUAL,                 // driver == version
    DRIVER_NOT_EQUAL,             // driver != version
    DRIVER_BETWEEN_EXCLUSIVE,     // driver > version && driver < versionMax
    DRIVER_BETWEEN_INCLUSIVE,     // driver >= version && driver <= versionMax
    DRIVER_BETWEEN_INCLUSIVE_START, // driver >= version && driver < versionMax
    DRIVER_COMPARISON_IGNORED
};

enum DeviceVendor {
    VendorAll,
    VendorIntel,
    VendorNVIDIA,
    VendorAMD,
    VendorATI,
    VendorMicrosoft,
    DeviceVendorMax
};

bool ParseDriverVersion(const OUString& rString, uint64_t& rVersion);

struct DriverInfo
{
    DriverInfo(OperatingSystem os, const OUString& vendor, VersionComparisonOp op,
            uint64_t driverVersion, bool bWhiteListed = false, const char *suggestedVersion = nullptr);

    DriverInfo();
    DriverInfo(const DriverInfo&);
    ~DriverInfo();

    OperatingSystem meOperatingSystem;
    uint32_t mnOperatingSystemVersion;

    OUString maAdapterVendor;

    std::vector<OUString> maDevices;

    // Whether the mDevices array should be deleted when this structure is
    // deallocated. False by default.
    bool mbDeleteDevices;

    bool mbWhitelisted;

    VersionComparisonOp meComparisonOp;

    /* versions are assumed to be A.B.C.D packed as 0xAAAABBBBCCCCDDDD */
    uint64_t mnDriverVersion;
    uint64_t mnDriverVersionMax;
    static uint64_t allDriverVersions;

    OUString maSuggestedVersion;
    OUString maMsg;
};

#define GFX_DRIVER_VERSION(a,b,c,d) \
    ((uint64_t(a)<<48) | (uint64_t(b)<<32) | (uint64_t(c)<<16) | uint64_t(d))

inline uint64_t V(uint32_t a, uint32_t b, uint32_t c, uint32_t d)
{
    // We make sure every driver number is padded by 0s, this will allow us the
    // easiest 'compare as if decimals' approach. See ParseDriverVersion for a
    // more extensive explanation of this approach.
    while (b > 0 && b < 1000) {
        b *= 10;
    }
    while (c > 0 && c < 1000) {
        c *= 10;
    }
    while (d > 0 && d < 1000) {
        d *= 10;
    }
    return GFX_DRIVER_VERSION(a, b, c, d);
}

}

class WinOpenGLDeviceInfo : public OpenGLDeviceInfo
{
private:
    OUString maDriverVersion;
    OUString maDriverVersion2;

    OUString maDriverDate;
    OUString maDriverDate2;

    OUString maDeviceID;
    OUString maDeviceID2;

    OUString maAdapterVendorID;
    OUString maAdapterDeviceID;
    OUString maAdapterSubsysID;

    OUString maAdapterVendorID2;
    OUString maAdapterDeviceID2;
    OUString maAdapterSubsysID2;

    OUString maDeviceKey;
    OUString maDeviceKey2;

    OUString maDeviceString;
    OUString maDeviceString2;
    uint32_t mnWindowsVersion;

    bool mbHasDualGPU;
    bool mbHasDriverVersionMismatch;
    bool mbRDP;

    void GetData();
    void FillBlacklist();
    bool FindBlocklistedDeviceInList();

    static OUString* mpDeviceVendors[wgl::DeviceVendorMax];
    static std::vector<wgl::DriverInfo> maDriverInfo;

public:
    WinOpenGLDeviceInfo();

    static OUString GetDeviceVendor(wgl::DeviceVendor eVendor);
    virtual ~WinOpenGLDeviceInfo();

    virtual bool isDeviceBlocked();
};

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */