705 lines
19 KiB
C
705 lines
19 KiB
C
/**********************************************************************
|
|
|
|
Copyright (c) 1992-1999 Microsoft Corporation
|
|
|
|
modmsg.c
|
|
|
|
DESCRIPTION:
|
|
Non-fixed code for doing output mapping. Keep out of the reach
|
|
of children. This prescription may be refilled twice. May cause
|
|
temporary distortion of reality in your vicinity.
|
|
|
|
HISTORY:
|
|
02/21/94 [jimge] created.
|
|
|
|
*********************************************************************/
|
|
|
|
#include "preclude.h"
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#include <mmsystem.h>
|
|
#include <mmddk.h>
|
|
#include "idf.h"
|
|
|
|
#include <mmreg.h>
|
|
#include <memory.h>
|
|
|
|
#include "midimap.h"
|
|
#include "res.h"
|
|
#include "debug.h"
|
|
|
|
|
|
//=========================== Globals ======================================
|
|
//
|
|
extern HANDLE hMutexConfig; // Located in DRVPROC.C
|
|
BOOL gfReconfigured = FALSE;
|
|
|
|
//=========================== Prototypes ===================================
|
|
//
|
|
|
|
PRIVATE MMRESULT FNLOCAL SendChannelInitString(
|
|
HMIDIOUT hmidi,
|
|
PBYTE pbinit,
|
|
DWORD cbinit);
|
|
|
|
/***************************************************************************
|
|
|
|
@doc internal
|
|
|
|
@api DWORD | modGetDevCaps | Handles the MODM_GETDEVCAPS message.
|
|
|
|
@parm LPMIDIOUTCAPS | pmoc | Pointer to a caps structure to fill in.
|
|
|
|
@parm DWORD | cbmoc | How big the caller thinks the structure is.
|
|
|
|
@rdesc Some MMSYSERR_xxx code.
|
|
|
|
***************************************************************************/
|
|
DWORD FNGLOBAL modGetDevCaps(
|
|
LPMIDIOUTCAPS pmoc,
|
|
DWORD cbmoc)
|
|
{
|
|
MIDIOUTCAPS moc;
|
|
MIDIOUTCAPS mocWork;
|
|
DWORD cbCopy;
|
|
WORD wMask;
|
|
UINT idx;
|
|
MMRESULT mmr;
|
|
PPORT pport;
|
|
|
|
moc.wMid = MM_MICROSOFT;
|
|
moc.wPid = MM_MIDI_MAPPER;
|
|
moc.vDriverVersion = 0x0500;
|
|
LoadString(ghinst, IDS_MIDIMAPPER, moc.szPname, sizeof(moc.szPname)/sizeof(moc.szPname[0]));
|
|
moc.wTechnology = MOD_MAPPER;
|
|
moc.wVoices = 0;
|
|
moc.wNotes = 0;
|
|
moc.wChannelMask = 0;
|
|
|
|
wMask = 1;
|
|
for (idx = 0; idx < MAX_CHANNELS; idx++)
|
|
{
|
|
if (gapChannel[idx])
|
|
moc.wChannelMask |= wMask;
|
|
wMask <<= 1;
|
|
}
|
|
|
|
// If any underlying device supports cache patches, we must support it.
|
|
// Only support volume or lrvolume, however, if ALL devices support it.
|
|
//
|
|
|
|
do
|
|
{
|
|
gfReconfigured = FALSE;
|
|
moc.dwSupport = MIDICAPS_STREAM|MIDICAPS_VOLUME|MIDICAPS_LRVOLUME;
|
|
|
|
for (pport = gpportList; pport; pport=pport->pNext)
|
|
{
|
|
mmr = midiOutGetDevCaps(pport->uDeviceID, &mocWork, sizeof(mocWork));
|
|
|
|
// This prevents a corrupt gpportList in the event of a pnp event
|
|
// during a midiOutGetDevCaps call...
|
|
if (gfReconfigured)
|
|
break;
|
|
|
|
if (MMSYSERR_NOERROR != mmr)
|
|
continue;
|
|
|
|
if (!(mocWork.dwSupport & MIDICAPS_LRVOLUME))
|
|
moc.dwSupport &= ~MIDICAPS_LRVOLUME;
|
|
|
|
if (!(mocWork.dwSupport & MIDICAPS_VOLUME))
|
|
moc.dwSupport &= ~(MIDICAPS_VOLUME|MIDICAPS_LRVOLUME);
|
|
|
|
moc.dwSupport |= (mocWork.dwSupport & MIDICAPS_CACHE);
|
|
}
|
|
}
|
|
while (gfReconfigured);
|
|
|
|
CLR_ALLOWVOLUME;
|
|
if (moc.dwSupport & MIDICAPS_VOLUME)
|
|
SET_ALLOWVOLUME;
|
|
|
|
CLR_ALLOWCACHE;
|
|
if (moc.dwSupport & MIDICAPS_CACHE)
|
|
SET_ALLOWCACHE;
|
|
|
|
cbCopy = min(cbmoc, sizeof(moc));
|
|
hmemcpy((LPSTR)pmoc, (LPSTR)&moc, cbCopy);
|
|
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
@doc internal
|
|
|
|
@api DWORD | modOpen | Handles the MODM_OPEN message.
|
|
|
|
@parm LPDWORD | lpdwInstance | Points to a DWORD where we can store
|
|
our instance data. We save our PINSTANCE here.
|
|
|
|
@parm LPMIDIOPENDESC | lpmidiopendesc | Points to parameters from
|
|
MMSYSTEM describing the caller's callback, etc.
|
|
|
|
@parm DWORD | fdwOpen | Flags describing the callback type.
|
|
|
|
@rdesc Some MMSYSERR_xxx code.
|
|
|
|
***************************************************************************/
|
|
DWORD FNGLOBAL modOpen(
|
|
PDWORD_PTR lpdwInstance,
|
|
LPMIDIOPENDESC lpmidiopendesc,
|
|
DWORD fdwOpen)
|
|
{
|
|
PINSTANCE pinstance = NULL;
|
|
PPORT pport;
|
|
MMRESULT mmrc = MMSYSERR_NOERROR;
|
|
UINT idx;
|
|
UINT idx2;
|
|
UINT auDeviceID[MAX_CHANNELS];
|
|
|
|
// Open in MIDI_IO_CONTROL -- only allows reconfigure message. This MUST
|
|
// ALWAYS succeed so we have a chance of recovery on reconfigure no matter
|
|
// how badly messed up the old config was.
|
|
//
|
|
if (!(fdwOpen & MIDI_IO_CONTROL))
|
|
{
|
|
if (IS_DEVSOPENED)
|
|
return MMSYSERR_ALLOCATED;
|
|
|
|
// Mapper is single instance now
|
|
//
|
|
assert(NULL == gpinstanceList);
|
|
}
|
|
else
|
|
{
|
|
if (NULL != gpIoctlInstance)
|
|
return MMSYSERR_ALLOCATED;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (fdwOpen & MIDI_IO_COOKED)
|
|
DPF(2, TEXT ("Mapper opened in polymsg mode!!!"));
|
|
#endif
|
|
|
|
// Alloc this zero-init so all the initial channel mappings in
|
|
// rgpChannel are NULL.
|
|
//
|
|
if (NULL == (pinstance = (PINSTANCE)LocalAlloc(LPTR, sizeof(INSTANCE))))
|
|
return MMSYSERR_NOMEM;
|
|
|
|
pinstance->hmidi = lpmidiopendesc->hMidi;
|
|
pinstance->dwCallback = lpmidiopendesc->dwCallback;
|
|
pinstance->dwInstance = lpmidiopendesc->dwInstance;
|
|
pinstance->fdwOpen = fdwOpen;
|
|
|
|
// Create Translation buffer
|
|
if (! InitTransBuffer (pinstance))
|
|
{
|
|
LocalFree ((HGLOBAL)pinstance);
|
|
return MMSYSERR_NOMEM;
|
|
}
|
|
|
|
if (fdwOpen & MIDI_IO_CONTROL)
|
|
{
|
|
*lpdwInstance = (DWORD_PTR)pinstance;
|
|
|
|
gpIoctlInstance = pinstance;
|
|
|
|
DriverCallback(
|
|
pinstance->dwCallback,
|
|
HIWORD(pinstance->fdwOpen),
|
|
(HDRVR)(pinstance->hmidi),
|
|
MM_MOM_OPEN,
|
|
pinstance->dwInstance,
|
|
0L,
|
|
0L);
|
|
|
|
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
|
|
DPF(2, TEXT ("modOpen pinstance %04X"), (WORD)pinstance);
|
|
|
|
*lpdwInstance = 0; // Assume failure
|
|
|
|
if (IS_CONFIGERR)
|
|
{
|
|
DPF(1, TEXT ("Open failed because configuration invalid"));
|
|
mmrc = MIDIERR_NOMAP;
|
|
goto midi_Out_Open_Cleanup;
|
|
}
|
|
|
|
if (fdwOpen & MIDI_IO_COOKED)
|
|
{
|
|
// Build list of device ID's (stream id's emuerate ports) and
|
|
// assign stream id's to channels.
|
|
//
|
|
for (idx = 0, pport = gpportList; pport; idx++,pport=pport->pNext)
|
|
{
|
|
auDeviceID[idx] = pport->uDeviceID;
|
|
for (idx2 = 0; idx2 < MAX_CHANNELS; idx2++)
|
|
if (gapChannel[idx2] && gapChannel[idx2]->pport == pport)
|
|
gapChannel[idx2]->dwStreamID = (DWORD)idx;
|
|
}
|
|
|
|
// Attempt to open.
|
|
//
|
|
mmrc = midiStreamOpen(&ghMidiStrm, auDeviceID, idx, (DWORD_PTR)modmCallback, 0L, CALLBACK_FUNCTION);
|
|
|
|
// Fall through to cleanup code
|
|
//
|
|
}
|
|
else
|
|
{
|
|
// Run through the port list and try to open all referenced ports
|
|
//
|
|
for (pport = gpportList; pport; pport=pport->pNext)
|
|
{
|
|
if (NULL == pport->hmidi)
|
|
{
|
|
mmrc = midiOutOpen(&pport->hmidi,
|
|
pport->uDeviceID,
|
|
(DWORD_PTR)modmCallback,
|
|
(DWORD_PTR)pport,
|
|
CALLBACK_FUNCTION|MIDI_IO_SHARED);
|
|
|
|
if (MMSYSERR_NOERROR != mmrc)
|
|
{
|
|
DPF(1, TEXT ("Could not open pport %04X device %u"), (WORD)pport, pport->uDeviceID);
|
|
|
|
// Just in case....
|
|
//
|
|
pport->hmidi = NULL;
|
|
|
|
for (pport = gpportList; pport; pport=pport->pNext)
|
|
if (NULL != pport->hmidi)
|
|
{
|
|
midiOutClose(pport->hmidi);
|
|
pport->hmidi = NULL;
|
|
}
|
|
|
|
// Return whatever caused the underlying open to fail
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
midi_Out_Open_Cleanup:
|
|
if (MMSYSERR_NOERROR != mmrc)
|
|
{
|
|
// Cleanup
|
|
CleanupTransBuffer (pinstance);
|
|
if (pinstance) LocalFree((HLOCAL)pinstance);
|
|
return mmrc;
|
|
}
|
|
|
|
gdwVolume = 0xFFFFFFFFL;
|
|
|
|
SET_DEVSOPENED;
|
|
|
|
// We've succeeded; put the instance into the global instance list
|
|
// and return it as our instance data.
|
|
//
|
|
pinstance->pNext = gpinstanceList;
|
|
gpinstanceList = pinstance;
|
|
|
|
*lpdwInstance = (DWORD_PTR)pinstance;
|
|
|
|
|
|
// Lock the segments we need. If we're doing packed mode mapping,
|
|
// we don't need the cooked mode segment in memory. However, the
|
|
// cooked mode mapper DOES call the packed routines, so we need to
|
|
// lock both in that case.
|
|
//
|
|
if (fdwOpen & MIDI_IO_COOKED)
|
|
{
|
|
LockMapperData();
|
|
LockPackedMapper();
|
|
LockCookedMapper();
|
|
}
|
|
else
|
|
{
|
|
LockMapperData();
|
|
LockPackedMapper();
|
|
}
|
|
|
|
// Do the (useless) callback
|
|
//
|
|
DriverCallback(
|
|
pinstance->dwCallback,
|
|
HIWORD(pinstance->fdwOpen),
|
|
(HDRVR)(pinstance->hmidi),
|
|
MM_MOM_OPEN,
|
|
pinstance->dwInstance,
|
|
0L,
|
|
0L);
|
|
|
|
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
@doc internal
|
|
|
|
@api DWORD | modPrepare | Handles the MODM_PREPARE message.
|
|
|
|
@parm LPMIDIHDR | lpmh | The user header to prepare.
|
|
|
|
@rdesc Some MMSYSERR_xxx code.
|
|
|
|
@comm
|
|
|
|
Create some shadow headers.
|
|
|
|
For the case of mapper opened for stream
|
|
we only require one shadow header that we can pass along to our
|
|
mapped-to stream. We need this because the mapped-to stream and
|
|
the mapped-from stream will both want to use the dwReserved[]
|
|
fields in the MIDIHDR.
|
|
|
|
For the case of mapper opened not-for-stream
|
|
This must be a long message header that we want to propogate to all
|
|
ports. Therefore we have gcPorts shadow headers and each one is
|
|
prepared on one node of the global port list.
|
|
|
|
In either case, we return MMSYSERR_NOTSUPPORTED on success so that
|
|
MMSYSTEM will take its default action and page lock the user MIDIHDR
|
|
for us.
|
|
|
|
***************************************************************************/
|
|
DWORD FNGLOBAL modPrepare(
|
|
LPMIDIHDR lpmh)
|
|
{
|
|
LPMIDIHDR lpmhNew;
|
|
LPMIDIHDR lpmhWork;
|
|
MMRESULT mmrcRet = MMSYSERR_NOERROR;
|
|
PPORT pport;
|
|
PPORT pportWork;
|
|
PSHADOWBLOCK psb = NULL;
|
|
|
|
psb = (PSHADOWBLOCK)LocalAlloc(LPTR, sizeof(*psb));
|
|
if (NULL == psb)
|
|
{
|
|
mmrcRet = MMSYSERR_NOMEM;
|
|
goto modPrepare_Cleanup;
|
|
}
|
|
|
|
psb->cRefCnt = 0;
|
|
psb->dwBufferLength = lpmh->dwBufferLength;
|
|
|
|
if (ghMidiStrm)
|
|
{
|
|
psb->lpmhShadow = (LPMIDIHDR)GlobalAllocPtr(
|
|
GMEM_MOVEABLE|GMEM_SHARE,
|
|
sizeof(*lpmhNew));
|
|
|
|
if (NULL == psb->lpmhShadow)
|
|
{
|
|
mmrcRet = MMSYSERR_NOMEM;
|
|
goto modPrepare_Cleanup;
|
|
}
|
|
|
|
lpmhNew = psb->lpmhShadow;
|
|
*lpmhNew = *lpmh;
|
|
|
|
lpmhNew->dwReserved[MH_SHADOWEE] = (DWORD_PTR)lpmh;
|
|
lpmh->dwReserved[MH_SHADOW] = (DWORD_PTR)psb;
|
|
|
|
lpmhNew->dwFlags |= MHDR_SHADOWHDR;
|
|
|
|
mmrcRet = midiOutPrepareHeader((HMIDIOUT)ghMidiStrm,
|
|
lpmhNew,
|
|
sizeof(*lpmhNew));
|
|
if (MMSYSERR_NOERROR != mmrcRet)
|
|
lpmh->dwReserved[MH_SHADOW] = 0;
|
|
}
|
|
else
|
|
{
|
|
LPMIDIHDR31 lpmh31 = (LPMIDIHDR31)lpmh;
|
|
|
|
// Prepare shadow headers for sending to multiple non-stream
|
|
// drivers
|
|
//
|
|
// NOTE: The parent header is a 3.1 style header; the children
|
|
// are 4.0 and thus are longer.
|
|
//
|
|
|
|
psb->lpmhShadow = (LPMIDIHDR)GlobalAllocPtr(
|
|
GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT,
|
|
sizeof(*lpmhNew)*gcPorts);
|
|
|
|
if (NULL == psb->lpmhShadow)
|
|
{
|
|
mmrcRet = MMSYSERR_NOMEM;
|
|
goto modPrepare_Cleanup;
|
|
}
|
|
|
|
lpmhNew = psb->lpmhShadow;
|
|
lpmhWork = lpmhNew;
|
|
for (pport = gpportList; pport; pport = pport->pNext, lpmhWork++)
|
|
{
|
|
*(LPMIDIHDR31)lpmhWork = *lpmh31;
|
|
lpmhWork->dwFlags |= MHDR_SHADOWHDR;
|
|
|
|
mmrcRet = midiOutPrepareHeader(pport->hmidi,
|
|
lpmhWork,
|
|
sizeof(*lpmhWork));
|
|
if (MMSYSERR_NOERROR != mmrcRet)
|
|
{
|
|
lpmhWork = lpmhNew;
|
|
for (pportWork = gpportList; pportWork != pport; pportWork = pportWork->pNext, lpmhWork++)
|
|
midiOutUnprepareHeader(pport->hmidi, lpmhWork, sizeof(*lpmhWork));
|
|
|
|
goto modPrepare_Cleanup;
|
|
}
|
|
|
|
lpmhWork->dwReserved[MH_SHADOWEE] = (DWORD_PTR)lpmh31;
|
|
}
|
|
|
|
DPF(1, TEXT ("Prepare: User header %p Shadow %p"), lpmh, lpmhNew);
|
|
|
|
lpmh31->reserved = (DWORD_PTR)psb;
|
|
}
|
|
|
|
// This will force MMSYSTEM to do default prepare on the parent header --
|
|
// i.e. page lock it for us.
|
|
//
|
|
modPrepare_Cleanup:
|
|
if (MMSYSERR_NOERROR != mmrcRet)
|
|
{
|
|
if (psb)
|
|
{
|
|
if (psb->lpmhShadow) GlobalFreePtr(psb->lpmhShadow);
|
|
LocalFree((HLOCAL)psb);
|
|
}
|
|
}
|
|
|
|
return (MMSYSERR_NOERROR != mmrcRet) ? mmrcRet : MMSYSERR_NOTSUPPORTED;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
@doc internal
|
|
|
|
@api DWORD | modUnprepare | Handles the MODM_UNPREPARE message.
|
|
|
|
@parm LPMIDIHDR | lpmh | The user header to unprepare.
|
|
|
|
@rdesc Some MMSYSERR_xxx code.
|
|
|
|
@comm
|
|
|
|
Fully undo the effects of the modPrepare call.
|
|
|
|
Unprepare and free all shadow headers.
|
|
|
|
Return MMSYSERR_NOTSUPPORTED so MMSYSTEM will correctly handle the
|
|
final unprepare of the user header.
|
|
|
|
***************************************************************************/
|
|
DWORD FNGLOBAL modUnprepare(
|
|
LPMIDIHDR lpmh)
|
|
{
|
|
LPMIDIHDR lpmhNew;
|
|
MMRESULT mmrc;
|
|
PPORT pport;
|
|
PSHADOWBLOCK psb;
|
|
|
|
if (ghMidiStrm)
|
|
{
|
|
psb = (PSHADOWBLOCK)(UINT_PTR)lpmh->dwReserved[MH_SHADOW];
|
|
lpmhNew = psb->lpmhShadow;
|
|
|
|
lpmhNew->dwBufferLength = psb->dwBufferLength;
|
|
mmrc = midiOutUnprepareHeader((HMIDIOUT)ghMidiStrm,
|
|
lpmhNew,
|
|
sizeof(*lpmhNew));
|
|
if (MMSYSERR_NOERROR != mmrc)
|
|
return mmrc;
|
|
|
|
LocalFree((HLOCAL)psb);
|
|
GlobalFreePtr(lpmhNew);
|
|
lpmh->dwReserved[MH_SHADOW] = 0;
|
|
}
|
|
else
|
|
{
|
|
LPMIDIHDR31 lpmh31 = (LPMIDIHDR31)lpmh;
|
|
|
|
psb = (PSHADOWBLOCK)(UINT_PTR)lpmh31->reserved;
|
|
lpmhNew = psb->lpmhShadow;
|
|
|
|
for (pport = gpportList; pport; pport = pport->pNext, ++lpmhNew)
|
|
{
|
|
lpmhNew->dwBufferLength = psb->dwBufferLength;
|
|
midiOutUnprepareHeader(pport->hmidi, lpmhNew, sizeof(*lpmhNew));
|
|
}
|
|
|
|
GlobalFreePtr(psb->lpmhShadow);
|
|
LocalFree((HLOCAL)psb);
|
|
|
|
lpmh31->reserved = 0;
|
|
}
|
|
|
|
// Need the default action of unprepare in MMSYSTEM here
|
|
//
|
|
return MMSYSERR_NOTSUPPORTED;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
@doc internal
|
|
|
|
@api DWORD | modClose | Handles the MODM_CLOSE message.
|
|
|
|
@parm PINSTANCE | pinstance | Pointer to an open instance to close.
|
|
|
|
@rdesc Some MMSYSERR_xxx code.
|
|
|
|
***************************************************************************/
|
|
DWORD FNGLOBAL modClose(
|
|
PINSTANCE pinstance)
|
|
{
|
|
PPORT pport;
|
|
|
|
DPF(1, TEXT ("Mapper close"));
|
|
// Close underlying streams on the query can-close (which is first)
|
|
// and just succeed the actual close
|
|
//
|
|
|
|
assert(pinstance);
|
|
|
|
if (pinstance->fdwOpen & MIDI_IO_CONTROL)
|
|
{
|
|
assert(pinstance == gpIoctlInstance);
|
|
|
|
gpIoctlInstance = NULL;
|
|
goto modClose_Cleanup;
|
|
}
|
|
|
|
// Assert that we're the only thing in the instance list
|
|
//
|
|
assert(gpinstanceList == pinstance);
|
|
assert(pinstance->pNext == NULL);
|
|
|
|
gpinstanceList = NULL;
|
|
|
|
if (pinstance->fdwOpen & MIDI_IO_COOKED)
|
|
UnlockCookedMapper();
|
|
|
|
UnlockMapperData();
|
|
UnlockPackedMapper();
|
|
|
|
if (ghMidiStrm)
|
|
{
|
|
midiStreamClose(ghMidiStrm);
|
|
ghMidiStrm = NULL;
|
|
}
|
|
else
|
|
{
|
|
for (pport = gpportList; pport; pport = pport->pNext)
|
|
{
|
|
if (NULL != pport->hmidi)
|
|
{
|
|
midiOutClose(pport->hmidi);
|
|
pport->hmidi = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
CLR_DEVSOPENED;
|
|
|
|
// If reconfigure due, do it!
|
|
//
|
|
if (IS_RECONFIGURE)
|
|
{
|
|
// Prevent Synchronization problems
|
|
// During Configuration
|
|
if (NULL != hMutexConfig)
|
|
WaitForSingleObject (hMutexConfig, INFINITE);
|
|
|
|
DPF(1, TEXT ("Delayed reconfigure now being done"));
|
|
UpdateInstruments(FALSE, 0);
|
|
|
|
if (NULL != hMutexConfig)
|
|
ReleaseMutex (hMutexConfig);
|
|
|
|
CLR_RECONFIGURE;
|
|
|
|
}
|
|
|
|
|
|
modClose_Cleanup:
|
|
DriverCallback(
|
|
pinstance->dwCallback,
|
|
HIWORD(pinstance->fdwOpen),
|
|
(HDRVR)(pinstance->hmidi),
|
|
MM_MOM_CLOSE,
|
|
pinstance->dwInstance,
|
|
0L,
|
|
0L);
|
|
|
|
// Free up instance memory.
|
|
//
|
|
CleanupTransBuffer (pinstance);
|
|
LocalFree((HLOCAL)pinstance);
|
|
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
@doc internal
|
|
|
|
@api DWORD | modGetPosition | Get the current position in the MIDI stream.
|
|
|
|
@parm LPINSTANCE | pinstance | Stream we want the position in.
|
|
|
|
@parm LPMMTIME | lpmmt | Pointer to a standard MMTIME struct to fill in.
|
|
|
|
@parm DWORD | cbmmt | Size of the MMTIME structure passed.
|
|
|
|
@comment
|
|
Pass the structure along to the first open subsidiary stream.
|
|
This will be considered the de facto timebase until there's a
|
|
way to set it.
|
|
|
|
@rdesc MMSYSERR_xxx
|
|
***************************************************************************/
|
|
DWORD FNGLOBAL modGetPosition(
|
|
PINSTANCE pinstance,
|
|
LPMMTIME lpmmt,
|
|
DWORD cbmmt)
|
|
{
|
|
return midiStreamPosition(ghMidiStrm,
|
|
lpmmt,
|
|
(UINT)cbmmt);
|
|
}
|
|
|
|
DWORD FNGLOBAL modSetVolume(
|
|
DWORD dwVolume)
|
|
{
|
|
PPORT pport;
|
|
MMRESULT mmrc;
|
|
MMRESULT mmrc2;
|
|
|
|
// Walk the port list and send the volume change to everyone
|
|
//
|
|
|
|
mmrc2 = MMSYSERR_NOERROR;
|
|
for (pport = gpportList; pport; pport = pport->pNext)
|
|
{
|
|
mmrc = midiOutSetVolume(pport->hmidi, dwVolume);
|
|
if (MMSYSERR_NOERROR != mmrc)
|
|
mmrc2 = mmrc;
|
|
}
|
|
|
|
return mmrc2;
|
|
}
|