1414 lines
37 KiB
C
1414 lines
37 KiB
C
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
mmedia.c
|
|
|
|
Abstract:
|
|
|
|
Multimedia settings migration functions for Win2000
|
|
|
|
Author:
|
|
|
|
Calin Negreanu (calinn) 02-Dec-1997
|
|
|
|
Revision History:
|
|
|
|
Ovidiu Temereanca (ovidiut) 29-Jan-1999
|
|
Ovidiu Temereanca (ovidiut) 05-Apr-1999 See NT bug 313357 for the story of all #if 0
|
|
|
|
--*/
|
|
|
|
#include "pch.h"
|
|
#include "mmediap.h"
|
|
|
|
#include <initguid.h>
|
|
#include <dsound.h>
|
|
#include <dsprv.h> // windows\inc
|
|
|
|
|
|
POOLHANDLE g_MmediaPool = NULL;
|
|
|
|
#define MM_POOLGETMEM(STRUCT,COUNT) (STRUCT*)PoolMemGetMemory(g_MmediaPool,COUNT*sizeof(STRUCT))
|
|
|
|
|
|
static PCTSTR g_UserData = NULL;
|
|
static HKEY g_UserRoot = NULL;
|
|
|
|
|
|
typedef HRESULT (STDAPICALLTYPE *PFNDLLGETCLASSOBJECT)(REFCLSID, REFIID, LPVOID FAR*);
|
|
|
|
|
|
BOOL
|
|
pRestoreSystemValue (
|
|
IN PCTSTR KeyName,
|
|
IN PCTSTR Field, OPTIONAL
|
|
IN PCTSTR StrValue, OPTIONAL
|
|
OUT PDWORD NumValue
|
|
)
|
|
{
|
|
TCHAR Key[MEMDB_MAX];
|
|
|
|
MemDbBuildKey (Key, MEMDB_CATEGORY_MMEDIA_SYSTEM, KeyName, Field, StrValue);
|
|
return MemDbGetValue (Key, NumValue);
|
|
}
|
|
|
|
|
|
PVOID
|
|
pRestoreSystemBinaryValue (
|
|
IN PCTSTR KeyName,
|
|
IN PCTSTR Field, OPTIONAL
|
|
OUT PDWORD DataSize
|
|
)
|
|
{
|
|
TCHAR Key[MEMDB_MAX];
|
|
|
|
MemDbBuildKey (Key, MEMDB_CATEGORY_MMEDIA_SYSTEM, KeyName, Field, NULL);
|
|
return (PVOID)MemDbGetBinaryValue (Key, DataSize);
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMSystemMixerSettings (
|
|
VOID
|
|
)
|
|
{
|
|
#if 0
|
|
|
|
UINT MixerID, MixerMaxID;
|
|
HMIXER mixer;
|
|
MIXERCAPS mixerCaps;
|
|
MIXERLINE mixerLine, mixerLineSource;
|
|
MIXERLINECONTROLS mixerLineControls;
|
|
MIXERCONTROL* pmxControl;
|
|
MIXERCONTROLDETAILS mixerControlDetails;
|
|
LONG rc;
|
|
DWORD Dest, Src, Control;
|
|
TCHAR MixerKey[MAX_PATH], LineKey[MAX_PATH], SrcKey[MAX_PATH], SubKey[MAX_PATH];
|
|
DWORD ValuesCount;
|
|
DWORD Value;
|
|
PVOID SetData;
|
|
BOOL b;
|
|
|
|
if (!pRestoreSystemValue (S_MIXERNUMDEVS, NULL, NULL, &MixerMaxID)) {
|
|
return FALSE;
|
|
}
|
|
|
|
MixerID = mixerGetNumDevs ();
|
|
if (!MixerID) {
|
|
DEBUGMSG ((DBG_MMEDIA, "pRestoreMMSystemMixerSettings: mixerGetNumDevs returned 0"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (MixerMaxID != MixerID) {
|
|
return FALSE;
|
|
}
|
|
|
|
for (MixerID = 0; MixerID < MixerMaxID; MixerID++) {
|
|
|
|
rc = mixerGetDevCaps (MixerID, &mixerCaps, sizeof (MIXERCAPS));
|
|
if (rc != MMSYSERR_NOERROR) {
|
|
DEBUGMSG ((DBG_MMEDIA, "mixerGetDevCaps failed for mixer %lu [rc=%#X]. No settings will be restored.", MixerID, rc));
|
|
continue;
|
|
}
|
|
|
|
wsprintf (MixerKey, S_MIXERID, MixerID);
|
|
if (!pRestoreSystemValue (MixerKey, S_NUMLINES, NULL, &Value)) {
|
|
continue;
|
|
}
|
|
|
|
if (mixerCaps.cDestinations > Value) {
|
|
//
|
|
// only try to restore first Value lines
|
|
//
|
|
mixerCaps.cDestinations = Value;
|
|
}
|
|
|
|
rc = mixerOpen (&mixer, MixerID, 0L, 0L, MIXER_OBJECTF_MIXER);
|
|
if (rc != MMSYSERR_NOERROR) {
|
|
DEBUGMSG ((DBG_MMEDIA, "mixerOpen failed for mixer %lu [rc=%#X]. No settings will be restored.", MixerID, rc));
|
|
continue;
|
|
}
|
|
|
|
for (Dest = 0; Dest < mixerCaps.cDestinations; Dest++) {
|
|
|
|
ZeroMemory (&mixerLine, sizeof (MIXERLINE));
|
|
|
|
mixerLine.cbStruct = sizeof (MIXERLINE);
|
|
mixerLine.dwDestination = Dest;
|
|
|
|
rc = mixerGetLineInfo ((HMIXEROBJ)mixer, &mixerLine, MIXER_GETLINEINFOF_DESTINATION);
|
|
if (rc == MMSYSERR_NOERROR) {
|
|
|
|
wsprintf (LineKey, S_LINEID, Dest);
|
|
|
|
b = pRestoreSystemValue (MixerKey, LineKey, S_NUMSOURCES, &Value) &&
|
|
Value == mixerLine.cConnections;
|
|
|
|
b = b &&
|
|
pRestoreSystemValue (MixerKey, LineKey, S_NUMCONTROLS, &Value) &&
|
|
Value == mixerLine.cControls;
|
|
|
|
if (b && mixerLine.cControls > 0) {
|
|
//
|
|
// get all control values for the destination
|
|
//
|
|
ZeroMemory (&mixerLineControls, sizeof (MIXERLINECONTROLS));
|
|
|
|
mixerLineControls.cbStruct = sizeof (MIXERLINECONTROLS);
|
|
mixerLineControls.dwLineID = mixerLine.dwLineID;
|
|
mixerLineControls.cControls = mixerLine.cControls;
|
|
mixerLineControls.cbmxctrl = sizeof (MIXERCONTROL);
|
|
mixerLineControls.pamxctrl = MM_POOLGETMEM (MIXERCONTROL, mixerLineControls.cControls);
|
|
if (mixerLineControls.pamxctrl) {
|
|
|
|
rc = mixerGetLineControls((HMIXEROBJ)mixer, &mixerLineControls, MIXER_GETLINECONTROLSF_ALL);
|
|
if (rc == MMSYSERR_NOERROR) {
|
|
|
|
for (
|
|
Control = 0, pmxControl = mixerLineControls.pamxctrl;
|
|
Control < mixerLineControls.cControls;
|
|
Control++, pmxControl++
|
|
) {
|
|
|
|
ZeroMemory (&mixerControlDetails, sizeof (MIXERCONTROLDETAILS));
|
|
|
|
mixerControlDetails.cbStruct = sizeof (MIXERCONTROLDETAILS);
|
|
mixerControlDetails.dwControlID = pmxControl->dwControlID;
|
|
mixerControlDetails.cMultipleItems = pmxControl->cMultipleItems;
|
|
mixerControlDetails.cChannels = mixerLine.cChannels;
|
|
if (pmxControl->fdwControl & MIXERCONTROL_CONTROLF_UNIFORM) {
|
|
mixerControlDetails.cChannels = 1;
|
|
}
|
|
ValuesCount = mixerControlDetails.cChannels;
|
|
if (pmxControl->fdwControl & MIXERCONTROL_CONTROLF_MULTIPLE) {
|
|
ValuesCount *= mixerControlDetails.cMultipleItems;
|
|
}
|
|
mixerControlDetails.cbDetails = sizeof (DWORD);
|
|
wsprintf (SubKey, TEXT("%s\\%lu"), LineKey, Control);
|
|
SetData = pRestoreSystemBinaryValue (MixerKey, SubKey, &Value);
|
|
if (SetData &&
|
|
Value == ValuesCount * mixerControlDetails.cbDetails
|
|
) {
|
|
mixerControlDetails.paDetails = SetData;
|
|
rc = mixerSetControlDetails ((HMIXEROBJ)mixer, &mixerControlDetails, MIXER_SETCONTROLDETAILSF_VALUE);
|
|
if (rc != MMSYSERR_NOERROR) {
|
|
DEBUGMSG ((DBG_MMEDIA, "mixerSetControlDetails failed for mixer %lu, Line=%lu, Ctl=%lu [rc=%#X]", MixerID, Dest, Control, rc));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
DEBUGMSG ((DBG_MMEDIA, "mixerGetLineControls failed for mixer %lu, Line=%#X [rc=%#X].", MixerID, mixerLineControls.dwLineID, rc));
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// set this information for all source connections
|
|
//
|
|
for (Src = 0; Src < mixerLine.cConnections; Src++) {
|
|
|
|
ZeroMemory (&mixerLineSource, sizeof (MIXERLINE));
|
|
|
|
mixerLineSource.cbStruct = sizeof(MIXERLINE);
|
|
mixerLineSource.dwDestination = Dest;
|
|
mixerLineSource.dwSource = Src;
|
|
|
|
rc = mixerGetLineInfo((HMIXEROBJ)mixer, &mixerLineSource, MIXER_GETLINEINFOF_SOURCE);
|
|
if (rc == MMSYSERR_NOERROR) {
|
|
|
|
wsprintf (SrcKey, S_SRCID, Src);
|
|
wsprintf (SubKey, TEXT("%s\\%s"), SrcKey, S_NUMCONTROLS);
|
|
if (!pRestoreSystemValue (MixerKey, LineKey, SubKey, &Value) ||
|
|
Value != mixerLineSource.cControls ||
|
|
mixerLineSource.cControls <= 0
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// set all control values
|
|
//
|
|
ZeroMemory (&mixerLineControls, sizeof (MIXERLINECONTROLS));
|
|
|
|
mixerLineControls.cbStruct = sizeof (MIXERLINECONTROLS);
|
|
mixerLineControls.dwLineID = mixerLineSource.dwLineID;
|
|
mixerLineControls.cControls = mixerLineSource.cControls;
|
|
mixerLineControls.cbmxctrl = sizeof (MIXERCONTROL);
|
|
mixerLineControls.pamxctrl = MM_POOLGETMEM (MIXERCONTROL, mixerLineControls.cControls);
|
|
if (mixerLineControls.pamxctrl) {
|
|
|
|
rc = mixerGetLineControls((HMIXEROBJ)mixer, &mixerLineControls, MIXER_GETLINECONTROLSF_ALL);
|
|
if (rc == MMSYSERR_NOERROR) {
|
|
|
|
for (
|
|
Control = 0, pmxControl = mixerLineControls.pamxctrl;
|
|
Control < mixerLineControls.cControls;
|
|
Control++, pmxControl++
|
|
) {
|
|
|
|
ZeroMemory (&mixerControlDetails, sizeof (MIXERCONTROLDETAILS));
|
|
|
|
mixerControlDetails.cbStruct = sizeof (MIXERCONTROLDETAILS);
|
|
mixerControlDetails.dwControlID = pmxControl->dwControlID;
|
|
mixerControlDetails.cMultipleItems = pmxControl->cMultipleItems;
|
|
mixerControlDetails.cChannels = mixerLineSource.cChannels;
|
|
if (pmxControl->fdwControl & MIXERCONTROL_CONTROLF_UNIFORM) {
|
|
mixerControlDetails.cChannels = 1;
|
|
}
|
|
ValuesCount = mixerControlDetails.cChannels;
|
|
if (pmxControl->fdwControl & MIXERCONTROL_CONTROLF_MULTIPLE) {
|
|
ValuesCount *= mixerControlDetails.cMultipleItems;
|
|
}
|
|
mixerControlDetails.cbDetails = sizeof (DWORD);
|
|
wsprintf (SubKey, TEXT("%s\\%s\\%lu"), LineKey, SrcKey, Control);
|
|
SetData = pRestoreSystemBinaryValue (MixerKey, SubKey, &Value);
|
|
if (SetData &&
|
|
Value == ValuesCount * mixerControlDetails.cbDetails
|
|
) {
|
|
mixerControlDetails.paDetails = SetData;
|
|
rc = mixerSetControlDetails ((HMIXEROBJ)mixer, &mixerControlDetails, MIXER_SETCONTROLDETAILSF_VALUE);
|
|
if (rc != MMSYSERR_NOERROR) {
|
|
DEBUGMSG ((DBG_MMEDIA, "mixerSetControlDetails failed for mixer %lu, Line=%lu, Src=%lu, Ctl=%lu [rc=%#X]", MixerID, Dest, Src, Control, rc));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
DEBUGMSG ((DBG_MMEDIA, "mixerGetLineControls failed for mixer %lu, Src=%lu, Line=%#X [rc=%#X].", MixerID, Src, mixerLineControls.dwLineID, rc));
|
|
}
|
|
}
|
|
} else {
|
|
DEBUGMSG ((DBG_MMEDIA, "mixerGetLineInfo failed for mixer %lu, Src=%lu [rc=%#X].", MixerID, Src, rc));
|
|
}
|
|
}
|
|
} else {
|
|
DEBUGMSG ((DBG_MMEDIA, "mixerGetLineInfo failed for mixer %lu [rc=%#X]. No settings will be preserved.", MixerID, rc));
|
|
}
|
|
}
|
|
|
|
mixerClose (mixer);
|
|
}
|
|
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CALLBACK
|
|
pDSDeviceCountCallback (
|
|
IN PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_DATA pDSDescData,
|
|
IN LPVOID UserData
|
|
)
|
|
{
|
|
PDWORD pWaveDeviceCount;
|
|
|
|
//
|
|
// don't count emulated devices
|
|
//
|
|
if (pDSDescData->Type == DIRECTSOUNDDEVICE_TYPE_EMULATED) {
|
|
return TRUE;
|
|
}
|
|
|
|
pWaveDeviceCount = (PDWORD)UserData;
|
|
|
|
if (pDSDescData->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
|
|
|
|
pWaveDeviceCount[0]++;
|
|
|
|
} else if (pDSDescData->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
|
|
|
|
pWaveDeviceCount[1]++;
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pGetDSWaveCount (
|
|
IN LPKSPROPERTYSET pKsPropertySet,
|
|
OUT PDWORD pWaveDeviceCount
|
|
)
|
|
{
|
|
DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_DATA Data;
|
|
|
|
pWaveDeviceCount[0] = pWaveDeviceCount[1] = 0;
|
|
|
|
Data.Callback = pDSDeviceCountCallback;
|
|
Data.Context = pWaveDeviceCount;
|
|
if (FAILED (IKsPropertySet_Get (
|
|
pKsPropertySet,
|
|
&DSPROPSETID_DirectSoundDevice,
|
|
DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE,
|
|
NULL,
|
|
0,
|
|
&Data,
|
|
sizeof(Data),
|
|
NULL
|
|
))) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
typedef struct {
|
|
DWORD HWLevel;
|
|
DWORD SRCLevel;
|
|
DWORD SpeakerConfig;
|
|
DWORD SpeakerType;
|
|
} DS_DATA, *PDS_DATA;
|
|
|
|
|
|
typedef struct {
|
|
DWORD HWLevel;
|
|
DWORD SRCLevel;
|
|
} DSC_DATA, *PDSC_DATA;
|
|
|
|
|
|
BOOL
|
|
pRestoreDSValues (
|
|
IN DWORD DeviceID,
|
|
OUT PDS_DATA DSData
|
|
)
|
|
{
|
|
TCHAR Device[MAX_PATH];
|
|
|
|
wsprintf (Device, S_WAVEID, DeviceID);
|
|
|
|
if (!pRestoreSystemValue (Device, S_DIRECTSOUND, S_ACCELERATION, &DSData->HWLevel)) {
|
|
return FALSE;
|
|
}
|
|
if (!pRestoreSystemValue (Device, S_DIRECTSOUND, S_SRCQUALITY, &DSData->SRCLevel)) {
|
|
return FALSE;
|
|
}
|
|
if (!pRestoreSystemValue (Device, S_DIRECTSOUND, S_SPEAKERCONFIG, &DSData->SpeakerConfig)) {
|
|
return FALSE;
|
|
}
|
|
if (!pRestoreSystemValue (Device, S_DIRECTSOUND, S_SPEAKERTYPE, &DSData->SpeakerType)) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreDSCValues (
|
|
IN DWORD DeviceID,
|
|
OUT PDSC_DATA DSCData
|
|
)
|
|
{
|
|
TCHAR Device[MAX_PATH];
|
|
|
|
wsprintf (Device, S_WAVEID, DeviceID);
|
|
|
|
if (!pRestoreSystemValue (Device, S_DIRECTSOUNDCAPTURE, S_ACCELERATION, &DSCData->HWLevel)) {
|
|
return FALSE;
|
|
}
|
|
if (!pRestoreSystemValue (Device, S_DIRECTSOUNDCAPTURE, S_SRCQUALITY, &DSCData->SRCLevel)) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pSetDSValues (
|
|
IN LPKSPROPERTYSET pKsPropertySet,
|
|
IN REFGUID DeviceGuid,
|
|
IN const PDS_DATA Data
|
|
)
|
|
{
|
|
DSPROPERTY_DIRECTSOUNDBASICACCELERATION_ACCELERATION_DATA BasicAcceleration;
|
|
DSPROPERTY_DIRECTSOUNDMIXER_SRCQUALITY_DATA SrcQuality;
|
|
DSPROPERTY_DIRECTSOUNDPERSISTENTDATA_PERSISTDATA_DATA SpeakerConfig;
|
|
DSPROPERTY_DIRECTSOUNDPERSISTENTDATA_PERSISTDATA_DATA SpeakerType;
|
|
HRESULT hr;
|
|
|
|
BasicAcceleration.DeviceId = *DeviceGuid;
|
|
BasicAcceleration.Level = (DIRECTSOUNDBASICACCELERATION_LEVEL)Data->HWLevel;
|
|
hr = IKsPropertySet_Set (
|
|
pKsPropertySet,
|
|
&DSPROPSETID_DirectSoundBasicAcceleration,
|
|
DSPROPERTY_DIRECTSOUNDBASICACCELERATION_ACCELERATION,
|
|
NULL,
|
|
0,
|
|
&BasicAcceleration,
|
|
sizeof(BasicAcceleration)
|
|
);
|
|
|
|
if(SUCCEEDED (hr)) {
|
|
SrcQuality.DeviceId = *DeviceGuid;
|
|
SrcQuality.Quality = (DIRECTSOUNDMIXER_SRCQUALITY)Data->SRCLevel;
|
|
hr = IKsPropertySet_Set (
|
|
pKsPropertySet,
|
|
&DSPROPSETID_DirectSoundMixer,
|
|
DSPROPERTY_DIRECTSOUNDMIXER_SRCQUALITY,
|
|
NULL,
|
|
0,
|
|
&SrcQuality,
|
|
sizeof(SrcQuality)
|
|
);
|
|
}
|
|
|
|
if(SUCCEEDED (hr)) {
|
|
SpeakerConfig.DeviceId = *DeviceGuid;
|
|
SpeakerConfig.SubKeyName = S_SPEAKERCONFIG;
|
|
SpeakerConfig.ValueName = S_SPEAKERCONFIG;
|
|
SpeakerConfig.RegistryDataType = REG_DWORD;
|
|
SpeakerConfig.Data = &Data->SpeakerConfig;
|
|
SpeakerConfig.DataSize = sizeof(Data->SpeakerConfig);
|
|
|
|
hr = IKsPropertySet_Set (
|
|
pKsPropertySet,
|
|
&DSPROPSETID_DirectSoundPersistentData,
|
|
DSPROPERTY_DIRECTSOUNDPERSISTENTDATA_PERSISTDATA,
|
|
NULL,
|
|
0,
|
|
&SpeakerConfig,
|
|
sizeof(SpeakerConfig)
|
|
);
|
|
}
|
|
|
|
if(SUCCEEDED (hr)) {
|
|
SpeakerType.DeviceId = *DeviceGuid;
|
|
SpeakerType.SubKeyName = S_SPEAKERTYPE;
|
|
SpeakerType.ValueName = S_SPEAKERTYPE;
|
|
SpeakerType.RegistryDataType = REG_DWORD;
|
|
SpeakerType.Data = &Data->SpeakerType;
|
|
SpeakerType.DataSize = sizeof(Data->SpeakerType);
|
|
|
|
hr = IKsPropertySet_Set (
|
|
pKsPropertySet,
|
|
&DSPROPSETID_DirectSoundPersistentData,
|
|
DSPROPERTY_DIRECTSOUNDPERSISTENTDATA_PERSISTDATA,
|
|
NULL,
|
|
0,
|
|
&SpeakerType,
|
|
sizeof(SpeakerType)
|
|
);
|
|
}
|
|
|
|
return SUCCEEDED (hr);
|
|
}
|
|
|
|
|
|
BOOL
|
|
pSetDSCValues (
|
|
IN LPKSPROPERTYSET pKsPropertySet,
|
|
IN REFGUID DeviceGuid,
|
|
IN const PDSC_DATA Data
|
|
)
|
|
{
|
|
DSPROPERTY_DIRECTSOUNDBASICACCELERATION_ACCELERATION_DATA BasicAcceleration;
|
|
DSPROPERTY_DIRECTSOUNDMIXER_SRCQUALITY_DATA SrcQuality;
|
|
HRESULT hr;
|
|
|
|
BasicAcceleration.DeviceId = *DeviceGuid;
|
|
BasicAcceleration.Level = (DIRECTSOUNDBASICACCELERATION_LEVEL)Data->HWLevel;
|
|
hr = IKsPropertySet_Set (
|
|
pKsPropertySet,
|
|
&DSPROPSETID_DirectSoundBasicAcceleration,
|
|
DSPROPERTY_DIRECTSOUNDBASICACCELERATION_ACCELERATION,
|
|
NULL,
|
|
0,
|
|
&BasicAcceleration,
|
|
sizeof(BasicAcceleration)
|
|
);
|
|
|
|
if(SUCCEEDED (hr)) {
|
|
SrcQuality.DeviceId = *DeviceGuid;
|
|
SrcQuality.Quality = (DIRECTSOUNDMIXER_SRCQUALITY)Data->SRCLevel;
|
|
hr = IKsPropertySet_Set (
|
|
pKsPropertySet,
|
|
&DSPROPSETID_DirectSoundMixer,
|
|
DSPROPERTY_DIRECTSOUNDMIXER_SRCQUALITY,
|
|
NULL,
|
|
0,
|
|
&SrcQuality,
|
|
sizeof(SrcQuality)
|
|
);
|
|
}
|
|
|
|
return SUCCEEDED (hr);
|
|
}
|
|
|
|
|
|
BOOL
|
|
CALLBACK
|
|
pRestoreDeviceSettings (
|
|
IN PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_DATA pDSDescData,
|
|
IN LPVOID UserData
|
|
)
|
|
{
|
|
LPKSPROPERTYSET pKsPropertySet = (LPKSPROPERTYSET)UserData;
|
|
DS_DATA DSData;
|
|
DSC_DATA DSCData;
|
|
|
|
if (pDSDescData->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
|
|
|
|
if (pRestoreDSValues (pDSDescData->WaveDeviceId, &DSData)) {
|
|
|
|
pSetDSValues (
|
|
pKsPropertySet,
|
|
&pDSDescData->DeviceId,
|
|
&DSData
|
|
);
|
|
}
|
|
|
|
} else if (pDSDescData->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
|
|
|
|
if (pRestoreDSCValues (pDSDescData->WaveDeviceId, &DSCData)) {
|
|
|
|
pSetDSCValues (
|
|
pKsPropertySet,
|
|
&pDSDescData->DeviceId,
|
|
&DSCData
|
|
);
|
|
}
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreWaveDevicesDSSettings (
|
|
IN LPKSPROPERTYSET pKsPropertySet
|
|
)
|
|
{
|
|
DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_DATA Data;
|
|
HRESULT hr;
|
|
DWORD WaveNumDevs;
|
|
//
|
|
// array of 2 longs; first counts wave-out devices, second wave-ins
|
|
//
|
|
DWORD WaveDeviceCount[2];
|
|
|
|
if (!pGetDSWaveCount (pKsPropertySet, WaveDeviceCount)) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (!pRestoreSystemValue (S_WAVENUMDEVS, NULL, NULL, &WaveNumDevs)) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (WaveDeviceCount[0] != WaveNumDevs || WaveDeviceCount[1] != WaveNumDevs) {
|
|
DEBUGMSG ((DBG_MMEDIA, "pRestoreWaveDevicesDSSettings: number of wave devices changed, no settings will be restored"));
|
|
return FALSE;
|
|
}
|
|
|
|
Data.Callback = pRestoreDeviceSettings;
|
|
Data.Context = pKsPropertySet;
|
|
hr = IKsPropertySet_Get (
|
|
pKsPropertySet,
|
|
&DSPROPSETID_DirectSoundDevice,
|
|
DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE,
|
|
NULL,
|
|
0,
|
|
&Data,
|
|
sizeof(Data),
|
|
NULL
|
|
);
|
|
|
|
return SUCCEEDED (hr);
|
|
}
|
|
|
|
|
|
BOOL
|
|
pDirectSoundPrivateCreate (
|
|
IN HINSTANCE LibDsound,
|
|
OUT LPKSPROPERTYSET* ppKsPropertySet
|
|
)
|
|
{
|
|
PFNDLLGETCLASSOBJECT pfnDllGetClassObject = NULL;
|
|
LPCLASSFACTORY pClassFactory = NULL;
|
|
LPKSPROPERTYSET pKsPropertySet = NULL;
|
|
HRESULT hr = DS_OK;
|
|
|
|
pfnDllGetClassObject = (PFNDLLGETCLASSOBJECT)GetProcAddress (
|
|
LibDsound,
|
|
"DllGetClassObject"
|
|
);
|
|
if(!pfnDllGetClassObject) {
|
|
hr = DSERR_GENERIC;
|
|
}
|
|
|
|
if(SUCCEEDED(hr)) {
|
|
hr = pfnDllGetClassObject (
|
|
&CLSID_DirectSoundPrivate,
|
|
&IID_IClassFactory,
|
|
(LPVOID*)&pClassFactory
|
|
);
|
|
}
|
|
|
|
//
|
|
// Create the DirectSoundPrivate object and query for an IKsPropertySet interface
|
|
//
|
|
if(SUCCEEDED(hr)) {
|
|
hr = pClassFactory->lpVtbl->CreateInstance (
|
|
pClassFactory,
|
|
NULL,
|
|
&IID_IKsPropertySet,
|
|
(LPVOID*)&pKsPropertySet
|
|
);
|
|
}
|
|
|
|
// Release the class factory
|
|
if(pClassFactory) {
|
|
pClassFactory->lpVtbl->Release (pClassFactory);
|
|
}
|
|
|
|
// Handle final success or failure
|
|
if(SUCCEEDED(hr)) {
|
|
*ppKsPropertySet = pKsPropertySet;
|
|
}
|
|
else if(pKsPropertySet) {
|
|
IKsPropertySet_Release (pKsPropertySet);
|
|
}
|
|
|
|
return SUCCEEDED (hr);
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMSystemDirectSound (
|
|
VOID
|
|
)
|
|
{
|
|
#if 0
|
|
|
|
HINSTANCE LibDsound = NULL;
|
|
LPKSPROPERTYSET pKsPropertySet;
|
|
BOOL b = FALSE;
|
|
|
|
LibDsound = LoadLibrary (S_DSOUNDLIB);
|
|
if(LibDsound) {
|
|
|
|
if (pDirectSoundPrivateCreate (LibDsound, &pKsPropertySet)) {
|
|
|
|
b = pRestoreWaveDevicesDSSettings (pKsPropertySet);
|
|
|
|
IKsPropertySet_Release (pKsPropertySet);
|
|
}
|
|
|
|
FreeLibrary (LibDsound);
|
|
}
|
|
|
|
return b;
|
|
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMSystemCDSettings (
|
|
VOID
|
|
)
|
|
{
|
|
DWORD Unit, Volume;
|
|
HKEY key, keyUnit;
|
|
BYTE defDrive[4] = {0,0,0,0};
|
|
BYTE defVolume[8] = {0,0,0,0,0,0,0,0};
|
|
TCHAR unitKeyStr [MAX_TCHAR_PATH];
|
|
LONG rc;
|
|
BOOL b = FALSE;
|
|
|
|
if (pRestoreSystemValue (S_CDROM, S_DEFAULTDRIVE, NULL, &Unit)) {
|
|
|
|
defDrive [0] = (BYTE)Unit;
|
|
|
|
key = CreateRegKey (HKEY_LOCAL_MACHINE, S_SKEY_CDAUDIO);
|
|
if (key) {
|
|
|
|
rc = RegSetValueEx (key, S_DEFAULTDRIVE, 0, REG_BINARY, defDrive, sizeof(defDrive));
|
|
if (rc == ERROR_SUCCESS) {
|
|
|
|
if (pRestoreSystemValue (S_CDROM, S_VOLUMESETTINGS, NULL, &Volume)) {
|
|
|
|
wsprintf (unitKeyStr, S_SKEY_CDUNIT, Unit);
|
|
|
|
keyUnit = CreateRegKey (HKEY_LOCAL_MACHINE, unitKeyStr);
|
|
if (keyUnit) {
|
|
|
|
defVolume [4] = (BYTE)Volume;
|
|
|
|
rc = RegSetValueEx (
|
|
keyUnit,
|
|
S_VOLUMESETTINGS,
|
|
0,
|
|
REG_BINARY,
|
|
defVolume,
|
|
sizeof(defVolume)
|
|
);
|
|
|
|
b = (rc == ERROR_SUCCESS);
|
|
|
|
CloseRegKey (keyUnit);
|
|
}
|
|
}
|
|
}
|
|
CloseRegKey (key);
|
|
}
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMSystemMCISoundSettings (
|
|
VOID
|
|
)
|
|
{
|
|
TCHAR DriverName[MAX_PATH], Param[2];
|
|
DWORD Size, Value;
|
|
HKEY KeyMCI32;
|
|
BOOL b = FALSE;
|
|
LONG rc;
|
|
|
|
rc = TrackedRegOpenKeyEx (HKEY_LOCAL_MACHINE, S_SKEY_WINNT_MCI, 0, KEY_READ, &KeyMCI32);
|
|
if (rc == ERROR_SUCCESS) {
|
|
|
|
Size = sizeof (DriverName);
|
|
rc = RegQueryValueEx (KeyMCI32, S_WAVEAUDIO, NULL, NULL, (LPBYTE)DriverName, &Size);
|
|
if (rc == ERROR_SUCCESS) {
|
|
|
|
if (pRestoreSystemValue (S_MCI, S_WAVEAUDIO, NULL, &Value)) {
|
|
if (Value >= 2 && Value <= 9) {
|
|
|
|
wsprintf (Param, TEXT("%lu"), Value);
|
|
if (WriteProfileString (DriverName, S_WAVEAUDIO, Param)) {
|
|
b = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CloseRegKey (KeyMCI32);
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreUserValue (
|
|
IN PCTSTR KeyName,
|
|
IN PCTSTR Field, OPTIONAL
|
|
IN PCTSTR StrValue, OPTIONAL
|
|
OUT PDWORD NumValue
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pRestoreUserValue gets a numeric value from MemDB database,
|
|
specific for the current user.
|
|
|
|
Arguments:
|
|
|
|
KeyName - Specifies the name of key
|
|
|
|
Field - Specifies an optional field
|
|
|
|
StrValue - Specifies an optional value name
|
|
|
|
NumValue - Receives the value, if present
|
|
|
|
Return Value:
|
|
|
|
TRUE if value was present and read successfully, FALSE if not
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR Key[MEMDB_MAX];
|
|
|
|
MemDbBuildKey (Key, g_UserData, KeyName, Field, StrValue);
|
|
return MemDbGetValue (Key, NumValue);
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMUserPreferredOnly (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pRestoreMMUserPreferredOnly restores user's preference to use only
|
|
selected devices for playback and record
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE if settings were restored properly
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY soundMapperKey;
|
|
DWORD preferredOnly;
|
|
LONG rc;
|
|
BOOL b = FALSE;
|
|
|
|
if (pRestoreUserValue (S_AUDIO, S_PREFERREDONLY, NULL, &preferredOnly)) {
|
|
|
|
soundMapperKey = CreateRegKey (g_UserRoot, S_SKEY_SOUNDMAPPER);
|
|
if (soundMapperKey != NULL) {
|
|
|
|
rc = RegSetValueEx (
|
|
soundMapperKey,
|
|
S_PREFERREDONLY,
|
|
0,
|
|
REG_DWORD,
|
|
(PCBYTE)&preferredOnly,
|
|
sizeof (preferredOnly)
|
|
);
|
|
|
|
b = (rc == ERROR_SUCCESS);
|
|
|
|
CloseRegKey (soundMapperKey);
|
|
}
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMUserShowVolume (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pRestoreMMUserShowVolume restores user's preference to have Volume settings
|
|
displayed on the taskbar or not
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE if settings were restored properly
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY sysTrayKey;
|
|
DWORD ShowVolume;
|
|
PDWORD Services;
|
|
LONG rc;
|
|
BOOL b = FALSE;
|
|
|
|
if (pRestoreUserValue (S_AUDIO, S_SHOWVOLUME, NULL, &ShowVolume)) {
|
|
|
|
sysTrayKey = CreateRegKey (g_UserRoot, S_SKEY_SYSTRAY);
|
|
if (sysTrayKey != NULL) {
|
|
|
|
Services = GetRegValueDword (sysTrayKey, S_SERVICES);
|
|
if (Services != NULL) {
|
|
|
|
if (ShowVolume) {
|
|
*Services |= SERVICE_SHOWVOLUME;
|
|
} else {
|
|
*Services &= ~SERVICE_SHOWVOLUME;
|
|
}
|
|
|
|
rc = RegSetValueEx (
|
|
sysTrayKey,
|
|
S_SERVICES,
|
|
0,
|
|
REG_DWORD,
|
|
(PCBYTE)Services,
|
|
sizeof (*Services)
|
|
);
|
|
|
|
b = (rc == ERROR_SUCCESS);
|
|
|
|
MemFreeWrapper (Services);
|
|
}
|
|
|
|
CloseRegKey (sysTrayKey);
|
|
}
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMUserVideoSettings (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pRestoreMMUserVideoSettings restores user's preferred Video for Windows settings.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE if settings were restored properly
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY videoSetKey;
|
|
DWORD VideoSettings;
|
|
LONG rc;
|
|
BOOL b = FALSE;
|
|
|
|
if (pRestoreUserValue (S_VIDEO, S_VIDEOSETTINGS, NULL, &VideoSettings)) {
|
|
|
|
videoSetKey = CreateRegKey (g_UserRoot, S_SKEY_VIDEOUSER);
|
|
if (videoSetKey != NULL) {
|
|
|
|
rc = RegSetValueEx (
|
|
videoSetKey,
|
|
S_DEFAULTOPTIONS,
|
|
0,
|
|
REG_DWORD,
|
|
(PCBYTE)&VideoSettings,
|
|
sizeof (VideoSettings)
|
|
);
|
|
|
|
b = (rc == ERROR_SUCCESS);
|
|
|
|
CloseRegKey (videoSetKey);
|
|
}
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMUserPreferredPlayback (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pRestoreMMUserPreferredPlayback restores user's preferred playback device.
|
|
If the system doesn't have at least 2 wave out devices, nothing is changed.
|
|
If there are multiple devices, selection is based on the device ID number,
|
|
which is supposed to be left unchanged.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE if settings were restored properly
|
|
|
|
--*/
|
|
|
|
{
|
|
#if 0
|
|
|
|
HKEY soundMapperKey;
|
|
UINT waveOutNumDevs;
|
|
DWORD UserPlayback, Value;
|
|
WAVEOUTCAPS waveOutCaps;
|
|
LONG rc;
|
|
|
|
BOOL b = FALSE;
|
|
|
|
waveOutNumDevs = waveOutGetNumDevs();
|
|
if (!waveOutNumDevs) {
|
|
DEBUGMSG ((DBG_MMEDIA, "pRestoreMMUserPreferredPlayback: waveOutGetNumDevs returned 0"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (waveOutNumDevs <= 1) {
|
|
return TRUE;
|
|
}
|
|
|
|
if (!pRestoreSystemValue (S_WAVEOUTNUMDEVS, NULL, NULL, &Value) ||
|
|
Value != (DWORD)waveOutNumDevs) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (pRestoreUserValue (S_AUDIO, S_PREFERREDPLAY, NULL, &UserPlayback)) {
|
|
|
|
rc = waveOutGetDevCaps (UserPlayback, &waveOutCaps, sizeof (waveOutCaps));
|
|
if (rc == MMSYSERR_NOERROR) {
|
|
|
|
soundMapperKey = CreateRegKey (g_UserRoot, S_SKEY_SOUNDMAPPER);
|
|
if (soundMapperKey != NULL) {
|
|
|
|
rc = RegSetValueEx (
|
|
soundMapperKey,
|
|
S_PLAYBACK,
|
|
0,
|
|
REG_SZ,
|
|
(PCBYTE)waveOutCaps.szPname,
|
|
SizeOfString (waveOutCaps.szPname)
|
|
);
|
|
|
|
b = (rc == ERROR_SUCCESS);
|
|
|
|
CloseRegKey (soundMapperKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
return b;
|
|
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMUserPreferredRecord (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pRestoreMMUserPreferredRecord restores user's preferred record device.
|
|
If the system doesn't have at least 2 wave in devices, nothing is changed.
|
|
If there are multiple devices, selection is based on the device ID number,
|
|
which is supposed to be left unchanged.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE if settings were restored properly
|
|
|
|
--*/
|
|
|
|
{
|
|
#if 0
|
|
|
|
HKEY soundMapperKey;
|
|
UINT waveInNumDevs;
|
|
DWORD UserRecord, Value;
|
|
WAVEINCAPS waveInCaps;
|
|
LONG rc;
|
|
BOOL b = FALSE;
|
|
|
|
waveInNumDevs = waveInGetNumDevs();
|
|
if (!waveInNumDevs) {
|
|
DEBUGMSG ((DBG_MMEDIA, "pRestoreMMUserPreferredRecord: waveInGetNumDevs returned 0"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (waveInNumDevs <= 1) {
|
|
return TRUE;
|
|
}
|
|
|
|
if (!pRestoreSystemValue (S_WAVEINNUMDEVS, NULL, NULL, &Value) ||
|
|
Value != (DWORD)waveInNumDevs) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (pRestoreUserValue (S_AUDIO, S_PREFERREDREC, NULL, &UserRecord)) {
|
|
|
|
rc = waveInGetDevCaps (UserRecord, &waveInCaps, sizeof (waveInCaps));
|
|
if (rc == MMSYSERR_NOERROR) {
|
|
|
|
soundMapperKey = CreateRegKey (g_UserRoot, S_SKEY_SOUNDMAPPER);
|
|
if (soundMapperKey != NULL) {
|
|
|
|
rc = RegSetValueEx (
|
|
soundMapperKey,
|
|
S_RECORD,
|
|
0,
|
|
REG_SZ,
|
|
(PCBYTE)waveInCaps.szPname,
|
|
SizeOfString (waveInCaps.szPname)
|
|
);
|
|
|
|
b = (rc == ERROR_SUCCESS);
|
|
|
|
CloseRegKey (soundMapperKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
return b;
|
|
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRestoreMMUserSndVol32 (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pRestoreMMUserSndVol32 restores SndVol32 options for the current user
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE if settings were restored properly
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY Options;
|
|
PDWORD Style;
|
|
DWORD NewStyle;
|
|
BOOL ShowAdvanced;
|
|
|
|
#if 0
|
|
|
|
HKEY VolControl, MixerKey;
|
|
DWORD Value;
|
|
UINT MixerID, MixerMaxID;
|
|
MIXERCAPS mixerCaps;
|
|
TCHAR MixerNum[MAX_PATH];
|
|
LONG rc;
|
|
|
|
#endif
|
|
|
|
if (pRestoreUserValue (S_SNDVOL32, S_SHOWADVANCED, NULL, &ShowAdvanced)) {
|
|
|
|
Options = CreateRegKey (g_UserRoot, S_SKEY_VOLCTL_OPTIONS);
|
|
if (Options != NULL) {
|
|
|
|
Style = GetRegValueDword (Options, S_STYLE);
|
|
if (Style != NULL) {
|
|
NewStyle = *Style;
|
|
MemFreeWrapper (Style);
|
|
} else {
|
|
NewStyle = 0;
|
|
}
|
|
|
|
if (ShowAdvanced) {
|
|
NewStyle |= STYLE_SHOWADVANCED;
|
|
} else {
|
|
NewStyle &= ~STYLE_SHOWADVANCED;
|
|
}
|
|
|
|
RegSetValueEx (
|
|
Options,
|
|
S_STYLE,
|
|
0,
|
|
REG_DWORD,
|
|
(PCBYTE)&NewStyle,
|
|
sizeof (NewStyle)
|
|
);
|
|
|
|
CloseRegKey (Options);
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
|
|
//
|
|
// restore window position for each mixer device
|
|
//
|
|
if (!pRestoreSystemValue (S_MIXERNUMDEVS, NULL, NULL, &MixerMaxID)) {
|
|
return FALSE;
|
|
}
|
|
|
|
MixerID = mixerGetNumDevs ();
|
|
if (!MixerID) {
|
|
DEBUGMSG ((DBG_MMEDIA, "pRestoreMMUserSndVol32: mixerGetNumDevs returned 0"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (MixerMaxID != MixerID) {
|
|
return FALSE;
|
|
}
|
|
|
|
VolControl = CreateRegKey (g_UserRoot, S_SKEY_VOLUMECONTROL);
|
|
if (VolControl != NULL) {
|
|
|
|
for (MixerID = 0; MixerID < MixerMaxID; MixerID++) {
|
|
|
|
rc = mixerGetDevCaps (MixerID, &mixerCaps, sizeof (MIXERCAPS));
|
|
if (rc == MMSYSERR_NOERROR) {
|
|
|
|
wsprintf (MixerNum, S_MIXERID, MixerID);
|
|
|
|
MixerKey = CreateRegKey (VolControl, mixerCaps.szPname);
|
|
if (MixerKey) {
|
|
|
|
if (pRestoreUserValue (S_SNDVOL32, MixerNum, S_X, &Value)) {
|
|
RegSetValueEx (
|
|
MixerKey,
|
|
S_X,
|
|
0,
|
|
REG_DWORD,
|
|
(PCBYTE)&Value,
|
|
sizeof (Value)
|
|
);
|
|
}
|
|
if (pRestoreUserValue (S_SNDVOL32, MixerNum, S_Y, &Value)) {
|
|
RegSetValueEx (
|
|
MixerKey,
|
|
S_Y,
|
|
0,
|
|
REG_DWORD,
|
|
(PCBYTE)&Value,
|
|
sizeof (Value)
|
|
);
|
|
}
|
|
|
|
CloseRegKey (MixerKey);
|
|
}
|
|
}
|
|
}
|
|
|
|
CloseRegKey (VolControl);
|
|
}
|
|
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pPreserveCurrentSoundScheme (
|
|
VOID
|
|
)
|
|
{
|
|
HKEY Sounds;
|
|
LONG rc = E_FAIL;
|
|
|
|
//
|
|
// if WinMM finds HKCU\Control Panel\Sounds [SystemDefault] = ","
|
|
// it doesn't override user's current sound scheme
|
|
//
|
|
Sounds = CreateRegKey (g_UserRoot, S_SKEY_CPANEL_SOUNDS);
|
|
if (Sounds != NULL) {
|
|
|
|
rc = RegSetValueEx (
|
|
Sounds,
|
|
S_SYSTEMDEFAULT,
|
|
0,
|
|
REG_SZ,
|
|
(PCBYTE)S_DUMMYVALUE,
|
|
SizeOfString (S_DUMMYVALUE)
|
|
);
|
|
|
|
CloseRegKey (Sounds);
|
|
}
|
|
|
|
return rc == ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
#define DEFMAC(Item) pRestore##Item,
|
|
|
|
static MM_SETTING_ACTION g_MMRestoreSystemSettings [] = {
|
|
MM_SYSTEM_SETTINGS
|
|
};
|
|
|
|
static MM_SETTING_ACTION g_MMRestoreUserSettings [] = {
|
|
MM_USER_SETTINGS
|
|
};
|
|
|
|
#undef DEFMAC
|
|
|
|
|
|
BOOL
|
|
RestoreMMSettings_System (
|
|
VOID
|
|
)
|
|
{
|
|
int i;
|
|
|
|
g_MmediaPool = PoolMemInitNamedPool ("MMediaNT");
|
|
if (!g_MmediaPool) {
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < sizeof (g_MMRestoreSystemSettings) / sizeof (MM_SETTING_ACTION); i++) {
|
|
(* g_MMRestoreSystemSettings[i]) ();
|
|
}
|
|
|
|
PoolMemDestroyPool (g_MmediaPool);
|
|
g_MmediaPool = NULL;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
RestoreMMSettings_User (
|
|
IN PCTSTR UserName,
|
|
IN HKEY UserRoot
|
|
)
|
|
{
|
|
INT i;
|
|
|
|
if (!UserName || UserName[0] == 0) {
|
|
return TRUE;
|
|
}
|
|
|
|
MYASSERT (g_UserData == NULL);
|
|
g_UserData = JoinPaths (MEMDB_CATEGORY_MMEDIA_USERS, UserName);
|
|
g_UserRoot = UserRoot;
|
|
|
|
__try {
|
|
for (i = 0; i < sizeof (g_MMRestoreUserSettings) / sizeof (MM_SETTING_ACTION); i++) {
|
|
(* g_MMRestoreUserSettings[i]) ();
|
|
}
|
|
|
|
//
|
|
// special action to prevent WinMM overriding current sound scheme
|
|
//
|
|
pPreserveCurrentSoundScheme ();
|
|
}
|
|
__finally {
|
|
FreePathString (g_UserData);
|
|
g_UserData = NULL;
|
|
g_UserRoot = NULL;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|