summaryrefslogtreecommitdiff
path: root/vcl/inc/opengl/win/WinDeviceInfo.hxx
blob: a400404910a107e602a874b39d5590c14461eda8 (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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
/* -*- 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();

    const OUString& GetDriverVersion() const
    {
        return maDriverVersion;
    }

    const OUString& GetDriverDate() const
    {
        return maDriverDate;
    }

    const OUString& GetDeviceID() const
    {
        return maDeviceID;
    }

    const OUString& GetAdapterVendorID() const
    {
        return maAdapterVendorID;
    }

    const OUString& GetAdapterDeviceID() const
    {
        return maAdapterDeviceID;
    }

    const OUString& GetAdapterSubsysID() const
    {
        return maAdapterSubsysID;
    }
    const OUString& GetDeviceKey() const
    {
        return maDeviceKey;
    }

    const OUString& GetDeviceString() const
    {
        return maDeviceString;
    }

    sal_uInt32 GetWindowsVersion() const
    {
        return mnWindowsVersion;
    }

};

#endif

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