diff options
| -rw-r--r-- | vcl/inc/opengl/win/WinDeviceInfo.hxx | 66 | ||||
| -rw-r--r-- | vcl/opengl/win/WinDeviceInfo.cxx | 346 |
2 files changed, 411 insertions, 1 deletions
diff --git a/vcl/inc/opengl/win/WinDeviceInfo.hxx b/vcl/inc/opengl/win/WinDeviceInfo.hxx index 140662e9f840..524198bd5bca 100644 --- a/vcl/inc/opengl/win/WinDeviceInfo.hxx +++ b/vcl/inc/opengl/win/WinDeviceInfo.hxx @@ -71,6 +71,67 @@ enum DeviceVendor { DeviceVendorMax }; +struct DriverInfo +{ + typedef std::vector<OUString> DeviceFamilyVector; + + // If |ownDevices| is true, you are transferring ownership of the devices + // array, and it will be deleted when this GfxDriverInfo is destroyed. + + DriverInfo(OperatingSystem os, const OUString& vendor, DeviceFamilyVector* devices, + VersionComparisonOp op, + uint64_t driverVersion, const char *suggestedVersion = nullptr, + bool ownDevices = false); + + DriverInfo(); + DriverInfo(const DriverInfo&); + ~DriverInfo(); + + OperatingSystem meOperatingSystem; + uint32_t mnOperatingSystemVersion; + + OUString maAdapterVendor; + + static DeviceFamilyVector* const allDevices; + DeviceFamilyVector* mpDevices; + + // Whether the mDevices array should be deleted when this structure is + // deallocated. False by default. + bool mbDeleteDevices; + + VersionComparisonOp meComparisonOp; + + /* versions are assumed to be A.B.C.D packed as 0xAAAABBBBCCCCDDDD */ + uint64_t mnDriverVersion; + uint64_t mnDriverVersionMax; + static uint64_t allDriverVersions; + + static const DeviceFamilyVector* GetDeviceFamily(DeviceFamily id); + static DeviceFamilyVector* mpDeviceFamilies[DeviceFamilyMax]; + + OUString maModel, maHardware, maProduct, maManufacturer; +}; + +#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 @@ -105,12 +166,15 @@ private: bool mbRDP; void GetData(); - OUString GetDeviceVendor(wgl::DeviceVendor eVendor); + void FillBlacklist(); static OUString* mpDeviceVendors[wgl::DeviceVendorMax]; + static std::vector<wgl::DriverInfo> maDriverInfo; public: WinOpenGLDeviceInfo(); + + static OUString GetDeviceVendor(wgl::DeviceVendor eVendor); virtual ~WinOpenGLDeviceInfo(); virtual bool isDeviceBlocked(); diff --git a/vcl/opengl/win/WinDeviceInfo.cxx b/vcl/opengl/win/WinDeviceInfo.cxx index b1ddf2f981cf..e319c43537aa 100644 --- a/vcl/opengl/win/WinDeviceInfo.cxx +++ b/vcl/opengl/win/WinDeviceInfo.cxx @@ -14,6 +14,22 @@ #include <cstdint> OUString* WinOpenGLDeviceInfo::mpDeviceVendors[wgl::DeviceVendorMax]; +std::vector<wgl::DriverInfo> WinOpenGLDeviceInfo::maDriverInfo; + +#define APPEND_TO_DRIVER_BLOCKLIST(os, vendor, devices, driverComparator, driverVersion, suggestedVersion) \ + maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion, suggestedVersion)) +#define APPEND_TO_DRIVER_BLOCKLIST2(os, vendor, devices, driverComparator, driverVersion) \ + maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion)) + +#define APPEND_TO_DRIVER_BLOCKLIST_RANGE(os, vendor, devices, driverComparator, driverVersion, driverVersionMax, suggestedVersion) \ + do { \ + assert(driverComparator == wgl::DRIVER_BETWEEN_EXCLUSIVE || \ + driverComparator == wgl::DRIVER_BETWEEN_INCLUSIVE || \ + driverComparator == wgl::DRIVER_BETWEEN_INCLUSIVE_START); \ + wgl::DriverInfo info(os, vendor, devices, driverComparator, driverVersion, suggestedVersion); \ + info.mnDriverVersionMax = driverVersionMax; \ + maDriverInfo.push_back(info); \ + } while (false) namespace { @@ -318,6 +334,211 @@ template<typename T> void appendIntegerWithPadding(OUString& rString, T value, s #define DEVICE_KEY_PREFIX L"\\Registry\\Machine\\" } +namespace wgl { + +uint64_t DriverInfo::allDriverVersions = ~(uint64_t(0)); +DriverInfo::DeviceFamilyVector* const DriverInfo::allDevices = nullptr; + +DriverInfo::DeviceFamilyVector* DriverInfo::mpDeviceFamilies[DeviceFamilyMax]; + +DriverInfo::DriverInfo() + : meOperatingSystem(wgl::DRIVER_OS_UNKNOWN), + mnOperatingSystemVersion(0), + maAdapterVendor(WinOpenGLDeviceInfo::GetDeviceVendor(VendorAll)), + mpDevices(allDevices), + mbDeleteDevices(false), + meComparisonOp(DRIVER_COMPARISON_IGNORED), + mnDriverVersion(0), + mnDriverVersionMax(0) +{} + +DriverInfo::DriverInfo(OperatingSystem os, const OUString& vendor, + DeviceFamilyVector* devices, + VersionComparisonOp op, + uint64_t driverVersion, + const char *suggestedVersion /* = nullptr */, + bool ownDevices /* = false */) + : meOperatingSystem(os), + mnOperatingSystemVersion(0), + maAdapterVendor(vendor), + mpDevices(devices), + mbDeleteDevices(ownDevices), + meComparisonOp(op), + mnDriverVersion(driverVersion), + mnDriverVersionMax(0) +{} + +DriverInfo::DriverInfo(const DriverInfo& aOrig) + : meOperatingSystem(aOrig.meOperatingSystem), + mnOperatingSystemVersion(aOrig.mnOperatingSystemVersion), + maAdapterVendor(aOrig.maAdapterVendor), + meComparisonOp(aOrig.meComparisonOp), + mnDriverVersion(aOrig.mnDriverVersion), + mnDriverVersionMax(aOrig.mnDriverVersionMax) +{ + //If we're managing the lifetime of the device family, we have to make a + // copy of the original's device family. + if (aOrig.mbDeleteDevices && aOrig.mpDevices) { + mpDevices = new DeviceFamilyVector; + *mpDevices = *aOrig.mpDevices; + } else { + mpDevices = aOrig.mpDevices; + } + + mbDeleteDevices = aOrig.mbDeleteDevices; +} + +DriverInfo::~DriverInfo() +{ + if (mbDeleteDevices) + delete mpDevices; +} + +// Macros for appending a device to the DeviceFamily. +#define APPEND_DEVICE(device) APPEND_DEVICE2(#device) +#define APPEND_DEVICE2(device) deviceFamily->push_back(OUString("#device")) + +const DriverInfo::DeviceFamilyVector* DriverInfo::GetDeviceFamily(DeviceFamily id) +{ + // The code here is too sensitive to fall through to the default case if the + // code is invalid. + assert(id >= 0 && id < DeviceFamilyMax); + + // If it already exists, we must have processed it once, so return it now. + if (mpDeviceFamilies[id]) + return mpDeviceFamilies[id]; + + mpDeviceFamilies[id] = new wgl::DriverInfo::DeviceFamilyVector; + wgl::DriverInfo::DeviceFamilyVector* deviceFamily = mpDeviceFamilies[id]; + + switch (id) { + case IntelGMA500: + APPEND_DEVICE(0x8108); /* IntelGMA500_1 */ + APPEND_DEVICE(0x8109); /* IntelGMA500_2 */ + break; + case IntelGMA900: + APPEND_DEVICE(0x2582); /* IntelGMA900_1 */ + APPEND_DEVICE(0x2782); /* IntelGMA900_2 */ + APPEND_DEVICE(0x2592); /* IntelGMA900_3 */ + APPEND_DEVICE(0x2792); /* IntelGMA900_4 */ + break; + case IntelGMA950: + APPEND_DEVICE(0x2772); /* Intel945G_1 */ + APPEND_DEVICE(0x2776); /* Intel945G_2 */ + APPEND_DEVICE(0x27a2); /* Intel945_1 */ + APPEND_DEVICE(0x27a6); /* Intel945_2 */ + APPEND_DEVICE(0x27ae); /* Intel945_3 */ + break; + case IntelGMA3150: + APPEND_DEVICE(0xa001); /* IntelGMA3150_Nettop_1 */ + APPEND_DEVICE(0xa002); /* IntelGMA3150_Nettop_2 */ + APPEND_DEVICE(0xa011); /* IntelGMA3150_Netbook_1 */ + APPEND_DEVICE(0xa012); /* IntelGMA3150_Netbook_2 */ + break; + case IntelGMAX3000: + APPEND_DEVICE(0x2972); /* Intel946GZ_1 */ + APPEND_DEVICE(0x2973); /* Intel946GZ_2 */ + APPEND_DEVICE(0x2982); /* IntelG35_1 */ + APPEND_DEVICE(0x2983); /* IntelG35_2 */ + APPEND_DEVICE(0x2992); /* IntelQ965_1 */ + APPEND_DEVICE(0x2993); /* IntelQ965_2 */ + APPEND_DEVICE(0x29a2); /* IntelG965_1 */ + APPEND_DEVICE(0x29a3); /* IntelG965_2 */ + APPEND_DEVICE(0x29b2); /* IntelQ35_1 */ + APPEND_DEVICE(0x29b3); /* IntelQ35_2 */ + APPEND_DEVICE(0x29c2); /* IntelG33_1 */ + APPEND_DEVICE(0x29c3); /* IntelG33_2 */ + APPEND_DEVICE(0x29d2); /* IntelQ33_1 */ + APPEND_DEVICE(0x29d3); /* IntelQ33_2 */ + APPEND_DEVICE(0x2a02); /* IntelGL960_1 */ + APPEND_DEVICE(0x2a03); /* IntelGL960_2 */ + APPEND_DEVICE(0x2a12); /* IntelGM965_1 */ + APPEND_DEVICE(0x2a13); /* IntelGM965_2 */ + break; + case IntelGMAX4500HD: + APPEND_DEVICE(0x2a42); /* IntelGMA4500MHD_1 */ + APPEND_DEVICE(0x2a43); /* IntelGMA4500MHD_2 */ + APPEND_DEVICE(0x2e42); /* IntelB43_1 */ + APPEND_DEVICE(0x2e43); /* IntelB43_2 */ + APPEND_DEVICE(0x2e92); /* IntelB43_3 */ + APPEND_DEVICE(0x2e93); /* IntelB43_4 */ + APPEND_DEVICE(0x2e32); /* IntelG41_1 */ + APPEND_DEVICE(0x2e33); /* IntelG41_2 */ + APPEND_DEVICE(0x2e22); /* IntelG45_1 */ + APPEND_DEVICE(0x2e23); /* IntelG45_2 */ + APPEND_DEVICE(0x2e12); /* IntelQ45_1 */ + APPEND_DEVICE(0x2e13); /* IntelQ45_2 */ + APPEND_DEVICE(0x0042); /* IntelHDGraphics */ + APPEND_DEVICE(0x0046); /* IntelMobileHDGraphics */ + APPEND_DEVICE(0x0102); /* IntelSandyBridge_1 */ + APPEND_DEVICE(0x0106); /* IntelSandyBridge_2 */ + APPEND_DEVICE(0x0112); /* IntelSandyBridge_3 */ + APPEND_DEVICE(0x0116); /* IntelSandyBridge_4 */ + APPEND_DEVICE(0x0122); /* IntelSandyBridge_5 */ + APPEND_DEVICE(0x0126); /* IntelSandyBridge_6 */ + APPEND_DEVICE(0x010a); /* IntelSandyBridge_7 */ + APPEND_DEVICE(0x0080); /* IntelIvyBridge */ + break; + case IntelHD3000: + APPEND_DEVICE(0x0126); + break; + case IntelMobileHDGraphics: + APPEND_DEVICE(0x0046); /* IntelMobileHDGraphics */ + break; + case NvidiaBlockD3D9Layers: + // Glitches whilst scrolling (see bugs 612007, 644787, 645872) + APPEND_DEVICE(0x00f3); /* NV43 [GeForce 6200 (TM)] */ + APPEND_DEVICE(0x0146); /* NV43 [Geforce Go 6600TE/6200TE (TM)] */ + APPEND_DEVICE(0x014f); /* NV43 [GeForce 6200 (TM)] */ + APPEND_DEVICE(0x0161); /* NV44 [GeForce 6200 TurboCache (TM)] */ + APPEND_DEVICE(0x0162); /* NV44 [GeForce 6200SE TurboCache (TM)] */ + APPEND_DEVICE(0x0163); /* NV44 [GeForce 6200 LE (TM)] */ + APPEND_DEVICE(0x0164); /* NV44 [GeForce Go 6200 (TM)] */ + APPEND_DEVICE(0x0167); /* NV43 [GeForce Go 6200/6400 (TM)] */ + APPEND_DEVICE(0x0168); /* NV43 [GeForce Go 6200/6400 (TM)] */ + APPEND_DEVICE(0x0169); /* NV44 [GeForce 6250 (TM)] */ + APPEND_DEVICE(0x0222); /* NV44 [GeForce 6200 A-LE (TM)] */ + APPEND_DEVICE(0x0240); /* C51PV [GeForce 6150 (TM)] */ + APPEND_DEVICE(0x0241); /* C51 [GeForce 6150 LE (TM)] */ + APPEND_DEVICE(0x0244); /* C51 [Geforce Go 6150 (TM)] */ + APPEND_DEVICE(0x0245); /* C51 [Quadro NVS 210S/GeForce 6150LE (TM)] */ + APPEND_DEVICE(0x0247); /* C51 [GeForce Go 6100 (TM)] */ + APPEND_DEVICE(0x03d0); /* C61 [GeForce 6150SE nForce 430 (TM)] */ + APPEND_DEVICE(0x03d1); /* C61 [GeForce 6100 nForce 405 (TM)] */ + APPEND_DEVICE(0x03d2); /* C61 [GeForce 6100 nForce 400 (TM)] */ + APPEND_DEVICE(0x03d5); /* C61 [GeForce 6100 nForce 420 (TM)] */ + break; + case RadeonX1000: + // This list is from the ATIRadeonX1000.kext Info.plist + APPEND_DEVICE(0x7187); + APPEND_DEVICE(0x7210); + APPEND_DEVICE(0x71de); + APPEND_DEVICE(0x7146); + APPEND_DEVICE(0x7142); + APPEND_DEVICE(0x7109); + APPEND_DEVICE(0x71c5); + APPEND_DEVICE(0x71c0); + APPEND_DEVICE(0x7240); + APPEND_DEVICE(0x7249); + APPEND_DEVICE(0x7291); + break; + case Geforce7300GT: + APPEND_DEVICE(0x0393); + break; + case Nvidia310M: + APPEND_DEVICE(0x0A70); + break; + // This should never happen, but we get a warning if we don't handle this. + case DeviceFamilyMax: + SAL_WARN("vcl.opengl", "Invalid DeviceFamily id"); + break; + } + + return deviceFamily; +} + +} + WinOpenGLDeviceInfo::WinOpenGLDeviceInfo(): mbHasDualGPU(false), mbHasDriverVersionMismatch(false), @@ -629,5 +850,130 @@ OUString WinOpenGLDeviceInfo::GetDeviceVendor(wgl::DeviceVendor id) return *mpDeviceVendors[id]; } +void WinOpenGLDeviceInfo::FillBlacklist() +{ + /* + * It should be noted here that more specialized rules on certain features + * should be inserted -before- more generalized restriction. As the first + * match for feature/OS/device found in the list will be used for the final + * blacklisting call. + */ + + /* + * NVIDIA entries + */ + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_WINDOWS_XP, + GetDeviceVendor(wgl::VendorNVIDIA), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(6,14,11,8265), "182.65" ); + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_WINDOWS_VISTA, + GetDeviceVendor(wgl::VendorNVIDIA), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(8,17,11,8265), "182.65" ); + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_WINDOWS_7, + GetDeviceVendor(wgl::VendorNVIDIA), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(8,17,11,8265), "182.65" ); + + /* + * AMD/ATI entries + */ + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(8,62,0,0), "9.6" ); + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(8,62,0,0), "9.6" ); + + /* + * Bug 783517 - crashes in AMD driver on Windows 8 + */ + APPEND_TO_DRIVER_BLOCKLIST_RANGE( wgl::DRIVER_OS_WINDOWS_8, + GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices, + wgl::DRIVER_BETWEEN_INCLUSIVE_START, wgl::V(8,982,0,0), wgl::V(8,983,0,0), "!= 8.982.*.*" ); + APPEND_TO_DRIVER_BLOCKLIST_RANGE( wgl::DRIVER_OS_WINDOWS_8, + GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices, + wgl::DRIVER_BETWEEN_INCLUSIVE_START, wgl::V(8,982,0,0), wgl::V(8,983,0,0), "!= 8.982.*.*" ); + + /* OpenGL on any ATI/AMD hardware is discouraged + * See: + * bug 619773 - WebGL: Crash with blue screen : "NMI: Parity Check / Memory Parity Error" + * bugs 584403, 584404, 620924 - crashes in atioglxx + * + many complaints about incorrect rendering + */ + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + + /* + * Intel entries + */ + + /* The driver versions used here come from bug 594877. They might not + * be particularly relevant anymore. + */ +#define IMPLEMENT_INTEL_DRIVER_BLOCKLIST(winVer, devFamily, driverVer) \ + APPEND_TO_DRIVER_BLOCKLIST2( winVer, \ + GetDeviceVendor(wgl::VendorIntel), (wgl::DriverInfo::DeviceFamilyVector*) wgl::DriverInfo::GetDeviceFamily(devFamily), \ + wgl::DRIVER_LESS_THAN, driverVer ) + + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA500, wgl::V(3,0,20,3200)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA900, wgl::V(6,14,10,4764)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA950, wgl::V(6,14,10,4926)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA3150, wgl::V(6,14,10,5134)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMAX3000, wgl::V(6,14,10,5218)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMAX4500HD, wgl::V(6,14,10,4969)); + + // StrechRect seems to suffer from precision issues which leads to artifacting + // during content drawing starting with at least version 6.14.10.5082 + // and going until 6.14.10.5218. See bug 919454 and bug 949275 for more info. + APPEND_TO_DRIVER_BLOCKLIST_RANGE(wgl::DRIVER_OS_WINDOWS_XP, + GetDeviceVendor(wgl::VendorIntel), + const_cast<wgl::DriverInfo::DeviceFamilyVector*>(wgl::DriverInfo::GetDeviceFamily(wgl::IntelGMAX4500HD)), + wgl::DRIVER_BETWEEN_EXCLUSIVE, wgl::V(6,14,10,5076), wgl::V(6,14,10,5218), "6.14.10.5218"); + + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA500, wgl::V(3,0,20,3200)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA900, wgl::DriverInfo::allDriverVersions); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA950, wgl::V(7,14,10,1504)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA3150, wgl::V(7,14,10,1910)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMAX3000, wgl::V(7,15,10,1666)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMAX4500HD, wgl::V(7,15,10,1666)); + + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA500, wgl::V(5,0,0,2026)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA900, wgl::DriverInfo::allDriverVersions); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA950, wgl::V(8,15,10,1930)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA3150, wgl::V(8,14,10,1972)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMAX3000, wgl::V(7,15,10,1666)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMAX4500HD, wgl::V(7,15,10,1666)); + + /* OpenGL on any Intel hardware is discouraged */ + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorIntel), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorIntel), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + + /** + * Disable acceleration on Intel HD 3000 for graphics drivers <= 8.15.10.2321. + * See bug 1018278 and bug 1060736. + */ + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorIntel), (wgl::DriverInfo::DeviceFamilyVector*) wgl::DriverInfo::GetDeviceFamily(wgl::IntelHD3000), + wgl::DRIVER_LESS_THAN_OR_EQUAL, wgl::V(8,15,10,2321), "8.15.10.2342" ); + + /* Microsoft RemoteFX; blocked less than 6.2.0.0 */ + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorMicrosoft), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(6,2,0,0), "< 6.2.0.0" ); + +} + /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |