You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2321 lines
79 KiB
2321 lines
79 KiB
/****************************************************************************
|
|
*
|
|
* File: sysinfo.cpp
|
|
* Project: DxDiag (DirectX Diagnostic Tool)
|
|
* Author: Mike Anderson ([email protected])
|
|
* CPU type detection code by Rich Granshaw
|
|
* CPU speed code by Michael Lyons
|
|
* Purpose: Gather system information (OS, hardware, name, etc.) on this machine
|
|
*
|
|
* \Multimedia\Testsrc\Tools\ShowCPUID\ can be used to debug CPUID problems.
|
|
*
|
|
* (C) Copyright 1998 Microsoft Corp. All rights reserved.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include <tchar.h>
|
|
#include <Windows.h>
|
|
#include <mmsystem.h>
|
|
#include <stdio.h>
|
|
#include <wbemidl.h>
|
|
#include <objbase.h>
|
|
#include <shfolder.h>
|
|
#include <dsound.h>
|
|
#include "dsprv.h"
|
|
#include "dsprvobj.h"
|
|
#include "sysinfo.h"
|
|
#include "fileinfo.h" // for GetLanguageFromFile
|
|
#include "resource.h"
|
|
|
|
|
|
#define REGSTR_PATH_D3D TEXT("Software\\Microsoft\\Direct3D")
|
|
#define REGSTR_VAL_DDRAW_LOADDEBUGRUNTIME TEXT("LoadDebugRuntime")
|
|
#define REGSTR_DINPUT_DLL TEXT("CLSID\\{25E609E4-B259-11CF-BFC7-444553540000}\\InProcServer32")
|
|
#define REGSTR_DMUSIC_DLL TEXT("CLSID\\{480FF4B0-28B2-11D1-BEF7-00C04FBF8FEF}\\InProcServer32")
|
|
|
|
struct PROCESSOR_ID_NUMBERS
|
|
{
|
|
DWORD dwType; // Intel: 0 = standard, 1 = Overdrive, 2 = dual processor.
|
|
DWORD dwFamily;
|
|
DWORD dwModel;
|
|
DWORD dwSteppingID;
|
|
};
|
|
|
|
extern IWbemServices* g_pIWbemServices;
|
|
typedef INT (WINAPI* LPDXSETUPGETVERSION)(DWORD* pdwVersion, DWORD* pdwRevision);
|
|
static VOID GetProcessorDescription(BOOL bNT, SYSTEM_INFO* psi, TCHAR* pszDesc, BOOL* pbNoCPUSpeed);
|
|
static VOID GetProcessorVendorNameAndType(OSVERSIONINFO& OSVersionInfo,
|
|
SYSTEM_INFO& SystemInfo, TCHAR* pszProcessor, BOOL* pbNoCPUSpeed);
|
|
static VOID GetVendorNameAndCaps(TCHAR* pszVendorName, TCHAR* pszIDTLongName,
|
|
PROCESSOR_ID_NUMBERS& ProcessorIdNumbers, BOOL* pbIsMMX, BOOL* pbIs3DNow, BOOL* pbIsKatmai, /*Pentium III/Streaming SIMD Instrucs*/
|
|
LPDWORD pdwKBytesLevel2Cache, LPDWORD pdwIntelBrandIndex, BOOL* pbNoCPUSpeed);
|
|
#ifdef _X86_
|
|
static INT GetCPUSpeed(VOID);
|
|
static INT GetCPUSpeedViaWMI(VOID);
|
|
#endif
|
|
static VOID GetComputerSystemInfo(TCHAR* szSystemManufacturerEnglish, TCHAR* szSystemModelEnglish);
|
|
static VOID GetBIOSInfo(TCHAR* szBIOSEnglish);
|
|
static VOID GetFileSystemStoringD3D8Cache( TCHAR* strFileSystemBuffer );
|
|
|
|
static VOID GetDXDebugLevels(SysInfo* pSysInfo);
|
|
static int GetDSDebugLevel();
|
|
static BOOL IsDMusicDebugRuntime();
|
|
static BOOL IsDMusicDebugRuntimeAvailable();
|
|
static int GetDMDebugLevel();
|
|
static BOOL IsDInput8DebugRuntime();
|
|
static BOOL IsDInput8DebugRuntimeAvailable();
|
|
static int GetDIDebugLevel();
|
|
static BOOL IsD3DDebugRuntime();
|
|
static BOOL IsD3D8DebugRuntimeAvailable();
|
|
static BOOL IsDDrawDebugRuntime();
|
|
static BOOL IsDPlayDebugRuntime();
|
|
static BOOL IsDSoundDebugRuntime();
|
|
static BOOL IsNetMeetingRunning();
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsPlatformNT
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsPlatformNT(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
return (OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsPlatform9x
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsPlatform9x(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
return (OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsWin2k
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsWin2k(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
return ( OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
|
|
OSVersionInfo.dwMajorVersion == 5 &&
|
|
OSVersionInfo.dwMinorVersion == 0 ); // should be 05.00.xxxx
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsWhistler
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsWhistler(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
return ( OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
|
|
OSVersionInfo.dwMajorVersion == 5 &&
|
|
( OSVersionInfo.dwMinorVersion == 1 || OSVersionInfo.dwMinorVersion == 2 ) );
|
|
// should be 05.01.xxxx (for WinXP) or 05.02.xxxx (for .NET server)
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsWinNT
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsWinNT(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
return ( OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
|
|
OSVersionInfo.dwMajorVersion <= 4 );
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsWinME
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsWinME(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
return( OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
|
|
OSVersionInfo.dwMajorVersion >= 4 &&
|
|
OSVersionInfo.dwMinorVersion >= 90 ); // should be 4.90.xxxx
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsWin98 - from http://kbinternal/kb/articles/q189/2/49.htm
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsWin98(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
return( OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
|
|
OSVersionInfo.dwMajorVersion == 4 &&
|
|
OSVersionInfo.dwMinorVersion == 10 ); // should be 4.10.xxxx
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsWin95 - from http://kbinternal/kb/articles/q189/2/49.htm
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsWin95(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
return( OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
|
|
OSVersionInfo.dwMajorVersion == 4 &&
|
|
OSVersionInfo.dwMinorVersion < 10 ); // should be 4.00.0950
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsWin3x
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsWin3x(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
return( OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
|
|
OSVersionInfo.dwMajorVersion < 4 ); // should be 3.xx.xxxx
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsIA64
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsIA64(VOID)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
SYSTEM_INFO SystemInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
GetSystemInfo(&SystemInfo);
|
|
|
|
return( OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
|
|
SystemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64 );
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetSystemInfo
|
|
*
|
|
****************************************************************************/
|
|
VOID GetSystemInfo(SysInfo* pSysInfo)
|
|
{
|
|
TCHAR szSystemPath[MAX_PATH];
|
|
HKEY hKey = NULL;
|
|
HKEY hSubKey = NULL;
|
|
ULONG ulType;
|
|
OSVERSIONINFO OSVersionInfo;
|
|
SYSTEM_INFO SystemInfo;
|
|
DWORD cbData;
|
|
LCID lcid;
|
|
DWORD dwKeyboardSubType;
|
|
WORD wLanguage;
|
|
TCHAR sz[200];
|
|
TCHAR szDebug[100];
|
|
|
|
// Get current time
|
|
TCHAR szDate[100];
|
|
TCHAR szTime[100];
|
|
GetLocalTime(&pSysInfo->m_time);
|
|
GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, NULL, NULL, szDate, 100);
|
|
wsprintf(szTime, TEXT("%02d:%02d:%02d"), pSysInfo->m_time.wHour,
|
|
pSysInfo->m_time.wMinute, pSysInfo->m_time.wSecond);
|
|
wsprintf(pSysInfo->m_szTimeLocal, TEXT("%s, %s"), szDate, szTime);
|
|
|
|
wsprintf(szDate, TEXT("%d/%d/%d"), pSysInfo->m_time.wMonth, pSysInfo->m_time.wDay, pSysInfo->m_time.wYear);
|
|
wsprintf(pSysInfo->m_szTime, TEXT("%s, %s"), szDate, szTime);
|
|
|
|
// Get the computer network name
|
|
cbData = sizeof(pSysInfo->m_szMachine) - 1;
|
|
if (!RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("System\\CurrentControlSet\\Control\\ComputerName\\ComputerName"), 0, KEY_READ, &hKey)
|
|
&& !RegQueryValueEx(hKey, TEXT("ComputerName"), 0, &ulType, (LPBYTE)pSysInfo->m_szMachine, &cbData)
|
|
&& ulType == REG_SZ)
|
|
{
|
|
// Got data OK.
|
|
}
|
|
else
|
|
{
|
|
LoadString(NULL, IDS_NOMACHINENAME, pSysInfo->m_szMachine, 200);
|
|
}
|
|
if (hKey)
|
|
{
|
|
RegCloseKey(hKey);
|
|
hKey = 0;
|
|
}
|
|
|
|
// Check for NEC PC-98
|
|
pSysInfo->m_bNECPC98 = FALSE;
|
|
lcid = GetSystemDefaultLCID();
|
|
if (lcid == 0x0411) // Windows 95 J
|
|
{
|
|
dwKeyboardSubType = GetKeyboardType(1);
|
|
if (HIBYTE(dwKeyboardSubType) == 0x0D) // NEC PC-98 series
|
|
{
|
|
pSysInfo->m_bNECPC98 = TRUE;
|
|
LoadString(NULL, IDS_NECPC98, sz, 200);
|
|
lstrcat(pSysInfo->m_szMachine, sz);
|
|
}
|
|
}
|
|
|
|
// Get Windows version
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
pSysInfo->m_dwMajorVersion = OSVersionInfo.dwMajorVersion;
|
|
pSysInfo->m_dwMinorVersion = OSVersionInfo.dwMinorVersion;
|
|
pSysInfo->m_dwBuildNumber = OSVersionInfo.dwBuildNumber;
|
|
pSysInfo->m_dwPlatformID = OSVersionInfo.dwPlatformId;
|
|
lstrcpy(pSysInfo->m_szCSDVersion, OSVersionInfo.szCSDVersion);
|
|
pSysInfo->m_bDebug = (GetSystemMetrics(SM_DEBUG) > 0);
|
|
|
|
// Get OS Name
|
|
TCHAR* pszWindowsKey;
|
|
if (pSysInfo->m_dwPlatformID == VER_PLATFORM_WIN32_NT)
|
|
pszWindowsKey = TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion");
|
|
else
|
|
pszWindowsKey = TEXT("Software\\Microsoft\\Windows\\CurrentVersion");
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszWindowsKey, 0, KEY_READ, &hKey))
|
|
{
|
|
cbData = 100;
|
|
RegQueryValueEx(hKey, TEXT("ProductName"), 0, &ulType, (LPBYTE)pSysInfo->m_szOS, &cbData);
|
|
cbData = 100;
|
|
RegQueryValueEx(hKey, TEXT("BuildLab"), 0, &ulType, (LPBYTE)pSysInfo->m_szBuildLab, &cbData);
|
|
RegCloseKey(hKey);
|
|
}
|
|
if (lstrlen(pSysInfo->m_szOS) == 0)
|
|
{
|
|
// it is very strange for ProductName registry info
|
|
// (see above) to be missing.
|
|
lstrcpy(pSysInfo->m_szOS, TEXT("Windows"));
|
|
}
|
|
if (pSysInfo->m_dwPlatformID == VER_PLATFORM_WIN32_NT)
|
|
{
|
|
// 25598: Append product type (professional, server, etc)
|
|
OSVERSIONINFOEX osve;
|
|
ZeroMemory(&osve, sizeof(osve));
|
|
osve.dwOSVersionInfoSize = sizeof(osve);
|
|
GetVersionEx((OSVERSIONINFO*)&osve);
|
|
if (osve.wProductType == VER_NT_SERVER && osve.wSuiteMask & VER_SUITE_DATACENTER)
|
|
{
|
|
lstrcat(pSysInfo->m_szOS, TEXT(" "));
|
|
LoadString(NULL, IDS_DATACENTERSERVER, sz, 200);
|
|
lstrcat(pSysInfo->m_szOS, sz);
|
|
}
|
|
else if (osve.wProductType == VER_NT_SERVER && osve.wSuiteMask & VER_SUITE_ENTERPRISE)
|
|
{
|
|
lstrcat(pSysInfo->m_szOS, TEXT(" "));
|
|
LoadString(NULL, IDS_ADVANCEDSERVER, sz, 200);
|
|
lstrcat(pSysInfo->m_szOS, sz);
|
|
}
|
|
else if (osve.wProductType == VER_NT_SERVER && osve.wSuiteMask & VER_SUITE_BLADE)
|
|
{
|
|
lstrcat(pSysInfo->m_szOS, TEXT(" "));
|
|
LoadString(NULL, IDS_WEBSERVER, sz, 200);
|
|
lstrcat(pSysInfo->m_szOS, sz);
|
|
}
|
|
else if (osve.wProductType == VER_NT_SERVER)
|
|
{
|
|
lstrcat(pSysInfo->m_szOS, TEXT(" "));
|
|
LoadString(NULL, IDS_SERVER, sz, 200);
|
|
lstrcat(pSysInfo->m_szOS, sz);
|
|
}
|
|
else if (osve.wProductType == VER_NT_WORKSTATION && (osve.wSuiteMask & VER_SUITE_PERSONAL))
|
|
{
|
|
lstrcat(pSysInfo->m_szOS, TEXT(" "));
|
|
LoadString(NULL, IDS_PERSONAL, sz, 200);
|
|
lstrcat(pSysInfo->m_szOS, sz);
|
|
}
|
|
else if (osve.wProductType == VER_NT_WORKSTATION)
|
|
{
|
|
lstrcat(pSysInfo->m_szOS, TEXT(" "));
|
|
LoadString(NULL, IDS_PROFESSIONAL, sz, 200);
|
|
lstrcat(pSysInfo->m_szOS, sz);
|
|
}
|
|
}
|
|
|
|
// Format Windows version
|
|
LoadString(NULL, IDS_WINVERFMT, sz, 200);
|
|
LoadString(NULL, IDS_DEBUG, szDebug, 100);
|
|
lstrcat(szDebug, TEXT(" "));
|
|
wsprintf(pSysInfo->m_szOSEx, sz,
|
|
pSysInfo->m_bDebug ? szDebug : TEXT(""),
|
|
pSysInfo->m_szOS, pSysInfo->m_dwMajorVersion, pSysInfo->m_dwMinorVersion,
|
|
LOWORD(pSysInfo->m_dwBuildNumber));
|
|
|
|
TCHAR szOSTmp[200];
|
|
if( _tcslen( pSysInfo->m_szCSDVersion) )
|
|
wsprintf( szOSTmp, TEXT("%s %s"), pSysInfo->m_szOSEx, pSysInfo->m_szCSDVersion );
|
|
else
|
|
lstrcpy( szOSTmp, pSysInfo->m_szOSEx );
|
|
|
|
if( _tcslen( pSysInfo->m_szBuildLab ) )
|
|
wsprintf( pSysInfo->m_szOSExLong, TEXT("%s (%s)"), szOSTmp, pSysInfo->m_szBuildLab );
|
|
else
|
|
lstrcpy( pSysInfo->m_szOSExLong, szOSTmp );
|
|
|
|
// Get the original language.
|
|
GetSystemDirectory(szSystemPath, MAX_PATH);
|
|
if (wLanguage = GetLanguageFromFile(TEXT("user.exe"), szSystemPath))
|
|
{
|
|
lcid = MAKELCID(wLanguage, SORT_DEFAULT);
|
|
}
|
|
// Get the language and regional setting and store them (in English) for saved file:
|
|
TCHAR szLanguage[200];
|
|
TCHAR szLanguageRegional[200];
|
|
if ((!GetLocaleInfo(lcid, LOCALE_SENGLANGUAGE, szLanguage, 200)))
|
|
szLanguage[0] = '\0';
|
|
if (!GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SENGLANGUAGE, szLanguageRegional, 200))
|
|
szLanguageRegional[0] = '\0';
|
|
LoadString(NULL, IDS_LANGUAGEFMT_ENGLISH, sz, 200);
|
|
wsprintf(pSysInfo->m_szLanguages, sz, szLanguage, szLanguageRegional);
|
|
|
|
// Now get same info in local language for display:
|
|
if ((!GetLocaleInfo(lcid, LOCALE_SNATIVELANGNAME, szLanguage, 200)))
|
|
szLanguage[0] = '\0';
|
|
if (!GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SNATIVELANGNAME, szLanguageRegional, 200))
|
|
szLanguageRegional[0] = '\0';
|
|
LoadString(NULL, IDS_LANGUAGEFMT, sz, 200);
|
|
wsprintf(pSysInfo->m_szLanguagesLocal, sz, szLanguage, szLanguageRegional);
|
|
|
|
// Get info about processor manufacturer and type
|
|
BOOL bNoCPUSpeed = TRUE;
|
|
|
|
GetSystemInfo(&SystemInfo);
|
|
GetProcessorDescription(pSysInfo->m_dwPlatformID == VER_PLATFORM_WIN32_NT,
|
|
&SystemInfo, pSysInfo->m_szProcessor, &bNoCPUSpeed);
|
|
GetComputerSystemInfo(pSysInfo->m_szSystemManufacturerEnglish, pSysInfo->m_szSystemModelEnglish);
|
|
GetBIOSInfo(pSysInfo->m_szBIOSEnglish);
|
|
|
|
#ifdef _X86_
|
|
// Append processor speed, if it can be computed
|
|
if ( bNoCPUSpeed )
|
|
{
|
|
INT iMhz = GetCPUSpeed();
|
|
if (iMhz > 0)
|
|
{
|
|
TCHAR szSpeed[50];
|
|
wsprintf(szSpeed, TEXT(", ~%dMHz"), iMhz);
|
|
lstrcat(pSysInfo->m_szProcessor, szSpeed);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
BOOL bGotMem = FALSE;
|
|
|
|
// Get system memory information
|
|
if( BIsPlatformNT() )
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
GetSystemDirectory(szPath, MAX_PATH);
|
|
lstrcat(szPath, TEXT("\\kernel32.dll"));
|
|
HINSTANCE hKernel32 = LoadLibrary(szPath);
|
|
if( hKernel32 != NULL )
|
|
{
|
|
typedef BOOL (WINAPI* PGlobalMemoryStatusEx)(OUT LPMEMORYSTATUSEX lpBuffer);
|
|
PGlobalMemoryStatusEx pGlobalMemoryStatusEx = (PGlobalMemoryStatusEx)GetProcAddress(hKernel32, "GlobalMemoryStatusEx");
|
|
if( pGlobalMemoryStatusEx != NULL )
|
|
{
|
|
MEMORYSTATUSEX MemoryStatus;
|
|
MemoryStatus.dwLength = sizeof(MEMORYSTATUSEX);
|
|
pGlobalMemoryStatusEx(&MemoryStatus);
|
|
pSysInfo->m_ullPhysicalMemory = MemoryStatus.ullTotalPhys;
|
|
pSysInfo->m_ullUsedPageFile = MemoryStatus.ullTotalPageFile - MemoryStatus.ullAvailPageFile;
|
|
pSysInfo->m_ullAvailPageFile = MemoryStatus.ullAvailPageFile;
|
|
bGotMem = TRUE;
|
|
}
|
|
FreeLibrary(hKernel32);
|
|
}
|
|
}
|
|
|
|
if( !bGotMem ) // Win9x or LoadLib failed
|
|
{
|
|
MEMORYSTATUS MemoryStatus;
|
|
MemoryStatus.dwLength = sizeof MemoryStatus;
|
|
GlobalMemoryStatus(&MemoryStatus);
|
|
pSysInfo->m_ullPhysicalMemory = MemoryStatus.dwTotalPhys;
|
|
pSysInfo->m_ullUsedPageFile = MemoryStatus.dwTotalPageFile - MemoryStatus.dwAvailPageFile;
|
|
pSysInfo->m_ullAvailPageFile = MemoryStatus.dwAvailPageFile;
|
|
}
|
|
|
|
// Format memory information:
|
|
DWORDLONG dwMB = (DWORDLONG)(pSysInfo->m_ullPhysicalMemory >> 20);
|
|
dwMB += dwMB % 2; // round up to even number
|
|
_stprintf(pSysInfo->m_szPhysicalMemory, TEXT("%I64dMB RAM"), dwMB);
|
|
|
|
DWORDLONG dwUsedMB = (pSysInfo->m_ullUsedPageFile >> 20);
|
|
DWORDLONG dwAvailMB = (pSysInfo->m_ullAvailPageFile >> 20);
|
|
|
|
LoadString(NULL, IDS_PAGEFILEFMT, sz, 200);
|
|
_stprintf(pSysInfo->m_szPageFile, sz, dwUsedMB, dwAvailMB);
|
|
|
|
LoadString(NULL, IDS_PAGEFILEFMT_ENGLISH, sz, 200);
|
|
_stprintf(pSysInfo->m_szPageFileEnglish, sz, dwUsedMB, dwAvailMB);
|
|
|
|
// Get DxDiag version:
|
|
TCHAR szFile[MAX_PATH];
|
|
if (0 != GetModuleFileName(NULL, szFile, MAX_PATH))
|
|
GetFileVersion(szFile, pSysInfo->m_szDxDiagVersion, NULL, NULL, NULL, NULL);
|
|
|
|
// Get DirectX Version using dsetup.dll
|
|
TCHAR szSetupPath[MAX_PATH];
|
|
HINSTANCE hInstDSetup;
|
|
LPDXSETUPGETVERSION pDXSGetVersion;
|
|
BOOL bFound = FALSE;
|
|
LoadString(NULL, IDS_NOTFOUND, pSysInfo->m_szDirectXVersionLong, 100);
|
|
|
|
if (!BIsPlatformNT() && GetDxSetupFolder(szSetupPath))
|
|
{
|
|
lstrcat(szSetupPath, TEXT("\\dsetup.dll"));
|
|
hInstDSetup = LoadLibrary(szSetupPath);
|
|
if (hInstDSetup != NULL)
|
|
{
|
|
pDXSGetVersion = (LPDXSETUPGETVERSION)GetProcAddress(hInstDSetup,
|
|
"DirectXSetupGetVersion");
|
|
if (pDXSGetVersion != NULL)
|
|
{
|
|
DWORD dwVersion = 0;
|
|
DWORD dwRevision = 0;
|
|
if (pDXSGetVersion(&dwVersion, &dwRevision) != 0)
|
|
{
|
|
wsprintf(pSysInfo->m_szDirectXVersion, TEXT("%d.%02d.%02d.%04d"),
|
|
HIWORD(dwVersion), LOWORD(dwVersion),
|
|
HIWORD(dwRevision), LOWORD(dwRevision));
|
|
bFound = TRUE;
|
|
}
|
|
}
|
|
FreeLibrary(hInstDSetup);
|
|
}
|
|
}
|
|
if (!bFound)
|
|
{
|
|
// Look in registry for DX version instead
|
|
HKEY hkey;
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\DirectX"),
|
|
0, KEY_READ, &hkey))
|
|
{
|
|
cbData = 100;
|
|
RegQueryValueEx(hkey, TEXT("Version"), 0, &ulType, (LPBYTE)pSysInfo->m_szDirectXVersion, &cbData);
|
|
RegCloseKey(hkey);
|
|
if (lstrlen(pSysInfo->m_szDirectXVersion) > 6 &&
|
|
lstrlen(pSysInfo->m_szDirectXVersion) < 20)
|
|
{
|
|
bFound = TRUE;
|
|
}
|
|
}
|
|
}
|
|
if (!bFound && !BIsPlatformNT())
|
|
{
|
|
// Report ddraw.dll version instead
|
|
// (except on Win2000, where ddraw.dll version is way different from DX version)
|
|
TCHAR szDDrawPath[MAX_PATH];
|
|
GetSystemDirectory(szDDrawPath, MAX_PATH);
|
|
lstrcat(szDDrawPath, TEXT("\\ddraw.dll"));
|
|
GetFileVersion(szDDrawPath, pSysInfo->m_szDirectXVersion, NULL, NULL, NULL);
|
|
}
|
|
if (lstrlen(pSysInfo->m_szDirectXVersion) > 0)
|
|
{
|
|
// Bug 18501: Add "friendly" version of version name
|
|
DWORD dwMajor;
|
|
DWORD dwMinor;
|
|
DWORD dwRevision;
|
|
DWORD dwBuild;
|
|
TCHAR szFriendly[100];
|
|
lstrcpy(szFriendly, TEXT(""));
|
|
if( _stscanf(pSysInfo->m_szDirectXVersion, TEXT("%d.%d.%d.%d"), &dwMajor, &dwMinor, &dwRevision, &dwBuild) != 4 )
|
|
{
|
|
dwMajor = 0;
|
|
dwMinor = 0;
|
|
dwRevision = 0;
|
|
dwBuild = 0;
|
|
}
|
|
wsprintf(pSysInfo->m_szDirectXVersion, TEXT("%d.%02d.%02d.%04d"), dwMajor, dwMinor, dwRevision, dwBuild);
|
|
// According to http://xevious/directx/versions.htm:
|
|
// 4.02.xx.xxxx is DX1
|
|
// 4.03.xx.xxxx is DX2
|
|
// 4.04.xx.xxxx is DX3
|
|
// 4.05.xx.xxxx is DX5
|
|
// 4.06.00.xxxx is DX6
|
|
// 4.06.02.xxxx is DX6.1
|
|
// 4.06.03.xxxx is DX6.1A
|
|
// 4.07.00.xxxx is DX7.0
|
|
// 4.07.01.xxxx is DX7.1
|
|
// Beyond that, who knows...
|
|
pSysInfo->m_dwDirectXVersionMajor = 0;
|
|
pSysInfo->m_dwDirectXVersionMinor = 0;
|
|
pSysInfo->m_cDirectXVersionLetter = TEXT(' ');
|
|
if (dwMajor == 4 && dwMinor == 2)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 1"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 1;
|
|
}
|
|
if (dwMajor == 4 && dwMinor == 3)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 2"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 2;
|
|
}
|
|
if (dwMajor == 4 && dwMinor == 4)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 3"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 3;
|
|
}
|
|
if (dwMajor == 4 && dwMinor == 5)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 5"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 5;
|
|
}
|
|
else if (dwMajor == 4 && dwMinor == 6 && dwRevision == 0)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 6"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 6;
|
|
}
|
|
else if (dwMajor == 4 && dwMinor == 6 && dwRevision == 2)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 6.1"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 6;
|
|
pSysInfo->m_dwDirectXVersionMinor = 1;
|
|
}
|
|
else if (dwMajor == 4 && dwMinor == 6 && dwRevision == 3)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 6.1a"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 6;
|
|
pSysInfo->m_dwDirectXVersionMinor = 1;
|
|
pSysInfo->m_cDirectXVersionLetter = TEXT('a');
|
|
}
|
|
else if (dwMajor == 4 && dwMinor == 7 && dwRevision == 0 && dwBuild == 716)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 7.0a"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 7;
|
|
pSysInfo->m_cDirectXVersionLetter = TEXT('a');
|
|
}
|
|
else if (dwMajor == 4 && dwMinor == 7 && dwRevision == 0)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 7.0"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 7;
|
|
}
|
|
else if (dwMajor == 4 && dwMinor == 7 && dwRevision == 1)
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 7.1"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 7;
|
|
pSysInfo->m_dwDirectXVersionMinor = 1;
|
|
}
|
|
else if (dwMajor == 4 && dwMinor == 8 && dwRevision == 0 )
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 8.0"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 8;
|
|
}
|
|
else if (dwMajor == 4 && dwMinor == 8 && dwRevision == 1 )
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 8.1"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 8;
|
|
pSysInfo->m_dwDirectXVersionMinor = 1;
|
|
}
|
|
else if (dwMajor == 4 && dwMinor == 9 )
|
|
{
|
|
lstrcpy(szFriendly, TEXT("DirectX 9.0"));
|
|
pSysInfo->m_dwDirectXVersionMajor = 9;
|
|
pSysInfo->m_dwDirectXVersionMinor = 0;
|
|
}
|
|
else
|
|
{
|
|
pSysInfo->m_dwDirectXVersionMajor = dwMinor;
|
|
pSysInfo->m_dwDirectXVersionMinor = dwRevision;
|
|
}
|
|
|
|
if (lstrlen(szFriendly) > 0)
|
|
wsprintf(pSysInfo->m_szDirectXVersionLong, TEXT("%s (%s)"), szFriendly, pSysInfo->m_szDirectXVersion);
|
|
else
|
|
lstrcpy(pSysInfo->m_szDirectXVersionLong, pSysInfo->m_szDirectXVersion);
|
|
}
|
|
|
|
// 24169: Detect setup switches
|
|
pSysInfo->m_dwSetupParam = 0xffffffff;
|
|
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\DirectX"), 0, KEY_READ, &hKey))
|
|
{
|
|
cbData = sizeof(DWORD);
|
|
RegQueryValueEx(hKey, TEXT("Command"), NULL, &ulType, (BYTE*)&(pSysInfo->m_dwSetupParam), &cbData);
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
// 48330: add debug level in txt file
|
|
GetDXDebugLevels( pSysInfo );
|
|
|
|
switch (pSysInfo->m_dwSetupParam)
|
|
{
|
|
case 0xffffffff: lstrcpy(pSysInfo->m_szSetupParam, TEXT("Not found")); break;
|
|
case 0: lstrcpy(pSysInfo->m_szSetupParam, TEXT("None")); break;
|
|
case 1: lstrcpy(pSysInfo->m_szSetupParam, TEXT("/Silent")); break;
|
|
case 2: lstrcpy(pSysInfo->m_szSetupParam, TEXT("/WindowsUpdate")); break;
|
|
case 3: lstrcpy(pSysInfo->m_szSetupParam, TEXT("/PackageInstall")); break;
|
|
case 4: lstrcpy(pSysInfo->m_szSetupParam, TEXT("/Silent /Reboot")); break;
|
|
case 5: lstrcpy(pSysInfo->m_szSetupParam, TEXT("/Reboot")); break;
|
|
default:
|
|
wsprintf(pSysInfo->m_szSetupParam, TEXT("Unknown Switch (%d)"), pSysInfo->m_dwSetupParam);
|
|
break;
|
|
}
|
|
|
|
GetFileSystemStoringD3D8Cache( pSysInfo->m_szD3D8CacheFileSystem );
|
|
|
|
pSysInfo->m_bNetMeetingRunning = IsNetMeetingRunning();
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetProcessorDescription
|
|
*
|
|
****************************************************************************/
|
|
VOID GetProcessorDescription(BOOL bNT, SYSTEM_INFO* psi, TCHAR* pszDesc, BOOL* pbNoCPUSpeed)
|
|
{
|
|
OSVERSIONINFO OSVersionInfo;
|
|
SYSTEM_INFO SystemInfo;
|
|
OSVersionInfo.dwOSVersionInfoSize = sizeof OSVersionInfo;
|
|
GetVersionEx(&OSVersionInfo);
|
|
GetSystemInfo(&SystemInfo);
|
|
GetProcessorVendorNameAndType(OSVersionInfo, SystemInfo, pszDesc, pbNoCPUSpeed);
|
|
if (SystemInfo.dwNumberOfProcessors > 1)
|
|
{
|
|
TCHAR szFmt[100];
|
|
TCHAR szNumProc[100];
|
|
LoadString(NULL, IDS_NUMPROCFMT, szFmt, 100);
|
|
wsprintf(szNumProc, szFmt, SystemInfo.dwNumberOfProcessors);
|
|
lstrcat(pszDesc, szNumProc);
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetProcessorVendorNameAndType
|
|
*
|
|
****************************************************************************/
|
|
VOID GetProcessorVendorNameAndType(OSVERSIONINFO& OSVersionInfo,
|
|
SYSTEM_INFO& SystemInfo, TCHAR* pszProcessor, BOOL* pbNoCPUSpeed)
|
|
{
|
|
TCHAR szVendorName[50];
|
|
TCHAR szLongName[50];
|
|
TCHAR szDesc[100];
|
|
BOOL bIsMMX = FALSE;
|
|
BOOL bIs3DNow = FALSE;
|
|
// 10/27/98(RichGr): Intel's Katmai New Instructions (KNI).
|
|
BOOL bIsKatmai = FALSE; /* 2/04/99(RichGr): Pentium III/Streaming SIMD Instrucs*/
|
|
PROCESSOR_ID_NUMBERS ProcessorIdNumbers;
|
|
DWORD dwKBytesLevel2Cache;
|
|
DWORD dwIntelBrandIndex;
|
|
|
|
memset(&szVendorName[0], 0, sizeof szVendorName);
|
|
memset(&szLongName[0], 0, sizeof szLongName);
|
|
memset(&ProcessorIdNumbers, 0, sizeof ProcessorIdNumbers);
|
|
|
|
// 6/21/99(RichGr): On the Intel, we can now interpret a 1-byte descriptor to give us
|
|
// the size of the Level 2 cache, if present.
|
|
dwKBytesLevel2Cache = 0;
|
|
// 4/26/01(RichGr): On the Intel, we have a new 1-byte index that specifies the brand.
|
|
dwIntelBrandIndex = 0;
|
|
|
|
if (OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS // Win9x
|
|
|| (OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT // WinNT
|
|
&& SystemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL))
|
|
{
|
|
GetVendorNameAndCaps(szVendorName, szLongName, ProcessorIdNumbers, &bIsMMX, &bIs3DNow,
|
|
&bIsKatmai, &dwKBytesLevel2Cache, &dwIntelBrandIndex, pbNoCPUSpeed);
|
|
|
|
if (szLongName[0]) // Use this if there's anything there.
|
|
lstrcpy(pszProcessor, szLongName);
|
|
else
|
|
{
|
|
lstrcpy(pszProcessor, szVendorName);
|
|
lstrcat(pszProcessor, TEXT(" "));
|
|
|
|
if ( !lstrcmp(szVendorName, TEXT("Intel")))
|
|
{
|
|
if (SystemInfo.dwProcessorType == PROCESSOR_INTEL_386)
|
|
lstrcat(pszProcessor, TEXT("80386"));
|
|
else
|
|
if (SystemInfo.dwProcessorType == PROCESSOR_INTEL_486)
|
|
lstrcat(pszProcessor, TEXT("80486"));
|
|
else
|
|
if (SystemInfo.dwProcessorType == PROCESSOR_INTEL_PENTIUM)
|
|
{
|
|
// 6/21/99(RichGr): A lot of this code is now derived from \\muroc\slm\proj\win\src\shell\cpls\system\sysset.c.
|
|
switch ( ProcessorIdNumbers.dwFamily )
|
|
{
|
|
// We should, of course, never hit these - they've been dealt with above.
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
lstrcat(pszProcessor, TEXT("80486"));
|
|
break;
|
|
|
|
case 5:
|
|
lstrcat(pszProcessor, TEXT("Pentium"));
|
|
|
|
if ( ProcessorIdNumbers.dwModel == 3 )
|
|
lstrcat(pszProcessor, TEXT(" Overdrive"));
|
|
|
|
break;
|
|
|
|
case 6:
|
|
switch ( ProcessorIdNumbers.dwModel )
|
|
{
|
|
//
|
|
//Model 1 and 2 are Pentium Pro
|
|
//
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
lstrcat(pszProcessor, TEXT("Pentium Pro"));
|
|
break;
|
|
|
|
//
|
|
//Model 3 and 4 are Pentium II
|
|
//
|
|
case 3:
|
|
case 4:
|
|
lstrcat(pszProcessor, TEXT("Pentium II"));
|
|
break;
|
|
|
|
//
|
|
//Model 5 is either Pentium II or Celeron (depending on if the chip
|
|
//has L2 cache or not)
|
|
//
|
|
case 5:
|
|
if ( dwKBytesLevel2Cache == 0 )
|
|
//
|
|
//No L2 cache so it is a Celeron
|
|
//
|
|
lstrcat(pszProcessor, TEXT("Celeron"));
|
|
else
|
|
//
|
|
//L2 cache so it is at least a Pentium II.
|
|
//
|
|
if ( bIsKatmai )
|
|
lstrcat(pszProcessor, TEXT("Pentium III"));
|
|
else
|
|
lstrcat(pszProcessor, TEXT("Pentium II"));
|
|
|
|
break;
|
|
|
|
case 6:
|
|
if ( dwKBytesLevel2Cache > 128 )
|
|
//
|
|
//L2 cache > 128K so it is at least a Pentium II
|
|
//
|
|
if ( bIsKatmai )
|
|
lstrcat(pszProcessor, TEXT("Pentium III"));
|
|
else
|
|
lstrcat(pszProcessor, TEXT("Pentium II"));
|
|
else
|
|
//
|
|
//L2 cache <= 128K so it is a Celeron
|
|
//
|
|
lstrcat(pszProcessor, TEXT("Celeron"));
|
|
|
|
break;
|
|
|
|
case 7:
|
|
lstrcat(pszProcessor, TEXT("Pentium III"));
|
|
break;
|
|
|
|
default:
|
|
if ( bIsKatmai )
|
|
{
|
|
// 4/26/01(RichGr): Pentium III Xeons and later have a one-byte Brand Index that we can use.
|
|
// More recent machines have a Brand String as well.
|
|
// see ftp://download.intel.com/design/Pentium4/manuals/24547103.pdf
|
|
if (dwIntelBrandIndex == 1)
|
|
lstrcat(pszProcessor, TEXT("Celeron"));
|
|
else
|
|
if (dwIntelBrandIndex == 0 || dwIntelBrandIndex == 2)
|
|
lstrcat(pszProcessor, TEXT("Pentium III"));
|
|
else
|
|
if (dwIntelBrandIndex == 3)
|
|
lstrcat(pszProcessor, TEXT("Pentium III Xeon"));
|
|
else
|
|
if (dwIntelBrandIndex == 8)
|
|
lstrcat(pszProcessor, TEXT("Pentium 4"));
|
|
else
|
|
lstrcat(pszProcessor, TEXT("Pentium"));
|
|
}
|
|
else
|
|
lstrcat(pszProcessor, TEXT("Pentium II"));
|
|
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
wsprintf( szDesc, TEXT("x86 Family %u Model %u Stepping %u"), ProcessorIdNumbers.dwFamily, ProcessorIdNumbers.dwModel,
|
|
ProcessorIdNumbers.dwSteppingID );
|
|
lstrcat(pszProcessor, szDesc);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if ( !lstrcmp(szVendorName, TEXT("AMD")))
|
|
{
|
|
if (SystemInfo.dwProcessorType == PROCESSOR_INTEL_486)
|
|
lstrcat(pszProcessor, TEXT("Am486 or Am5X86"));
|
|
else
|
|
if (SystemInfo.dwProcessorType == PROCESSOR_INTEL_PENTIUM)
|
|
{
|
|
if (ProcessorIdNumbers.dwFamily == 5)
|
|
{
|
|
if (ProcessorIdNumbers.dwModel < 6)
|
|
{
|
|
wsprintf(szDesc, TEXT("K5 (Model %d)"), ProcessorIdNumbers.dwModel);
|
|
lstrcat(pszProcessor, szDesc);
|
|
}
|
|
else
|
|
{
|
|
lstrcat(pszProcessor, TEXT("K6"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wsprintf(szDesc, TEXT("K%d (Model %d)"), ProcessorIdNumbers.dwFamily, ProcessorIdNumbers.dwModel);
|
|
lstrcat(pszProcessor, szDesc);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if ( !lstrcmp(szVendorName, TEXT("Cyrix")))
|
|
{
|
|
if (ProcessorIdNumbers.dwFamily == 4)
|
|
{
|
|
if (ProcessorIdNumbers.dwModel == 4)
|
|
lstrcat(pszProcessor, TEXT("MediaGX"));
|
|
}
|
|
else
|
|
if (ProcessorIdNumbers.dwFamily == 5)
|
|
{
|
|
if (ProcessorIdNumbers.dwModel == 2)
|
|
lstrcat(pszProcessor, TEXT("6x86"));
|
|
else
|
|
if (ProcessorIdNumbers.dwModel == 4)
|
|
lstrcat(pszProcessor, TEXT("GXm"));
|
|
}
|
|
else
|
|
if (ProcessorIdNumbers.dwFamily == 6)
|
|
{
|
|
lstrcat(pszProcessor, TEXT("6x86MX"));
|
|
}
|
|
}
|
|
else
|
|
if ( !lstrcmp(szVendorName, TEXT("IDT")))
|
|
{
|
|
// 4/21/98(RichGr): There's only 1 chip available at present.
|
|
// 7/07/98(RichGr): Now there are two chips.
|
|
// Note: Although the C6 is MMX-compatible, Intel does not allow IDT to display the word "MMX"
|
|
// in association with the name IDT, so we'll skip that.
|
|
// See http://www.winchip.com/ for more info.
|
|
if (ProcessorIdNumbers.dwFamily == 5)
|
|
{
|
|
if (ProcessorIdNumbers.dwModel == 4)
|
|
lstrcat(pszProcessor, TEXT("WinChip C6"));
|
|
else
|
|
if (ProcessorIdNumbers.dwModel >= 8) // 7/07/98(RichGr): Assume later models have the same feature.
|
|
lstrcat(pszProcessor, TEXT("WinChip 2"));
|
|
}
|
|
else
|
|
lstrcat(pszProcessor, TEXT("WinChip"));
|
|
}
|
|
else
|
|
{
|
|
if (SystemInfo.dwProcessorType == PROCESSOR_INTEL_486)
|
|
lstrcat(pszProcessor, TEXT("486"));
|
|
else
|
|
if (SystemInfo.dwProcessorType == PROCESSOR_INTEL_PENTIUM)
|
|
{
|
|
if (ProcessorIdNumbers.dwFamily == 5)
|
|
lstrcat(pszProcessor, TEXT("P5"));
|
|
else
|
|
if (ProcessorIdNumbers.dwFamily == 6)
|
|
lstrcat(pszProcessor, TEXT("P6"));
|
|
else
|
|
lstrcat(pszProcessor, TEXT("P5"));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bIsKatmai
|
|
&& !lstrcmp(szVendorName, TEXT("Intel")))
|
|
;
|
|
else
|
|
{
|
|
if (bIsMMX || bIs3DNow)
|
|
lstrcat(pszProcessor, TEXT(", "));
|
|
|
|
if (bIsMMX)
|
|
lstrcat(pszProcessor, TEXT(" MMX"));
|
|
|
|
if (bIs3DNow)
|
|
{
|
|
if (bIsMMX)
|
|
lstrcat(pszProcessor, TEXT(", "));
|
|
|
|
lstrcat(pszProcessor, TEXT(" 3DNow"));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if (OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) // WinNT
|
|
{
|
|
if (SystemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64)
|
|
{
|
|
lstrcpy(pszProcessor, TEXT("IA64 "));
|
|
}
|
|
else
|
|
if (SystemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
|
|
{
|
|
lstrcpy(pszProcessor, TEXT("AMD64 "));
|
|
}
|
|
else
|
|
lstrcpy(pszProcessor, TEXT("Unknown "));
|
|
}
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetVendorNameAndCaps
|
|
*
|
|
****************************************************************************/
|
|
VOID GetVendorNameAndCaps(TCHAR* pszVendorName, TCHAR* pszLongName,
|
|
PROCESSOR_ID_NUMBERS& ProcessorIdNumbers, BOOL* pbIsMMX, BOOL* pbIs3DNow, BOOL* pbIsKatmai, /*Pentium III/Streaming SIMD Instrucs*/
|
|
LPDWORD pdwKBytesLevel2Cache, LPDWORD pdwIntelBrandIndex, BOOL* pbNoCPUSpeed)
|
|
{
|
|
CHAR szVendorLabel[13];
|
|
CHAR szLongName[50];
|
|
DWORD dwFamilyModelStep;
|
|
BOOL bCPUID_works;
|
|
DWORD dwFeaturesFlags;
|
|
BYTE byteCacheDescriptors[4] = {0,0,0,0};
|
|
DWORD dwIntelBrandIndex;
|
|
PCHAR psz;
|
|
|
|
memset(&szVendorLabel[0], 0, sizeof szVendorLabel);
|
|
memset(&szLongName[0], 0, sizeof szLongName);
|
|
dwFamilyModelStep = 0;
|
|
dwFeaturesFlags = 0;
|
|
*pbIsMMX = FALSE;
|
|
*pbIs3DNow = FALSE;
|
|
*pbIsKatmai = FALSE; /* 2/04/99(RichGr): Pentium III/Streaming SIMD Instrucs*/
|
|
bCPUID_works = FALSE;
|
|
*pdwKBytesLevel2Cache = 0;
|
|
dwIntelBrandIndex = 0;
|
|
|
|
#ifdef _X86_
|
|
// Determine whether CPUID instruction can be executed.
|
|
__asm
|
|
{
|
|
// CPUID trashes lots - save everything. Also, Retail build makes assumptions about reg values.
|
|
pushad
|
|
|
|
// Load value of flags register into eax.
|
|
pushfd
|
|
pop eax
|
|
|
|
// Save original flags register value in ebx.
|
|
mov ebx, eax
|
|
|
|
// Alter bit 21 and write new value into flags register.
|
|
xor eax, 0x00200000
|
|
push eax
|
|
popfd
|
|
|
|
// Retrieve the new value of the flags register.
|
|
pushfd
|
|
pop eax
|
|
|
|
// Compare with the original value.
|
|
xor eax, ebx
|
|
|
|
// If the new value is the same as the old, the CPUID instruction cannot
|
|
// be executed. Most 486s and all Pentium-class processors should be able
|
|
// to execute CPUID.
|
|
// 4/21/98(RichGr): One Cyrix 6x86 machine in the Apps Lab (AP_LAREDO) can't execute
|
|
// CPUID in ring 3, for no apparent reason. Another similar machine works fine.
|
|
je done1
|
|
|
|
mov bCPUID_works, 1 // bCPUID_works = TRUE
|
|
|
|
// Execute CPUID with eax = 0 to get Vendor Label.
|
|
xor eax, eax
|
|
_emit 0x0F // CPUID
|
|
_emit 0xA2
|
|
|
|
// Move Vendor Label from regs to string.
|
|
mov dword ptr[szVendorLabel + 0], ebx
|
|
mov dword ptr[szVendorLabel + 4], edx
|
|
mov dword ptr[szVendorLabel + 8], ecx
|
|
|
|
// Execute CPUID with eax = 1 to pick up Family, Model and Stepping ID, and to check for MMX support.
|
|
mov eax, 1
|
|
_emit 0x0F // CPUID
|
|
_emit 0xA2
|
|
|
|
// Save Family/Model/Stepping ID.
|
|
mov dwFamilyModelStep, eax
|
|
|
|
// 4/26/01(RichGr): Save Brand Index (new for PIII Xeons and after). This is the low byte only.
|
|
mov dwIntelBrandIndex, ebx
|
|
|
|
// 2/04/99(RichGr): Save Features Flags.
|
|
mov dwFeaturesFlags, edx
|
|
|
|
// 6/21/99(RichGr): Execute CPUID with eax == 2 to pick up descriptor for size of Level 2 cache.
|
|
mov eax, 2
|
|
_emit 0x0F // CPUID
|
|
_emit 0xA2
|
|
|
|
// Save Level 2 cache size descriptor in byte 0, together with 3 other cache descriptors in bytes 1 - 3.
|
|
// See \\muroc\slm\proj\win\src\shell\cpls\system\sysset.c and cpuid.asm,
|
|
// and Intel Architecture Software Developer's Manual (1997), volume 2, p. 105.
|
|
mov dword ptr[byteCacheDescriptors], edx
|
|
|
|
done1:
|
|
// Restore everything.
|
|
popad
|
|
}
|
|
#endif // _X86_
|
|
|
|
|
|
dwIntelBrandIndex &= 0xFF;
|
|
*pdwIntelBrandIndex = dwIntelBrandIndex;
|
|
|
|
// 6/21/99(RichGr): The following values were helpfully provided by David Penley(Intel):
|
|
/* 40H No L2 Cache
|
|
41H L2 Unified cache: 128K Bytes, 4-way set associative, 32 byte line size
|
|
42H L2 Unified cache: 256K Bytes, 4-way set associative, 32 byte line size
|
|
43H L2 Unified cache: 512K Bytes, 4-way set associative, 32 byte line size
|
|
44H L2 Unified cache: 1M Byte, 4-way set associative, 32 byte line size
|
|
45H L2 Unified cache: 2M Byte, 4-way set associative, 32 byte line size
|
|
|
|
Updated manuals can be had at... http://developer.intel.com/design/pentiumiii/xeon/manuals/
|
|
*/
|
|
|
|
if (szVendorLabel[0])
|
|
{
|
|
if ( !strcmp(&szVendorLabel[0], "GenuineIntel"))
|
|
{
|
|
lstrcpy(pszVendorName, TEXT("Intel"));
|
|
|
|
// 4/29/01: This doesn't cover the Pentium 4, but we don't need cache size
|
|
// for it at present.
|
|
if ( byteCacheDescriptors[0] == 0x40 )
|
|
*pdwKBytesLevel2Cache = 0;
|
|
else
|
|
if ( byteCacheDescriptors[0] == 0x41 )
|
|
*pdwKBytesLevel2Cache = 128;
|
|
else
|
|
if ( byteCacheDescriptors[0] == 0x42 )
|
|
*pdwKBytesLevel2Cache = 256;
|
|
else
|
|
if ( byteCacheDescriptors[0] == 0x43 )
|
|
*pdwKBytesLevel2Cache = 512;
|
|
else
|
|
if ( byteCacheDescriptors[0] == 0x44 )
|
|
*pdwKBytesLevel2Cache = 1024;
|
|
else
|
|
if ( byteCacheDescriptors[0] == 0x45 )
|
|
*pdwKBytesLevel2Cache = 2048;
|
|
}
|
|
else
|
|
if ( !strcmp(&szVendorLabel[0], "AuthenticAMD"))
|
|
lstrcpy(pszVendorName, TEXT("AMD"));
|
|
else
|
|
if ( !strcmp(&szVendorLabel[0], "CyrixInstead"))
|
|
lstrcpy(pszVendorName, TEXT("Cyrix"));
|
|
else
|
|
if ( !strcmp(&szVendorLabel[0], "CentaurHauls"))
|
|
lstrcpy(pszVendorName, TEXT("IDT"));
|
|
else
|
|
{
|
|
#ifdef UNICODE
|
|
MultiByteToWideChar(CP_ACP, 0, szVendorLabel, -1, pszVendorName, 50);
|
|
#else
|
|
lstrcpy(pszVendorName, szVendorLabel);
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
lstrcpy(pszVendorName, TEXT("Intel"));
|
|
|
|
if (dwFamilyModelStep)
|
|
{
|
|
ProcessorIdNumbers.dwType = (dwFamilyModelStep & 0x00003000) >> 12;
|
|
ProcessorIdNumbers.dwFamily = (dwFamilyModelStep & 0x00000F00) >> 8;
|
|
ProcessorIdNumbers.dwModel = (dwFamilyModelStep & 0x000000F0) >> 4;
|
|
ProcessorIdNumbers.dwSteppingID = dwFamilyModelStep & 0x0000000F;
|
|
}
|
|
|
|
if (dwFeaturesFlags)
|
|
{
|
|
// Check whether MMX is supported.
|
|
if (dwFeaturesFlags & 0x00800000)
|
|
*pbIsMMX = TRUE;
|
|
|
|
// 2/04/99(RichGr): Check whether Katmai is supported (aka Pentium III/Streaming SIMD Instrucs).
|
|
if ((dwFeaturesFlags & 0x02000000)
|
|
&& !lstrcmp(pszVendorName, TEXT("Intel")))
|
|
*pbIsKatmai = TRUE;
|
|
}
|
|
|
|
// 7/07/98(RichGr): Added for IDT's Long Name feature.
|
|
// 9/10/98(RichGr): Attempt this on all processors, and skip if there's nothing there.
|
|
#ifdef _X86_
|
|
if (bCPUID_works)
|
|
{
|
|
__asm
|
|
{
|
|
// CPUID trashes lots - save everything. Also, Retail build makes assumptions about reg values.
|
|
pushad
|
|
|
|
|
|
// 9/10/98(RichGr): Check for extended CPUID support.
|
|
mov eax, 0x80000000
|
|
_emit 0x0F // CPUID
|
|
_emit 0xA2
|
|
cmp eax, 0x80000001 // Jump if no extended CPUID.
|
|
jb done2
|
|
|
|
// Check for AMD's 3DNow feature. Note: They believe this may be added to other non-AMD CPUs as well.
|
|
// Adapted from one of AMD's webpages at: http://www.amd.com/3dsdk/library/macros/amddcpu.html
|
|
mov eax, 0x80000001
|
|
_emit 0x0F // CPUID
|
|
_emit 0xA2
|
|
test edx, 0x80000000 // Check for 3DNow flag.
|
|
jz LongName
|
|
mov eax, pbIs3DNow
|
|
mov dword ptr[eax], 1 // bIs3DNow = TRUE
|
|
|
|
// Execute CPUID with eax = 0x80000002 thru 0x80000004 to get 48-byte Long Name (for instance: "IDT WinChip 2-3D").
|
|
LongName:
|
|
mov esi, 0x80000001
|
|
xor edi, edi
|
|
NameLoop:
|
|
inc esi
|
|
mov eax,esi
|
|
cmp eax, 0x80000004
|
|
jg done2
|
|
|
|
_emit 0x0F // CPUID
|
|
_emit 0xA2
|
|
|
|
// 9/10/98(RichGr): The first time thru, check that there's valid alphanumeric data.
|
|
cmp esi, 0x80000002 // First time?
|
|
jg Move // If not, skip this test.
|
|
cmp al, 0x20 // If first character < ' ', skip.
|
|
jl done2
|
|
cmp al, 0x7a // If first character > 'z', skip.
|
|
jg done2
|
|
|
|
// Move Long Name from regs to string.
|
|
Move:
|
|
mov dword ptr[szLongName + edi + 0x0], eax
|
|
mov dword ptr[szLongName + edi + 0x4], ebx
|
|
mov dword ptr[szLongName + edi + 0x8], ecx
|
|
mov dword ptr[szLongName + edi + 0x0c], edx
|
|
add edi, 0x10
|
|
jmp NameLoop
|
|
|
|
done2:
|
|
// Restore everything.
|
|
popad
|
|
}
|
|
|
|
if ( szLongName[0] )
|
|
{
|
|
// Move beyond Intel's leading spaces.
|
|
for (psz = &szLongName[0]; *psz == ' '; psz++);
|
|
|
|
if (*psz)
|
|
{
|
|
#ifdef UNICODE
|
|
MultiByteToWideChar(CP_ACP, 0, psz, -1, pszLongName, 50);
|
|
#else
|
|
strcpy(pszLongName, psz);
|
|
#endif
|
|
// 4/29/01(RichGr): Intel Brand Strings show the maximum rated CPU Speed, no need for further detection.
|
|
if ( !lstrcmp(pszVendorName, TEXT("Intel")))
|
|
*pbNoCPUSpeed = FALSE;
|
|
}
|
|
}
|
|
}
|
|
#endif // _X86_
|
|
}
|
|
|
|
|
|
#ifdef _X86_
|
|
|
|
// Some static variables used by GetCPUSpeed
|
|
static int s_milliseconds;
|
|
static __int64 s_ticks;
|
|
|
|
/****************************************************************************
|
|
*
|
|
* fabs
|
|
*
|
|
****************************************************************************/
|
|
FLOAT inline fabs(FLOAT a)
|
|
{
|
|
if (a < 0.0f)
|
|
return -a;
|
|
else
|
|
return a;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* StartTimingCPU
|
|
*
|
|
****************************************************************************/
|
|
int StartTimingCPU( HANDLE& hProcess, DWORD& oldclass )
|
|
{
|
|
//
|
|
// detect ability to get info
|
|
//
|
|
|
|
// 4/03/2000(RichGr): The RDTSC instruction is crashing on some older Cyrix machines,
|
|
// so wrap a __try/__except around everything.
|
|
__try
|
|
{
|
|
__asm
|
|
{
|
|
pushfd ; push extended flags
|
|
pop eax ; store eflags into eax
|
|
mov ebx, eax ; save EBX for testing later
|
|
xor eax, (1<<21) ; switch bit 21
|
|
push eax ; push eflags
|
|
popfd ; pop them again
|
|
pushfd ; push extended flags
|
|
pop eax ; store eflags into eax
|
|
cmp eax, ebx ; see if bit 21 has changed
|
|
jz no_cpuid ; make sure it's now on
|
|
}
|
|
|
|
//
|
|
// start timing
|
|
//
|
|
// 10/31/99(RichGr): Bump up the priority to real-time, drawing from ToddLa's code.
|
|
// See file:\\pyrex\user\toddla\speed.c
|
|
hProcess = GetCurrentProcess();
|
|
oldclass = GetPriorityClass(hProcess);
|
|
SetPriorityClass(hProcess, REALTIME_PRIORITY_CLASS);
|
|
Sleep(10);
|
|
|
|
s_milliseconds = -(int)timeGetTime();
|
|
|
|
__asm
|
|
{
|
|
lea ecx, s_ticks ; get the offset
|
|
mov dword ptr [ecx], 0 ; zero the memory
|
|
mov dword ptr [ecx+4], 0 ;
|
|
// rdtsc ; read time-stamp counter
|
|
__emit 0fh
|
|
__emit 031h
|
|
sub [ecx], eax ; store the negative
|
|
sbb [ecx+4], edx ; in the variable
|
|
}
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
goto no_cpuid;
|
|
}
|
|
|
|
return 0;
|
|
|
|
no_cpuid:
|
|
// 10/31/99(RichGr): In case someone changes the code, make sure that the priority is restored
|
|
// to normal if there is an error return.
|
|
if ( hProcess && oldclass )
|
|
SetPriorityClass( hProcess, oldclass );
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* StopTimingCPU
|
|
*
|
|
****************************************************************************/
|
|
void StopTimingCPU( HANDLE& hProcess, DWORD& oldclass )
|
|
{
|
|
s_milliseconds += (int)timeGetTime();
|
|
|
|
__asm
|
|
{
|
|
lea ecx, s_ticks ; get the offset
|
|
// rdtsc ; read time-stamp counter
|
|
__emit 0fh
|
|
__emit 031h
|
|
add [ecx], eax ; add the tick count
|
|
adc [ecx+4], edx ;
|
|
}
|
|
|
|
// 10/31/99(RichGr): Restore the priority to normal.
|
|
if ( hProcess && oldclass )
|
|
SetPriorityClass( hProcess, oldclass );
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* CalcCPUSpeed
|
|
*
|
|
****************************************************************************/
|
|
INT CalcCPUSpeed(VOID)
|
|
{
|
|
//
|
|
// get the actual cpu speed in MHz, and
|
|
// then find the one in the CPU speed list
|
|
// that is closest
|
|
//
|
|
const struct tagCPUSPEEDS
|
|
{
|
|
float fSpeed;
|
|
int iSpeed;
|
|
} cpu_speeds[] =
|
|
{
|
|
//
|
|
// valid CPU speeds that are not integrally divisible by
|
|
// 16.67 MHz
|
|
//
|
|
{ 60.00f, 60 },
|
|
{ 75.00f, 75 },
|
|
{ 90.00f, 90 },
|
|
{ 120.00f, 120 },
|
|
{ 180.00f, 180 },
|
|
};
|
|
|
|
//
|
|
// find the closest one
|
|
//
|
|
float fSpeed=((float)s_ticks)/((float)s_milliseconds*1000.0f);
|
|
int iSpeed=cpu_speeds[0].iSpeed;
|
|
float fDiff=(float)fabs(fSpeed-cpu_speeds[0].fSpeed);
|
|
|
|
for (int i=1 ; i<sizeof(cpu_speeds)/sizeof(cpu_speeds[0]) ; i++)
|
|
{
|
|
float fTmpDiff = (float)fabs(fSpeed-cpu_speeds[i].fSpeed);
|
|
|
|
if (fTmpDiff < fDiff)
|
|
{
|
|
iSpeed=cpu_speeds[i].iSpeed;
|
|
fDiff=fTmpDiff;
|
|
}
|
|
}
|
|
|
|
//
|
|
// now, calculate the nearest multiple of fIncr
|
|
// speed
|
|
//
|
|
|
|
|
|
//
|
|
// now, if the closest one is not within one incr, calculate
|
|
// the nearest multiple of fIncr speed and see if that's
|
|
// closer
|
|
//
|
|
const float fIncr=16.66666666666666666666667f;
|
|
const int iIncr=4267; // fIncr << 8
|
|
|
|
//if (fDiff > fIncr)
|
|
{
|
|
//
|
|
// get the number of fIncr quantums the speed is
|
|
//
|
|
int iQuantums = (int)((fSpeed / fIncr) + 0.5f);
|
|
float fQuantumSpeed = (float)iQuantums * fIncr;
|
|
float fTmpDiff = (float)fabs(fQuantumSpeed - fSpeed);
|
|
|
|
if (fTmpDiff < fDiff)
|
|
{
|
|
iSpeed = (iQuantums * iIncr) >> 8;
|
|
fDiff=fTmpDiff;
|
|
}
|
|
}
|
|
|
|
return iSpeed;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetCPUSpeed
|
|
*
|
|
****************************************************************************/
|
|
INT GetCPUSpeed(VOID)
|
|
{
|
|
INT nCPUSpeed;
|
|
|
|
// Try first using WMI - may not work on Win9x
|
|
nCPUSpeed = GetCPUSpeedViaWMI();
|
|
if( nCPUSpeed != -1 )
|
|
return nCPUSpeed;
|
|
|
|
// If WMI fails, then fall back on brute force cpu detection.
|
|
#undef MAX_SAMPLES
|
|
#define MAX_SAMPLES 10
|
|
|
|
int nSpeed = 0, nSpeeds[MAX_SAMPLES] = {0};
|
|
int nCount = 0, nCounts[MAX_SAMPLES] = {0};
|
|
int i, j;
|
|
HANDLE hProcess = NULL;
|
|
DWORD oldclass = 0;
|
|
|
|
// 10/12/99(RichGr): Pick up the most frequently occurring speed in a number of short samples,
|
|
// instead of waiting once for a whole second (see DxDiag).
|
|
for ( i = 0; i < MAX_SAMPLES; i++ )
|
|
{
|
|
if ( !StartTimingCPU( hProcess, oldclass ))
|
|
{
|
|
// 10/21/99(RichGr): Sleep() time is important. On a 266 MHz running Win98 under the kernel
|
|
// debugger, the original value of Sleep(10) sometimes gave a speed of 283 MHz.
|
|
// Sleep(5) to Sleep(30) were also unreliable. Sleep(40) and Sleep(50) looked good,
|
|
// and I picked (50) for a little margin.
|
|
Sleep(50);
|
|
StopTimingCPU( hProcess, oldclass );
|
|
nSpeed = CalcCPUSpeed();
|
|
|
|
for ( j = 0; j < MAX_SAMPLES; j++ )
|
|
{
|
|
if ( nSpeeds[j] == 0 || nSpeed == nSpeeds[j] ) // If the speed matches, increment the count.
|
|
{
|
|
nSpeeds[j] = nSpeed;
|
|
nCounts[j]++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find the speed with the biggest count.
|
|
for ( i = j = 0, nCount = 0; i < MAX_SAMPLES; i++ )
|
|
{
|
|
if ( nCounts[i] > nCount )
|
|
{
|
|
nCount = nCounts[i];
|
|
j = i;
|
|
}
|
|
}
|
|
|
|
return nSpeeds[j];
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetCPUSpeedViaWMI
|
|
*
|
|
****************************************************************************/
|
|
INT GetCPUSpeedViaWMI(VOID)
|
|
{
|
|
HRESULT hr;
|
|
INT nCPUSpeed = -1;
|
|
|
|
IEnumWbemClassObject* pEnumProcessorDevs = NULL;
|
|
IWbemClassObject* pProcessorDev = NULL;
|
|
BSTR pClassName = NULL;
|
|
BSTR pPropName = NULL;
|
|
VARIANT var;
|
|
DWORD uReturned = 0;
|
|
|
|
ZeroMemory( &var, sizeof(VARIANT) );
|
|
VariantClear( &var );
|
|
|
|
if( NULL == g_pIWbemServices )
|
|
return -1;
|
|
|
|
pClassName = SysAllocString( L"Win32_Processor" );
|
|
hr = g_pIWbemServices->CreateInstanceEnum( pClassName, 0, NULL,
|
|
&pEnumProcessorDevs );
|
|
if( FAILED(hr) || pEnumProcessorDevs == NULL )
|
|
goto LCleanup;
|
|
|
|
// Get the first one in the list
|
|
hr = pEnumProcessorDevs->Next( 1000, // timeout in two seconds
|
|
1, // return just one storage device
|
|
&pProcessorDev, // pointer to storage device
|
|
&uReturned ); // number obtained: one or zero
|
|
if( FAILED(hr) || uReturned == 0 || pProcessorDev == NULL )
|
|
goto LCleanup;
|
|
|
|
// 298510: MaxClockSpeed on WMI on Whistler & beyond works
|
|
if( BIsWhistler() )
|
|
pPropName = SysAllocString( L"MaxClockSpeed" );
|
|
else
|
|
pPropName = SysAllocString( L"CurrentClockSpeed" );
|
|
|
|
hr = pProcessorDev->Get( pPropName, 0L, &var, NULL, NULL );
|
|
if( FAILED(hr) )
|
|
goto LCleanup;
|
|
|
|
// Success - record VT_I4 value in nCPUSpeed
|
|
nCPUSpeed = var.lVal;
|
|
|
|
LCleanup:
|
|
VariantClear( &var );
|
|
|
|
if(pPropName)
|
|
SysFreeString(pPropName);
|
|
if(pClassName)
|
|
SysFreeString(pClassName);
|
|
|
|
if(pProcessorDev)
|
|
pProcessorDev->Release();
|
|
if(pEnumProcessorDevs)
|
|
pEnumProcessorDevs->Release();
|
|
|
|
// Return either -1 or the CPU speed we found.
|
|
return nCPUSpeed;
|
|
}
|
|
|
|
#endif // _X86_
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetComputerSystemInfo
|
|
*
|
|
****************************************************************************/
|
|
VOID GetComputerSystemInfo(TCHAR* szSystemManufacturerEnglish, TCHAR* szSystemModelEnglish)
|
|
{
|
|
HRESULT hr;
|
|
|
|
IEnumWbemClassObject* pEnumDevices = NULL;
|
|
IWbemClassObject* pDevice = NULL;
|
|
BSTR pClassName = NULL;
|
|
BSTR pPropName = NULL;
|
|
DWORD uReturned = 0;
|
|
VARIANT var;
|
|
|
|
ZeroMemory( &var, sizeof(VARIANT) );
|
|
VariantClear( &var );
|
|
|
|
if( NULL == g_pIWbemServices )
|
|
goto LCleanup;
|
|
|
|
pClassName = SysAllocString( L"Win32_ComputerSystem" );
|
|
hr = g_pIWbemServices->CreateInstanceEnum( pClassName, 0, NULL,
|
|
&pEnumDevices );
|
|
if( FAILED(hr) || pEnumDevices == NULL )
|
|
goto LCleanup;
|
|
|
|
// Get the first one in the list
|
|
hr = pEnumDevices->Next( 1000, // timeout in two seconds
|
|
1, // return just one storage device
|
|
&pDevice, // pointer to storage device
|
|
&uReturned ); // number obtained: one or zero
|
|
if( FAILED(hr) || uReturned == 0 || pDevice == NULL )
|
|
goto LCleanup;
|
|
|
|
pPropName = SysAllocString( L"Manufacturer" );
|
|
hr = pDevice->Get( pPropName, 0L, &var, NULL, NULL );
|
|
if( FAILED(hr) )
|
|
goto LCleanup;
|
|
if(pPropName)
|
|
{
|
|
SysFreeString(pPropName);
|
|
pPropName = NULL;
|
|
}
|
|
if( var.bstrVal != NULL )
|
|
{
|
|
#ifdef UNICODE
|
|
_tcsncpy(szSystemManufacturerEnglish, var.bstrVal, 200);
|
|
szSystemManufacturerEnglish[199]=0;
|
|
#else
|
|
WideCharToMultiByte(CP_ACP, 0, var.bstrVal, SysStringLen(var.bstrVal), szSystemManufacturerEnglish, 199, NULL, NULL);
|
|
#endif
|
|
}
|
|
|
|
VariantClear( &var );
|
|
|
|
pPropName = SysAllocString( L"Model" );
|
|
hr = pDevice->Get( pPropName, 0L, &var, NULL, NULL );
|
|
if( FAILED(hr) )
|
|
goto LCleanup;
|
|
if(pPropName)
|
|
{
|
|
SysFreeString(pPropName);
|
|
pPropName = NULL;
|
|
}
|
|
if( var.bstrVal != NULL )
|
|
{
|
|
#ifdef UNICODE
|
|
_tcsncpy(szSystemModelEnglish, var.bstrVal, 200);
|
|
szSystemModelEnglish[199]=0;
|
|
#else
|
|
WideCharToMultiByte(CP_ACP, 0, var.bstrVal, SysStringLen(var.bstrVal), szSystemModelEnglish, 199, NULL, NULL);
|
|
#endif
|
|
}
|
|
|
|
VariantClear( &var );
|
|
|
|
LCleanup:
|
|
|
|
if( lstrlen(szSystemModelEnglish) == 0 )
|
|
lstrcpy( szSystemModelEnglish, TEXT("n/a") );
|
|
if( lstrlen(szSystemManufacturerEnglish) == 0 )
|
|
lstrcpy( szSystemManufacturerEnglish, TEXT("n/a") );
|
|
|
|
if(pPropName)
|
|
SysFreeString(pPropName);
|
|
if(pClassName)
|
|
SysFreeString(pClassName);
|
|
|
|
if(pDevice)
|
|
pDevice->Release();
|
|
if(pEnumDevices)
|
|
pEnumDevices->Release();
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetBIOSInfo
|
|
*
|
|
****************************************************************************/
|
|
VOID GetBIOSInfo(TCHAR* szBIOSEnglish)
|
|
{
|
|
HRESULT hr;
|
|
|
|
IEnumWbemClassObject* pEnumDevices = NULL;
|
|
IWbemClassObject* pDevice = NULL;
|
|
BSTR pClassName = NULL;
|
|
BSTR pPropName = NULL;
|
|
DWORD uReturned = 0;
|
|
VARIANT var;
|
|
|
|
ZeroMemory( &var, sizeof(VARIANT) );
|
|
VariantClear( &var );
|
|
|
|
if( NULL == g_pIWbemServices )
|
|
goto LCleanup;
|
|
|
|
pClassName = SysAllocString( L"Win32_BIOS" );
|
|
hr = g_pIWbemServices->CreateInstanceEnum( pClassName, 0, NULL,
|
|
&pEnumDevices );
|
|
if( FAILED(hr) || pEnumDevices == NULL )
|
|
goto LCleanup;
|
|
|
|
// Get the first one in the list
|
|
hr = pEnumDevices->Next( 1000, // timeout in two seconds
|
|
1, // return just one storage device
|
|
&pDevice, // pointer to storage device
|
|
&uReturned ); // number obtained: one or zero
|
|
if( FAILED(hr) || uReturned == 0 || pDevice == NULL )
|
|
goto LCleanup;
|
|
|
|
pPropName = SysAllocString( L"Version" );
|
|
hr = pDevice->Get( pPropName, 0L, &var, NULL, NULL );
|
|
if( FAILED(hr) )
|
|
goto LCleanup;
|
|
if( var.bstrVal != NULL )
|
|
{
|
|
#ifdef UNICODE
|
|
_tcsncpy(szBIOSEnglish, var.bstrVal, 200);
|
|
szBIOSEnglish[199]=0;
|
|
#else
|
|
WideCharToMultiByte(CP_ACP, 0, var.bstrVal, SysStringLen(var.bstrVal), szBIOSEnglish, 199, NULL, NULL);
|
|
#endif
|
|
}
|
|
|
|
VariantClear( &var );
|
|
|
|
LCleanup:
|
|
|
|
if( lstrlen(szBIOSEnglish) == 0 )
|
|
lstrcpy( szBIOSEnglish, TEXT("n/a") );
|
|
|
|
if(pPropName)
|
|
SysFreeString(pPropName);
|
|
if(pClassName)
|
|
SysFreeString(pClassName);
|
|
|
|
if(pDevice)
|
|
pDevice->Release();
|
|
if(pEnumDevices)
|
|
pEnumDevices->Release();
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetDXDebugLevels
|
|
*
|
|
****************************************************************************/
|
|
VOID GetDXDebugLevels(SysInfo* pSysInfo)
|
|
{
|
|
pSysInfo->m_bIsD3D8DebugRuntimeAvailable = IsD3D8DebugRuntimeAvailable();
|
|
pSysInfo->m_bIsD3DDebugRuntime = IsD3DDebugRuntime();
|
|
pSysInfo->m_bIsDInput8DebugRuntimeAvailable = IsDInput8DebugRuntimeAvailable();
|
|
pSysInfo->m_bIsDInput8DebugRuntime = IsDInput8DebugRuntime();
|
|
pSysInfo->m_bIsDMusicDebugRuntimeAvailable = IsDMusicDebugRuntimeAvailable();
|
|
pSysInfo->m_bIsDMusicDebugRuntime = IsDMusicDebugRuntime();
|
|
pSysInfo->m_bIsDDrawDebugRuntime = IsDDrawDebugRuntime();
|
|
pSysInfo->m_bIsDPlayDebugRuntime = IsDPlayDebugRuntime();
|
|
pSysInfo->m_bIsDSoundDebugRuntime = IsDSoundDebugRuntime();
|
|
|
|
pSysInfo->m_nD3DDebugLevel = (int) GetProfileInt(TEXT("Direct3D"), TEXT("debug"), 0);
|
|
pSysInfo->m_nDDrawDebugLevel = (int) GetProfileInt(TEXT("DirectDraw"),TEXT("debug"), 0);
|
|
pSysInfo->m_nDIDebugLevel = GetDIDebugLevel();
|
|
pSysInfo->m_nDMusicDebugLevel = GetDMDebugLevel();
|
|
pSysInfo->m_nDPlayDebugLevel = (int) GetProfileInt(TEXT("DirectPlay"), TEXT("Debug"), 0);
|
|
pSysInfo->m_nDSoundDebugLevel = GetDSDebugLevel();
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsD3D8DebugRuntimeAvailable
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsD3D8DebugRuntimeAvailable()
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
GetSystemDirectory(szPath, MAX_PATH);
|
|
lstrcat(szPath, TEXT("\\d3d8d.dll"));
|
|
|
|
if (GetFileAttributes(szPath) != -1)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsD3DDebugRuntime
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsD3DDebugRuntime()
|
|
{
|
|
DWORD size;
|
|
DWORD type;
|
|
DWORD lData;
|
|
HKEY hkey;
|
|
BOOL rc;
|
|
|
|
rc = FALSE;
|
|
if (!RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_D3D, 0, KEY_READ, &hkey))
|
|
{
|
|
size = sizeof(DWORD);
|
|
if (!RegQueryValueEx(hkey, REGSTR_VAL_DDRAW_LOADDEBUGRUNTIME, NULL, &type, (LPBYTE)&lData, &size))
|
|
if (lData)
|
|
rc = TRUE;
|
|
RegCloseKey(hkey);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetDIDebugLevel
|
|
*
|
|
****************************************************************************/
|
|
int GetDIDebugLevel()
|
|
{
|
|
DWORD dwDebugBits;
|
|
DWORD dwDebugBitsMax;
|
|
LONG iGenerator;
|
|
|
|
dwDebugBitsMax = 0;
|
|
dwDebugBits = GetProfileInt(TEXT("Debug"), TEXT("dinput"), 0);
|
|
if (dwDebugBits > dwDebugBitsMax)
|
|
dwDebugBitsMax = dwDebugBits;
|
|
|
|
enum
|
|
{
|
|
GENERATOR_KBD = 0,
|
|
GENERATOR_MOUSE,
|
|
GENERATOR_JOY,
|
|
GENERATOR_HID,
|
|
GENERATOR_MAX
|
|
};
|
|
|
|
static TCHAR* szGeneratorNames[] =
|
|
{
|
|
TEXT("DInput.06"),
|
|
TEXT("DInput.04"),
|
|
TEXT("DInput.08"),
|
|
TEXT("DInput.17"),
|
|
};
|
|
|
|
static BOOL bGeneratorArray[4];
|
|
|
|
for (iGenerator = 0; iGenerator < GENERATOR_MAX; iGenerator++)
|
|
{
|
|
dwDebugBits = GetProfileInt(TEXT("Debug"), szGeneratorNames[iGenerator], 0);
|
|
bGeneratorArray[iGenerator] = (dwDebugBits > 0);
|
|
if (dwDebugBits > dwDebugBitsMax)
|
|
dwDebugBitsMax = dwDebugBits;
|
|
}
|
|
|
|
if (dwDebugBitsMax & 0x20) // verbose
|
|
return 5;
|
|
if (dwDebugBitsMax & 0x02) // function entry
|
|
return 4;
|
|
if (dwDebugBitsMax & 0x01) // trace
|
|
return 3;
|
|
if (dwDebugBitsMax & 0x08) // benign
|
|
return 2;
|
|
if (dwDebugBitsMax & 0x10) // severe
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsDInput8DebugRuntimeAvailable
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsDInput8DebugRuntimeAvailable()
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
GetSystemDirectory(szPath, MAX_PATH);
|
|
lstrcat(szPath, TEXT("\\dinput8d.dll"));
|
|
|
|
if (GetFileAttributes(szPath) != -1)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsDInput8DebugRuntime
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsDInput8DebugRuntime()
|
|
{
|
|
DWORD size;
|
|
DWORD type;
|
|
TCHAR szData[MAX_PATH];
|
|
HKEY hkey;
|
|
BOOL rc;
|
|
|
|
rc = FALSE;
|
|
if (!RegOpenKeyEx(HKEY_CLASSES_ROOT, REGSTR_DINPUT_DLL, 0, KEY_READ, &hkey))
|
|
{
|
|
size = sizeof(szData);
|
|
if (!RegQueryValueEx(hkey, NULL, NULL, &type, (LPBYTE)szData, &size))
|
|
{
|
|
if (_tcsstr(szData, TEXT("dinput8d.dll")))
|
|
rc = TRUE;
|
|
}
|
|
RegCloseKey(hkey);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetDMDebugLevel
|
|
*
|
|
****************************************************************************/
|
|
int GetDMDebugLevel()
|
|
{
|
|
DWORD dwDMusicDebugLevel = 0;
|
|
DWORD dw;
|
|
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMBAND"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMCOMPOS"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMIME"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMLOADER"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMUSIC"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMUSIC16"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMUSIC32"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMSTYLE"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMSYNTH"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DMSCRIPT"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
if ((dw = GetProfileInt( TEXT("Debug"), TEXT("DSWAVE"), 0)) > dwDMusicDebugLevel)
|
|
dwDMusicDebugLevel = dw;
|
|
|
|
return dwDMusicDebugLevel;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsDMusicDebugRuntimeAvailable
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsDMusicDebugRuntimeAvailable()
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
GetSystemDirectory(szPath, MAX_PATH);
|
|
lstrcat(szPath, TEXT("\\dmusicd.dll"));
|
|
|
|
if (GetFileAttributes(szPath) != -1)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsDMusicDebugRuntime
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsDMusicDebugRuntime()
|
|
{
|
|
DWORD size;
|
|
DWORD type;
|
|
TCHAR szData[MAX_PATH];
|
|
HKEY hkey;
|
|
BOOL rc;
|
|
|
|
rc = FALSE;
|
|
if (!RegOpenKeyEx(HKEY_CLASSES_ROOT, REGSTR_DMUSIC_DLL, 0, KEY_READ, &hkey))
|
|
{
|
|
size = sizeof(szData);
|
|
if (!RegQueryValueEx(hkey, NULL, NULL, &type, (LPBYTE)szData, &size))
|
|
{
|
|
if (_tcsstr(szData, TEXT("dmusicd.dll")) ||
|
|
_tcsstr(szData, TEXT("DMUSICD.DLL")))
|
|
{
|
|
rc = TRUE;
|
|
}
|
|
}
|
|
RegCloseKey(hkey);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetDSDebugLevel
|
|
*
|
|
****************************************************************************/
|
|
int GetDSDebugLevel()
|
|
{
|
|
DWORD dwSoundLevel = 0;
|
|
|
|
// Pick up the DMusic DLL debug settings that are controlled on the
|
|
// DSound page
|
|
HRESULT hr;
|
|
HINSTANCE hinst;
|
|
LPKSPROPERTYSET pksps = NULL;
|
|
hinst = LoadLibrary( TEXT("dsound.dll") );
|
|
if (hinst != NULL)
|
|
{
|
|
if (SUCCEEDED(hr = DirectSoundPrivateCreate(&pksps)))
|
|
{
|
|
hr = PrvGetDebugInformation(pksps, NULL, &dwSoundLevel, NULL, NULL);
|
|
pksps->Release();
|
|
}
|
|
FreeLibrary(hinst);
|
|
}
|
|
|
|
return dwSoundLevel;
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsFileDebug
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsFileDebug( TCHAR* szPath )
|
|
{
|
|
UINT cb;
|
|
DWORD dwHandle;
|
|
BYTE FileVersionBuffer[4096];
|
|
VS_FIXEDFILEINFO* pVersion = NULL;
|
|
|
|
cb = GetFileVersionInfoSize(szPath, &dwHandle/*ignored*/);
|
|
if (cb > 0)
|
|
{
|
|
if (cb > sizeof(FileVersionBuffer))
|
|
cb = sizeof(FileVersionBuffer);
|
|
|
|
if(GetFileVersionInfo(szPath, 0, cb, FileVersionBuffer))
|
|
{
|
|
if(VerQueryValue(FileVersionBuffer, TEXT("\\"), (VOID**)&pVersion, &cb))
|
|
{
|
|
if( pVersion )
|
|
{
|
|
if( pVersion->dwFileFlags & VS_FF_DEBUG )
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsDDrawDebugRuntime
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsDDrawDebugRuntime()
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
GetSystemDirectory(szPath, MAX_PATH);
|
|
lstrcat(szPath, TEXT("\\ddraw.dll"));
|
|
|
|
return IsFileDebug(szPath);
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsDPlayDebugRuntime
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsDPlayDebugRuntime()
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
GetSystemDirectory(szPath, MAX_PATH);
|
|
lstrcat(szPath, TEXT("\\dpnet.dll"));
|
|
|
|
return IsFileDebug(szPath);
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsDSoundDebugRuntime
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsDSoundDebugRuntime()
|
|
{
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
GetSystemDirectory(szPath, MAX_PATH);
|
|
lstrcat(szPath, TEXT("\\dsound.dll"));
|
|
|
|
return IsFileDebug(szPath);
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* BIsDxDiag64Bit
|
|
*
|
|
****************************************************************************/
|
|
BOOL BIsDxDiag64Bit(VOID)
|
|
{
|
|
#ifdef _WIN64
|
|
return TRUE;
|
|
#else
|
|
return FALSE;
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* GetFileSystemStoringD3D8Cache
|
|
*
|
|
****************************************************************************/
|
|
VOID GetFileSystemStoringD3D8Cache( TCHAR* strFileSystemBuffer )
|
|
{
|
|
TCHAR strPath[MAX_PATH + 16];
|
|
BOOL bFound = FALSE;
|
|
|
|
GetSystemDirectory( strPath, MAX_PATH);
|
|
lstrcat( strPath, TEXT("\\d3d8caps.dat") );
|
|
|
|
if (GetFileAttributes(strPath) != 0xffffffff)
|
|
bFound = TRUE;
|
|
|
|
if( !bFound && BIsPlatformNT() )
|
|
{
|
|
// stolen from \dxg\d3d8\fw\fcache.cpp, OpenCacheFile().
|
|
HMODULE hShlwapi = NULL;
|
|
typedef HRESULT (WINAPI * PSHGETSPECIALFOLDERPATH) (HWND, LPTSTR, int, BOOL);
|
|
PSHGETSPECIALFOLDERPATH pSHGetSpecialFolderPath = NULL;
|
|
|
|
hShlwapi = LoadLibrary( TEXT("SHELL32.DLL") );
|
|
if( NULL != hShlwapi )
|
|
{
|
|
#ifdef UNICODE
|
|
pSHGetSpecialFolderPath = (PSHGETSPECIALFOLDERPATH)
|
|
GetProcAddress(hShlwapi,"SHGetSpecialFolderPathW");
|
|
#else
|
|
pSHGetSpecialFolderPath = (PSHGETSPECIALFOLDERPATH)
|
|
GetProcAddress(hShlwapi,"SHGetSpecialFolderPathA");
|
|
#endif
|
|
|
|
if(pSHGetSpecialFolderPath)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// <user name>\Local Settings\Applicaiton Data (non roaming)
|
|
hr = pSHGetSpecialFolderPath( NULL, strPath,
|
|
CSIDL_LOCAL_APPDATA,
|
|
FALSE );
|
|
if( SUCCEEDED(hr) )
|
|
{
|
|
lstrcat( strPath, TEXT("\\d3d8caps.dat") );
|
|
|
|
if (GetFileAttributes(strPath) != 0xffffffff)
|
|
bFound = TRUE;
|
|
}
|
|
}
|
|
FreeLibrary(hShlwapi);
|
|
}
|
|
}
|
|
|
|
if( bFound )
|
|
{
|
|
DWORD dwVolumeSerialNumber;
|
|
DWORD dwMaxComponentLength;
|
|
DWORD dwFileSystemFlags;
|
|
|
|
// Trim to root dir -- "x:\"
|
|
strPath[3] = 0;
|
|
|
|
BOOL bSuccess = GetVolumeInformation( strPath, NULL, 0, &dwVolumeSerialNumber,
|
|
&dwMaxComponentLength, &dwFileSystemFlags,
|
|
strFileSystemBuffer, MAX_PATH );
|
|
if( !bSuccess )
|
|
lstrcpy( strFileSystemBuffer, TEXT("Unknown") );
|
|
}
|
|
else
|
|
{
|
|
lstrcpy( strFileSystemBuffer, TEXT("n/a") );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* IsNetMeetingRunning
|
|
*
|
|
****************************************************************************/
|
|
BOOL IsNetMeetingRunning()
|
|
{
|
|
HWND hNetMeeting = FindWindow( TEXT("MPWClass"), NULL );
|
|
|
|
return( hNetMeeting != NULL );
|
|
}
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Name: DXUtil_strcmpi()
|
|
// Desc: compares 2 strings
|
|
//-----------------------------------------------------------------------------
|
|
int DXUtil_strcmpi( TCHAR* str1, TCHAR* str2 )
|
|
{
|
|
int nResult = CompareString( LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, str1, -1, str2, -1 );
|
|
|
|
if( nResult == CSTR_EQUAL )
|
|
return 0;
|
|
if( nResult == CSTR_LESS_THAN )
|
|
return -1;
|
|
else
|
|
return 1;
|
|
}
|