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
|
// Copyright (c) 2006-2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/gpu/gpu_info_collector.h"
#include <windows.h>
#include <d3d9.h>
#include "base/logging.h"
#include "base/scoped_native_library.h"
#include "base/string_util.h"
namespace gpu_info_collector {
bool CollectGraphicsInfo(GPUInfo& gpu_info) {
FilePath d3d_path(base::GetNativeLibraryName(L"d3d9"));
base::ScopedNativeLibrary d3dlib(d3d_path);
typedef IDirect3D9* (WINAPI *Direct3DCreate9Proc)(UINT);
Direct3DCreate9Proc d3d_create_proc =
static_cast<Direct3DCreate9Proc>(
d3dlib.GetFunctionPointer("Direct3DCreate9"));
if (!d3d_create_proc) {
return false;
}
IDirect3D9 *d3d = d3d_create_proc(D3D_SDK_VERSION);
if (!d3d) {
return false;
}
return CollectGraphicsInfoD3D(d3d, gpu_info);
}
bool CollectGraphicsInfoD3D(IDirect3D9* d3d,
GPUInfo& gpu_info) {
// Get device information
D3DADAPTER_IDENTIFIER9 identifier;
HRESULT hr = d3d->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &identifier);
if (hr != D3D_OK) {
d3d->Release();
return false;
}
uint32 vendor_id = identifier.VendorId;
uint32 device_id = identifier.DeviceId;
// Get version information
D3DCAPS9 d3d_caps;
HRESULT caps_result = d3d->GetDeviceCaps(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
&d3d_caps);
if (caps_result != D3D_OK) {
d3d->Release();
return false;
}
uint32 driver_major_version_hi = HIWORD(identifier.DriverVersion.HighPart);
uint32 driver_major_version_lo = LOWORD(identifier.DriverVersion.HighPart);
uint32 driver_minor_version_hi = HIWORD(identifier.DriverVersion.LowPart);
uint32 driver_minor_version_lo = LOWORD(identifier.DriverVersion.LowPart);
std::wstring driver_version = StringPrintf(L"%d.%d.%d.%d",
driver_major_version_hi,
driver_major_version_lo,
driver_minor_version_hi,
driver_minor_version_lo);
d3d->Release();
// Get shader versions
uint32 pixel_shader_version = d3d_caps.PixelShaderVersion;
uint32 vertex_shader_version = d3d_caps.VertexShaderVersion;
gpu_info.SetGraphicsInfo(vendor_id, device_id, driver_version,
pixel_shader_version, vertex_shader_version);
return true;
}
bool CollectGraphicsInfoGL(GPUInfo& gpu_info) {
// Taken from http://developer.nvidia.com/object/device_ids.html
DISPLAY_DEVICE dd;
dd.cb = sizeof(DISPLAY_DEVICE);
int i = 0;
std::wstring id;
for (int i = 0; EnumDisplayDevices(NULL, i, &dd, 0); ++i) {
if (dd.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) {
id = dd.DeviceID;
break;
}
}
if (id.empty()) {
return false;
}
uint32 vendor_id;
uint32 device_id;
std::wstring vendorid = id.substr(8, 4);
std::wstring deviceid = id.substr(17, 4);
swscanf_s(vendorid.c_str(), L"%x", &vendor_id);
swscanf_s(deviceid.c_str(), L"%x", &device_id);
std::wstring driver_version = L"";
uint32 pixel_shader_version = 0;
uint32 vertex_shader_version = 0;
gpu_info.SetGraphicsInfo(vendor_id, device_id, driver_version,
pixel_shader_version, vertex_shader_version);
return true;
// TODO(rlp): Add driver and pixel versions
}
} // namespace gpu_info_collector
|
