Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/windows/media/winmm/winmm.c

1873 lines
60 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/****************************************************************************\
*
* Module Name : winmm.c
*
* Multimedia support library
*
* This module contains the entry point, startup and termination code
*
* Copyright (c) 1992 Microsoft Corporation
*
\****************************************************************************/
#define UNICODE
#include "nt.h"
#include "ntrtl.h"
#include "nturtl.h"
#include "winmmi.h"
#include "mmioi.h"
#include "mci.h"
#include <regstr.h>
#define _INC_WOW_CONVERSIONS
#include "mmwow32.h"
BOOL WaveInit(void);
BOOL MidiInit(void);
BOOL AuxInit(void);
void InitDevices(void);
void InitHandles(void);
HANDLE mmDrvOpen(LPWSTR szAlias);
void WOWAppExit(HANDLE hTask);
void MigrateSoundEvents(void);
STATIC void NEAR PASCAL mregAddIniScheme(LPTSTR lszSection,
LPTSTR lszSchemeID,
LPTSTR lszSchemeName,
LPTSTR lszINI);
STATIC void NEAR PASCAL mregCreateSchemeID(LPTSTR szSchemeName, LPTSTR szSchemeID);
int lstrncmpi (LPTSTR pszA, LPTSTR pszB, size_t cch);
void RemoveMediaPath (LPTSTR pszTarget, LPTSTR pszSource);
#ifndef cchLENGTH
#define cchLENGTH(_sz) (sizeof(_sz) / sizeof(_sz[0]))
#endif
/****************************************************************************
global data
****************************************************************************/
HANDLE ghInst; // Module handle
BOOL WinmmRunningInServer; // Are we running in the user/base server?
BOOL WinmmRunningInWOW; // Are we running in WOW
CRITICAL_SECTION DriverListCritSec; // Protect driver interface globals
CRITICAL_SECTION DriverLoadFreeCritSec; // Protect driver load/unload
CRITICAL_SECTION MapperInitCritSec; // Protect test of mapper initialized
MIDIDRV midioutdrv[MAXMIDIDRIVERS+1]; // midi output device driver list
MIDIDRV midiindrv[MAXMIDIDRIVERS+1]; // midi input device driver list
WAVEDRV waveoutdrv[MAXWAVEDRIVERS+1]; // wave output device driver list
WAVEDRV waveindrv[MAXWAVEDRIVERS+1]; // wave input device driver list
AUXDRV auxdrv[MAXAUXDRIVERS+1]; // aux device driver list
UINT wTotalMidiOutDevs; // total midi output devices
UINT wTotalMidiInDevs; // total midi input devices
UINT wTotalWaveOutDevs; // total wave output devices
UINT wTotalWaveInDevs; // total wave input devices
UINT wTotalAuxDevs; // total auxiliary output devices
#ifdef DEBUG_RETAIL
BYTE fIdReverse; // reverse wave/midi id's
#endif
// For sounds:
STATIC TCHAR gszControlIniTime[] = TEXT("ControlIniTimeStamp");
TCHAR gszControlPanel[] = TEXT("Control Panel");
TCHAR gszSchemesRootKey[] = TEXT("AppEvents\\Schemes");
TCHAR gszJustSchemesKey[] = TEXT("Schemes");
TCHAR aszExplorer[] = TEXT("Explorer");
TCHAR aszDefault[] = TEXT(".Default");
TCHAR aszCurrent[] = TEXT(".Current");
TCHAR gszAppEventsKey[] = TEXT("AppEvents");
TCHAR gszSchemeAppsKey[] = TEXT("Apps");
TCHAR aszSoundsSection[] = TEXT("Sounds");
TCHAR aszSoundSection[] = TEXT("Sound");
TCHAR aszActiveKey[] = TEXT("Active");
TCHAR aszBoolOne[] = TEXT("1");
TCHAR asz2Format[] = TEXT("%s\\%s");
TCHAR asz3Format[] = TEXT("%s\\%s\\%s");
TCHAR asz4Format[] = TEXT("%s\\%s\\%s\\%s");
TCHAR asz5Format[] = TEXT("%s\\%s\\%s\\%s\\%s");
TCHAR asz6Format[] = TEXT("%s\\%s\\%s\\%s\\%s\\%s");
STATIC TCHAR aszSchemeLabelsKey[] = TEXT("EventLabels");
STATIC TCHAR aszSchemeNamesKey[] = TEXT("Names");
STATIC TCHAR aszControlINI[] = TEXT("control.ini");
STATIC TCHAR aszWinINI[] = TEXT("win.ini");
STATIC TCHAR aszSchemesSection[] = TEXT("SoundSchemes");
STATIC TCHAR gszSoundScheme[] = TEXT("SoundScheme.%s");
STATIC TCHAR aszCurrentSection[] = TEXT("Current");
STATIC TCHAR aszYourOldScheme[] = TEXT("Your Old Scheme");
STATIC TCHAR aszNone[] = TEXT("<none>");
STATIC TCHAR aszDummyDrv[] = TEXT("mmsystem.dll");
STATIC TCHAR aszDummySnd[] = TEXT("SystemDefault");
STATIC TCHAR aszDummySndValue[] = TEXT(",");
STATIC TCHAR aszExtendedSounds[] = TEXT("ExtendedSounds");
STATIC TCHAR aszExtendedSoundsYes[] = TEXT("yes");
STATIC TCHAR gszApp[] = TEXT("App");
STATIC TCHAR gszSystem[] = TEXT("System");
STATIC TCHAR gszAsterisk[] = TEXT("Asterisk");
STATIC TCHAR gszDefault[] = TEXT("Default");
STATIC TCHAR gszExclamation[] = TEXT("Exclamation");
STATIC TCHAR gszExit[] = TEXT("Exit");
STATIC TCHAR gszQuestion[] = TEXT("Question");
STATIC TCHAR gszStart[] = TEXT("Start");
STATIC TCHAR gszHand[] = TEXT("Hand");
STATIC TCHAR gszClose[] = TEXT("Close");
STATIC TCHAR gszMaximize[] = TEXT("Maximize");
STATIC TCHAR gszMinimize[] = TEXT("Minimize");
STATIC TCHAR gszOpen[] = TEXT("Open");
STATIC TCHAR gszRestoreDown[] = TEXT("RestoreDown");
STATIC TCHAR gszRestoreUp[] = TEXT("RestoreUp");
STATIC TCHAR aszOptionalClips[] = REGSTR_PATH_SETUP REGSTR_KEY_SETUP TEXT("\\OptionalComponents\\Clips");
STATIC TCHAR aszInstalled[] = TEXT("Installed");
STATIC TCHAR * gpszSounds[] = {
gszClose,
gszMaximize,
gszMinimize,
gszOpen,
gszRestoreDown,
gszRestoreUp,
gszAsterisk,
gszDefault,
gszExclamation,
gszExit,
gszQuestion,
gszStart,
gszHand
};
STATIC TCHAR aszMigration[] = TEXT("Migrated Schemes");
#define wCurrentSchemeMigrationLEVEL 1
static struct {
LPCTSTR pszEvent;
int idDescription;
LPCTSTR pszApp;
} gaEventLabels[] = {
{ TEXT("AppGPFault"), STR_LABEL_APPGPFAULT, aszDefault },
{ TEXT("Close"), STR_LABEL_CLOSE, aszDefault },
{ TEXT("EmptyRecycleBin"), STR_LABEL_EMPTYRECYCLEBIN, aszExplorer },
{ TEXT("Maximize"), STR_LABEL_MAXIMIZE, aszDefault },
{ TEXT("MenuCommand"), STR_LABEL_MENUCOMMAND, aszDefault },
{ TEXT("MenuPopup"), STR_LABEL_MENUPOPUP, aszDefault },
{ TEXT("Minimize"), STR_LABEL_MINIMIZE, aszDefault },
{ TEXT("Open"), STR_LABEL_OPEN, aszDefault },
{ TEXT("RestoreDown"), STR_LABEL_RESTOREDOWN, aszDefault },
{ TEXT("RestoreUp"), STR_LABEL_RESTOREUP, aszDefault },
{ TEXT("RingIn"), STR_LABEL_RINGIN, aszDefault },
{ TEXT("RingOut"), STR_LABEL_RINGOUT, aszDefault },
{ TEXT("SystemAsterisk"), STR_LABEL_SYSTEMASTERISK, aszDefault },
{ TEXT(".Default"), STR_LABEL_SYSTEMDEFAULT, aszDefault },
{ TEXT("SystemExclamation"), STR_LABEL_SYSTEMEXCLAMATION, aszDefault },
{ TEXT("SystemExit"), STR_LABEL_SYSTEMEXIT, aszDefault },
{ TEXT("SystemHand"), STR_LABEL_SYSTEMHAND, aszDefault },
{ TEXT("SystemQuestion"), STR_LABEL_SYSTEMQUESTION, aszDefault },
{ TEXT("SystemStart"), STR_LABEL_SYSTEMSTART, aszDefault },
};
TCHAR gszDefaultBeepOldAlias[] = TEXT("SystemDefault");
#define nEVENTLABELS (sizeof(gaEventLabels)/sizeof(gaEventLabels[0]))
STATIC TCHAR gszChimes[] = TEXT("chimes.wav");
STATIC TCHAR gszDing[] = TEXT("ding.wav");
STATIC TCHAR gszTada[] = TEXT("tada.wav");
STATIC TCHAR gszChord[] = TEXT("chord.wav");
STATIC TCHAR * gpszKnownWAVFiles[] = {
gszChord,
gszTada,
gszChimes,
gszDing,
};
#define INISECTION 768
#define BIGINISECTION 2048
TCHAR szNull[] = TEXT("");
TCHAR aszSetup[] = REGSTR_PATH_SETUP;
TCHAR aszValMedia[] = REGSTR_VAL_MEDIA;
TCHAR aszValMediaUnexpanded[] = TEXT("MediaPathUnexpanded");
extern HANDLE hInstalledDriverList; // List of installed driver instances
extern int cInstalledDrivers; // High water count of installed driver instances
/**************************************************************************
@doc EXTERNAL
@api BOOL | DllInstanceInit | This procedure is called whenever a
process attaches or detaches from the DLL.
@parm PVOID | hModule | Handle of the DLL.
@parm ULONG | Reason | What the reason for the call is.
@parm PCONTEXT | pContext | Some random other information.
@rdesc The return value is TRUE if the initialisation completed ok,
FALSE if not.
**************************************************************************/
BOOL DllInstanceInit(PVOID hModule, ULONG Reason, PCONTEXT pContext)
{
PIMAGE_NT_HEADERS NtHeaders; // For checking if we're in the
HANDLE hModWow32;
// server.
ghInst = (HANDLE) hModule;
DBG_UNREFERENCED_PARAMETER(pContext);
if (Reason == DLL_PROCESS_ATTACH) {
#if DBG
CHAR strname[MAX_PATH];
GetModuleFileNameA(NULL, strname, sizeof(strname));
dprintf2(("Process attaching, exe=%hs (Pid %x Tid %x)", strname, GetCurrentProcessId(), GetCurrentThreadId()));
#endif
//
// We don't need to know when threads start
//
DisableThreadLibraryCalls(hModule);
//
// Get access to the process heap. This is cheaper in terms of
// overall resource being chewed up than creating our own heap.
//
hHeap = RtlProcessHeap();
if (hHeap == NULL) {
return FALSE;
}
//
// Find out if we're in WOW
//
if ( (hModWow32 = GetModuleHandleW( L"WOW32.DLL" )) != NULL ) {
WinmmRunningInWOW = TRUE;
GetVDMPointer =
(LPGETVDMPOINTER)GetProcAddress( hModWow32, "WOWGetVDMPointer");
lpWOWHandle32 =
(LPWOWHANDLE32)GetProcAddress( hModWow32, "WOWHandle32" );
lpWOWHandle16 =
(LPWOWHANDLE16)GetProcAddress( hModWow32, "WOWHandle16" );
}
else {
WinmmRunningInWOW = FALSE;
}
//
// Find out if we're in the server
//
NtHeaders = RtlImageNtHeader(NtCurrentPeb()->ImageBaseAddress);
WinmmRunningInServer =
(NtHeaders->OptionalHeader.Subsystem != IMAGE_SUBSYSTEM_WINDOWS_CUI) &&
(NtHeaders->OptionalHeader.Subsystem != IMAGE_SUBSYSTEM_WINDOWS_GUI);
InitializeCriticalSection(&DriverListCritSec);
InitializeCriticalSection(&DriverLoadFreeCritSec);
InitializeCriticalSection(&MapperInitCritSec);
InitDebugLevel();
InitHandles();
mciInitCrit();
InitDevices();
// it is important that the MCI window initialisation is done AFTER
// we have initialised Wave, Midi, etc. devices. Note the server
// uses Wave devices, but nothing else (e.g. MCI, midi...)
if (!WinmmRunningInServer) {
mciGlobalInit();
} else {
InitializeCriticalSection(&mciGlobalCritSec);
}
InitializeCriticalSection(&WavHdrCritSec);
InitializeCriticalSection(&SoundCritSec);
InitializeCriticalSection(&midiStrmHdrCritSec);
} else if (Reason == DLL_PROCESS_DETACH) {
dprintf2(("Process ending (Pid %x Tid %x)", GetCurrentProcessId(), GetCurrentThreadId()));
if (!WinmmRunningInServer) {
TimeCleanup(0); // DLL cleanup
}
DeleteCriticalSection(&HandleListCritSec);
mciCleanup();
mmRegFree();
DeleteCriticalSection(&WavHdrCritSec);
DeleteCriticalSection(&SoundCritSec);
DeleteCriticalSection(&midiStrmHdrCritSec);
DeleteCriticalSection(&DriverListCritSec);
DeleteCriticalSection(&DriverLoadFreeCritSec);
DeleteCriticalSection(&MapperInitCritSec);
if (hInstalledDriverList)
{
GlobalFree ((HGLOBAL)hInstalledDriverList);
hInstalledDriverList = NULL;
cInstalledDrivers = 0; // Count of installed drivers
}
} else if (Reason == 999) {
// This is a dummy call to an entry point in ADVAPI32.DLL. By
// statically linking to the library we avoid the following:
// An application links to winmm.dll and advapi32.dll
// When the application loads the list of dependent dlls is built,
// and a list of the dll init routines is created. It happens
// that the winmm init routine is called first.
// IF there is a sound card in the system, winmm's dll init routine
// call LoadLibrary on the sound driver DLL. This DLL WILL
// reference advapi32.dll - and call entry points in advapi32.
// Unfortunately the init routine of advapi32.dll is marked as
// having RUN - although that is not yet the case as we are still
// within the load routine for winmm.
// When the advapi32 entry point runs, it relies on its init
// routine having completed; specifically a CriticalSection should
// have been initialised. This is not the case, and BOOM!
// The workaround is to ensure that advapi32.dll runs its init
// routine first. This is done by making sure that WINMM has a
// static link to the dll.
ImpersonateSelf(999); // This routine will never be called.
// If it is called, it will fail.
}
return TRUE;
}
/*****************************************************************************
* @doc EXTERNAL MMSYSTEM
*
* @api void | WOWAppExit | This function cleans up when a (WOW) application
* terminates.
*
* @parm HANDLE | hTask | Thread id of application (equivalent to windows task
* handle).
*
* @rdesc Nothing
*
* @comm Note that NOT ALL threads are WOW threads. We rely here on the
* fact that ONLY MCI creates threads other than WOW threads which
* use our low level device resources.
*
* Note also that once a thread is inside here no other threads can
* go through here so, since we clean up MCI devices first, their
* low level devices will be freed before we get to their threads.
*
****************************************************************************/
void WOWAppExit(HANDLE hTask)
{
MCIDEVICEID DeviceID;
HANDLE h, hNext;
dprintf3(("WOW Multi-media - thread %x exiting", (UINT)hTask));
//
// Free MCI devices allocated by this task (thread).
//
EnterCriticalSection(&mciCritSec);
for (DeviceID=1; DeviceID < MCI_wNextDeviceID; DeviceID++)
{
if (MCI_VALID_DEVICE_ID(DeviceID) &&
MCI_lpDeviceList[DeviceID]->hCreatorTask == hTask)
{
//
// Note that the loop control variables are globals so will be
// reloaded on each iteration.
//
// Also no new devices will be opened by APPs because this is WOW
//
// Hence it's safe (and essential!) to leave the critical
// section which we send the close command
//
dprintf2(("MCI device %ls (%d) not released.", MCI_lpDeviceList[DeviceID]->lpstrInstallName, DeviceID));
LeaveCriticalSection(&mciCritSec);
mciSendCommandW(DeviceID, MCI_CLOSE, 0, 0);
EnterCriticalSection(&mciCritSec);
}
}
LeaveCriticalSection(&mciCritSec);
//
// Free any timers
//
TimeCleanup((DWORD)hTask);
//
// free all WAVE/MIDI/MMIO handles
//
EnterCriticalSection(&HandleListCritSec);
h = GetHandleFirst();
while (h)
{
hNext = GetHandleNext(h);
if (GetHandleOwner(h) == hTask)
{
HANDLE hdrvDestroy;
//
// hack for the wave/midi mapper, always free handles backward.
//
if (hNext && GetHandleOwner(hNext) == hTask) {
h = hNext;
continue;
}
//
// do this so even if the close fails we will not
// find it again.
//
SetHandleOwner(h, NULL);
//
// set the hdrvDestroy global so DriverCallback will not
// do anything for this device
//
hdrvDestroy = h;
switch(GetHandleType(h))
{
case TYPE_WAVEOUT:
dprintf1(("WaveOut handle (%04X) was not released.", h));
waveOutReset((HWAVEOUT)h);
waveOutClose((HWAVEOUT)h);
break;
case TYPE_WAVEIN:
dprintf1(("WaveIn handle (%04X) was not released.", h));
waveInReset((HWAVEIN)h);
waveInClose((HWAVEIN)h);
break;
case TYPE_MIDIOUT:
dprintf1(("MidiOut handle (%04X) was not released.", h));
midiOutReset((HMIDIOUT)h);
midiOutClose((HMIDIOUT)h);
break;
case TYPE_MIDIIN:
dprintf1(("MidiIn handle (%04X) was not released.", h));
midiInReset((HMIDIIN)h);
midiInClose((HMIDIIN)h);
break;
//
// This is not required because WOW does not open any
// mmio files.
//
// case TYPE_MMIO:
// dprintf1(("MMIO handle (%04X) was not released.", h));
// if (mmioClose((HMMIO)h, 0) != 0)
// mmioClose((HMMIO)h, MMIO_FHOPEN);
// break;
}
//
// unset hdrvDestroy so DriverCallback will work.
// some hosebag drivers (like the TIMER driver)
// may pass NULL as their driver handle.
// so dont set it to NULL.
//
hdrvDestroy = (HANDLE)-1;
//
// the reason we start over is because a single free may cause
// multiple free's (ie MIDIMAPPER has another HMIDI open, ...)
//
h = GetHandleFirst();
} else {
h = GetHandleNext(h);
}
}
LeaveCriticalSection(&HandleListCritSec);
//
// Clean up an installed IO procs for mmio
//
// This is not required because wow does not install any io procs.
//
// mmioCleanupIOProcs(hTask);
//
// If avicap32.dll is loaded, then ask it to clean up
// capture drivers
{
HMODULE hmod;
hmod = GetModuleHandle(TEXT("avicap32.dll"));
if (hmod) {
typedef void (*AppCleanupProc)(HANDLE);
AppCleanupProc fp;
fp = (AppCleanupProc) GetProcAddress(hmod, "AppCleanup");
if (fp) {
fp(hTask);
}
}
}
}
void InitHandles(void)
{
InitializeCriticalSection(&HandleListCritSec);
}
void FreeUnusedDrivers(PMMDRV pmmdrv, int NumberOfEntries)
{
int i;
for (i = 0; i < NumberOfEntries; i++) {
if (pmmdrv[i].hDriver != NULL) {
if (pmmdrv[i].bNumDevs == 0) {
DrvClose(pmmdrv[i].hDriver, 0, 0);
pmmdrv[i].hDriver = NULL;
pmmdrv[i].drvMessage = NULL;
}
} else {
break;
}
}
}
extern BOOL IMixerLoadDrivers( void );
void InitDevices(void)
{
WaveInit();
//
// The server only needs wave to do message beeps.
//
if (!WinmmRunningInServer) {
MidiInit();
if (!TimeInit()) {
dprintf1(("Failed to initialize timer services"));
}
midiEmulatorInit();
AuxInit();
JoyInit();
IMixerLoadDrivers();
//
// Clear up any drivers which don't have any devices (we do it this
// way so we don't keep loading and unloading mmdrv.dll).
//
// Note - we only load the mappers if there are real devices so we
// don't need to worry about unloading them.
//
FreeUnusedDrivers(waveindrv, MAXWAVEDRIVERS);
FreeUnusedDrivers(midioutdrv, MAXMIDIDRIVERS);
FreeUnusedDrivers(midiindrv, MAXMIDIDRIVERS);
FreeUnusedDrivers(auxdrv, MAXAUXDRIVERS);
}
FreeUnusedDrivers(waveoutdrv, MAXWAVEDRIVERS);
}
/*****************************************************************************
* @doc EXTERNAL MMSYSTEM
*
* @api UINT | mmsystemGetVersion | This function returns the current
* version number of the Multimedia extensions system software.
*
* @rdesc The return value specifies the major and minor version numbers of
* the Multimedia extensions. The high-order byte specifies the major
* version number. The low-order byte specifies the minor version number.
*
****************************************************************************/
UINT APIENTRY mmsystemGetVersion(void)
{
return(MMSYSTEM_VERSION);
}
#define MAXDRIVERORDINAL 9
/****************************************************************************
strings
****************************************************************************/
STATICDT SZCODE szWodMessage[] = WOD_MESSAGE;
STATICDT SZCODE szWidMessage[] = WID_MESSAGE;
STATICDT SZCODE szModMessage[] = MOD_MESSAGE;
STATICDT SZCODE szMidMessage[] = MID_MESSAGE;
STATICDT SZCODE szAuxMessage[] = AUX_MESSAGE;
STATICDT WSZCODE wszWave[] = L"wave";
STATICDT WSZCODE wszMidi[] = L"midi";
STATICDT WSZCODE wszAux[] = L"aux";
STATICDT WSZCODE wszMidiMapper[]= L"midimapper";
STATICDT WSZCODE wszWaveMapper[]= L"wavemapper";
STATICDT WSZCODE wszAuxMapper[] = L"auxmapper";
WSZCODE wszNull[] = L"";
WSZCODE wszSystemIni[] = L"system.ini";
WSZCODE wszDrivers[] = DRIVERS_SECTION;
/*
** WaveMapperInit
**
** Initialize the wave mapper if it's not already initialized.
**
*/
BOOL WaveMapperInitialized = FALSE;
void WaveMapperInit(void)
{
HDRVR h;
EnterCriticalSection(&MapperInitCritSec);
if (WaveMapperInitialized) {
LeaveCriticalSection(&MapperInitCritSec);
return;
}
/* The wave mapper.
*
* MMSYSTEM allows the user to install a special wave driver which is
* not visible to the application as a physical device (it is not
* included in the number returned from getnumdevs).
*
* An application opens the wave mapper when it does not care which
* physical device is used to input or output waveform data. Thus
* it is the wave mapper's task to select a physical device that can
* render the application-specified waveform format or to convert the
* data into a format that is renderable by an available physical
* device.
*/
if (wTotalWaveInDevs + wTotalWaveOutDevs > 0)
{
if (0 != (h = mmDrvOpen(wszWaveMapper)))
{
mmDrvInstall(h, wszWaveMapper, NULL, MMDRVI_MAPPER|MMDRVI_WAVEOUT|MMDRVI_HDRV);
if (!WinmmRunningInServer) {
h = mmDrvOpen(wszWaveMapper);
mmDrvInstall(h, wszWaveMapper, NULL, MMDRVI_MAPPER|MMDRVI_WAVEIN |MMDRVI_HDRV);
}
}
}
WaveMapperInitialized = TRUE;
LeaveCriticalSection(&MapperInitCritSec);
}
/*
** MidiMapperInit
**
** Initialize the MIDI mapper if it's not already initialized.
**
*/
void MidiMapperInit(void)
{
static BOOL MidiMapperInitialized = FALSE;
HDRVR h;
EnterCriticalSection(&MapperInitCritSec);
if (MidiMapperInitialized) {
LeaveCriticalSection(&MapperInitCritSec);
return;
}
/* The midi mapper.
*
* MMSYSTEM allows the user to install a special midi driver which is
* not visible to the application as a physical device (it is not
* included in the number returned from getnumdevs).
*
* An application opens the midi mapper when it does not care which
* physical device is used to input or output midi data. It
* is the midi mapper's task to modify the midi data so that it is
* suitable for playback on the connected synthesizer hardware.
*/
if (wTotalMidiInDevs + wTotalMidiOutDevs > 0)
{
if (0 != (h = mmDrvOpen(wszMidiMapper)))
{
mmDrvInstall(h, wszMidiMapper, NULL, MMDRVI_MAPPER|MMDRVI_MIDIOUT|MMDRVI_HDRV);
h = mmDrvOpen(wszMidiMapper);
mmDrvInstall(h, wszMidiMapper, NULL, MMDRVI_MAPPER|MMDRVI_MIDIIN |MMDRVI_HDRV);
}
}
MidiMapperInitialized = TRUE;
LeaveCriticalSection(&MapperInitCritSec);
}
/*****************************************************************************
* @doc INTERNAL WAVE
*
* @api BOOL | WaveInit | This function initialises the wave services.
*
* @rdesc Returns TRUE if the services of all loaded wave drivers are
* correctly initialised, FALSE if an error occurs.
*
* @comm the wave devices are loaded in the following order
*
* \Device\WaveIn0
* \Device\WaveIn1
* \Device\WaveIn2
* \Device\WaveIn3
*
****************************************************************************/
BOOL WaveInit(void)
{
WCHAR szKey[ (sizeof(wszWave) + sizeof( WCHAR )) / sizeof( WCHAR ) ];
int i;
HDRVR h;
// Find the real WAVE drivers
lstrcpyW(szKey, wszWave);
szKey[ (sizeof(szKey) / sizeof( WCHAR )) - 1 ] = (WCHAR)'\0';
for (i=0; i<=MAXDRIVERORDINAL; i++)
{
h = mmDrvOpen(szKey);
if (h)
{
mmDrvInstall(h, szKey, NULL, MMDRVI_WAVEOUT|MMDRVI_HDRV);
if (!WinmmRunningInServer) {
h = mmDrvOpen(szKey);
mmDrvInstall(h, szKey, NULL, MMDRVI_WAVEIN |MMDRVI_HDRV);
}
}
szKey[ (sizeof(wszWave) / sizeof(WCHAR)) - 1] = (WCHAR)('1' + i);
}
return TRUE;
}
/*****************************************************************************
* @doc INTERNAL MIDI
*
* @api BOOL | MidiInit | This function initialises the midi services.
*
* @rdesc The return value is TRUE if the services are initialised, FALSE if
* an error occurs
*
* @comm the midi devices are loaded from SYSTEM.INI in the following order
*
* midi
* midi1
* midi2
* midi3
*
****************************************************************************/
BOOL MidiInit(void)
{
WCHAR szKey[ (sizeof(wszMidi) + sizeof( WCHAR )) / sizeof( WCHAR ) ];
int i;
HDRVR h;
// Find the real MIDI drivers
lstrcpyW(szKey, wszMidi);
szKey[ (sizeof(szKey) / sizeof( WCHAR )) - 1 ] = (WCHAR)'\0';
for (i=0; i<=MAXDRIVERORDINAL; i++)
{
h = mmDrvOpen(szKey);
if (h)
{
mmDrvInstall(h, szKey, NULL, MMDRVI_MIDIOUT|MMDRVI_HDRV);
h = mmDrvOpen(szKey);
mmDrvInstall(h, szKey, NULL, MMDRVI_MIDIIN |MMDRVI_HDRV);
}
szKey[ (sizeof(wszMidi) / sizeof(WCHAR)) - 1] = (WCHAR)('1' + i);
}
return TRUE;
}
/*****************************************************************************
* @doc INTERNAL AUX
*
* @api BOOL | AuxInit | This function initialises the auxiliary output
* services.
*
* @rdesc The return value is TRUE if the services are initialised, FALSE if
* an error occurs
*
* @comm SYSTEM.INI is searched for auxn.drv=.... where n can be from 1 to 4.
* Each driver is loaded and the number of devices it supports is read
* from it.
*
* AUX devices are loaded from SYSTEM.INI in the following order
*
* aux
* aux1
* aux2
* aux3
*
****************************************************************************/
BOOL AuxInit(void)
{
WCHAR szKey[ (sizeof(wszAux) + sizeof( WCHAR )) / sizeof( WCHAR ) ];
int i;
HDRVR h;
// Find the real Aux drivers
lstrcpyW(szKey, wszAux);
szKey[ (sizeof(szKey) / sizeof( WCHAR )) - 1 ] = (WCHAR)'\0';
for (i=0; i<=MAXDRIVERORDINAL; i++)
{
h = mmDrvOpen(szKey);
if (h)
{
mmDrvInstall(h, szKey, NULL, MMDRVI_AUX|MMDRVI_HDRV);
}
// advance driver ordinal
szKey[ (sizeof(wszAux) / sizeof(WCHAR)) - 1] = (WCHAR)('1' + i);
}
/* The aux mapper.
*
* MMSYSTEM allows the user to install a special aux driver which is
* not visible to the application as a physical device (it is not
* included in the number returned from getnumdevs).
*
* I'm not sure why anyone would do this but I'll provide the
* capability for symmetry.
*
*/
if (wTotalAuxDevs > 0)
{
h = mmDrvOpen(wszAuxMapper);
if (h)
{
mmDrvInstall(h, wszAuxMapper, NULL, MMDRVI_MAPPER|MMDRVI_AUX|MMDRVI_HDRV);
}
}
return TRUE;
}
/*****************************************************************************
*
* @doc INTERNAL
*
* @api HANDLE | mmDrvOpen | This function load's an installable driver, but
* first checks weather it exists in the [Drivers] section.
*
* @parm LPSTR | szAlias | driver alias to load
*
* @rdesc The return value is return value from DrvOpen or NULL if the alias
* was not found in the [Drivers] section.
*
****************************************************************************/
HANDLE mmDrvOpen(LPWSTR szAlias)
{
WCHAR buf[300]; // Make this large to bypass GetPrivate... bug
if ( winmmGetPrivateProfileString( wszDrivers,
szAlias,
wszNull,
buf,
sizeof(buf) / sizeof(WCHAR),
wszSystemIni) ) {
return (HANDLE)DrvOpen(szAlias, NULL, 0L);
}
else {
return NULL;
}
}
/*****************************************************************************
* @doc INTERNAL
*
* @api HANDLE | mmDrvInstall | This function installs/removes a WAVE/MIDI driver
*
* @parm HANDLE | hDriver | Module handle or driver handle containing driver
*
* @parm WCHAR * | wszDrvEntry | String corresponding to hDriver to be stored for
* later use
*
* @parm DRIVERMSGPROC | drvMessage | driver message procedure, if NULL
* the standard name will be used (looked for with GetProcAddress)
*
* @parm UINT | wFlags | flags
*
* @flag MMDRVI_TYPE | driver type mask
* @flag MMDRVI_WAVEIN | install driver as a wave input driver
* @flag MMDRVI_WAVEOUT | install driver as a wave ouput driver
* @flag MMDRVI_MIDIIN | install driver as a midi input driver
* @flag MMDRVI_MIDIOUT | install driver as a midi output driver
* @flag MMDRVI_AUX | install driver as a aux driver
*
* @flag MMDRVI_MAPPER | install this driver as the mapper
* @flag MMDRVI_HDRV | hDriver is a installable driver
* @flag MMDRVI_REMOVE | remove the driver
*
* @rdesc returns NULL if unable to install driver
*
****************************************************************************/
UINT APIENTRY mmDrvInstall(
HANDLE hDriver,
WCHAR * wszDrvEntry,
DRIVERMSGPROC drvMessage,
UINT wFlags
)
{
#define SZ_SIZE 128
int i;
DWORD dw;
PMMDRV pdrv;
HANDLE hModule;
int max_drivers;
UINT msg_num_devs;
UINT *pTotalDevs;
CHAR *szMessage;
WCHAR sz[SZ_SIZE];
if (hDriver && (wFlags & MMDRVI_HDRV))
{
hModule = DrvGetModuleHandle(hDriver);
}
else
{
hModule = hDriver;
hDriver = NULL;
}
switch (wFlags & MMDRVI_TYPE)
{
case MMDRVI_WAVEOUT:
pdrv = (PMMDRV)waveoutdrv;
max_drivers = MAXWAVEDRIVERS;
msg_num_devs = WODM_GETNUMDEVS;
pTotalDevs = &wTotalWaveOutDevs;
szMessage = szWodMessage;
break;
case MMDRVI_WAVEIN:
pdrv = (PMMDRV)waveindrv;
max_drivers = MAXWAVEDRIVERS;
msg_num_devs = WIDM_GETNUMDEVS;
pTotalDevs = &wTotalWaveInDevs;
szMessage = szWidMessage;
break;
case MMDRVI_MIDIOUT:
pdrv = (PMMDRV)midioutdrv;
max_drivers = MAXMIDIDRIVERS;
msg_num_devs = MODM_GETNUMDEVS;
pTotalDevs = &wTotalMidiOutDevs;
szMessage = szModMessage;
break;
case MMDRVI_MIDIIN:
pdrv = (PMMDRV)midiindrv;
max_drivers = MAXMIDIDRIVERS;
msg_num_devs = MIDM_GETNUMDEVS;
pTotalDevs = &wTotalMidiInDevs;
szMessage = szMidMessage;
break;
case MMDRVI_AUX:
pdrv = (PMMDRV)auxdrv;
max_drivers = MAXAUXDRIVERS;
msg_num_devs = AUXDM_GETNUMDEVS;
pTotalDevs = &wTotalAuxDevs;
szMessage = szAuxMessage;
break;
default:
goto error_exit;
}
if (drvMessage == NULL && hModule != NULL)
drvMessage = (DRIVERMSGPROC)GetProcAddress(hModule, szMessage);
if (drvMessage == NULL)
goto error_exit;
#if 0
//
// either install or remove the specified driver
//
if (wFlags & MMDRVI_REMOVE)
{
//
// try to find the driver, search to max_drivers+1 so we find the
// mapper too.
//
for (i=0; i<max_drivers+1 && pdrv[i].drvMessage != drvMessage; i++)
;
//
// we did not find it!
//
if (i==max_drivers+1)
goto error_exit; // not found
//
// we need to check if any outstanding handles are open on
// this device, if there are we cant unload it!
//
if (pdrv[i].bUsage > 0)
goto error_exit; // in use
//
// dont decrement number of dev's for the mapper
//
if (i != max_drivers)
*pTotalDevs -= pdrv[i].bNumDevs;
//
// unload the driver if we loaded it in the first place
//
if (pdrv[i].hDriver)
DrvClose(pdrv[i].hDriver, 0, 0);
pdrv[i].drvMessage = NULL;
pdrv[i].hDriver = NULL;
pdrv[i].bNumDevs = 0;
pdrv[i].bUsage = 0;
pdrv[i].wszDrvEntry[0] = 0;
return TRUE;
}
else
#endif // 0
{
//
// try to find the driver already installed
//
for (i=0; i<max_drivers+1 && pdrv[i].drvMessage != drvMessage; i++)
;
if (i!=max_drivers+1) // we found it, dont re-install it!
goto error_exit;
//
// Find a slot the the device, if we are installing a 'MAPPER' place
// it in the last slot.
//
if (wFlags & MMDRVI_MAPPER)
{
i = max_drivers;
//
// don't allow more than one mapper
//
if (pdrv[i].drvMessage)
goto error_exit;
}
else
{
for (i=0; i<max_drivers && pdrv[i].drvMessage != NULL; i++)
;
if (i==max_drivers)
goto error_exit;
}
//
// call driver to get num-devices it supports
//
dw = drvMessage(0,msg_num_devs,0L,0L,0L);
//
// the device returned a error, or has no devices
//
// if (HIWORD(dw) != 0 || LOWORD(dw) == 0)
if (HIWORD(dw) != 0)
goto error_exit;
pdrv[i].hDriver = hDriver;
pdrv[i].bNumDevs = (BYTE)LOWORD(dw);
pdrv[i].bUsage = 0;
pdrv[i].drvMessage = drvMessage;
winmmGetPrivateProfileString(wszDrivers, // ini section
wszDrvEntry, // key name
wszDrvEntry, // default if no match
sz, // return buffer
SZ_SIZE, // sizeof of return buffer
wszSystemIni); // ini. file
lstrcpyW(pdrv[i].wszDrvEntry,sz);
//
// dont increment number of dev's for the mapper
//
if (i != max_drivers)
*pTotalDevs += pdrv[i].bNumDevs;
return (BOOL)(i+1); // return a non-zero value
}
error_exit:
if (hDriver && !(wFlags & MMDRVI_REMOVE))
DrvClose(hDriver, 0, 0);
return FALSE;
#undef SZ_SIZE
}
/*
*************************************************************************
* MigrateSoundEvents
*
* Description:
* Looks at the sounds section in win.ini for sound entries.
* Gets a current scheme name from the current section in control.ini
* Failing that it tries to find the current scheme in the registry
* Failing that it uses .default as the current scheme.
* Copies each of the entries in the win.ini sound section into the
* registry under the scheme name obtained
* If the scheme name came from control.ini, it creates a key from the
* scheme name. This key is created by removing all the existing spaces
* in the scheme name. This key and scheme name is added to the registry
*
*************************************************************************
*/
void MigrateSoundEvents (void)
{
LPTSTR szSectionBuf;
TCHAR aszEvent[SCH_TYPE_MAX_LENGTH];
BOOL fPrimaryMigration = FALSE;
szSectionBuf = (LPTSTR)LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, INISECTION * sizeof(TCHAR));
if (!szSectionBuf)
return;
// If a MediaPathUnexpanded key exists (it will be something
// like "%SystemRoot%\Media"), expand it into a fully-qualified
// path and write out a matching MediaPath key (which will look
// like "c:\win\media"). This is done every time we enter the
// migration path, whether or not there's anything else to do.
//
// Setup would like to write the MediaPath key with the
// "%SystemRoot%" crap still in it--but while we could touch
// our apps to understand expansion, any made-for-Win95 apps
// probably wouldn't think to expand the string, and so wouldn't
// work properly. Instead, it writes the MediaPathUnexpanded
// key, and we make sure that the MediaPath key is kept up-to-date
// in the event that the Windows drive gets remapped (isn't
// NT cool that way?).
//
if (mmRegQueryMachineValue (aszSetup, aszValMediaUnexpanded,
cchLENGTH(aszEvent), aszEvent))
{
WCHAR szExpanded[MAX_PATH];
ExpandEnvironmentStrings (aszEvent, szExpanded, cchLENGTH(szExpanded));
mmRegSetMachineValue (aszSetup, aszValMedia, szExpanded);
}
// If there exists an event label for "SystemDefault", delete it.
//
// Also, if the key AppEvents\Schemes\Apps\.Default\SystemDefault
// exists, delete it.
//
wsprintf (aszEvent, asz3Format,
gszAppEventsKey, aszSchemeLabelsKey, gszDefaultBeepOldAlias);
if (mmRegQueryUserKey (aszEvent)) // AppEvents\EventLabels\SystemDefault
mmRegDeleteUserKey (aszEvent);
wsprintf (aszEvent, asz4Format, gszSchemesRootKey, gszSchemeAppsKey,
aszDefault, gszDefaultBeepOldAlias);
if (mmRegQueryUserKey (aszEvent)) // ApEvts\Schemes\Apps\.Def\SystemDefault
mmRegDeleteUserKey (aszEvent);
// mmRegCreateUserKey doesn't work unless the parent path already
// exists, so we have to create the basic tree structure up-front.
//
// Create AppEvents
// Create AppEvents\EventLabels
// Create AppEvents\Schemes
// Create AppEvents\Schemes\Apps
// Create AppEvents\Schemes\Names
//
if (!mmRegCreateUserKey (NULL, gszAppEventsKey))
return;
if (!mmRegCreateUserKey (gszAppEventsKey, aszSchemeLabelsKey))
return;
if (!mmRegCreateUserKey (gszAppEventsKey, gszJustSchemesKey))
return;
if (!mmRegCreateUserKey (gszSchemesRootKey, gszSchemeAppsKey))
return;
if (!mmRegCreateUserKey (gszSchemesRootKey, aszSchemeNamesKey))
return;
// Go through CONTROL.INI's SoundSchemes section, and migrate
// any schemes we find there.
//
if (GetPrivateProfileString (aszSchemesSection, NULL, szNull,
szSectionBuf, INISECTION, aszControlINI))
{
LPTSTR szKey;
for (szKey = szSectionBuf; *szKey; szKey += lstrlen(szKey) + 1)
{
if (lstrcmpi(szKey, aszYourOldScheme))
{
TCHAR aszScheme[SCH_TYPE_MAX_LENGTH];
TCHAR aszSchemeID[SCH_TYPE_MAX_LENGTH];
wsprintf (aszScheme, gszSoundScheme, szKey);
mregCreateSchemeID (aszScheme, aszSchemeID);
mregAddIniScheme (aszScheme, aszSchemeID, szKey, aszControlINI);
// Erase the entry from the schemes section once
// it has been migrated
//
WritePrivateProfileString (aszSchemesSection,
szKey, NULL,
aszControlINI);
}
}
}
if ( (!GetPrivateProfileString (aszSoundsSection, aszDummySnd, szNull,
aszEvent, cchLENGTH(aszEvent), aszWinINI)) ||
(lstrcmp (aszEvent, aszDummySndValue)) ||
(aszEvent[ lstrlen(aszEvent)+1 ] != TEXT('\0')) )
{
TCHAR aszKey[164];
TCHAR aszAppName[164];
mregAddIniScheme (aszSoundsSection, aszCurrent, NULL, aszWinINI);
// Make the current scheme be the one we just added (".Current")
//
mmRegSetUserValue (gszSchemesRootKey, NULL, aszCurrent);
// Make the name of the ".Default" application be "Windows":
//
wsprintf(aszKey, asz2Format, gszSchemesRootKey, gszSchemeAppsKey);
if (mmRegCreateUserKey (aszKey, aszDefault))
{
wsprintf(aszKey, asz3Format,
gszSchemesRootKey, gszSchemeAppsKey, aszDefault);
LoadString (ghInst, STR_WINDOWS_APP_NAME,
aszAppName, cchLENGTH(aszAppName));
mmRegSetUserValue (aszKey, NULL, aszAppName);
}
// Make the name of the "Explorer" application be
// "Windows Explorer":
//
wsprintf(aszKey, asz2Format, gszSchemesRootKey, gszSchemeAppsKey);
if (mmRegCreateUserKey (aszKey, aszExplorer))
{
wsprintf(aszKey, asz3Format,
gszSchemesRootKey, gszSchemeAppsKey, aszExplorer);
LoadString (ghInst, STR_EXPLORER_APP_NAME,
aszAppName, cchLENGTH(aszAppName));
mmRegSetUserValue (aszKey, NULL, aszAppName);
}
// Remove current sounds section and add a blank entry
// to make silly apps work which really need to have
// this section here.
//
WritePrivateProfileString (aszSoundsSection,
NULL, NULL,
aszWinINI);
WritePrivateProfileString (aszSoundsSection,
aszDummySnd, aszDummySndValue,
aszWinINI);
fPrimaryMigration = TRUE;
}
// If there's no "Migrated Schemes" key, or if its value it
// describes is < the "current migration level", then we'll
// need to ensure that all currently-migrated schemes mention
// each of the known sound events (from gaEventLabels), and
// that the EventLabels keys are filled out. Note that we'll
// also do this if we just migrated something for the .Current
// scheme (above).
//
if (!mmRegQueryUserValue (gszAppEventsKey, aszMigration,
cchLENGTH( aszEvent ), aszEvent))
{
fPrimaryMigration = TRUE;
}
else
{
LONG wInReg = 0;
TCHAR *pch;
for (pch = aszEvent; *pch >= TEXT('0') && *pch <= TEXT('9'); ++pch)
{
wInReg *= 10;
wInReg += (LONG)( *(pch) - TEXT('0') );
}
if (wInReg < wCurrentSchemeMigrationLEVEL)
{
fPrimaryMigration = TRUE;
}
}
if (fPrimaryMigration)
{
TCHAR aszKeyParent[SCH_TYPE_MAX_LENGTH];
TCHAR aszKey[SCH_TYPE_MAX_LENGTH];
short iEventLabel;
// First ensure that all EventLabels exist
//
wsprintf (aszKeyParent, asz2Format, gszAppEventsKey, aszSchemeLabelsKey);
for (iEventLabel = 0; iEventLabel < nEVENTLABELS; ++iEventLabel)
{
if (mmRegCreateUserKey (aszKeyParent,
gaEventLabels[ iEventLabel ].pszEvent))
{
wsprintf (aszKey, asz3Format,
gszAppEventsKey,
aszSchemeLabelsKey,
gaEventLabels[ iEventLabel ].pszEvent);
LoadString (ghInst, gaEventLabels[ iEventLabel ].idDescription,
aszEvent, cchLENGTH(aszEvent));
mmRegSetUserValue (aszKey, NULL, aszEvent);
}
}
// Then ensure that the ExtendedSounds key exists; if not,
// add it and make it say "yes" (so the shell will issue reqs
// for the new-for-Win95 events)
//
wsprintf (aszKeyParent, asz2Format, gszControlPanel, aszSoundSection);
if (!mmRegQueryUserValue (aszKeyParent, aszExtendedSounds,
cchLENGTH( aszEvent ), aszEvent))
{
if (mmRegCreateUserKey (gszControlPanel, aszSoundSection))
{
mmRegSetUserValue (aszKeyParent,
aszExtendedSounds,
aszExtendedSoundsYes);
}
}
// Then ensure that the appropriate app (.Default or Explorer),
// for the .Current scheme, has any entry for each of the known
// events; if we have to create a new entry, don't give it a
// sound.
//
for (iEventLabel = 0; iEventLabel < nEVENTLABELS; ++iEventLabel)
{
// Does AppEvents\Schemes\Apps\{app}\{event}\.Current
// have an entry? If not, we need to fill out this key
// some.
//
wsprintf (aszKeyParent, asz5Format,
gszSchemesRootKey,
gszSchemeAppsKey,
gaEventLabels[ iEventLabel ].pszApp,
gaEventLabels[ iEventLabel ].pszEvent,
aszCurrent);
if (mmRegQueryUserValue (aszKeyParent, NULL,
cchLENGTH( aszEvent ), aszEvent))
{
continue;
}
// Otherwise, create the key:
// AppEvents\Schemes\Apps\{app}
//
wsprintf (aszKeyParent, asz2Format,
gszSchemesRootKey,
gszSchemeAppsKey);
if (!mmRegCreateUserKey (aszKeyParent,
gaEventLabels[ iEventLabel ].pszApp))
{
continue;
}
// Create the key:
// AppEvents\Schemes\Apps\{app}\{event}
//
wsprintf (aszKeyParent, asz3Format,
gszSchemesRootKey,
gszSchemeAppsKey,
gaEventLabels[ iEventLabel ].pszApp);
if (!mmRegCreateUserKey (aszKeyParent,
gaEventLabels[ iEventLabel ].pszEvent))
{
continue;
}
// Create the key:
// AppEvents\Schemes\Apps\{app}\{event}\.Current
//
wsprintf (aszKeyParent, asz4Format,
gszSchemesRootKey,
gszSchemeAppsKey,
gaEventLabels[ iEventLabel ].pszApp,
gaEventLabels[ iEventLabel ].pszEvent);
if (!mmRegCreateUserKey (aszKeyParent, aszCurrent))
{
continue;
}
// Give a value of "" to the key:
// AppEvents\Schemes\Apps\{app}\{event}\.Current
//
wsprintf (aszKeyParent, asz5Format,
gszSchemesRootKey,
gszSchemeAppsKey,
gaEventLabels[ iEventLabel ].pszApp,
gaEventLabels[ iEventLabel ].pszEvent,
aszCurrent);
mmRegSetUserValue (aszKeyParent, NULL, TEXT(""));
}
// Record the fact that we're now up-to-date WRT migration.
//
wsprintf (aszEvent, TEXT("%lu"), (long)wCurrentSchemeMigrationLEVEL);
mmRegSetUserValue (gszAppEventsKey, aszMigration, aszEvent);
}
LocalFree ((HLOCAL)szSectionBuf);
}
/*==========================================================================*/
/*
* Description:
* Parse the inf line containing the event entry
* The 0th entry is the keyname for the event
* The 1st entry is the full or relative path name of the file related
* to the event
* The 2nd entry is the printable name of the event
* Once the line is parsed, the file name associated with the event is
* added to the registry
* EventKey
* |
* ---SchemeKey = FileName
*
* The printable event name is added to the registry as follows
* EventLabels
* |
* ---EventKey = Printable Event Name
*/
STATIC void NEAR PASCAL mregAddIniScheme(LPTSTR lszSection,
LPTSTR lszSchemeID,
LPTSTR lszSchemeName,
LPTSTR lszINI)
{
TCHAR aszKey[164];
TCHAR szFileName[MAX_PATH];
LONG cbSize;
TCHAR aszValue[64];
LPTSTR szSectionBuf;
LPTSTR szKnownPrograms;
LPTSTR lpszFile;
short iEventLabel;
if (lszSchemeName)
{
wsprintf(aszKey, asz2Format, gszSchemesRootKey, aszSchemeNamesKey);
if (mmRegCreateUserKey (aszKey, lszSchemeID))
{
cbSize = cchLENGTH(aszValue);
if (!mmRegQueryUserValue (aszKey, lszSchemeID, cbSize, aszValue))
{
wsprintf(aszKey, asz3Format,
gszSchemesRootKey, aszSchemeNamesKey, lszSchemeID);
mmRegSetUserValue (aszKey, NULL, lszSchemeName);
}
}
}
for (iEventLabel = 0; iEventLabel < nEVENTLABELS; ++iEventLabel)
{
wsprintf(aszKey, asz2Format, gszSchemesRootKey, gszSchemeAppsKey);
if (mmRegCreateUserKey (aszKey, gaEventLabels[ iEventLabel ].pszApp))
{
wsprintf(aszKey, asz3Format,
gszSchemesRootKey,
gszSchemeAppsKey,
gaEventLabels[ iEventLabel ].pszApp);
if (!mmRegCreateUserKey (aszKey, gaEventLabels[iEventLabel].pszEvent))
continue;
wsprintf(aszKey, asz4Format,
gszSchemesRootKey,
gszSchemeAppsKey,
gaEventLabels[ iEventLabel ].pszApp,
gaEventLabels[ iEventLabel ].pszEvent);
mmRegCreateUserKey (aszKey, lszSchemeID);
}
}
szKnownPrograms = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, INISECTION * sizeof(TCHAR));
if (!szKnownPrograms)
return;
szSectionBuf = LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, BIGINISECTION * sizeof(TCHAR));
if (!szSectionBuf)
{
LocalFree((HLOCAL)szKnownPrograms);
return;
}
if (GetPrivateProfileString(lszSection, NULL, szNull, szSectionBuf, BIGINISECTION, lszINI))
{
LPTSTR szKey;
UINT uKeyLen;
LPTSTR lszNextProg;
LPTSTR lszTmp;
TCHAR szKnownWAVPath[MAX_PATH];
LPTSTR lpszNextFile;
BOOL fClipsInstalled;
// Test to see if Clips are installed
//
fClipsInstalled = FALSE;
if (mmRegQueryMachineValue (aszOptionalClips, aszInstalled,
cchLENGTH(aszValue), aszValue))
{
if (aszValue[0] == TEXT('1'))
{
fClipsInstalled = TRUE;
}
}
if (fClipsInstalled)
{
if (mmRegQueryMachineValue (aszSetup, aszValMedia,
cchLENGTH(szKnownWAVPath), szKnownWAVPath))
{
lpszNextFile = (szKnownWAVPath + lstrlen(szKnownWAVPath));
*lpszNextFile = TEXT('\\');
lpszNextFile++;
*lpszNextFile = TEXT('\0');
}
else
{
fClipsInstalled = FALSE;
}
}
lszNextProg = szKnownPrograms;
for (szKey = szSectionBuf; *szKey; szKey += uKeyLen + 1)
{
UINT uSound;
uKeyLen = lstrlen(szKey);
// skip dummy entry
//
if (!lstrcmp(szKey, aszDummySnd)) {
if (!GetPrivateProfileString(lszSection, szKey, szNull, aszValue, cchLENGTH(aszValue), lszINI) || (aszValue[0] == TEXT(',')))
continue;
}
for (uSound = 0; uSound < (sizeof(gpszSounds) / sizeof(TCHAR*)); uSound++)
{
UINT uSoundLen;
TCHAR szProgram[64];
uSoundLen = lstrlen(gpszSounds[uSound]);
if ((uKeyLen > uSoundLen) && !lstrcmpi(gpszSounds[uSound], (szKey + (uKeyLen - uSoundLen))))
{
lstrcpy(szProgram, szKey);
*(szProgram + (uKeyLen - uSoundLen)) = 0;
if (*(szProgram + (uKeyLen - uSoundLen - 1)) == TEXT(' '))
break;
for (lszTmp = szKnownPrograms; lszTmp < lszNextProg; lszTmp += lstrlen(lszTmp) +1)
{
if (!lstrcmpi(lszTmp, szProgram))
break;
}
if (lszTmp >= lszNextProg)
{
lstrcpy(lszNextProg, szProgram);
lszNextProg += lstrlen(lszNextProg)+1;
}
break;
}
}
}
for (szKey = szSectionBuf; *szKey; szKey += uKeyLen + 1)
{
LPTSTR lszRealEvent;
LPTSTR lszRealApp;
TCHAR aszValue[128];
TCHAR aszEvent[64];
LPTSTR lszValue;
UINT uSound;
uKeyLen = lstrlen(szKey);
if (!GetPrivateProfileString(lszSection, szKey, szNull, aszValue, cchLENGTH(aszValue), lszINI))
continue;
if (!lstrcmp(szKey, aszDummySnd) && (aszValue[0] == TEXT(','))) // skip dummy entry
continue;
lszRealEvent = szKey;
lszRealApp = aszDefault;
if (!lstrncmpi(szKey, gszApp, lstrlen(gszApp)+1))
{
lszRealEvent = aszEvent;
lstrcpy(aszEvent, (szKey + lstrlen(gszApp)));
}
else if (lstrncmpi(szKey, gszSystem, lstrlen(gszSystem)+1))
{
for (lszTmp = szKnownPrograms; *lszTmp; lszTmp += lstrlen(lszTmp) +1)
{
if (!lstrncmpi(szKey, lszTmp, lstrlen(lszTmp)+1))
{
for (uSound = 0; uSound < (sizeof(gpszSounds) / sizeof(TCHAR*)); uSound++)
{
if (!lstrcmpi(gpszSounds[uSound], (szKey + lstrlen(lszTmp))))
{
lszRealApp = szKey;
lszRealEvent = aszEvent;
lstrcpy(aszEvent, (szKey + lstrlen(lszTmp)));
*(szKey + lstrlen(lszTmp)) = 0;
break;
}
}
break;
}
}
}
for (lszValue = aszValue; *lszValue && (*lszValue != TEXT(',')); ++lszValue)
;
if (*lszValue)
{
*(lszValue++) = 0;
while ((*lszValue == TEXT(' ')) || (*lszValue == TEXT('\t')))
++lszValue;
}
if (!lstrcmpi(aszValue, aszNone))
aszValue[0] = TEXT('\0');
lpszFile = aszValue;
if (*lpszFile == TEXT('\0'))
goto ExistCheckDone;
if (fClipsInstalled)
{
for (uSound = 0; uSound < (sizeof(gpszKnownWAVFiles) / sizeof(TCHAR *)); uSound++)
{
if (!lstrcmpi(gpszKnownWAVFiles[uSound], (lpszFile + lstrlen(lpszFile) - lstrlen(gpszKnownWAVFiles[uSound]))))
{
lstrcpy(lpszNextFile, gpszKnownWAVFiles[uSound]);
lpszFile = szKnownWAVPath;
break;
}
}
}
if (GetFileAttributes (lpszFile) != (DWORD)-1)
lpszFile = lpszFile;
else
lpszFile = aszValue;
//
// Create AppEvents\Schemes\Apps\[SchemeName]\[Event]
//
ExistCheckDone:
wsprintf (aszKey, asz2Format,
gszSchemesRootKey, gszSchemeAppsKey);
if (!mmRegCreateUserKey (aszKey, lszRealApp))
continue;
wsprintf (aszKey, asz3Format,
gszSchemesRootKey, gszSchemeAppsKey, lszRealApp);
if (!mmRegCreateUserKey (aszKey, lszRealEvent))
continue;
wsprintf (aszKey, asz4Format,
gszSchemesRootKey, gszSchemeAppsKey,
lszRealApp, lszRealEvent);
if (!mmRegCreateUserKey (aszKey, lszSchemeID))
continue;
wsprintf (aszKey, asz5Format,
gszSchemesRootKey, gszSchemeAppsKey,
lszRealApp, lszRealEvent, lszSchemeID);
RemoveMediaPath (szFileName, lpszFile);
mmRegSetUserValue (aszKey, NULL, szFileName);
#if 0 // BUGBUG: Was disabled in Win95 too!
wsprintf (aszKey, asz6Format,
gszSchemesRootKey, gszSchemeAppsKey,
lszRealApp, lszRealEvent, lszSchemeID, aszActiveKey);
mmRegSetUserValue (aszKey, NULL, aszBoolOne);
#endif
if (!*lszValue)
continue;
// Ensure AppEvents\EventLabels\[Event] exists
//
wsprintf(aszKey, asz2Format, gszAppEventsKey, aszSchemeLabelsKey);
if (!mmRegCreateUserKey (aszKey, lszRealEvent))
continue;
cbSize = cchLENGTH(aszValue);
if (!mmRegQueryUserValue (aszKey, lszRealEvent, cbSize, aszValue))
{
wsprintf(aszKey, asz3Format,
gszAppEventsKey, aszSchemeLabelsKey, lszRealEvent);
mmRegSetUserValue (aszKey, NULL, lszValue);
}
}
}
LocalFree((HLOCAL)szSectionBuf);
LocalFree((HLOCAL)szKnownPrograms);
}
STATIC void NEAR PASCAL mregCreateSchemeID(LPTSTR szSchemeName, LPTSTR szSchemeID)
{
UINT uSection;
UINT uScheme;
TCHAR aszSchemeID[SCH_TYPE_MAX_LENGTH];
lstrcpyn(aszSchemeID, szSchemeName, cchLENGTH(aszSchemeID));
for (uSection = uScheme = 0; aszSchemeID[uScheme];)
{
if ((aszSchemeID[uScheme] == TEXT(' ')) || (aszSchemeID[uScheme] == TEXT('\\')))
lstrcpyn(&aszSchemeID[uScheme], szSchemeName + ++uSection, cchLENGTH(aszSchemeID) - uScheme);
else
{
++uScheme;
++uSection;
}
}
lstrcpy(szSchemeID, aszSchemeID);
}
void RemoveMediaPath (LPTSTR pszTarget, LPTSTR pszSource)
{
static TCHAR szMediaPath[ MAX_PATH ] = TEXT("");
if (szMediaPath[0] == TEXT('\0'))
{
mmRegQueryMachineValue (aszSetup, aszValMedia,
cchLENGTH(szMediaPath), szMediaPath);
if ( (szMediaPath[0] != TEXT('\0')) &&
(szMediaPath[ lstrlen(szMediaPath)-1 ] != TEXT('\\')) )
{
lstrcat (szMediaPath, TEXT("\\"));
}
}
if (szMediaPath[0] == TEXT('\0'))
{
lstrcpy (pszTarget, pszSource);
}
else
{
size_t cch = lstrlen (szMediaPath);
if (!lstrncmpi (pszSource, szMediaPath, cch))
{
lstrcpy (pszTarget, &pszSource[ cch ]);
}
else
{
lstrcpy (pszTarget, pszSource);
}
}
}
int lstrncmpi (LPTSTR pszA, LPTSTR pszB, size_t cch)
{
#ifdef UNICODE
size_t cchA, cchB;
TCHAR *pch;
for (cchA = 1, pch = pszA; cchA < cch; cchA++, pch++)
{
if (*pch == TEXT('\0'))
break;
}
for (cchB = 1, pch = pszB; cchB < cch; cchB++, pch++)
{
if (*pch == TEXT('\0'))
break;
}
return (CompareStringW (GetThreadLocale(), NORM_IGNORECASE,
pszA, cchA, pszB, cchB)
)-2; // CompareStringW returns {1,2,3} instead of {-1,0,1}.
#else
return strnicmp (pszA, pszB, cch);
#endif
}
Reference in New Issue Copy Permalink