henrike@webrtc.org | 47be73b | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2008 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #include "webrtc/base/systeminfo.h" |
| 12 | |
| 13 | #if defined(WEBRTC_WIN) |
| 14 | #include <winsock2.h> |
| 15 | #ifndef EXCLUDE_D3D9 |
| 16 | #include <d3d9.h> |
| 17 | #endif |
| 18 | #include <intrin.h> // for __cpuid() |
| 19 | #elif defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| 20 | #include <ApplicationServices/ApplicationServices.h> |
| 21 | #include <CoreServices/CoreServices.h> |
| 22 | #elif defined(WEBRTC_LINUX) |
| 23 | #include <unistd.h> |
| 24 | #endif |
| 25 | #if defined(WEBRTC_MAC) |
| 26 | #include <sys/sysctl.h> |
| 27 | #endif |
| 28 | |
| 29 | #if defined(WEBRTC_WIN) |
| 30 | #include "webrtc/base/scoped_ptr.h" |
| 31 | #include "webrtc/base/win32.h" |
| 32 | #elif defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| 33 | #include "webrtc/base/macconversion.h" |
| 34 | #elif defined(WEBRTC_LINUX) |
| 35 | #include "webrtc/base/linux.h" |
| 36 | #endif |
| 37 | #include "webrtc/base/common.h" |
| 38 | #include "webrtc/base/logging.h" |
| 39 | #include "webrtc/base/stringutils.h" |
| 40 | |
| 41 | namespace rtc { |
| 42 | |
| 43 | // See Also: http://msdn.microsoft.com/en-us/library/ms683194(v=vs.85).aspx |
| 44 | #if defined(WEBRTC_WIN) |
| 45 | typedef BOOL (WINAPI *LPFN_GLPI)( |
| 46 | PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, |
| 47 | PDWORD); |
| 48 | |
| 49 | static void GetProcessorInformation(int* physical_cpus, int* cache_size) { |
| 50 | // GetLogicalProcessorInformation() is available on Windows XP SP3 and beyond. |
| 51 | LPFN_GLPI glpi = reinterpret_cast<LPFN_GLPI>(GetProcAddress( |
| 52 | GetModuleHandle(L"kernel32"), |
| 53 | "GetLogicalProcessorInformation")); |
| 54 | if (NULL == glpi) { |
| 55 | return; |
| 56 | } |
| 57 | // Determine buffer size, allocate and get processor information. |
| 58 | // Size can change between calls (unlikely), so a loop is done. |
| 59 | DWORD return_length = 0; |
| 60 | scoped_ptr<SYSTEM_LOGICAL_PROCESSOR_INFORMATION[]> infos; |
| 61 | while (!glpi(infos.get(), &return_length)) { |
| 62 | if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) { |
| 63 | infos.reset(new SYSTEM_LOGICAL_PROCESSOR_INFORMATION[ |
| 64 | return_length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION)]); |
| 65 | } else { |
| 66 | return; |
| 67 | } |
| 68 | } |
| 69 | *physical_cpus = 0; |
| 70 | *cache_size = 0; |
| 71 | for (size_t i = 0; |
| 72 | i < return_length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); ++i) { |
| 73 | if (infos[i].Relationship == RelationProcessorCore) { |
| 74 | ++*physical_cpus; |
| 75 | } else if (infos[i].Relationship == RelationCache) { |
| 76 | int next_cache_size = static_cast<int>(infos[i].Cache.Size); |
| 77 | if (next_cache_size >= *cache_size) { |
| 78 | *cache_size = next_cache_size; |
| 79 | } |
| 80 | } |
| 81 | } |
| 82 | return; |
| 83 | } |
| 84 | #else |
| 85 | // TODO(fbarchard): Use gcc 4.4 provided cpuid intrinsic |
| 86 | // 32 bit fpic requires ebx be preserved |
| 87 | #if (defined(__pic__) || defined(__APPLE__)) && defined(__i386__) |
| 88 | static inline void __cpuid(int cpu_info[4], int info_type) { |
| 89 | __asm__ volatile ( // NOLINT |
| 90 | "mov %%ebx, %%edi\n" |
| 91 | "cpuid\n" |
| 92 | "xchg %%edi, %%ebx\n" |
| 93 | : "=a"(cpu_info[0]), "=D"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3]) |
| 94 | : "a"(info_type) |
| 95 | ); // NOLINT |
| 96 | } |
| 97 | #elif defined(__i386__) || defined(__x86_64__) |
| 98 | static inline void __cpuid(int cpu_info[4], int info_type) { |
| 99 | __asm__ volatile ( // NOLINT |
| 100 | "cpuid\n" |
| 101 | : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3]) |
| 102 | : "a"(info_type) |
| 103 | ); // NOLINT |
| 104 | } |
| 105 | #endif |
| 106 | #endif // WEBRTC_WIN |
| 107 | |
| 108 | // Note(fbarchard): |
| 109 | // Family and model are extended family and extended model. 8 bits each. |
| 110 | SystemInfo::SystemInfo() |
| 111 | : physical_cpus_(1), logical_cpus_(1), cache_size_(0), |
| 112 | cpu_family_(0), cpu_model_(0), cpu_stepping_(0), |
| 113 | cpu_speed_(0), memory_(0) { |
| 114 | // Initialize the basic information. |
| 115 | #if defined(__arm__) || defined(_M_ARM) |
| 116 | cpu_arch_ = SI_ARCH_ARM; |
| 117 | #elif defined(__x86_64__) || defined(_M_X64) |
| 118 | cpu_arch_ = SI_ARCH_X64; |
| 119 | #elif defined(__i386__) || defined(_M_IX86) |
| 120 | cpu_arch_ = SI_ARCH_X86; |
| 121 | #else |
| 122 | cpu_arch_ = SI_ARCH_UNKNOWN; |
| 123 | #endif |
| 124 | |
| 125 | #if defined(WEBRTC_WIN) |
| 126 | SYSTEM_INFO si; |
| 127 | GetSystemInfo(&si); |
| 128 | logical_cpus_ = si.dwNumberOfProcessors; |
| 129 | GetProcessorInformation(&physical_cpus_, &cache_size_); |
| 130 | if (physical_cpus_ <= 0) { |
| 131 | physical_cpus_ = logical_cpus_; |
| 132 | } |
| 133 | cpu_family_ = si.wProcessorLevel; |
| 134 | cpu_model_ = si.wProcessorRevision >> 8; |
| 135 | cpu_stepping_ = si.wProcessorRevision & 0xFF; |
| 136 | #elif defined(WEBRTC_MAC) |
| 137 | uint32_t sysctl_value; |
| 138 | size_t length = sizeof(sysctl_value); |
| 139 | if (!sysctlbyname("hw.physicalcpu_max", &sysctl_value, &length, NULL, 0)) { |
| 140 | physical_cpus_ = static_cast<int>(sysctl_value); |
| 141 | } |
| 142 | length = sizeof(sysctl_value); |
| 143 | if (!sysctlbyname("hw.logicalcpu_max", &sysctl_value, &length, NULL, 0)) { |
| 144 | logical_cpus_ = static_cast<int>(sysctl_value); |
| 145 | } |
| 146 | uint64_t sysctl_value64; |
| 147 | length = sizeof(sysctl_value64); |
| 148 | if (!sysctlbyname("hw.l3cachesize", &sysctl_value64, &length, NULL, 0)) { |
| 149 | cache_size_ = static_cast<int>(sysctl_value64); |
| 150 | } |
| 151 | if (!cache_size_) { |
| 152 | length = sizeof(sysctl_value64); |
| 153 | if (!sysctlbyname("hw.l2cachesize", &sysctl_value64, &length, NULL, 0)) { |
| 154 | cache_size_ = static_cast<int>(sysctl_value64); |
| 155 | } |
| 156 | } |
| 157 | length = sizeof(sysctl_value); |
| 158 | if (!sysctlbyname("machdep.cpu.family", &sysctl_value, &length, NULL, 0)) { |
| 159 | cpu_family_ = static_cast<int>(sysctl_value); |
| 160 | } |
| 161 | length = sizeof(sysctl_value); |
| 162 | if (!sysctlbyname("machdep.cpu.model", &sysctl_value, &length, NULL, 0)) { |
| 163 | cpu_model_ = static_cast<int>(sysctl_value); |
| 164 | } |
| 165 | length = sizeof(sysctl_value); |
| 166 | if (!sysctlbyname("machdep.cpu.stepping", &sysctl_value, &length, NULL, 0)) { |
| 167 | cpu_stepping_ = static_cast<int>(sysctl_value); |
| 168 | } |
| 169 | #elif defined(__native_client__) |
| 170 | // TODO(ryanpetrie): Implement this via PPAPI when it's available. |
| 171 | #else // WEBRTC_LINUX |
| 172 | ProcCpuInfo proc_info; |
| 173 | if (proc_info.LoadFromSystem()) { |
| 174 | proc_info.GetNumCpus(&logical_cpus_); |
| 175 | proc_info.GetNumPhysicalCpus(&physical_cpus_); |
| 176 | proc_info.GetCpuFamily(&cpu_family_); |
| 177 | #if defined(CPU_X86) |
| 178 | // These values only apply to x86 systems. |
| 179 | proc_info.GetSectionIntValue(0, "model", &cpu_model_); |
| 180 | proc_info.GetSectionIntValue(0, "stepping", &cpu_stepping_); |
| 181 | proc_info.GetSectionIntValue(0, "cpu MHz", &cpu_speed_); |
| 182 | proc_info.GetSectionIntValue(0, "cache size", &cache_size_); |
| 183 | cache_size_ *= 1024; |
| 184 | #endif |
| 185 | } |
| 186 | // ProcCpuInfo reads cpu speed from "cpu MHz" under /proc/cpuinfo. |
| 187 | // But that number is a moving target which can change on-the-fly according to |
| 188 | // many factors including system workload. |
| 189 | // See /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors. |
| 190 | // The one in /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq is more |
| 191 | // accurate. We use it as our cpu speed when it is available. |
| 192 | // cpuinfo_max_freq is measured in KHz and requires conversion to MHz. |
| 193 | int max_freq = rtc::ReadCpuMaxFreq(); |
| 194 | if (max_freq > 0) { |
| 195 | cpu_speed_ = max_freq / 1000; |
| 196 | } |
| 197 | #endif |
| 198 | // For L2 CacheSize see also |
| 199 | // http://www.flounder.com/cpuid_explorer2.htm#CPUID(0x800000006) |
| 200 | #ifdef CPU_X86 |
| 201 | if (cache_size_ == 0) { |
| 202 | int cpu_info[4]; |
| 203 | __cpuid(cpu_info, 0x80000000); // query maximum extended cpuid function. |
| 204 | if (static_cast<uint32>(cpu_info[0]) >= 0x80000006) { |
| 205 | __cpuid(cpu_info, 0x80000006); |
| 206 | cache_size_ = (cpu_info[2] >> 16) * 1024; |
| 207 | } |
| 208 | } |
| 209 | #endif |
| 210 | } |
| 211 | |
| 212 | // Return the number of cpu threads available to the system. |
| 213 | int SystemInfo::GetMaxCpus() { |
| 214 | return logical_cpus_; |
| 215 | } |
| 216 | |
| 217 | // Return the number of cpu cores available to the system. |
| 218 | int SystemInfo::GetMaxPhysicalCpus() { |
| 219 | return physical_cpus_; |
| 220 | } |
| 221 | |
| 222 | // Return the number of cpus available to the process. Since affinity can be |
| 223 | // changed on the fly, do not cache this value. |
| 224 | // Can be affected by heat. |
| 225 | int SystemInfo::GetCurCpus() { |
| 226 | int cur_cpus; |
| 227 | #if defined(WEBRTC_WIN) |
| 228 | DWORD_PTR process_mask, system_mask; |
| 229 | ::GetProcessAffinityMask(::GetCurrentProcess(), &process_mask, &system_mask); |
| 230 | for (cur_cpus = 0; process_mask; ++cur_cpus) { |
| 231 | // Sparse-ones algorithm. There are slightly faster methods out there but |
| 232 | // they are unintuitive and won't make a difference on a single dword. |
| 233 | process_mask &= (process_mask - 1); |
| 234 | } |
| 235 | #elif defined(WEBRTC_MAC) |
| 236 | uint32_t sysctl_value; |
| 237 | size_t length = sizeof(sysctl_value); |
| 238 | int error = sysctlbyname("hw.ncpu", &sysctl_value, &length, NULL, 0); |
| 239 | cur_cpus = !error ? static_cast<int>(sysctl_value) : 1; |
| 240 | #else |
| 241 | // Linux, Solaris, WEBRTC_ANDROID |
| 242 | cur_cpus = static_cast<int>(sysconf(_SC_NPROCESSORS_ONLN)); |
| 243 | #endif |
| 244 | return cur_cpus; |
| 245 | } |
| 246 | |
| 247 | // Return the type of this CPU. |
| 248 | SystemInfo::Architecture SystemInfo::GetCpuArchitecture() { |
| 249 | return cpu_arch_; |
| 250 | } |
| 251 | |
| 252 | // Returns the vendor string from the cpu, e.g. "GenuineIntel", "AuthenticAMD". |
| 253 | // See "Intel Processor Identification and the CPUID Instruction" |
| 254 | // (Intel document number: 241618) |
| 255 | std::string SystemInfo::GetCpuVendor() { |
| 256 | if (cpu_vendor_.empty()) { |
| 257 | #if defined(CPU_X86) |
| 258 | int cpu_info[4]; |
| 259 | __cpuid(cpu_info, 0); |
| 260 | cpu_info[0] = cpu_info[1]; // Reorder output |
| 261 | cpu_info[1] = cpu_info[3]; |
| 262 | cpu_info[2] = cpu_info[2]; |
| 263 | cpu_info[3] = 0; |
| 264 | cpu_vendor_ = std::string(reinterpret_cast<char*>(&cpu_info[0])); |
| 265 | #elif defined(CPU_ARM) |
| 266 | cpu_vendor_ = std::string("ARM"); |
| 267 | #else |
| 268 | cpu_vendor_ = std::string("Undefined"); |
| 269 | #endif |
| 270 | } |
| 271 | return cpu_vendor_; |
| 272 | } |
| 273 | |
| 274 | int SystemInfo::GetCpuCacheSize() { |
| 275 | return cache_size_; |
| 276 | } |
| 277 | |
| 278 | // Return the "family" of this CPU. |
| 279 | int SystemInfo::GetCpuFamily() { |
| 280 | return cpu_family_; |
| 281 | } |
| 282 | |
| 283 | // Return the "model" of this CPU. |
| 284 | int SystemInfo::GetCpuModel() { |
| 285 | return cpu_model_; |
| 286 | } |
| 287 | |
| 288 | // Return the "stepping" of this CPU. |
| 289 | int SystemInfo::GetCpuStepping() { |
| 290 | return cpu_stepping_; |
| 291 | } |
| 292 | |
| 293 | // Return the clockrate of the primary processor in Mhz. This value can be |
| 294 | // cached. Returns -1 on error. |
| 295 | int SystemInfo::GetMaxCpuSpeed() { |
| 296 | if (cpu_speed_) { |
| 297 | return cpu_speed_; |
| 298 | } |
| 299 | #if defined(WEBRTC_WIN) |
| 300 | HKEY key; |
| 301 | static const WCHAR keyName[] = |
| 302 | L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"; |
| 303 | |
| 304 | if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName , 0, KEY_QUERY_VALUE, &key) |
| 305 | == ERROR_SUCCESS) { |
| 306 | DWORD data, len; |
| 307 | len = sizeof(data); |
| 308 | |
| 309 | if (RegQueryValueEx(key, L"~Mhz", 0, 0, reinterpret_cast<LPBYTE>(&data), |
| 310 | &len) == ERROR_SUCCESS) { |
| 311 | cpu_speed_ = data; |
| 312 | } else { |
| 313 | LOG(LS_WARNING) << "Failed to query registry value HKLM\\" << keyName |
| 314 | << "\\~Mhz"; |
| 315 | cpu_speed_ = -1; |
| 316 | } |
| 317 | |
| 318 | RegCloseKey(key); |
| 319 | } else { |
| 320 | LOG(LS_WARNING) << "Failed to open registry key HKLM\\" << keyName; |
| 321 | cpu_speed_ = -1; |
| 322 | } |
| 323 | #elif defined(WEBRTC_MAC) |
| 324 | uint64_t sysctl_value; |
| 325 | size_t length = sizeof(sysctl_value); |
| 326 | int error = sysctlbyname("hw.cpufrequency_max", &sysctl_value, &length, |
| 327 | NULL, 0); |
| 328 | cpu_speed_ = !error ? static_cast<int>(sysctl_value/1000000) : -1; |
| 329 | #else |
| 330 | // TODO(fbarchard): Implement using proc/cpuinfo |
| 331 | cpu_speed_ = 0; |
| 332 | #endif |
| 333 | return cpu_speed_; |
| 334 | } |
| 335 | |
| 336 | // Dynamically check the current clockrate, which could be reduced because of |
| 337 | // powersaving profiles. Eventually for windows we want to query WMI for |
| 338 | // root\WMI::ProcessorPerformance.InstanceName="Processor_Number_0".frequency |
| 339 | int SystemInfo::GetCurCpuSpeed() { |
| 340 | #if defined(WEBRTC_WIN) |
| 341 | // TODO(fbarchard): Add WMI check, requires COM initialization |
| 342 | // NOTE(fbarchard): Testable on Sandy Bridge. |
| 343 | return GetMaxCpuSpeed(); |
| 344 | #elif defined(WEBRTC_MAC) |
| 345 | uint64_t sysctl_value; |
| 346 | size_t length = sizeof(sysctl_value); |
| 347 | int error = sysctlbyname("hw.cpufrequency", &sysctl_value, &length, NULL, 0); |
| 348 | return !error ? static_cast<int>(sysctl_value/1000000) : GetMaxCpuSpeed(); |
| 349 | #else // WEBRTC_LINUX |
| 350 | // TODO(fbarchard): Use proc/cpuinfo for Cur speed on Linux. |
| 351 | return GetMaxCpuSpeed(); |
| 352 | #endif |
| 353 | } |
| 354 | |
| 355 | // Returns the amount of installed physical memory in Bytes. Cacheable. |
| 356 | // Returns -1 on error. |
| 357 | int64 SystemInfo::GetMemorySize() { |
| 358 | if (memory_) { |
| 359 | return memory_; |
| 360 | } |
| 361 | |
| 362 | #if defined(WEBRTC_WIN) |
| 363 | MEMORYSTATUSEX status = {0}; |
| 364 | status.dwLength = sizeof(status); |
| 365 | |
| 366 | if (GlobalMemoryStatusEx(&status)) { |
| 367 | memory_ = status.ullTotalPhys; |
| 368 | } else { |
| 369 | LOG_GLE(LS_WARNING) << "GlobalMemoryStatusEx failed."; |
| 370 | memory_ = -1; |
| 371 | } |
| 372 | |
| 373 | #elif defined(WEBRTC_MAC) |
| 374 | size_t len = sizeof(memory_); |
| 375 | int error = sysctlbyname("hw.memsize", &memory_, &len, NULL, 0); |
| 376 | if (error || memory_ == 0) { |
| 377 | memory_ = -1; |
| 378 | } |
| 379 | #else // WEBRTC_LINUX |
| 380 | memory_ = static_cast<int64>(sysconf(_SC_PHYS_PAGES)) * |
| 381 | static_cast<int64>(sysconf(_SC_PAGESIZE)); |
| 382 | if (memory_ < 0) { |
| 383 | LOG(LS_WARNING) << "sysconf(_SC_PHYS_PAGES) failed." |
| 384 | << "sysconf(_SC_PHYS_PAGES) " << sysconf(_SC_PHYS_PAGES) |
| 385 | << "sysconf(_SC_PAGESIZE) " << sysconf(_SC_PAGESIZE); |
| 386 | memory_ = -1; |
| 387 | } |
| 388 | #endif |
| 389 | |
| 390 | return memory_; |
| 391 | } |
| 392 | |
| 393 | |
| 394 | // Return the name of the machine model we are currently running on. |
| 395 | // This is a human readable string that consists of the name and version |
| 396 | // number of the hardware, i.e 'MacBookAir1,1'. Returns an empty string if |
| 397 | // model can not be determined. The string is cached for subsequent calls. |
| 398 | std::string SystemInfo::GetMachineModel() { |
| 399 | if (!machine_model_.empty()) { |
| 400 | return machine_model_; |
| 401 | } |
| 402 | |
| 403 | #if defined(WEBRTC_MAC) |
| 404 | char buffer[128]; |
| 405 | size_t length = sizeof(buffer); |
| 406 | int error = sysctlbyname("hw.model", buffer, &length, NULL, 0); |
| 407 | if (!error) { |
| 408 | machine_model_.assign(buffer, length - 1); |
| 409 | } else { |
| 410 | machine_model_.clear(); |
| 411 | } |
| 412 | #else |
| 413 | machine_model_ = "Not available"; |
| 414 | #endif |
| 415 | |
| 416 | return machine_model_; |
| 417 | } |
| 418 | |
| 419 | #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| 420 | // Helper functions to query IOKit for video hardware properties. |
| 421 | static CFTypeRef SearchForProperty(io_service_t port, CFStringRef name) { |
| 422 | return IORegistryEntrySearchCFProperty(port, kIOServicePlane, |
| 423 | name, kCFAllocatorDefault, |
| 424 | kIORegistryIterateRecursively | kIORegistryIterateParents); |
| 425 | } |
| 426 | |
| 427 | static void GetProperty(io_service_t port, CFStringRef name, int* value) { |
| 428 | if (!value) return; |
| 429 | CFTypeRef ref = SearchForProperty(port, name); |
| 430 | if (ref) { |
| 431 | CFTypeID refType = CFGetTypeID(ref); |
| 432 | if (CFNumberGetTypeID() == refType) { |
| 433 | CFNumberRef number = reinterpret_cast<CFNumberRef>(ref); |
| 434 | p_convertCFNumberToInt(number, value); |
| 435 | } else if (CFDataGetTypeID() == refType) { |
| 436 | CFDataRef data = reinterpret_cast<CFDataRef>(ref); |
| 437 | if (CFDataGetLength(data) == sizeof(UInt32)) { |
| 438 | *value = *reinterpret_cast<const UInt32*>(CFDataGetBytePtr(data)); |
| 439 | } |
| 440 | } |
| 441 | CFRelease(ref); |
| 442 | } |
| 443 | } |
| 444 | |
| 445 | static void GetProperty(io_service_t port, CFStringRef name, |
| 446 | std::string* value) { |
| 447 | if (!value) return; |
| 448 | CFTypeRef ref = SearchForProperty(port, name); |
| 449 | if (ref) { |
| 450 | CFTypeID refType = CFGetTypeID(ref); |
| 451 | if (CFStringGetTypeID() == refType) { |
| 452 | CFStringRef stringRef = reinterpret_cast<CFStringRef>(ref); |
| 453 | p_convertHostCFStringRefToCPPString(stringRef, *value); |
| 454 | } else if (CFDataGetTypeID() == refType) { |
| 455 | CFDataRef dataRef = reinterpret_cast<CFDataRef>(ref); |
| 456 | *value = std::string(reinterpret_cast<const char*>( |
| 457 | CFDataGetBytePtr(dataRef)), CFDataGetLength(dataRef)); |
| 458 | } |
| 459 | CFRelease(ref); |
| 460 | } |
| 461 | } |
| 462 | #endif |
| 463 | |
| 464 | // Fills a struct with information on the graphics adapater and returns true |
| 465 | // iff successful. |
| 466 | bool SystemInfo::GetGpuInfo(GpuInfo *info) { |
| 467 | if (!info) return false; |
| 468 | #if defined(WEBRTC_WIN) && !defined(EXCLUDE_D3D9) |
| 469 | D3DADAPTER_IDENTIFIER9 identifier; |
| 470 | HRESULT hr = E_FAIL; |
| 471 | HINSTANCE d3d_lib = LoadLibrary(L"d3d9.dll"); |
| 472 | |
| 473 | if (d3d_lib) { |
| 474 | typedef IDirect3D9* (WINAPI *D3DCreate9Proc)(UINT); |
| 475 | D3DCreate9Proc d3d_create_proc = reinterpret_cast<D3DCreate9Proc>( |
| 476 | GetProcAddress(d3d_lib, "Direct3DCreate9")); |
| 477 | if (d3d_create_proc) { |
| 478 | IDirect3D9* d3d = d3d_create_proc(D3D_SDK_VERSION); |
| 479 | if (d3d) { |
| 480 | hr = d3d->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &identifier); |
| 481 | d3d->Release(); |
| 482 | } |
| 483 | } |
| 484 | FreeLibrary(d3d_lib); |
| 485 | } |
| 486 | |
| 487 | if (hr != D3D_OK) { |
| 488 | LOG(LS_ERROR) << "Failed to access Direct3D9 information."; |
| 489 | return false; |
| 490 | } |
| 491 | |
| 492 | info->device_name = identifier.DeviceName; |
| 493 | info->description = identifier.Description; |
| 494 | info->vendor_id = identifier.VendorId; |
| 495 | info->device_id = identifier.DeviceId; |
| 496 | info->driver = identifier.Driver; |
| 497 | // driver_version format: product.version.subversion.build |
| 498 | std::stringstream ss; |
| 499 | ss << HIWORD(identifier.DriverVersion.HighPart) << "." |
| 500 | << LOWORD(identifier.DriverVersion.HighPart) << "." |
| 501 | << HIWORD(identifier.DriverVersion.LowPart) << "." |
| 502 | << LOWORD(identifier.DriverVersion.LowPart); |
| 503 | info->driver_version = ss.str(); |
| 504 | return true; |
| 505 | #elif defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| 506 | // We'll query the IOKit for the gpu of the main display. |
| 507 | io_service_t display_service_port = CGDisplayIOServicePort( |
| 508 | kCGDirectMainDisplay); |
| 509 | GetProperty(display_service_port, CFSTR("vendor-id"), &info->vendor_id); |
| 510 | GetProperty(display_service_port, CFSTR("device-id"), &info->device_id); |
| 511 | GetProperty(display_service_port, CFSTR("model"), &info->description); |
| 512 | return true; |
| 513 | #else // WEBRTC_LINUX |
| 514 | // TODO(fbarchard): Implement this on Linux |
| 515 | return false; |
| 516 | #endif |
| 517 | } |
| 518 | } // namespace rtc |