OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
7507d3c0e1
Windows-Server-2003/multimedia/media/winmm/pref.c

1953 lines
60 KiB
C
Raw Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/* Copyright (c) 1998-2001 Microsoft Corporation */
#define UNICODE
#define _UNICODE
#include "nt.h"
#include "ntrtl.h"
#include "nturtl.h"
#include "winmmi.h"
#include <mmreg.h>
#include <regstr.h>
#include <stdlib.h>
#include <tchar.h>
#include "audiosrvc.h"
extern PCWSTR waveReferenceDevInterfaceById(IN PWAVEDRV pdrvZ, IN UINT_PTR id);
extern PCWSTR midiReferenceDevInterfaceById(IN PMIDIDRV pdrvZ, IN UINT_PTR id);
#define REGSTR_PATH_MULTIMEDIA_SOUNDMAPPER TEXT("Software\\Microsoft\\Multimedia\\Sound Mapper")
#define REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PLAYBACK TEXT("Playback")
#define REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_RECORD TEXT("Record")
#define REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_CONSOLEVOICECOM_PLAYBACK TEXT("ConsoleVoiceComPlayback")
#define REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_CONSOLEVOICECOM_RECORD TEXT("ConsoleVoiceComRecord")
#define REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PREFERREDONLY TEXT("PreferredOnly")
#define REGSTR_PATH_MEDIARESOURCES_MIDI REGSTR_PATH_MEDIARESOURCES TEXT("\\MIDI")
#define REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_ACTIVE TEXT("Active")
#define REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_DESCRIPTION TEXT("Description")
#define REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_DEVICEINTERFACE TEXT("DeviceInterface")
#define REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_PHYSDEVID TEXT("PhysDevID")
#define REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_PORT TEXT("Port")
#define REGSTR_PATH_MULTIMEDIA_MIDIMAP REGSTR_PATH_MULTIMEDIA TEXT("\\MIDIMap")
#define REGSTR_VAL_MULTIMEDIA_MIDIMAP_CONFIGURECOUNT TEXT("ConfigureCount")
#define REGSTR_VAL_MULTIMEDIA_MIDIMAP_USESCHEME TEXT("UseScheme")
#define REGSTR_VAL_MULTIMEDIA_MIDIMAP_DRIVERLIST TEXT("DriverList")
#define REGSTR_VAL_MULTIMEDIA_MIDIMAP_AUTOSCHEME TEXT("AutoScheme")
#define REGSTR_VAL_MULTIMEDIA_MIDIMAP_CURRENTINSTRUMENT TEXT("CurrentInstrument")
#define REGSTR_VAL_MULTIMEDIA_MIDIMAP_DEVICEINTERFACE TEXT("DeviceInterface")
#define REGSTR_VAL_MULTIMEDIA_MIDIMAP_RELATIVEINDEX TEXT("RelativeIndex")
#define REGSTR_VAL_MULTIMEDIA_MIDIMAP_SZPNAME TEXT("szPname")
#define REGSTR_VAL_SETUPPREFERREDAUDIODEVICES TEXT("SetupPreferredAudioDevices")
#define REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT TEXT("SetupPreferredAudioDevicesCount")
extern BOOL WaveMapperInitialized; // in winmm.c
extern BOOL MidiMapperInitialized; // in winmm.c
// Preferred Ids. Setting these to *_MAPPER indicates no setting.
PWSTR gpstrWoDefaultStringId = NULL;
PWSTR gpstrWiDefaultStringId = NULL;
PWSTR gpstrWoConsoleVoiceComStringId = NULL;
PWSTR gpstrWiConsoleVoiceComStringId = NULL;
BOOL gfUsePreferredWaveOnly = TRUE;
PWSTR gpstrMoDefaultStringId = NULL;
// These will be TRUE if we sent the preferred device change
// to sysaudio.
BOOL gfWaveOutPreferredMessageSent = FALSE;
BOOL gfWaveInPreferredMessageSent = FALSE;
BOOL gfMidiOutPreferredMessageSent = FALSE;
//------------------------------------------------------------------------------
//
//
// Registry helpers
//
//
//------------------------------------------------------------------------------
LONG RegQuerySzValue(HKEY hkey, PCTSTR pValueName, PTSTR *ppstrValue)
{
LONG result;
DWORD typeValue;
DWORD cbstrValue = 0;
BOOL f;
result = RegQueryValueEx(hkey, pValueName, 0, &typeValue, NULL, &cbstrValue);
if (ERROR_SUCCESS == result)
{
if (REG_SZ == typeValue)
{
PTSTR pstrValue;
pstrValue = HeapAlloc(hHeap, 0, cbstrValue);
if (pstrValue)
{
result = RegQueryValueEx(hkey, pValueName, 0, &typeValue, (PBYTE)pstrValue, &cbstrValue);
if (ERROR_SUCCESS == result)
{
if (REG_SZ == typeValue)
{
*ppstrValue = pstrValue;
} else {
result = ERROR_FILE_NOT_FOUND;
f = HeapFree(hHeap, 0, pstrValue);
WinAssert(f);
}
} else {
f = HeapFree(hHeap, 0, pstrValue);
WinAssert(f);
}
} else {
result = ERROR_OUTOFMEMORY;
}
} else {
result = ERROR_FILE_NOT_FOUND;
}
}
return result;
}
LONG RegQueryDwordValue(HKEY hkey, PCTSTR pValueName, PDWORD pdwValue)
{
DWORD cbdwValue;
LONG result;
cbdwValue = sizeof(*pdwValue);
result = RegQueryValueEx(hkey, pValueName, 0, NULL, (PBYTE)pdwValue, &cbdwValue);
return result;
}
LONG RegSetSzValue(HKEY hkey, PCTSTR pValueName, PCTSTR pstrValue)
{
DWORD cbstrValue = (lstrlen(pstrValue) + 1) * sizeof(pstrValue[0]);
return RegSetValueEx(hkey, pValueName, 0, REG_SZ, (PBYTE)pstrValue, cbstrValue);
}
LONG RegSetDwordValue(HKEY hkey, PCTSTR pValueName, DWORD dwValue)
{
return RegSetValueEx(hkey, pValueName, 0, REG_DWORD, (PBYTE)&dwValue, sizeof(dwValue));
}
//------------------------------------------------------------------------------
//
//
// AutoSetupPreferredAudio functions
//
//
//------------------------------------------------------------------------------
//--------------------------------------------------------------------------;
//
// DWORD GetCurrentSetupPreferredAudioCount
//
// Arguments:
//
// Return value:
//
// History:
// 1/19/99 FrankYe Created
//
//--------------------------------------------------------------------------;
DWORD GetCurrentSetupPreferredAudioCount(void)
{
HKEY hkeySetupPreferredAudioDevices;
DWORD SetupCount = 0;
if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_MEDIARESOURCES TEXT("\\") REGSTR_VAL_SETUPPREFERREDAUDIODEVICES, 0, KEY_QUERY_VALUE, &hkeySetupPreferredAudioDevices))
{
if (ERROR_SUCCESS != RegQueryDwordValue(hkeySetupPreferredAudioDevices, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, &SetupCount)) {
Squirt("GCSPATS: Couldn't read hklm\\...\\SetupPreferredAudioDevicesCount");
}
if (ERROR_SUCCESS != RegCloseKey(hkeySetupPreferredAudioDevices)) {
WinAssert(!"GCSPATS: unexpected failure of RegCloseKey");
}
} else {
Squirt("GCSPATS: Couldn't open hklm\\...\\SetupPreferredAudioDevices");
}
return SetupCount;
}
//--------------------------------------------------------------------------;
//
// DWORD GetDeviceInterfaceSetupPreferredAudioCount
//
// Arguments:
//
// Return value:
//
// History:
// 1/19/99 FrankYe Created
//
//--------------------------------------------------------------------------;
DWORD GetDeviceInterfaceSetupPreferredAudioCount(PCWSTR DeviceInterface)
{
PMMDEVICEINTERFACEINFO pdii;
PMMPNPINFO pPnpInfo;
LONG cbPnpInfo;
DWORD count;
int ii;
// Handle empty DeviceInterface names in case of legacy drivers
if (0 == lstrlen(DeviceInterface)) return 0;
if (ERROR_SUCCESS != winmmGetPnpInfo(&cbPnpInfo, &pPnpInfo)) return 0;
pdii = (PMMDEVICEINTERFACEINFO)&(pPnpInfo[1]);
pdii = PAD_POINTER(pdii);
for (ii = pPnpInfo->cDevInterfaces; ii; ii--)
{
// Searching for the device interface...
if (0 == lstrcmpi(pdii->szName, DeviceInterface)) break;
pdii = (PMMDEVICEINTERFACEINFO)(pdii->szName + lstrlenW(pdii->szName) + 1);
pdii = PAD_POINTER(pdii);
}
WinAssert(ii);
count = pdii->SetupPreferredAudioCount;
HeapFree(hHeap, 0, pPnpInfo);
return count;
}
//------------------------------------------------------------------------------
//
//
// NotifyServerPreferredDeviceChange
//
//
//------------------------------------------------------------------------------
void NotifyServerPreferredDeviceChange(void)
{
winmmAdvisePreferredDeviceChange();
}
//------------------------------------------------------------------------------
//
//
// Wave
//
//
//------------------------------------------------------------------------------
MMRESULT waveWritePersistentConsoleVoiceCom(BOOL fOut, PTSTR pstrPref, BOOL fPrefOnly)
{
HKEY hkcu;
HKEY hkSoundMapper;
LONG result;
BOOL fSuccess;
if (!NT_SUCCESS(RtlOpenCurrentUser(GENERIC_WRITE, &hkcu))) return MMSYSERR_WRITEERROR;
result = RegCreateKeyEx(hkcu, REGSTR_PATH_MULTIMEDIA_SOUNDMAPPER, 0, TEXT("\0"), REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hkSoundMapper, NULL);
if (ERROR_SUCCESS == result)
{
DWORD cbstrPref;
cbstrPref = (lstrlen(pstrPref) + 1) * sizeof(pstrPref[0]);
if (fOut)
{
result = RegSetSzValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_CONSOLEVOICECOM_PLAYBACK, pstrPref);
}
else
{
result = RegSetSzValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_CONSOLEVOICECOM_RECORD, pstrPref);
}
if (ERROR_SUCCESS == result)
{
fSuccess = TRUE;
result = RegSetDwordValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PREFERREDONLY, (DWORD)fPrefOnly);
if (ERROR_SUCCESS != result) {
Squirt("wWPCVC: Could not write hkcu\\...\\Sound Mapper\\PreferredOnly");
}
result = RegSetDwordValue(hkSoundMapper, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, GetCurrentSetupPreferredAudioCount());
if (ERROR_SUCCESS != result) {
Squirt("wWPCVC: Could not write hkcu\\...\\Sound Mapper\\SetupPreferredAudioCount");
}
}
result = RegCloseKey(hkSoundMapper);
WinAssert(ERROR_SUCCESS == result);
}
NtClose(hkcu);
return MMSYSERR_NOERROR;
}
BOOL waveReadPersistentConsoleVoiceCom(BOOL fOut, PTSTR *ppstrPref, PBOOL pfPrefOnly, PDWORD pSetupCount)
{
HKEY hkcu;
HKEY hkSoundMapper;
LONG result;
BOOL fSuccess;
fSuccess = FALSE;
*ppstrPref = NULL;
*pfPrefOnly = FALSE;
*pSetupCount = 0;
if (!NT_SUCCESS(RtlOpenCurrentUser(GENERIC_READ, &hkcu))) return FALSE;
result = RegOpenKeyEx(hkcu, REGSTR_PATH_MULTIMEDIA_SOUNDMAPPER, 0, KEY_QUERY_VALUE, &hkSoundMapper);
if (ERROR_SUCCESS == result)
{
DWORD SetupCount;
result = RegQueryDwordValue(hkSoundMapper, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, &SetupCount);
SetupCount = (ERROR_SUCCESS == result) ? SetupCount : 0;
if (ERROR_SUCCESS == result)
{
PTSTR pstrPref;
BOOL fPrefOnly;
DWORD dwPrefOnly;
result = RegQueryDwordValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PREFERREDONLY, &dwPrefOnly);
fPrefOnly = (ERROR_SUCCESS == result) ? (0 != dwPrefOnly) : FALSE;
if (fOut)
{
result = RegQuerySzValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_CONSOLEVOICECOM_PLAYBACK, &pstrPref);
}
else
{
result = RegQuerySzValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_CONSOLEVOICECOM_RECORD, &pstrPref);
}
if (ERROR_SUCCESS != result) pstrPref = NULL;
*ppstrPref = pstrPref;
*pfPrefOnly = fPrefOnly;
*pSetupCount = SetupCount;
fSuccess = TRUE;
}
result = RegCloseKey(hkSoundMapper);
WinAssert(ERROR_SUCCESS == result);
}
NtClose(hkcu);
return fSuccess;
}
MMRESULT wavePickBestConsoleVoiceComId(BOOL fOut, PUINT pPrefId, PDWORD pdwFlags)
{
PTSTR pstrPref;
UINT cWaveId;
UINT WaveId;
UINT UserSelectedId;
UINT NonConsoleId;
UINT PreferredId;
DWORD UserSelectedIdSetupCount;
BOOL fPrefOnly;
BOOL f;
UserSelectedId = WAVE_MAPPER;
if (fOut)
{
waveOutGetCurrentPreferredId(&NonConsoleId, NULL);
cWaveId = waveOutGetNumDevs();
waveReadPersistentConsoleVoiceCom(fOut, &pstrPref, &fPrefOnly, &UserSelectedIdSetupCount);
*pdwFlags = fPrefOnly ? DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY : 0;
for (WaveId = cWaveId-1; ((int)WaveId) >= 0; WaveId--)
{
WAVEOUTCAPS wc;
MMRESULT mmr;
mmr = waveOutGetDevCaps(WaveId, &wc, sizeof(wc));
if (mmr) continue;
wc.szPname[MAXPNAMELEN-1] = TEXT('\0');
if (pstrPref && !lstrcmp(wc.szPname, pstrPref))
{
UserSelectedId = WaveId;
break;
}
}
}
else
{
waveInGetCurrentPreferredId(&NonConsoleId, NULL);
cWaveId = waveInGetNumDevs();
waveReadPersistentConsoleVoiceCom(fOut, &pstrPref, &fPrefOnly, &UserSelectedIdSetupCount);
*pdwFlags = fPrefOnly ? DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY : 0;
for (WaveId = cWaveId-1; ((int)WaveId) >= 0; WaveId--)
{
WAVEINCAPS wc;
MMRESULT mmr;
mmr = waveInGetDevCaps(WaveId, &wc, sizeof(wc));
if (mmr) continue;
wc.szPname[MAXPNAMELEN-1] = TEXT('\0');
if (pstrPref && !lstrcmp(wc.szPname, pstrPref))
{
UserSelectedId = WaveId;
break;
}
}
}
if (pstrPref) {
f = HeapFree(hHeap, 0, pstrPref);
WinAssert(f);
pstrPref = NULL;
}
PreferredId = ((WAVE_MAPPER == UserSelectedId)?NonConsoleId:UserSelectedId);
*pPrefId = PreferredId;
return MMSYSERR_NOERROR;
}
//------------------------------------------------------------------------------
//
//
// WaveOut
//
//
//------------------------------------------------------------------------------
DWORD waveOutGetSetupPreferredAudioCount(UINT WaveId)
{
PCWSTR DeviceInterface;
DWORD dwCount;
DeviceInterface = waveReferenceDevInterfaceById(&waveoutdrvZ, WaveId);
if(DeviceInterface == NULL) {
return 0;
}
dwCount = GetDeviceInterfaceSetupPreferredAudioCount(DeviceInterface);
wdmDevInterfaceDec(DeviceInterface);
return dwCount;
}
MMRESULT waveOutSendPreferredMessage(BOOL fClear)
{
PCWSTR DeviceInterface;
UINT WaveId, Flags;
MMRESULT mmr;
if(!gfLogon) {
return MMSYSERR_NOERROR;
}
waveOutGetCurrentPreferredId(&WaveId, &Flags);
//Squirt("waveOutSendPreferredMessage: id %d f %d", WaveId, fClear);
if(WaveId == WAVE_MAPPER) {
return MMSYSERR_NOERROR;
}
DeviceInterface = waveReferenceDevInterfaceById(&waveoutdrvZ, WaveId);
if(DeviceInterface == NULL) {
return MMSYSERR_NOERROR;
}
gfWaveOutPreferredMessageSent = TRUE;
mmr = waveOutMessage((HWAVEOUT)(UINT_PTR)WaveId, WODM_PREFERRED, (DWORD_PTR)fClear, (DWORD_PTR)DeviceInterface);
wdmDevInterfaceDec(DeviceInterface);
return mmr;
}
BOOL waveOutReadPersistentPref(PTSTR *ppstrPref, PBOOL pfPrefOnly, PDWORD pSetupCount)
{
HKEY hkcu;
HKEY hkSoundMapper;
LONG result;
BOOL fSuccess;
fSuccess = FALSE;
*ppstrPref = NULL;
*pfPrefOnly = FALSE;
*pSetupCount = 0;
if (!NT_SUCCESS(RtlOpenCurrentUser(GENERIC_READ, &hkcu))) return FALSE;
result = RegOpenKeyEx(hkcu, REGSTR_PATH_MULTIMEDIA_SOUNDMAPPER, 0, KEY_QUERY_VALUE, &hkSoundMapper);
if (ERROR_SUCCESS == result)
{
DWORD SetupCount;
result = RegQueryDwordValue(hkSoundMapper, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, &SetupCount);
SetupCount = (ERROR_SUCCESS == result) ? SetupCount : 0;
if (ERROR_SUCCESS == result)
{
PTSTR pstrPref;
BOOL fPrefOnly;
DWORD dwPrefOnly;
result = RegQueryDwordValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PREFERREDONLY, &dwPrefOnly);
fPrefOnly = (ERROR_SUCCESS == result) ? (0 != dwPrefOnly) : FALSE;
result = RegQuerySzValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PLAYBACK, &pstrPref);
if (ERROR_SUCCESS != result) pstrPref = NULL;
*ppstrPref = pstrPref;
*pfPrefOnly = fPrefOnly;
*pSetupCount = SetupCount;
fSuccess = TRUE;
}
result = RegCloseKey(hkSoundMapper);
WinAssert(ERROR_SUCCESS == result);
}
NtClose(hkcu);
return fSuccess;
}
MMRESULT waveOutPickBestId(PUINT pPrefId, PDWORD pdwFlags)
{
PTSTR pstrPref;
UINT cWaveId;
UINT WaveId;
UINT MappableId;
UINT MixableId;
UINT UserSelectedId;
UINT PreferredId;
DWORD WaveIdSetupCount;
DWORD MappableIdSetupCount;
DWORD MixableIdSetupCount;
DWORD UserSelectedIdSetupCount;
DWORD PreferredIdSetupCount;
BOOL fPrefOnly;
BOOL f;
MappableId = WAVE_MAPPER;
MixableId = WAVE_MAPPER;
UserSelectedId = WAVE_MAPPER;
PreferredId = WAVE_MAPPER;
MappableIdSetupCount = 0;
MixableIdSetupCount = 0;
UserSelectedIdSetupCount = 0;
PreferredIdSetupCount = 0;
cWaveId = waveOutGetNumDevs();
waveOutReadPersistentPref(&pstrPref, &fPrefOnly, &UserSelectedIdSetupCount);
*pdwFlags = fPrefOnly ? DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY : 0;
for (WaveId = cWaveId-1; ((int)WaveId) >= 0; WaveId--)
{
WAVEOUTCAPS wc;
UINT uMixerId;
MMRESULT mmr;
PWAVEDRV pdrv;
BOOL fThisSession;
//
// check the protocol name
// mask all inappropriate TS/non-TS drivers
//
if (waveReferenceDriverById(&waveoutdrvZ, WaveId, &pdrv, NULL)) continue;
fThisSession = !lstrcmpW(pdrv->wszSessProtocol, SessionProtocolName);
mregDecUsagePtr(pdrv);
if (!fThisSession) continue;
mmr = waveOutGetDevCaps(WaveId, &wc, sizeof(wc));
if (mmr) continue;
wc.szPname[MAXPNAMELEN-1] = TEXT('\0');
if (pstrPref && !lstrcmp(wc.szPname, pstrPref)) UserSelectedId = WaveId;
WaveIdSetupCount = waveOutGetSetupPreferredAudioCount(WaveId);
mmr = waveOutMessage((HWAVEOUT)(UINT_PTR)WaveId, DRV_QUERYMAPPABLE, 0L, 0L);
if (mmr) continue;
if (WaveIdSetupCount >= MappableIdSetupCount) {
MappableId = WaveId;
MappableIdSetupCount = WaveIdSetupCount;
}
mmr = mixerGetID((HMIXEROBJ)(UINT_PTR)WaveId, &uMixerId, MIXER_OBJECTF_WAVEOUT);
if (mmr) continue;
if (WaveIdSetupCount >= MixableIdSetupCount) {
MixableId = WaveId;
MixableIdSetupCount = WaveIdSetupCount;
}
}
if (pstrPref) {
f = HeapFree(hHeap, 0, pstrPref);
WinAssert(f);
pstrPref = NULL;
}
PreferredId = MappableId;
PreferredIdSetupCount = MappableIdSetupCount;
if ((MixableIdSetupCount >= PreferredIdSetupCount) && (WAVE_MAPPER != MixableId))
{
PreferredId = MixableId;
PreferredIdSetupCount = MixableIdSetupCount;
}
if ((UserSelectedIdSetupCount >= PreferredIdSetupCount) && (WAVE_MAPPER != UserSelectedId))
{
PreferredId = UserSelectedId;
PreferredIdSetupCount = UserSelectedIdSetupCount;
}
*pPrefId = PreferredId;
return MMSYSERR_NOERROR;
}
void waveOutGetCurrentPreferredId(PUINT pPrefId, PDWORD pdwFlags)
{
*pPrefId = WAVE_MAPPER;
if (pdwFlags) *pdwFlags = gfUsePreferredWaveOnly ? DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY : 0;
if (gpstrWoDefaultStringId) mregGetIdFromStringId(&waveoutdrvZ, gpstrWoDefaultStringId, pPrefId);
return;
}
BOOL waveOutWritePersistentPref(PTSTR pstrPref, BOOL fPrefOnly)
{
HKEY hkcu;
HKEY hkSoundMapper;
LONG result;
BOOL fSuccess;
if (!NT_SUCCESS(RtlOpenCurrentUser(GENERIC_WRITE, &hkcu))) return MMSYSERR_WRITEERROR;
result = RegCreateKeyEx(hkcu, REGSTR_PATH_MULTIMEDIA_SOUNDMAPPER, 0, TEXT("\0"), REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hkSoundMapper, NULL);
if (ERROR_SUCCESS == result)
{
DWORD cbstrPref;
cbstrPref = (lstrlen(pstrPref) + 1) * sizeof(pstrPref[0]);
result = RegSetSzValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PLAYBACK, pstrPref);
if (ERROR_SUCCESS == result)
{
fSuccess = TRUE;
result = RegSetDwordValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PREFERREDONLY, (DWORD)fPrefOnly);
if (ERROR_SUCCESS != result) {
Squirt("wOWPP: Could not write hkcu\\...\\Sound Mapper\\PreferredOnly");
}
result = RegSetDwordValue(hkSoundMapper, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, GetCurrentSetupPreferredAudioCount());
if (ERROR_SUCCESS != result) {
Squirt("wOWPP: Could not write hkcu\\...\\Sound Mapper\\SetupPreferredAudioCount");
}
}
result = RegCloseKey(hkSoundMapper);
WinAssert(ERROR_SUCCESS == result);
}
NtClose(hkcu);
return MMSYSERR_NOERROR;
}
MMRESULT waveOutSetCurrentPreferredId(UINT PrefId, DWORD dwFlags)
{
MMRESULT mmr;
WinAssert(PrefId < wTotalWaveOutDevs || PrefId == WAVE_MAPPER);
mmr = MMSYSERR_NOERROR;
if (gpstrWoDefaultStringId) HeapFree(hHeap, 0, gpstrWoDefaultStringId);
gpstrWoDefaultStringId = NULL;
if (wTotalWaveOutDevs)
{
UINT mixerId;
PWAVEDRV pwavedrv;
UINT port;
mmr = waveReferenceDriverById(&waveoutdrvZ, PrefId, &pwavedrv, &port);
if (!mmr)
{
mmr = mregCreateStringIdFromDriverPort(pwavedrv, port, &gpstrWoDefaultStringId, NULL);
if (!mmr)
{
if (!gfDisablePreferredDeviceReordering)
{
// Rearrange some of the driver list so that the preferred waveOut
// device and its associated mixer device have a good chance of
// having device ID 0
mmr = mixerGetID((HMIXEROBJ)(UINT_PTR)PrefId, &mixerId, MIXER_OBJECTF_WAVEOUT);
if (mmr) mixerId = 0;
if (0 != PrefId)
{
// Move the wave driver to the head of this list. This usually
// makes the preferred device have ID 0.
EnterNumDevs("waveOutSetCurrentPreferredId");
pwavedrv->Prev->Next = pwavedrv->Next;
pwavedrv->Next->Prev = pwavedrv->Prev;
pwavedrv->Next = waveoutdrvZ.Next;
pwavedrv->Prev = &waveoutdrvZ;
waveoutdrvZ.Next->Prev = pwavedrv;
waveoutdrvZ.Next = pwavedrv;
LeaveNumDevs("waveOutSetCurrentPreferredId");
mregDecUsagePtr(pwavedrv);
}
if (0 != mixerId)
{
PMIXERDRV pmixerdrv;
mmr = mixerReferenceDriverById(mixerId, &pmixerdrv, NULL);
if (!mmr)
{
EnterNumDevs("waveOutSetCurrentPreferredId");
pmixerdrv->Prev->Next = pmixerdrv->Next;
pmixerdrv->Next->Prev = pmixerdrv->Prev;
pmixerdrv->Next = mixerdrvZ.Next;
pmixerdrv->Prev = &mixerdrvZ;
mixerdrvZ.Next->Prev = pmixerdrv;
mixerdrvZ.Next = pmixerdrv;
LeaveNumDevs("waveOutSetCurrentPreferredId");
mregDecUsagePtr(pmixerdrv);
}
}
}
// Errors in this body are not critical
mmr = MMSYSERR_NOERROR;
}
}
}
if (!mmr)
{
gfUsePreferredWaveOnly = (0 != (dwFlags & DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY));
// Reconfigure the mapper only if it was already loaded. Don't cause it to
// load simply so that we can reconfigure it!
if (WaveMapperInitialized) waveOutMessage((HWAVEOUT)(UINT_PTR)WAVE_MAPPER, DRVM_MAPPER_RECONFIGURE, 0, 0);
}
return mmr;
}
MMRESULT waveOutSetPersistentPreferredId(UINT PrefId, DWORD dwFlags)
{
MMRESULT mmr;
WAVEOUTCAPS woc;
if (0 != (dwFlags & ~DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY)) return MMSYSERR_INVALPARAM;
mmr = waveOutGetDevCaps(PrefId, &woc, sizeof(woc));
if (!mmr)
{
woc.szPname[MAXPNAMELEN-1] = TEXT('\0');
mmr = waveOutWritePersistentPref(woc.szPname, 0 != (dwFlags & 0x00000001));
if (!mmr) {
NotifyServerPreferredDeviceChange();
} else {
Squirt("waveOutSetPersistentPreferredId: waveOutWritePersistenPref failed, mmr=%08Xh", mmr);
}
}
return mmr;
}
void waveOutGetCurrentConsoleVoiceComId(PUINT pPrefId, PDWORD pdwFlags)
{
*pPrefId = WAVE_MAPPER;
*pdwFlags = gfUsePreferredWaveOnly ? DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY : 0;
if (gpstrWoConsoleVoiceComStringId) mregGetIdFromStringId(&waveoutdrvZ, gpstrWoConsoleVoiceComStringId, pPrefId);
return;
}
MMRESULT waveOutSetPersistentConsoleVoiceComId(UINT PrefId, DWORD dwFlags)
{
MMRESULT mmr;
WAVEOUTCAPS woc;
if (0 != (dwFlags & ~DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY)) return MMSYSERR_INVALPARAM;
mmr = waveOutGetDevCaps(PrefId, &woc, sizeof(woc));
if (!mmr)
{
woc.szPname[MAXPNAMELEN-1] = TEXT('\0');
mmr = waveWritePersistentConsoleVoiceCom(TRUE, woc.szPname, 0 != (dwFlags & 0x00000001));
if (!mmr) {
NotifyServerPreferredDeviceChange();
} else {
Squirt("waveOutSetPersistentConsoleVoiceComId: waveWritePersistentConsoleVoiceCom failed, mmr=%08Xh", mmr);
}
}
return mmr;
}
MMRESULT waveOutSetCurrentConsoleVoiceComId(UINT PrefId, DWORD dwFlags)
{
MMRESULT mmr;
WinAssert(PrefId < wTotalWaveOutDevs || PrefId == WAVE_MAPPER);
mmr = MMSYSERR_NOERROR;
if (gpstrWoConsoleVoiceComStringId) HeapFree(hHeap, 0, gpstrWoConsoleVoiceComStringId);
gpstrWoConsoleVoiceComStringId = NULL;
if (wTotalWaveOutDevs)
{
PWAVEDRV pwavedrv;
UINT port;
mmr = waveReferenceDriverById(&waveoutdrvZ, PrefId, &pwavedrv, &port);
if (!mmr)
{
mregCreateStringIdFromDriverPort(pwavedrv, port, &gpstrWoConsoleVoiceComStringId, NULL);
gfUsePreferredWaveOnly = (0 != (dwFlags & DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY));
}
}
return mmr;
}
//------------------------------------------------------------------------------
//
//
// WaveIn
//
//
//------------------------------------------------------------------------------
DWORD waveInGetSetupPreferredAudioCount(UINT WaveId)
{
PCWSTR DeviceInterface;
DWORD dwCount;
DeviceInterface = waveReferenceDevInterfaceById(&waveindrvZ, WaveId);
if(DeviceInterface == NULL) {
return 0;
}
dwCount = GetDeviceInterfaceSetupPreferredAudioCount(DeviceInterface);
wdmDevInterfaceDec(DeviceInterface);
return dwCount;
}
MMRESULT waveInSendPreferredMessage(BOOL fClear)
{
PCWSTR DeviceInterface;
UINT WaveId, Flags;
MMRESULT mmr;
if(!gfLogon) {
return MMSYSERR_NOERROR;
}
waveInGetCurrentPreferredId(&WaveId, &Flags);
//Squirt("waveInSendPreferredMessage: id %d f %d", WaveId, fClear);
if(WaveId == WAVE_MAPPER) {
return MMSYSERR_NOERROR;
}
DeviceInterface = waveReferenceDevInterfaceById(&waveindrvZ, WaveId);
if(DeviceInterface == NULL) {
return MMSYSERR_NOERROR;
}
gfWaveInPreferredMessageSent = TRUE;
mmr = waveInMessage((HWAVEIN)(UINT_PTR)WaveId, WIDM_PREFERRED, (DWORD_PTR)fClear, (DWORD_PTR)DeviceInterface);
wdmDevInterfaceDec(DeviceInterface);
return mmr;
}
BOOL waveInReadPersistentPref(PTSTR *ppstrPref, PBOOL pfPrefOnly, PDWORD pSetupCount)
{
HKEY hkcu;
HKEY hkSoundMapper;
LONG result;
BOOL fSuccess;
fSuccess = FALSE;
*ppstrPref = NULL;
*pfPrefOnly = FALSE;
*pSetupCount = 0;
if (!NT_SUCCESS(RtlOpenCurrentUser(GENERIC_READ, &hkcu))) return FALSE;
result = RegOpenKeyEx(hkcu, REGSTR_PATH_MULTIMEDIA_SOUNDMAPPER, 0, KEY_QUERY_VALUE, &hkSoundMapper);
if (ERROR_SUCCESS == result)
{
DWORD SetupCount;
result = RegQueryDwordValue(hkSoundMapper, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, &SetupCount);
SetupCount = (ERROR_SUCCESS == result) ? SetupCount : 0;
if (ERROR_SUCCESS == result)
{
PTSTR pstrPref;
BOOL fPrefOnly;
DWORD dwPrefOnly;
result = RegQueryDwordValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PREFERREDONLY, &dwPrefOnly);
fPrefOnly = (ERROR_SUCCESS == result) ? (0 != dwPrefOnly) : FALSE;
result = RegQuerySzValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_RECORD, &pstrPref);
if (ERROR_SUCCESS != result) pstrPref = NULL;
*ppstrPref = pstrPref;
*pfPrefOnly = fPrefOnly;
*pSetupCount = SetupCount;
fSuccess = TRUE;
}
result = RegCloseKey(hkSoundMapper);
WinAssert(ERROR_SUCCESS == result);
}
NtClose(hkcu);
return fSuccess;
}
MMRESULT waveInPickBestId(PUINT pPrefId, PDWORD pdwFlags)
{
PTSTR pstrPref;
UINT cWaveId;
UINT WaveId;
UINT MappableId;
UINT MixableId;
UINT UserSelectedId;
UINT PreferredId;
DWORD WaveIdSetupCount;
DWORD MappableIdSetupCount;
DWORD MixableIdSetupCount;
DWORD UserSelectedIdSetupCount;
DWORD PreferredIdSetupCount;
BOOL fPrefOnly;
BOOL f;
MappableId = WAVE_MAPPER;
MixableId = WAVE_MAPPER;
UserSelectedId = WAVE_MAPPER;
PreferredId = WAVE_MAPPER;
MappableIdSetupCount = 0;
MixableIdSetupCount = 0;
UserSelectedIdSetupCount = 0;
PreferredIdSetupCount = 0;
cWaveId = waveInGetNumDevs();
waveInReadPersistentPref(&pstrPref, &fPrefOnly, &UserSelectedIdSetupCount);
*pdwFlags = fPrefOnly ? DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY : 0;
for (WaveId = cWaveId-1; ((int)WaveId) >= 0; WaveId--)
{
WAVEINCAPS wic;
UINT uMixerId;
MMRESULT mmr;
mmr = waveInGetDevCaps(WaveId, &wic, sizeof(wic));
if (MMSYSERR_NOERROR != mmr) continue;
wic.szPname[MAXPNAMELEN-1] = TEXT('\0');
if (pstrPref && !lstrcmp(wic.szPname, pstrPref)) UserSelectedId = WaveId;
WaveIdSetupCount = waveInGetSetupPreferredAudioCount(WaveId);
mmr = waveInMessage((HWAVEIN)(UINT_PTR)WaveId, DRV_QUERYMAPPABLE, 0L, 0L);
if (MMSYSERR_NOERROR != mmr) continue;
if (WaveIdSetupCount >= MappableIdSetupCount) {
MappableId = WaveId;
MappableIdSetupCount = WaveIdSetupCount;
}
mmr = mixerGetID((HMIXEROBJ)(UINT_PTR)WaveId, &uMixerId, MIXER_OBJECTF_WAVEIN);
if (MMSYSERR_NOERROR != mmr) continue;
if (WaveIdSetupCount >= MixableIdSetupCount) {
MixableId = WaveId;
MixableIdSetupCount = WaveIdSetupCount;
}
}
if (pstrPref) {
f = HeapFree(hHeap, 0, pstrPref);
WinAssert(f);
pstrPref = NULL;
}
PreferredId = MappableId;
PreferredIdSetupCount = MappableIdSetupCount;
if ((MixableIdSetupCount >= PreferredIdSetupCount) && (WAVE_MAPPER != MixableId)) {
PreferredId = MixableId;
PreferredIdSetupCount = MixableIdSetupCount;
}
if ((UserSelectedIdSetupCount >= PreferredIdSetupCount) && (WAVE_MAPPER != UserSelectedId))
{
PreferredId = UserSelectedId;
PreferredIdSetupCount = UserSelectedIdSetupCount;
}
*pPrefId = PreferredId;
return MMSYSERR_NOERROR;
}
void waveInGetCurrentPreferredId(PUINT pPrefId, PDWORD pdwFlags)
{
*pPrefId = WAVE_MAPPER;
if (pdwFlags) *pdwFlags = gfUsePreferredWaveOnly ? DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY : 0;
if (gpstrWiDefaultStringId) mregGetIdFromStringId(&waveindrvZ, gpstrWiDefaultStringId, pPrefId);
return;
}
BOOL waveInWritePersistentPref(PTSTR pstrPref, BOOL fPrefOnly)
{
HKEY hkcu;
HKEY hkSoundMapper;
LONG result;
BOOL fSuccess;
if (!NT_SUCCESS(RtlOpenCurrentUser(GENERIC_WRITE, &hkcu))) return MMSYSERR_WRITEERROR;
result = RegCreateKeyEx(hkcu, REGSTR_PATH_MULTIMEDIA_SOUNDMAPPER, 0, TEXT("\0"), REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, NULL, &hkSoundMapper, NULL);
if (ERROR_SUCCESS == result)
{
DWORD cbstrPref;
cbstrPref = (lstrlen(pstrPref) + 1) * sizeof(pstrPref[0]);
result = RegSetSzValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_RECORD, pstrPref);
if (ERROR_SUCCESS == result)
{
fSuccess = TRUE;
result = RegSetDwordValue(hkSoundMapper, REGSTR_VAL_MULTIMEDIA_SOUNDMAPPER_PREFERREDONLY, (DWORD)fPrefOnly);
if (ERROR_SUCCESS != result) {
Squirt("wiWPP: Could not write hkcu\\...\\Sound Mapper\\PreferredOnly");
}
result = RegSetDwordValue(hkSoundMapper, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, GetCurrentSetupPreferredAudioCount());
if (ERROR_SUCCESS != result) {
Squirt("wiWPP: Could not write hkcu\\...\\Sound Mapper\\SetupPreferredAudioCount");
}
}
result = RegCloseKey(hkSoundMapper);
WinAssert(ERROR_SUCCESS == result);
}
NtClose(hkcu);
return MMSYSERR_NOERROR;
}
MMRESULT waveInSetCurrentPreferredId(UINT PrefId, DWORD dwFlags)
{
MMRESULT mmr;
WinAssert(PrefId < wTotalWaveInDevs || PrefId == WAVE_MAPPER);
mmr = MMSYSERR_NOERROR;
if (gpstrWiDefaultStringId) HeapFree(hHeap, 0, gpstrWiDefaultStringId);
gpstrWiDefaultStringId = NULL;
if (wTotalWaveInDevs)
{
PWAVEDRV pwavedrv;
UINT port;
mmr = waveReferenceDriverById(&waveindrvZ, PrefId, &pwavedrv, &port);
if (!mmr)
{
mmr = mregCreateStringIdFromDriverPort(pwavedrv, port, &gpstrWiDefaultStringId, NULL);
if (!mmr)
{
if (!gfDisablePreferredDeviceReordering)
{
// Rearrange some of the driver list so that the preferred waveIn
// device has a good chance of having device ID 0
if (0 != PrefId)
{
// Move the wave driver to the head of this list. This usually
// makes the preferred device have ID 0.
EnterNumDevs("waveInSetCurrentPreferredId");
pwavedrv->Prev->Next = pwavedrv->Next;
pwavedrv->Next->Prev = pwavedrv->Prev;
pwavedrv->Next = waveindrvZ.Next;
pwavedrv->Prev = &waveindrvZ;
waveindrvZ.Next->Prev = pwavedrv;
waveindrvZ.Next = pwavedrv;
LeaveNumDevs("waveInSetCurrentPreferredId");
mregDecUsagePtr(pwavedrv);
}
}
}
}
}
if (!mmr)
{
gfUsePreferredWaveOnly = (0 != (dwFlags & DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY));
// Reconfigure the mapper only if it was already loaded. Don't cause it to
// load simply so that we can reconfigure it!
if (WaveMapperInitialized) waveInMessage((HWAVEIN)(UINT_PTR)WAVE_MAPPER, DRVM_MAPPER_RECONFIGURE, 0, 0);
}
return mmr;
}
MMRESULT waveInSetPersistentPreferredId(UINT PrefId, DWORD dwFlags)
{
MMRESULT mmr;
WAVEINCAPS wc;
if (0 != (dwFlags & ~DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY)) return MMSYSERR_INVALPARAM;
mmr = waveInGetDevCaps(PrefId, &wc, sizeof(wc));
if (!mmr)
{
wc.szPname[MAXPNAMELEN-1] = TEXT('\0');
mmr = waveInWritePersistentPref(wc.szPname, 0 != (dwFlags & DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY));
if (!mmr) {
NotifyServerPreferredDeviceChange();
} else {
Squirt("waveInSetPersistentPreferredId: waveInWritePersistenPref failed, mmr=%08Xh", mmr);
}
}
return mmr;
}
void waveInGetCurrentConsoleVoiceComId(PUINT pPrefId, PDWORD pdwFlags)
{
*pPrefId = WAVE_MAPPER;
*pdwFlags = gfUsePreferredWaveOnly ? DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY : 0;
if (gpstrWiConsoleVoiceComStringId) mregGetIdFromStringId(&waveindrvZ, gpstrWiConsoleVoiceComStringId, pPrefId);
return;
}
MMRESULT waveInSetPersistentConsoleVoiceComId(UINT PrefId, DWORD dwFlags)
{
MMRESULT mmr;
WAVEINCAPS wic;
if (0 != (dwFlags & ~DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY)) return MMSYSERR_INVALPARAM;
mmr = waveInGetDevCaps(PrefId, &wic, sizeof(wic));
if (!mmr)
{
wic.szPname[MAXPNAMELEN-1] = TEXT('\0');
mmr = waveWritePersistentConsoleVoiceCom(FALSE, wic.szPname, 0 != (dwFlags & 0x00000001));
if (!mmr) {
NotifyServerPreferredDeviceChange();
} else {
Squirt("waveInSetPersistentConsoleVoiceComId: waveWritePersistentConsoleVoiceCom failed, mmr=%08Xh", mmr);
}
}
return mmr;
}
MMRESULT waveInSetCurrentConsoleVoiceComId(UINT PrefId, DWORD dwFlags)
{
MMRESULT mmr;
WinAssert(PrefId < wTotalWaveInDevs || PrefId == WAVE_MAPPER);
mmr = MMSYSERR_NOERROR;
if (gpstrWiConsoleVoiceComStringId) HeapFree(hHeap, 0, gpstrWiConsoleVoiceComStringId);
gpstrWiConsoleVoiceComStringId = NULL;
if (wTotalWaveInDevs)
{
PWAVEDRV pwavedrv;
UINT port;
mmr = waveReferenceDriverById(&waveindrvZ, PrefId, &pwavedrv, &port);
if (!mmr)
{
mregCreateStringIdFromDriverPort(pwavedrv, port, &gpstrWiConsoleVoiceComStringId, NULL);
gfUsePreferredWaveOnly = (0 != (dwFlags & DRVM_MAPPER_PREFERRED_FLAGS_PREFERREDONLY));
}
}
return mmr;
}
//------------------------------------------------------------------------------
//
//
// MidiOut
//
//
//------------------------------------------------------------------------------
DWORD midiOutGetSetupPreferredAudioCount(UINT MidiId)
{
PCWSTR DeviceInterface;
DWORD dwCount;
DeviceInterface = midiReferenceDevInterfaceById(&midioutdrvZ, MidiId);
if(DeviceInterface == NULL) {
return 0;
}
dwCount = GetDeviceInterfaceSetupPreferredAudioCount(DeviceInterface);
wdmDevInterfaceDec(DeviceInterface);
return dwCount;
}
MMRESULT midiOutSendPreferredMessage(BOOL fClear)
{
PCWSTR DeviceInterface;
UINT MidiId;
MMRESULT mmr;
if(!gfLogon) {
return MMSYSERR_NOERROR;
}
midiOutGetCurrentPreferredId(&MidiId, NULL);
if(MidiId == WAVE_MAPPER) {
return MMSYSERR_NOERROR;
}
DeviceInterface = midiReferenceDevInterfaceById(&midioutdrvZ, MidiId);
if(DeviceInterface == NULL) {
return MMSYSERR_NOERROR;
}
gfMidiOutPreferredMessageSent = TRUE;
mmr = midiOutMessage((HMIDIOUT)(UINT_PTR)MidiId, MODM_PREFERRED, (DWORD_PTR)fClear, (DWORD_PTR)DeviceInterface);
wdmDevInterfaceDec(DeviceInterface);
return mmr;
}
MMRESULT midiOutWritePersistentPref(IN UINT MidiOutId, IN ULONG SetupCount)
{
HKEY hkMidiMapper;
HKEY hkcu;
MIDIOUTCAPS moc;
DWORD dwDisposition;
LONG result;
MMRESULT mmr;
mmr = midiOutGetDevCaps(MidiOutId, &moc, sizeof(moc));
if (MMSYSERR_NOERROR != mmr) return mmr;
if (!NT_SUCCESS(RtlOpenCurrentUser(GENERIC_ALL, &hkcu))) return MMSYSERR_WRITEERROR;
result = RegCreateKeyEx(hkcu, REGSTR_PATH_MULTIMEDIA_MIDIMAP, 0, TEXT(""), REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_QUERY_VALUE, NULL, &hkMidiMapper, &dwDisposition);
if (ERROR_SUCCESS == result)
{
PCWSTR pstrDeviceInterface;
UINT RelativeIndex;
pstrDeviceInterface = midiReferenceDevInterfaceById(&midioutdrvZ, MidiOutId);
if (pstrDeviceInterface) {
UINT i;
RelativeIndex = 0;
for (i = 0; i < MidiOutId; i++) {
PCWSTR pstr = midiReferenceDevInterfaceById(&midioutdrvZ, i);
if (pstr && !lstrcmpi(pstrDeviceInterface, pstr)) RelativeIndex++;
if (pstr) wdmDevInterfaceDec(pstr);
}
} else {
RelativeIndex = 0;
}
result = RegSetSzValue(hkMidiMapper, REGSTR_VAL_MULTIMEDIA_MIDIMAP_SZPNAME, moc.szPname);
if (ERROR_SUCCESS == result) result = RegSetDwordValue(hkMidiMapper, REGSTR_VAL_MULTIMEDIA_MIDIMAP_RELATIVEINDEX, RelativeIndex);
if (ERROR_SUCCESS == result) result = RegSetSzValue(hkMidiMapper, REGSTR_VAL_MULTIMEDIA_MIDIMAP_DEVICEINTERFACE, pstrDeviceInterface ? pstrDeviceInterface : TEXT(""));
if (ERROR_SUCCESS == result) result = RegSetDwordValue(hkMidiMapper, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, SetupCount);
if (ERROR_SUCCESS == result) RegDeleteValue(hkMidiMapper, REGSTR_VAL_MULTIMEDIA_MIDIMAP_CURRENTINSTRUMENT);
if (pstrDeviceInterface) wdmDevInterfaceDec(pstrDeviceInterface);
RegCloseKey(hkMidiMapper);
}
if (ERROR_SUCCESS != result) mmr = MMSYSERR_WRITEERROR;
NtClose(hkcu);
return mmr;
}
MMRESULT midiOutGetIdFromName(IN PTSTR pstrName, OUT UINT *pMidiOutId)
{
UINT MidiOutId;
UINT cMidiOutId;
MMRESULT mmr;
cMidiOutId = midiOutGetNumDevs();
for (MidiOutId = 0; MidiOutId < cMidiOutId; MidiOutId++)
{
MIDIOUTCAPS moc;
mmr = midiOutGetDevCaps(MidiOutId, &moc, sizeof(moc));
if (MMSYSERR_NOERROR == mmr)
{
if (!lstrcmp(pstrName, moc.szPname))
{
mmr = MMSYSERR_NOERROR;
break;
}
}
}
if (MidiOutId == cMidiOutId)
{
mmr = MMSYSERR_NODRIVER;
}
if (MMSYSERR_NOERROR == mmr) *pMidiOutId = MidiOutId;
return mmr;
}
MMRESULT midiOutGetIdFromDiAndIndex(IN PTSTR pstrDeviceInterface, IN INT RelativeIndex, OUT UINT *pMidiOutId)
{
UINT cMidiOut;
UINT MidiOutId;
MMRESULT mmr;
mmr = MMSYSERR_NODRIVER;
cMidiOut = midiOutGetNumDevs();
if (0 == cMidiOut) return MMSYSERR_NODRIVER;
for (MidiOutId = 0; MidiOutId < cMidiOut; MidiOutId++) {
PCWSTR pstr = midiReferenceDevInterfaceById(&midioutdrvZ, MidiOutId);
if (pstr && !lstrcmpi(pstr, pstrDeviceInterface) && (0 == RelativeIndex--)) {
*pMidiOutId = MidiOutId;
wdmDevInterfaceDec(pstr);
mmr = MMSYSERR_NOERROR;
break;
}
if (pstr) wdmDevInterfaceDec(pstr);
}
return mmr;
}
MMRESULT midiOutGetInstrumentDriverData(IN PCTSTR pstrMidiSubkeyName, OUT PTSTR *ppstrDeviceInterface, OUT UINT *pDriverNum, OUT UINT *pPortNum, OUT PTSTR *ppstrPname)
{
HKEY hkMidi;
HKEY hkMidiSubkey;
LONG result;
MMRESULT mmr;
BOOL f;
mmr = MMSYSERR_ERROR;
result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGSTR_PATH_MEDIARESOURCES_MIDI, 0, KEY_QUERY_VALUE, &hkMidi);
if (ERROR_SUCCESS != result) return MMSYSERR_ERROR;
result = RegOpenKeyEx(hkMidi, pstrMidiSubkeyName, 0, KEY_QUERY_VALUE, &hkMidiSubkey);
if (ERROR_SUCCESS == result)
{
PTSTR pstrActive;
result = RegQuerySzValue(hkMidiSubkey, REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_ACTIVE, &pstrActive);
if (ERROR_SUCCESS == result)
{
PTCHAR pchEnd;
BOOL fActive = _tcstol(pstrActive, &pchEnd, 10);
f = HeapFree(hHeap, 0, pstrActive);
WinAssert(f);
if (fActive)
{
PTSTR pstrDeviceInterface = NULL;
PTSTR pstrPname = NULL;
DWORD dwDriverNum;
DWORD dwPortNum;
result = RegQueryDwordValue(hkMidiSubkey, REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_PHYSDEVID, &dwDriverNum);
if (ERROR_SUCCESS == result) result = RegQueryDwordValue(hkMidiSubkey, REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_PORT, &dwPortNum);
if (ERROR_SUCCESS == result) RegQuerySzValue(hkMidiSubkey, REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_DEVICEINTERFACE, &pstrDeviceInterface);
if (ERROR_SUCCESS == result) RegQuerySzValue(hkMidiSubkey, REGSTR_VAL_MEDIARESOURCES_MIDI_SUBKEY_DESCRIPTION, &pstrPname);
if (ERROR_SUCCESS == result)
{
*ppstrDeviceInterface = NULL;
*ppstrPname = NULL;
if (pstrDeviceInterface) {
if (lstrlen(pstrDeviceInterface)> 0) {
*ppstrDeviceInterface = pstrDeviceInterface;
} else {
HeapFree(hHeap, 0, pstrDeviceInterface);
}
}
if (pstrPname) {
if (lstrlen(pstrPname)> 0) {
*ppstrPname = pstrPname;
} else {
HeapFree(hHeap, 0, pstrPname);
}
}
*pDriverNum = dwDriverNum;
*pPortNum = dwPortNum;
mmr = MMSYSERR_NOERROR;
}
}
}
result = RegCloseKey(hkMidiSubkey);
WinAssert(ERROR_SUCCESS == result);
}
result = RegCloseKey(hkMidi);
WinAssert(ERROR_SUCCESS == result);
return mmr;
}
MMRESULT midiOutGetIdFromInstrument(IN PTSTR pstrMidiKeyName, OUT UINT *outMidiOutId)
{
PTSTR pstrDeviceInterface, pstrPname;
UINT DriverNum, PortNum;
UINT MidiOutId;
MMRESULT mmr;
mmr = midiOutGetInstrumentDriverData(pstrMidiKeyName, &pstrDeviceInterface, &DriverNum, &PortNum, &pstrPname);
if (MMSYSERR_NOERROR == mmr) {
if (pstrDeviceInterface) {
mmr = midiOutGetIdFromDiAndIndex(pstrDeviceInterface, PortNum, &MidiOutId);
} else if (pstrPname) {
mmr = midiOutGetIdFromName(pstrPname, &MidiOutId);
} else {
PMIDIDRV pmidioutdrv = midioutdrvZ.Next;
UINT DriverNum1 = DriverNum + 1;
MidiOutId = 0;
while ((pmidioutdrv != &midioutdrvZ) && (0 < DriverNum1))
{
MidiOutId += pmidioutdrv->NumDevs;
DriverNum1--;
pmidioutdrv = pmidioutdrv->Next;
}
if ((pmidioutdrv != &midioutdrvZ) && (PortNum < pmidioutdrv->NumDevs))
{
MidiOutId += PortNum;
} else {
MidiOutId = MIDI_MAPPER;
mmr = MMSYSERR_ERROR;
}
}
if (pstrDeviceInterface) HeapFree(hHeap, 0, pstrDeviceInterface);
if (pstrPname) HeapFree(hHeap, 0, pstrPname);
}
if (MMSYSERR_NOERROR == mmr) {
MIDIOUTCAPS moc;
WinAssert(MIDI_MAPPER != MidiOutId);
mmr = midiOutGetDevCaps(MidiOutId, &moc, sizeof(moc));
}
if (MMSYSERR_NOERROR == mmr) *outMidiOutId = MidiOutId;
return mmr;
}
MMRESULT midiOutReadCurrentInstrument(OUT PTSTR *ppstrCurrentInstrument, OUT DWORD *pSetupCount)
{
HKEY hkcu;
HKEY hkMidiMapper;
LONG result;
MMRESULT mmr;
mmr = MMSYSERR_ERROR;
if (!NT_SUCCESS(RtlOpenCurrentUser(GENERIC_READ, &hkcu))) return MMSYSERR_READERROR;
result = RegOpenKeyEx(hkcu, REGSTR_PATH_MULTIMEDIA_MIDIMAP, 0, KEY_QUERY_VALUE, &hkMidiMapper);
if (ERROR_SUCCESS == result)
{
result = RegQuerySzValue(hkMidiMapper, REGSTR_VAL_MULTIMEDIA_MIDIMAP_CURRENTINSTRUMENT, ppstrCurrentInstrument);
if (ERROR_SUCCESS == result)
{
DWORD SetupCount;
result = RegQueryDwordValue(hkMidiMapper, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, &SetupCount);
SetupCount = (ERROR_SUCCESS == result) ? SetupCount : 0;
*pSetupCount = SetupCount;
mmr = MMSYSERR_NOERROR;
} else {
mmr = MMSYSERR_ERROR;
}
result = RegCloseKey(hkMidiMapper);
WinAssert(ERROR_SUCCESS == result);
}
NtClose(hkcu);
return mmr;
}
MMRESULT midiOutReadPreferredDeviceData(OUT PTSTR *ppstrDeviceInterface, OUT UINT *pRelativeIndex, OUT PTSTR *ppstrPname, OUT ULONG *pSetupCount)
{
HKEY hkcu;
HKEY hkMidiMapper;
LONG result;
MMRESULT mmr;
if (!NT_SUCCESS(RtlOpenCurrentUser(GENERIC_READ, &hkcu))) return MMSYSERR_READERROR;
result = RegOpenKeyEx(hkcu, REGSTR_PATH_MULTIMEDIA_MIDIMAP, 0, KEY_QUERY_VALUE, &hkMidiMapper);
if (ERROR_SUCCESS == result)
{
PTSTR pstrDeviceInterface = NULL;
PTSTR pstrPname = NULL;
DWORD dwIndex;
DWORD dwSetupCount;
// See if we have a Pname. It is okay not to.
result = RegQuerySzValue(hkMidiMapper, REGSTR_VAL_MULTIMEDIA_MIDIMAP_SZPNAME, &pstrPname);
if (ERROR_FILE_NOT_FOUND == result) result = ERROR_SUCCESS;
// See if we have a device interface + relative index. It is okay not to.
if (ERROR_SUCCESS == result) result = RegQueryDwordValue(hkMidiMapper, REGSTR_VAL_MULTIMEDIA_MIDIMAP_RELATIVEINDEX, &dwIndex);
if (ERROR_SUCCESS == result) result = RegQuerySzValue(hkMidiMapper, REGSTR_VAL_MULTIMEDIA_MIDIMAP_DEVICEINTERFACE, &pstrDeviceInterface);
if (ERROR_FILE_NOT_FOUND == result) result = ERROR_SUCCESS;
// The device interface value might be zero length. Act as thought it
// doesn't exist in this case.
if ((ERROR_SUCCESS == result) && (pstrDeviceInterface) && (0 == lstrlen(pstrDeviceInterface)))
{
HeapFree(hHeap, 0, pstrDeviceInterface);
pstrDeviceInterface = NULL;
dwIndex = 0;
}
if (ERROR_SUCCESS != RegQueryDwordValue(hkMidiMapper, REGSTR_VAL_SETUPPREFERREDAUDIODEVICESCOUNT, &dwSetupCount)) {
dwSetupCount = 0;
}
if (ERROR_SUCCESS == result) {
if (pstrPname || pstrDeviceInterface) {
*ppstrDeviceInterface = pstrDeviceInterface;
*ppstrPname = pstrPname;
*pRelativeIndex = dwIndex;
*pSetupCount = dwSetupCount;
mmr = MMSYSERR_NOERROR;
} else {
mmr = MMSYSERR_VALNOTFOUND;
}
} else {
mmr = MMSYSERR_READERROR;
}
if (MMSYSERR_NOERROR != mmr) {
if (pstrDeviceInterface) HeapFree(hHeap, 0, pstrDeviceInterface);
if (pstrPname) HeapFree(hHeap, 0, pstrPname);
}
RegCloseKey(hkMidiMapper);
} else {
if (ERROR_FILE_NOT_FOUND == result) mmr = MMSYSERR_KEYNOTFOUND;
else mmr = MMSYSERR_READERROR;
}
NtClose(hkcu);
return mmr;
}
MMRESULT midiOutReadPersistentPreferredId(OUT UINT *pMidiPrefId, OUT ULONG *pSetupCount)
{
PTSTR pstrDeviceInterface;
PTSTR pstrPname;
UINT RelativeIndex;
UINT MidiOutId;
ULONG SetupCount;
MMRESULT mmr;
mmr = midiOutReadPreferredDeviceData(&pstrDeviceInterface, &RelativeIndex, &pstrPname, &SetupCount);
if (MMSYSERR_NOERROR == mmr) {
WinAssert(pstrDeviceInterface || pstrPname);
if (pstrDeviceInterface) {
mmr = midiOutGetIdFromDiAndIndex(pstrDeviceInterface, RelativeIndex, &MidiOutId);
} else {
WinAssert(pstrPname);
mmr = midiOutGetIdFromName(pstrPname, &MidiOutId);
}
if (pstrDeviceInterface) HeapFree(hHeap, 0, pstrDeviceInterface);
if (pstrPname) HeapFree(hHeap, 0, pstrPname);
} else if (MMSYSERR_VALNOTFOUND == mmr || MMSYSERR_KEYNOTFOUND == mmr) {
PTSTR pstrMidiKeyName;
mmr = midiOutReadCurrentInstrument(&pstrMidiKeyName, &SetupCount);
if (MMSYSERR_NOERROR == mmr) {
mmr = midiOutGetIdFromInstrument(pstrMidiKeyName, &MidiOutId);
// Since this is older format for storing preference, let's
// rewrite it in newer format.
if (MMSYSERR_NOERROR == mmr)
{
midiOutWritePersistentPref(MidiOutId, SetupCount);
}
HeapFree(hHeap, 0, pstrMidiKeyName);
}
}
if (MMSYSERR_NOERROR == mmr) {
*pMidiPrefId = MidiOutId;
*pSetupCount = SetupCount;
}
return mmr;
}
MMRESULT midiOutPickBestId(PUINT pMidiPrefId, UINT WaveOutPrefId)
{
MIDIOUTCAPS moc;
UINT cMidiOutId;
UINT MidiOutId;
UINT UserSelectedMidiOutId;
UINT WavetableMidiOutId;
UINT SoftwareMidiOutId;
UINT OtherMidiOutId;
UINT FmMidiOutId;
UINT ExternalMidiOutId;
DWORD MidiOutIdCount;
DWORD UserSelectedMidiOutIdCount;
DWORD WavetableMidiOutIdCount;
DWORD SoftwareMidiOutIdCount;
DWORD OtherMidiOutIdCount;
DWORD FmMidiOutIdCount;
DWORD ExternalMidiOutIdCount;
MMRESULT mmrLastError;
MMRESULT mmr;
BOOL f;
UserSelectedMidiOutId = MIDI_MAPPER;
WavetableMidiOutId = MIDI_MAPPER;
SoftwareMidiOutId = MIDI_MAPPER;
OtherMidiOutId = MIDI_MAPPER;
FmMidiOutId = MIDI_MAPPER;
ExternalMidiOutId = MIDI_MAPPER;
MidiOutId = MIDI_MAPPER;
UserSelectedMidiOutIdCount = 0;
WavetableMidiOutIdCount = 0;
SoftwareMidiOutIdCount = 0;
OtherMidiOutIdCount = 0;
FmMidiOutIdCount = 0;
ExternalMidiOutIdCount = 0;
MidiOutIdCount = 0;
mmr = midiOutReadPersistentPreferredId(&UserSelectedMidiOutId, &UserSelectedMidiOutIdCount);
mmrLastError = MMSYSERR_NODRIVER;
cMidiOutId = midiOutGetNumDevs();
for (MidiOutId = 0; MidiOutId < cMidiOutId; MidiOutId++)
{
mmr = midiOutGetDevCaps(MidiOutId, &moc, sizeof(moc));
if (MMSYSERR_NOERROR == mmr)
{
MidiOutIdCount = midiOutGetSetupPreferredAudioCount(MidiOutId);
if (MOD_SWSYNTH == moc.wTechnology &&
MM_MSFT_WDMAUDIO_MIDIOUT == moc.wPid &&
MM_MICROSOFT == moc.wMid)
{
// We need to special case this synth, and get the count from
// the preferred audio device.
SoftwareMidiOutId = MidiOutId;
if ((-1) != WaveOutPrefId) {
SoftwareMidiOutIdCount = waveOutGetSetupPreferredAudioCount(WaveOutPrefId);
} else {
SoftwareMidiOutIdCount = 0;
}
} else if (MOD_FMSYNTH == moc.wTechnology) {
FmMidiOutId = MidiOutId;
FmMidiOutIdCount = MidiOutIdCount;
} else if (MOD_MIDIPORT == moc.wTechnology) {
ExternalMidiOutId = MidiOutId;
ExternalMidiOutIdCount = MidiOutIdCount;
} else if (MOD_WAVETABLE == moc.wTechnology) {
WavetableMidiOutId = MidiOutId;
WavetableMidiOutIdCount = MidiOutIdCount;
} else {
OtherMidiOutId = MidiOutId;
OtherMidiOutIdCount = MidiOutIdCount;
}
} else {
mmrLastError = mmr;
}
}
MidiOutId = ExternalMidiOutId;
MidiOutIdCount = ExternalMidiOutIdCount;
if ((FmMidiOutIdCount >= MidiOutIdCount) && (MIDI_MAPPER != FmMidiOutId))
{
MidiOutId = FmMidiOutId;
MidiOutIdCount = FmMidiOutIdCount;
}
if ((OtherMidiOutIdCount >= MidiOutIdCount) && (MIDI_MAPPER != OtherMidiOutId))
{
MidiOutId = OtherMidiOutId;
MidiOutIdCount = OtherMidiOutIdCount;
}
if ((SoftwareMidiOutIdCount >= MidiOutIdCount) && (MIDI_MAPPER != SoftwareMidiOutId))
{
MidiOutId = SoftwareMidiOutId;
MidiOutIdCount = SoftwareMidiOutIdCount;
}
if ((WavetableMidiOutIdCount >= MidiOutIdCount) && (MIDI_MAPPER != WavetableMidiOutId))
{
MidiOutId = WavetableMidiOutId;
MidiOutIdCount = WavetableMidiOutIdCount;
}
if ((UserSelectedMidiOutIdCount >= MidiOutIdCount) && (MIDI_MAPPER != UserSelectedMidiOutId))
{
MidiOutId = UserSelectedMidiOutId;
MidiOutIdCount = UserSelectedMidiOutIdCount;
}
if ((-1) != MidiOutId) {
mmr = MMSYSERR_NOERROR;
} else {
mmr = mmrLastError;
}
if (MMSYSERR_NOERROR == mmr) *pMidiPrefId = MidiOutId;
return mmr;
}
void midiOutGetCurrentPreferredId(PUINT pPrefId, PDWORD pdwFlags)
{
*pPrefId = WAVE_MAPPER;
if (pdwFlags) *pdwFlags = 0;;
if (gpstrMoDefaultStringId) mregGetIdFromStringId(&midioutdrvZ, gpstrMoDefaultStringId, pPrefId);
return;
}
MMRESULT midiOutSetCurrentPreferredId(UINT PrefId)
{
MMRESULT mmr;
WinAssert(PrefId < wTotalMidiOutDevs || PrefId == MIDI_MAPPER);
mmr = MMSYSERR_NOERROR;
if (gpstrMoDefaultStringId) HeapFree(hHeap, 0, gpstrMoDefaultStringId);
gpstrMoDefaultStringId = NULL;
if (wTotalMidiOutDevs)
{
PMIDIDRV pmididrv;
UINT port;
mmr = midiReferenceDriverById(&midioutdrvZ, PrefId, &pmididrv, &port);
if (!mmr)
{
mmr = mregCreateStringIdFromDriverPort(pmididrv, port, &gpstrMoDefaultStringId, NULL);
if (!mmr)
{
if (!gfDisablePreferredDeviceReordering)
{
// Rearrange some of the driver list so that the preferred midiOut
// device has a good chance of having device ID 0
if (0 != PrefId)
{
// Move the midi driver to the head of this list. This usually
// makes the preferred device have ID 0.
EnterNumDevs("midiOutSetCurrentPreferredId");
pmididrv->Prev->Next = pmididrv->Next;
pmididrv->Next->Prev = pmididrv->Prev;
pmididrv->Next = midioutdrvZ.Next;
pmididrv->Prev = &midioutdrvZ;
midioutdrvZ.Next->Prev = pmididrv;
midioutdrvZ.Next = pmididrv;
LeaveNumDevs("midiOutSetCurrentPreferredId");
mregDecUsagePtr(pmididrv);
}
}
}
}
}
if (!mmr)
{
// Reconfigure the mapper only if it was already loaded. Don't cause it to
// load simply so that we can reconfigure it!
if (MidiMapperInitialized) midiOutMessage((HMIDIOUT)(UINT_PTR)MIDI_MAPPER, DRVM_MAPPER_RECONFIGURE, 0, 0);
}
return mmr;
}
MMRESULT midiOutSetPersistentPreferredId(UINT PrefId, DWORD dwFlags)
{
MMRESULT mmr;
mmr = midiOutWritePersistentPref(PrefId, GetCurrentSetupPreferredAudioCount());
if (!mmr) NotifyServerPreferredDeviceChange();
return mmr;
}
//------------------------------------------------------------------------------
//
//
// RefreshPreferredDevices
//
//
//------------------------------------------------------------------------------
void RefreshPreferredDevices(void)
{
UINT WaveOutPreferredId;
DWORD WaveOutPreferredFlags;
UINT WaveInPreferredId;
DWORD WaveInPreferredFlags;
UINT WaveOutConsoleVoiceComId;
DWORD WaveOutConsoleVoiceComFlags;
UINT WaveInConsoleVoiceComId;
DWORD WaveInConsoleVoiceComFlags;
UINT MidiOutPreferredId;
UINT OldWaveOutPreferredId;
DWORD OldWaveOutPreferredFlags;
UINT OldWaveInPreferredId;
DWORD OldWaveInPreferredFlags;
UINT OldWaveOutConsoleVoiceComId;
DWORD OldWaveOutConsoleVoiceComFlags;
UINT OldWaveInConsoleVoiceComId;
DWORD OldWaveInConsoleVoiceComFlags;
UINT OldMidiOutPreferredId;
// Squirt("RefreshPreferredDevices");
BOOL fImpersonate = FALSE;
waveOutGetCurrentPreferredId(&OldWaveOutPreferredId, &OldWaveOutPreferredFlags);
if (!waveOutPickBestId(&WaveOutPreferredId, &WaveOutPreferredFlags)) {
if ((WaveOutPreferredId != OldWaveOutPreferredId) ||
(WaveOutPreferredFlags != OldWaveOutPreferredFlags) ||
!gfWaveOutPreferredMessageSent)
{
// Squirt("RefreshPreferredDevices: different waveOut preference %d -> %d", OldWaveOutPreferredId, WaveOutPreferredId);
waveOutSendPreferredMessage(TRUE);
waveOutSetCurrentPreferredId(WaveOutPreferredId, WaveOutPreferredFlags);
waveOutSendPreferredMessage(FALSE);
}
}
waveOutGetCurrentConsoleVoiceComId(&OldWaveOutConsoleVoiceComId, &OldWaveOutConsoleVoiceComFlags);
if (!wavePickBestConsoleVoiceComId(TRUE, &WaveOutConsoleVoiceComId, &WaveOutConsoleVoiceComFlags)) {
if ((WaveOutConsoleVoiceComId != OldWaveOutConsoleVoiceComId) ||
(WaveOutConsoleVoiceComFlags != OldWaveOutConsoleVoiceComFlags))
{
// Squirt("RefreshPreferredDevices: different waveOut preference %d -> %d", OldWaveOutConsoleVoiceComId, WaveOutConsoleVoiceComId);
waveOutSetCurrentConsoleVoiceComId(WaveOutConsoleVoiceComId, WaveOutConsoleVoiceComFlags);
}
}
waveInGetCurrentPreferredId(&OldWaveInPreferredId, &OldWaveInPreferredFlags);
if (!waveInPickBestId(&WaveInPreferredId, &WaveInPreferredFlags)) {
if ((WaveInPreferredId != OldWaveInPreferredId) ||
(WaveInPreferredFlags != OldWaveInPreferredFlags) ||
!gfWaveInPreferredMessageSent)
{
// Squirt("RefreshPreferredDevices: different waveIn preference %d -> %d", OldWaveInPreferredId, WaveInPreferredId);
waveInSendPreferredMessage(TRUE);
waveInSetCurrentPreferredId(WaveInPreferredId, WaveInPreferredFlags);
waveInSendPreferredMessage(FALSE);
}
}
waveInGetCurrentConsoleVoiceComId(&OldWaveInConsoleVoiceComId, &OldWaveInConsoleVoiceComFlags);
if (!wavePickBestConsoleVoiceComId(FALSE, &WaveInConsoleVoiceComId, &WaveInConsoleVoiceComFlags)) {
if ((WaveInConsoleVoiceComId != OldWaveInConsoleVoiceComId) ||
(WaveInConsoleVoiceComFlags != OldWaveInConsoleVoiceComFlags))
{
// Squirt("RefreshPreferredDevices: different waveIn preference %d -> %d", OldWaveInConsoleVoiceComId, WaveInConsoleVoiceComId);
waveInSetCurrentConsoleVoiceComId(WaveInConsoleVoiceComId, WaveInConsoleVoiceComFlags);
}
}
midiOutGetCurrentPreferredId(&OldMidiOutPreferredId, NULL);
if (!midiOutPickBestId(&MidiOutPreferredId, WaveOutPreferredId)) {
if (MidiOutPreferredId != OldMidiOutPreferredId ||
!gfMidiOutPreferredMessageSent)
{
// Squirt("RefreshPreferredDevices: different midiOut preference %d -> %d", OldMidiOutPreferredId, MidiOutPreferredId);
midiOutSendPreferredMessage(TRUE);
midiOutSetCurrentPreferredId(MidiOutPreferredId);
midiOutSendPreferredMessage(FALSE);
}
}
// Squirt("RefreshPreferredDevices: return");
return;
}
void InvalidatePreferredDevices(void)
{
if (gpstrWoDefaultStringId) HeapFree(hHeap, 0, gpstrWoDefaultStringId);
if (gpstrWiDefaultStringId) HeapFree(hHeap, 0, gpstrWiDefaultStringId);
gpstrWoDefaultStringId = NULL;
gpstrWiDefaultStringId = NULL;
if (gpstrWoConsoleVoiceComStringId) HeapFree(hHeap, 0, gpstrWoConsoleVoiceComStringId);
if (gpstrWiConsoleVoiceComStringId) HeapFree(hHeap, 0, gpstrWiConsoleVoiceComStringId);
gpstrWoConsoleVoiceComStringId = NULL;
gpstrWiConsoleVoiceComStringId = NULL;
if (gpstrMoDefaultStringId) HeapFree(hHeap, 0, gpstrMoDefaultStringId);
gpstrMoDefaultStringId = NULL;
}
Copy Permalink