archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/multimedia/directx/dxdiag/sndinfo.cpp

723 lines
25 KiB
Raw Blame History

/****************************************************************************
*
* File: sndinfo.cpp
* Project: DxDiag (DirectX Diagnostic Tool)
* Author: Mike Anderson ([email protected])
* Purpose: Gather information about sound devices on this machine
*
* (C) Copyright 1998-1999 Microsoft Corp. All rights reserved.
*
****************************************************************************/
#define DIRECTSOUND_VERSION 0x0600
#include <tchar.h>
#include <Windows.h>
#include <mmsystem.h>
#include <d3dtypes.h>
#include <dsound.h>
#include <stdio.h>
#include "mmddk.h" // for DRV_QUERYDEVNODE
#include "dsprv.h"
#include "dsprvobj.h"
#include "reginfo.h"
#include "sysinfo.h" // for BIsPlatformNT
#include "dispinfo.h"
#include "sndinfo.h"
#include "fileinfo.h" // for GetFileVersion, FileIsSigned
#include "resource.h"
// This function is defined in sndinfo7.cpp:
HRESULT GetRegKey(LPKSPROPERTYSET pKSPS7, REFGUID guidDeviceID, TCHAR* pszRegKey);
typedef HRESULT (WINAPI* LPDIRECTSOUNDENUMERATE)(LPDSENUMCALLBACK lpDSEnumCallback,
LPVOID lpContext);
typedef HRESULT (WINAPI* LPDIRECTSOUNDCREATE)(LPGUID lpGUID, LPDIRECTSOUND* ppDS,
LPUNKNOWN pUnkOuter);
static BOOL CALLBACK DSEnumCallback(LPGUID pGuid, TCHAR* pszDescription,
TCHAR* pszModule, LPVOID lpContext);
static VOID GetRegSoundInfo9x(SoundInfo* pSoundInfo);
static VOID GetRegSoundInfoNT(SoundInfo* pSoundInfo);
static HRESULT GetDirectSoundInfo(LPDIRECTSOUNDCREATE pDSCreate, SoundInfo* pSoundInfo);
static HRESULT CheckRegistry(RegError** ppRegErrorFirst);
static LPKSPROPERTYSET s_pKSPS = NULL;
static DWORD s_dwWaveIDDefault = 0;
/****************************************************************************
*
* GetBasicSoundInfo
*
****************************************************************************/
HRESULT GetBasicSoundInfo(SoundInfo** ppSoundInfoFirst)
{
HRESULT hr = S_OK;
TCHAR szPath[MAX_PATH];
HINSTANCE hInstDSound = NULL;
LPDIRECTSOUNDENUMERATE pdse;
lstrcpy( szPath, TEXT("") );
// Find which waveout device is the default, the one that would
// be used by DirectSoundCreate(NULL). If the following code
// fails, assume it's device 0.
DWORD dwParam2 = 0;
waveOutMessage( (HWAVEOUT)IntToPtr(WAVE_MAPPER), DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR) &s_dwWaveIDDefault, (DWORD_PTR) &dwParam2 );
if( s_dwWaveIDDefault == -1 )
s_dwWaveIDDefault = 0;
GetSystemDirectory(szPath, MAX_PATH);
lstrcat(szPath, TEXT("\\dsound.dll"));
hInstDSound = LoadLibrary(szPath);
if (hInstDSound == NULL)
goto LEnd;
// Get Private DirectSound object:
if (FAILED(hr = DirectSoundPrivateCreate(&s_pKSPS)))
{
// note: no error. This will always fail on Win95.
}
// Get DirectSoundEnumerate and call it:
pdse = (LPDIRECTSOUNDENUMERATE)GetProcAddress(hInstDSound,
#ifdef UNICODE
"DirectSoundEnumerateW"
#else
"DirectSoundEnumerateA"
#endif
);
if (pdse == NULL)
goto LEnd;
if (FAILED(hr = pdse((LPDSENUMCALLBACK)DSEnumCallback, ppSoundInfoFirst)))
goto LEnd;
LEnd:
if (s_pKSPS != NULL)
{
s_pKSPS->Release();
s_pKSPS = NULL;
}
if (hInstDSound != NULL)
FreeLibrary(hInstDSound);
return hr;
}
/****************************************************************************
*
* DSEnumCallback
*
****************************************************************************/
BOOL CALLBACK DSEnumCallback(LPGUID pGuid, TCHAR* pszDescription,
TCHAR* pszModule, LPVOID lpContext)
{
SoundInfo** ppSoundInfoFirst = (SoundInfo**)lpContext;
SoundInfo* pSoundInfoNew;
PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_DATA pdsdData = NULL;
if (pGuid == NULL)
return TRUE; // skip this guy
// We decided to only report on the default, primary DSound device for
// now. Remove the next few lines to show a page per device.
// Use private interface to get bonus information:
if (*ppSoundInfoFirst != NULL)
return FALSE; // We got our device, so stop enumerating
if (s_pKSPS != NULL)
{
if (FAILED(PrvGetDeviceDescription(s_pKSPS, *pGuid, &pdsdData)))
return TRUE; // error on this device--keep enumerating
if (pdsdData->WaveDeviceId != s_dwWaveIDDefault)
return TRUE; // not default device--keep enumerating
}
// Note: on Win95, where s_pKSPS is NULL, we can't get the device ID,
// so we don't know which DSound device is the default one. So just
// use the first one that comes up in the enumeration after the one
// with NULL pGuid.
pSoundInfoNew = new SoundInfo;
if (pSoundInfoNew == NULL)
return FALSE;
ZeroMemory(pSoundInfoNew, sizeof(SoundInfo));
if (*ppSoundInfoFirst == NULL)
{
*ppSoundInfoFirst = pSoundInfoNew;
}
else
{
SoundInfo* pSoundInfo;
for (pSoundInfo = *ppSoundInfoFirst;
pSoundInfo->m_pSoundInfoNext != NULL;
pSoundInfo = pSoundInfo->m_pSoundInfoNext)
{
}
pSoundInfo->m_pSoundInfoNext = pSoundInfoNew;
}
pSoundInfoNew->m_guid = *pGuid;
lstrcpy(pSoundInfoNew->m_szDescription, pszDescription);
if (s_pKSPS == NULL)
{
// Without the DSound private interface, we can't use it to get
// waveout device ID or devnode. Assume device ID is 0, and use
// waveOutMessage(DRV_QUERYDEVNODE) to get dev node.
waveOutMessage((HWAVEOUT)0, DRV_QUERYDEVNODE, (DWORD_PTR)&pSoundInfoNew->m_dwDevnode, 0);
pSoundInfoNew->m_lwAccelerationLevel = -1;
}
else
{
pSoundInfoNew->m_dwDevnode = pdsdData->Devnode;
if (pdsdData->Type == 0)
LoadString(NULL, IDS_EMULATED, pSoundInfoNew->m_szType, 100);
else if (pdsdData->Type == 1)
LoadString(NULL, IDS_VXD, pSoundInfoNew->m_szType, 100);
else if (pdsdData->Type == 2)
LoadString(NULL, IDS_WDM, pSoundInfoNew->m_szType, 100);
DIRECTSOUNDBASICACCELERATION_LEVEL accelLevel;
if (FAILED(PrvGetBasicAcceleration(s_pKSPS, *pGuid, &accelLevel)))
pSoundInfoNew->m_lwAccelerationLevel = -1;
else
pSoundInfoNew->m_lwAccelerationLevel = (LONG)accelLevel;
// This will only work on DX7 and beyond
GetRegKey(s_pKSPS, *pGuid, pSoundInfoNew->m_szRegKey);
}
WAVEOUTCAPS waveoutcaps;
LONG devID;
if (pdsdData == NULL)
devID = 0;
else
devID = pdsdData->WaveDeviceId;
if (MMSYSERR_NOERROR == waveOutGetDevCaps(devID, &waveoutcaps, sizeof(waveoutcaps)))
{
// May want to use mmreg.h to add strings for manufacturer/product names here
wsprintf(pSoundInfoNew->m_szManufacturerID, TEXT("%d"), waveoutcaps.wMid);
wsprintf(pSoundInfoNew->m_szProductID, TEXT("%d"), waveoutcaps.wPid);
}
// Sometimes, pszModule is the full path. Sometimes it's just the leaf.
// Sometimes, it's something inbetween. Separate the leaf, and look
// in a few different places.
TCHAR* pszLeaf;
pszLeaf = _tcsrchr(pszModule, TEXT('\\'));
if (pszLeaf == NULL)
{
lstrcpy(pSoundInfoNew->m_szDriverName, pszModule);
}
else
{
lstrcpy(pSoundInfoNew->m_szDriverName, (pszLeaf + 1));
}
// Try just module string
lstrcpy(pSoundInfoNew->m_szDriverPath, pszModule);
if (pszLeaf == NULL || GetFileAttributes(pSoundInfoNew->m_szDriverPath) == 0xFFFFFFFF)
{
// Try windows dir + module string
GetWindowsDirectory(pSoundInfoNew->m_szDriverPath, MAX_PATH);
lstrcat(pSoundInfoNew->m_szDriverPath, TEXT("\\"));
lstrcat(pSoundInfoNew->m_szDriverPath, pszModule);
if (GetFileAttributes(pSoundInfoNew->m_szDriverPath) == 0xFFFFFFFF)
{
// Try system dir + module string
GetSystemDirectory(pSoundInfoNew->m_szDriverPath, MAX_PATH);
lstrcat(pSoundInfoNew->m_szDriverPath, TEXT("\\"));
lstrcat(pSoundInfoNew->m_szDriverPath, pszModule);
if (GetFileAttributes(pSoundInfoNew->m_szDriverPath) == 0xFFFFFFFF)
{
// Try windows dir + \system32\drivers\ + module string
GetWindowsDirectory(pSoundInfoNew->m_szDriverPath, MAX_PATH);
lstrcat(pSoundInfoNew->m_szDriverPath, TEXT("\\System32\\Drivers\\"));
lstrcat(pSoundInfoNew->m_szDriverPath, pszModule);
}
}
}
PrvReleaseDeviceDescription( pdsdData );
return TRUE;
}
/****************************************************************************
*
* GetExtraSoundInfo
*
****************************************************************************/
HRESULT GetExtraSoundInfo(SoundInfo* pSoundInfoFirst)
{
SoundInfo* pSoundInfo;
BOOL bNT = BIsPlatformNT();
for (pSoundInfo = pSoundInfoFirst; pSoundInfo != NULL;
pSoundInfo = pSoundInfo->m_pSoundInfoNext)
{
CheckRegistry(&pSoundInfo->m_pRegErrorFirst);
if (bNT)
GetRegSoundInfoNT(pSoundInfo);
else
GetRegSoundInfo9x(pSoundInfo);
// Bug 18245: Try to distinguish between the various IBM MWave cards
if (_tcsstr(pSoundInfo->m_szDeviceID, TEXT("MWAVEAUDIO_0460")) != NULL)
lstrcat(pSoundInfo->m_szDescription, TEXT(" (Stingray)"));
else if (_tcsstr(pSoundInfo->m_szDeviceID, TEXT("MWAVEAUDIO_0465")) != NULL)
lstrcat(pSoundInfo->m_szDescription, TEXT(" (Marlin)"));
else
{
TCHAR szBoard[100];
lstrcpy( szBoard, TEXT("") );
GetPrivateProfileString(TEXT("Mwave,Board"), TEXT("board"), TEXT(""),
szBoard, 100, TEXT("MWave.ini"));
if (lstrcmp(szBoard, TEXT("MWAT-046")) == 0)
lstrcat(pSoundInfo->m_szDescription, TEXT(" (Dolphin)"));
else if (lstrcmp(szBoard, TEXT("MWAT-043")) == 0)
lstrcat(pSoundInfo->m_szDescription, TEXT(" (Whale)"));
}
// Sometimes, like when a sound driver is emulated, the driver
// will be reported as something like "WaveOut 0". In this case,
// just blank out the file-related fields.
if (_tcsstr(pSoundInfo->m_szDriverName, TEXT(".")) == NULL)
{
lstrcpy(pSoundInfo->m_szDriverName, TEXT(""));
lstrcpy(pSoundInfo->m_szDriverPath, TEXT(""));
}
else
{
GetFileVersion(pSoundInfo->m_szDriverPath, pSoundInfo->m_szDriverVersion,
pSoundInfo->m_szDriverAttributes, pSoundInfo->m_szDriverLanguageLocal, pSoundInfo->m_szDriverLanguage,
&pSoundInfo->m_bDriverBeta, &pSoundInfo->m_bDriverDebug);
FileIsSigned(pSoundInfo->m_szDriverPath, &pSoundInfo->m_bDriverSigned, &pSoundInfo->m_bDriverSignedValid);
GetFileDateAndSize(pSoundInfo->m_szDriverPath,
pSoundInfo->m_szDriverDateLocal, pSoundInfo->m_szDriverDate, &pSoundInfo->m_numBytes);
}
}
return S_OK;
}
/****************************************************************************
*
* GetRegSoundInfo9x
*
****************************************************************************/
VOID GetRegSoundInfo9x(SoundInfo* pSoundInfo)
{
HKEY hkey = NULL;
DWORD iKey = 0;
TCHAR szSubKey[200];
DWORD dwSubKeySize;
TCHAR szClass[100];
DWORD dwClassSize;
HKEY hkeySub = NULL;
DWORD dwDevnode;
DWORD cb;
DWORD dwType;
HKEY hkeyOther = NULL;
// We have the DevNode, so find the device in the registry with the
// matching DevNode and gather more info there.
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("System\\CurrentControlSet\\control\\MediaResources\\wave"),
0, KEY_READ, &hkey))
{
while (TRUE)
{
dwSubKeySize = sizeof(szSubKey);
dwClassSize = sizeof(szClass);
if (ERROR_SUCCESS != RegEnumKeyEx(hkey, iKey, szSubKey, &dwSubKeySize, NULL, szClass, &dwClassSize, NULL))
break;
if (ERROR_SUCCESS == RegOpenKeyEx(hkey, szSubKey, 0, KEY_READ, &hkeySub))
{
cb = sizeof(dwDevnode);
if (ERROR_SUCCESS == RegQueryValueEx(hkeySub, TEXT("DevNode"), NULL, &dwType, (BYTE*)&dwDevnode, &cb))
{
if (dwDevnode == pSoundInfo->m_dwDevnode)
{
// Found match...gather yummy info
cb = sizeof(pSoundInfo->m_szDeviceID);
RegQueryValueEx(hkeySub, TEXT("DeviceID"), NULL, &dwType, (BYTE*)pSoundInfo->m_szDeviceID, &cb);
// Occasionally the driver name that DirectSoundEnumerate spits out
// is garbage (as with my Crystal SoundFusion). If that's the case,
// use the driver name listed here instead.
if (lstrlen(pSoundInfo->m_szDriverName) < 4)
{
cb = sizeof(pSoundInfo->m_szDriverName);
RegQueryValueEx(hkeySub, TEXT("Driver"), NULL, &dwType, (BYTE*)pSoundInfo->m_szDriverName, &cb);
GetSystemDirectory(pSoundInfo->m_szDriverPath, MAX_PATH);
lstrcat(pSoundInfo->m_szDriverPath, TEXT("\\"));
lstrcat(pSoundInfo->m_szDriverPath, pSoundInfo->m_szDriverName);
}
TCHAR szOtherKey[300];
cb = sizeof(szOtherKey);
RegQueryValueEx(hkeySub, TEXT("SOFTWAREKEY"), NULL, &dwType, (BYTE*)szOtherKey, &cb);
if (lstrlen(szOtherKey) > 0)
{
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, szOtherKey, 0, KEY_READ, &hkeyOther))
{
cb = sizeof(pSoundInfo->m_szOtherDrivers);
RegQueryValueEx(hkeyOther, TEXT("Driver"), NULL, &dwType, (BYTE*)pSoundInfo->m_szOtherDrivers, &cb);
cb = sizeof(pSoundInfo->m_szProvider);
RegQueryValueEx(hkeyOther, TEXT("ProviderName"), NULL, &dwType, (BYTE*)pSoundInfo->m_szProvider, &cb);
RegCloseKey(hkeyOther);
}
}
}
}
RegCloseKey(hkeySub);
}
iKey++;
}
RegCloseKey(hkey);
}
}
/****************************************************************************
*
* GetRegSoundInfoNT
*
****************************************************************************/
VOID GetRegSoundInfoNT(SoundInfo* pSoundInfo)
{
TCHAR szFullKey[200];
HKEY hkey;
DWORD cbData;
DWORD dwType;
TCHAR szDriverKey[200];
TCHAR szOtherFullKey[200];
lstrcpy(szFullKey, TEXT("System\\CurrentControlSet\\Enum\\"));
lstrcat(szFullKey, pSoundInfo->m_szRegKey);
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, szFullKey, 0, KEY_READ, &hkey))
{
cbData = sizeof(pSoundInfo->m_szDeviceID);
RegQueryValueEx(hkey, TEXT("HardwareID"), 0, &dwType, (LPBYTE)pSoundInfo->m_szDeviceID, &cbData);
cbData = sizeof(szDriverKey);
RegQueryValueEx(hkey, TEXT("Driver"), 0, &dwType, (LPBYTE)szDriverKey, &cbData);
RegCloseKey(hkey);
}
lstrcpy(szOtherFullKey, TEXT("System\\CurrentControlSet\\Control\\Class\\"));
lstrcat(szOtherFullKey, szDriverKey);
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, szOtherFullKey, 0, KEY_READ, &hkey))
{
cbData = sizeof(pSoundInfo->m_szProvider);
RegQueryValueEx(hkey, TEXT("ProviderName"), 0, &dwType, (LPBYTE)pSoundInfo->m_szProvider, &cbData);
RegCloseKey(hkey);
}
}
/****************************************************************************
*
* GetDSSoundInfo
*
****************************************************************************/
HRESULT GetDSSoundInfo(SoundInfo* pSoundInfoFirst)
{
HRESULT hr;
HRESULT hrRet = S_OK;
SoundInfo* pSoundInfo;
TCHAR szPath[MAX_PATH];
HINSTANCE hInstDSound;
LPDIRECTSOUNDCREATE pDSCreate;
GetSystemDirectory(szPath, MAX_PATH);
lstrcat(szPath, TEXT("\\dsound.dll"));
hInstDSound = LoadLibrary(szPath);
if (hInstDSound == NULL)
return E_FAIL;
pDSCreate = (LPDIRECTSOUNDCREATE)GetProcAddress(hInstDSound, "DirectSoundCreate");
if (pDSCreate == NULL)
{
FreeLibrary(hInstDSound);
return E_FAIL;
}
for (pSoundInfo = pSoundInfoFirst; pSoundInfo != NULL;
pSoundInfo = pSoundInfo->m_pSoundInfoNext)
{
if (FAILED(hr = GetDirectSoundInfo(pDSCreate, pSoundInfo)))
hrRet = hr; // but keep going
}
FreeLibrary(hInstDSound);
return hrRet;
}
/****************************************************************************
*
* IsDriverWDM
*
****************************************************************************/
BOOL IsDriverWDM( TCHAR* szDriverName )
{
if( _tcsstr( szDriverName, TEXT(".sys") ) == NULL )
return FALSE;
else
return TRUE;
}
/****************************************************************************
*
* GetDirectSoundInfo
*
****************************************************************************/
HRESULT GetDirectSoundInfo(LPDIRECTSOUNDCREATE pDSCreate, SoundInfo* pSoundInfo)
{
HRESULT hr;
LPDIRECTSOUND pds = NULL;
GUID* pGUID;
DSCAPS dscaps;
// Right now, this function only calls DSCreate/GetCaps to determine if
// the driver is signed. If we have already determined that it is by
// other means, don't bother with this test.
if (pSoundInfo->m_bDriverSigned)
return S_OK;
// Bug 29918: If this is a WDM driver, then don't call GetCaps() since
// on DX7.1+ GetCaps() will always return DSCAPS_CERTIFIED on WDM drivers
if( IsDriverWDM( pSoundInfo->m_szDriverName ) )
return S_OK;
if (pSoundInfo->m_guid == GUID_NULL)
pGUID = NULL;
else
pGUID = &pSoundInfo->m_guid;
if (FAILED(hr = pDSCreate(pGUID, &pds, NULL)))
goto LFail;
dscaps.dwSize = sizeof(dscaps);
if (FAILED(hr = pds->GetCaps(&dscaps)))
goto LFail;
pSoundInfo->m_bDriverSignedValid = TRUE;
if (dscaps.dwFlags & DSCAPS_CERTIFIED)
pSoundInfo->m_bDriverSigned = TRUE;
pds->Release();
return S_OK;
LFail:
if (pds != NULL)
pds->Release();
return hr;
}
/****************************************************************************
*
* ChangeAccelerationLevel
*
****************************************************************************/
HRESULT ChangeAccelerationLevel(SoundInfo* pSoundInfo, LONG lwLevel)
{
HRESULT hr = S_OK;
DIRECTSOUNDBASICACCELERATION_LEVEL level = (DIRECTSOUNDBASICACCELERATION_LEVEL)lwLevel;
LPKSPROPERTYSET pksps = NULL;
TCHAR szPath[MAX_PATH];
HINSTANCE hInstDSound = NULL;
GetSystemDirectory(szPath, MAX_PATH);
lstrcat(szPath, TEXT("\\dsound.dll"));
hInstDSound = LoadLibrary(szPath);
if (hInstDSound == NULL)
{
hr = DDERR_NOTFOUND;
goto LEnd;
}
if (FAILED(hr = DirectSoundPrivateCreate(&pksps)))
goto LEnd;
if (FAILED(hr = PrvSetBasicAcceleration(pksps, pSoundInfo->m_guid, level)))
goto LEnd;
LEnd:
if (pksps != NULL)
pksps->Release();
if (hInstDSound != NULL)
FreeLibrary(hInstDSound);
pSoundInfo->m_lwAccelerationLevel = lwLevel;
return hr;
}
/****************************************************************************
*
* CheckRegistry
*
****************************************************************************/
HRESULT CheckRegistry(RegError** ppRegErrorFirst)
{
HRESULT hr;
HKEY HKCR = HKEY_CLASSES_ROOT;
TCHAR szVersion[100];
HKEY hkey;
DWORD cbData;
ULONG ulType;
DWORD dwMajor = 0;
DWORD dwMinor = 0;
DWORD dwRevision = 0;
DWORD dwBuild = 0;
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\DirectX"),
0, KEY_READ, &hkey))
{
cbData = 100;
RegQueryValueEx(hkey, TEXT("Version"), 0, &ulType, (LPBYTE)szVersion, &cbData);
RegCloseKey(hkey);
if (lstrlen(szVersion) > 6 &&
lstrlen(szVersion) < 20)
{
_stscanf(szVersion, TEXT("%d.%d.%d.%d"), &dwMajor, &dwMinor, &dwRevision, &dwBuild);
}
}
// No registry checking on DX versions before DX7
if (dwMinor < 7)
return S_OK;
// From dsound.inf:
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("DirectSound"), TEXT(""), TEXT("*"))))
return hr;
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("DirectSound\\CLSID"), TEXT(""), TEXT("{47D4D946-62E8-11cf-93BC-444553540000}"))))
return hr;
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("CLSID\\{47D4D946-62E8-11cf-93BC-444553540000}"), TEXT(""), TEXT("*"))))
return hr;
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("CLSID\\{47D4D946-62E8-11cf-93BC-444553540000}\\InprocServer32"), TEXT(""), TEXT("dsound.dll"), CRF_LEAF)))
return hr;
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("CLSID\\{47D4D946-62E8-11cf-93BC-444553540000}\\InprocServer32"), TEXT("ThreadingModel"), TEXT("Both"))))
return hr;
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("DirectSoundCapture"), TEXT(""), TEXT("*"))))
return hr;
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("DirectSoundCapture\\CLSID"), TEXT(""), TEXT("{B0210780-89CD-11d0-AF08-00A0C925CD16}"))))
return hr;
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("CLSID\\{B0210780-89CD-11d0-AF08-00A0C925CD16}"), TEXT(""), TEXT("*"))))
return hr;
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("CLSID\\{B0210780-89CD-11d0-AF08-00A0C925CD16}\\InprocServer32"), TEXT(""), TEXT("dsound.dll"), CRF_LEAF)))
return hr;
if (FAILED(hr = CheckRegString(ppRegErrorFirst, HKCR, TEXT("CLSID\\{B0210780-89CD-11d0-AF08-00A0C925CD16}\\InprocServer32"), TEXT("ThreadingModel"), TEXT("Both"))))
return hr;
return S_OK;
}
/****************************************************************************
*
* DestroySoundInfo
*
****************************************************************************/
VOID DestroySoundInfo(SoundInfo* pSoundInfoFirst)
{
SoundInfo* pSoundInfo;
SoundInfo* pSoundInfoNext;
for (pSoundInfo = pSoundInfoFirst; pSoundInfo != NULL;
pSoundInfo = pSoundInfoNext)
{
DestroyReg( &pSoundInfo->m_pRegErrorFirst );
pSoundInfoNext = pSoundInfo->m_pSoundInfoNext;
delete pSoundInfo;
}
}
/****************************************************************************
*
* DiagnoseSound
*
****************************************************************************/
VOID DiagnoseSound(SoundInfo* pSoundInfoFirst)
{
SoundInfo* pSoundInfo;
TCHAR sz[500];
TCHAR szFmt[500];
for (pSoundInfo = pSoundInfoFirst; pSoundInfo != NULL;
pSoundInfo = pSoundInfo->m_pSoundInfoNext)
{
_tcscpy( pSoundInfo->m_szNotes, TEXT("") );
_tcscpy( pSoundInfo->m_szNotesEnglish, TEXT("") );
// Report any problems:
BOOL bProblem = FALSE;
if ( pSoundInfo->m_bDriverSignedValid &&
!pSoundInfo->m_bDriverSigned &&
lstrlen(pSoundInfo->m_szDriverName) > 0)
{
LoadString(NULL, IDS_UNSIGNEDDRIVERFMT1, szFmt, 300);
wsprintf(sz, szFmt, pSoundInfo->m_szDriverName);
_tcscat( pSoundInfo->m_szNotes, sz );
LoadString(NULL, IDS_UNSIGNEDDRIVERFMT1_ENGLISH, szFmt, 300);
wsprintf(sz, szFmt, pSoundInfo->m_szDriverName);
_tcscat( pSoundInfo->m_szNotesEnglish, sz );
bProblem = TRUE;
}
if (pSoundInfo->m_pRegErrorFirst != NULL)
{
LoadString(NULL, IDS_REGISTRYPROBLEM, sz, 500);
_tcscat( pSoundInfo->m_szNotes, sz );
LoadString(NULL, IDS_REGISTRYPROBLEM_ENGLISH, sz, 500);
_tcscat( pSoundInfo->m_szNotesEnglish, sz );
bProblem = TRUE;
}
// Report any DSound test results:
if (pSoundInfo->m_testResultSnd.m_bStarted &&
!pSoundInfo->m_testResultSnd.m_bCancelled)
{
LoadString(NULL, IDS_DSRESULTS, sz, 500);
_tcscat( pSoundInfo->m_szNotes, sz );
_tcscat( pSoundInfo->m_szNotes, pSoundInfo->m_testResultSnd.m_szDescription );
_tcscat( pSoundInfo->m_szNotes, TEXT("\r\n") );
LoadString(NULL, IDS_DSRESULTS_ENGLISH, sz, 500);
_tcscat( pSoundInfo->m_szNotesEnglish, sz );
_tcscat( pSoundInfo->m_szNotesEnglish, pSoundInfo->m_testResultSnd.m_szDescriptionEnglish );
_tcscat( pSoundInfo->m_szNotesEnglish, TEXT("\r\n") );
bProblem = TRUE;
}
else
{
LoadString(NULL, IDS_DSINSTRUCTIONS, sz, 500);
_tcscat( pSoundInfo->m_szNotes, sz );
LoadString(NULL, IDS_DSINSTRUCTIONS_ENGLISH, sz, 500);
_tcscat( pSoundInfo->m_szNotesEnglish, sz );
}
if (!bProblem)
{
LoadString(NULL, IDS_NOPROBLEM, sz, 500);
_tcscat( pSoundInfo->m_szNotes, sz );
LoadString(NULL, IDS_NOPROBLEM_ENGLISH, sz, 500);
_tcscat( pSoundInfo->m_szNotesEnglish, sz );
}
}
}