915 lines
25 KiB
C
915 lines
25 KiB
C
/* Copyright (c) 1998-1999 Microsoft Corporation */
|
|
/*
|
|
* @Doc DMusic16
|
|
*
|
|
* @Module MIDIIn.c - Legacy MIDI capture emulation for DirectMusic |
|
|
*/
|
|
#pragma warning(disable:4704) /* Inline assembly */
|
|
|
|
#include <windows.h>
|
|
#include <mmsystem.h>
|
|
#include <stddef.h>
|
|
|
|
#include "dmusic16.h"
|
|
#include "debug.h"
|
|
|
|
#define IS_STATUS_BYTE(x) ((x) & 0x80)
|
|
#define IS_CHANNEL_MSG(x) (((x) & 0xF0) != 0xF0)
|
|
#define IS_SYSEX(x) ((x) == 0xF0)
|
|
|
|
#define SYSEX_SIZE 4096
|
|
/* (65535 - sizeof(MIDIHDR) - sizeof(EVENT) - sizeof(SEGHDR)) */
|
|
#define SYSEX_BUFFERS 8 /* Keep 2 buffers outstanding */
|
|
|
|
static unsigned cbChanMsg[16] =
|
|
{
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* Running status */
|
|
3, 3, 3, 3, 2, 2, 3, 0
|
|
};
|
|
|
|
static unsigned cbSysCommData[16] =
|
|
{
|
|
1, 2, 3, 2, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1
|
|
};
|
|
|
|
VOID CALLBACK _loadds midiInProc(HMIDIIN hMidiIn, UINT wMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2);
|
|
STATIC BOOL NEAR PASCAL RecordShortEvent(NPOPENHANDLE poh, DWORD dwMessage, DWORD dwTime);
|
|
STATIC BOOL NEAR PASCAL RecordSysExEvent(NPOPENHANDLE poh, LPMIDIHDR lpmh, DWORD dwTime);
|
|
STATIC VOID NEAR PASCAL NotifyClientList(LPOPENHANDLE poh);
|
|
STATIC VOID NEAR PASCAL ThruClientList(LPOPENHANDLE poh, DWORD dwMessage);
|
|
STATIC VOID NEAR PASCAL RefillFreeEventList(NPOPENHANDLE poh);
|
|
STATIC VOID NEAR PASCAL MidiInFlushQueues(NPOPENHANDLE poh);
|
|
|
|
#pragma alloc_text(INIT_TEXT, MidiOutOnLoad)
|
|
#pragma alloc_text(FIX_IN_TEXT, midiInProc)
|
|
#pragma alloc_text(FIX_IN_TEXT, RecordShortEvent)
|
|
#pragma alloc_text(FIX_IN_TEXT, RecordSysExEvent)
|
|
#pragma alloc_text(FIX_IN_TEXT, NotifyClientList)
|
|
#pragma alloc_text(FIX_IN_TEXT, ThruClientList)
|
|
|
|
/* @func Called at DLL <f LibInit>
|
|
*
|
|
* @comm
|
|
*
|
|
* Currently does nothing.
|
|
*
|
|
*/
|
|
VOID PASCAL
|
|
MidiInOnLoad(VOID)
|
|
{
|
|
}
|
|
|
|
/* @func Called at DLL <f LibExit>
|
|
*
|
|
* @comm
|
|
*
|
|
* Currently does nothing
|
|
*/
|
|
VOID PASCAL
|
|
MidiInOnExit()
|
|
{
|
|
}
|
|
|
|
/* @func Open a MIDI in device
|
|
*
|
|
* @rdesc Returns one of the following:
|
|
* @flag MMSYSERR_NOERROR | on success
|
|
* @flag MMSYSERR_NOMEM | on out of memory
|
|
*
|
|
* @comm
|
|
*
|
|
* Makes sure only one client is opening the device.
|
|
*
|
|
* Opens the device and starts MIDI input on it, noting the time of the start for timestamp calculations.
|
|
*/
|
|
MMRESULT PASCAL
|
|
MidiInOnOpen(
|
|
NPOPENHANDLEINSTANCE pohi) /* @parm The open handle instance to fulfill */
|
|
{
|
|
NPOPENHANDLE poh = pohi->pHandle;
|
|
|
|
int iChannel;
|
|
MMRESULT mmr;
|
|
|
|
/* Protect here against more than one client opening an input device.
|
|
*/
|
|
if (poh->uReferenceCount > 1)
|
|
{
|
|
return MMSYSERR_ALLOCATED;
|
|
}
|
|
|
|
/* Per client initialize thruing to NULL.
|
|
*/
|
|
pohi->pThru = (NPTHRUCHANNEL)LocalAlloc(LPTR, MIDI_CHANNELS * sizeof(THRUCHANNEL));
|
|
if (pohi->pThru == NULL)
|
|
{
|
|
return MMSYSERR_NOMEM;
|
|
}
|
|
|
|
DPF(2, "MidiInOnOpen: pohi %04X pThru %04X", pohi, pohi->pThru);
|
|
|
|
for (iChannel = 0; iChannel < MIDI_CHANNELS; iChannel++)
|
|
{
|
|
pohi->pThru[iChannel].pohi = (HANDLE)NULL;
|
|
}
|
|
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
/* @func Close a MIDI in device
|
|
*
|
|
* @comm
|
|
*
|
|
* Close the device using the <f midiInClose> API.
|
|
*/
|
|
VOID PASCAL
|
|
MidiInOnClose(
|
|
NPOPENHANDLEINSTANCE pohi) /* @parm The open handle instance to close */
|
|
{
|
|
}
|
|
|
|
/* @func Activate a MIDI in device
|
|
*
|
|
* @rdesc Returns one of the following:
|
|
* @flag MMSYSERR_NOERROR | on success
|
|
* @flag MMSYSERR_ALLOCATED | if the device is already in use
|
|
*
|
|
* May also return any of the possible return codes from the <f midiInOpen> API call.
|
|
*
|
|
* @comm
|
|
*
|
|
* Opens the device and starts MIDI input on it, noting the time of the start for timestamp calculations.
|
|
*/
|
|
MMRESULT PASCAL
|
|
MidiInOnActivate(
|
|
NPOPENHANDLEINSTANCE pohi)
|
|
{
|
|
NPOPENHANDLE poh = pohi->pHandle;
|
|
|
|
MMRESULT mmr;
|
|
|
|
if (1 == poh->uActiveCount)
|
|
{
|
|
poh->wFlags &= ~OH_F_CLOSING;
|
|
mmr = midiInOpen(&poh->hmi,
|
|
poh->id,
|
|
(DWORD)midiInProc,
|
|
(DWORD)(LPOPENHANDLE)poh,
|
|
CALLBACK_FUNCTION);
|
|
if (mmr)
|
|
{
|
|
return mmr;
|
|
}
|
|
|
|
mmr = midiInStart(poh->hmi);
|
|
poh->msStartTime = timeGetTime();
|
|
if (mmr)
|
|
{
|
|
midiInClose(poh->hmi);
|
|
}
|
|
|
|
/* NOTE: poh memory is guaranteed zeroed by allocator, so we have
|
|
* no event count and NULL pointers right now.
|
|
*/
|
|
RefillFreeEventList(poh);
|
|
}
|
|
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
/* @func Deactivate a MIDI in device
|
|
*
|
|
* @comm
|
|
*
|
|
* Close the device using the <f midiInClose> API.
|
|
*/
|
|
MMRESULT PASCAL
|
|
MidiInOnDeactivate(
|
|
NPOPENHANDLEINSTANCE pohi)
|
|
{
|
|
NPOPENHANDLE poh = pohi->pHandle;
|
|
|
|
MMRESULT mmr;
|
|
|
|
if (0 == poh->uActiveCount)
|
|
{
|
|
poh->wFlags |= OH_F_CLOSING;
|
|
mmr = midiInStop(poh->hmi);
|
|
if (mmr)
|
|
{
|
|
return mmr;
|
|
}
|
|
|
|
if (MMSYSERR_NOERROR == midiInReset(poh->hmi))
|
|
{
|
|
while (poh->wPostedSysExBuffers)
|
|
{
|
|
}
|
|
}
|
|
|
|
midiInClose(poh->hmi);
|
|
MidiInFlushQueues(poh);
|
|
}
|
|
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
|
|
/* @func Set the event handle to signal
|
|
*
|
|
* @rdesc Always returns MMSYSERR_NOERROR.
|
|
*
|
|
* @comm
|
|
*
|
|
* This function is exported through the thunk layer to DMusic32.DLL
|
|
*
|
|
* This handle is already the VxD handle that can be passed to VWin32 via MMDEVLDR using
|
|
* <f SetWin32Event>.
|
|
*
|
|
* Input notification is delivered to the Win32 application using events. The application creates
|
|
* an event using the <f CreateEvent> API and gives it to the DirectMusic port. The port code
|
|
* for legacy emulation calls the undocumented Win9x kernel API <f OpenVxDHandle> to retrieve
|
|
* an equivalent event handle that is valid in any kernel context. That handle is passed to
|
|
* this function.
|
|
*
|
|
* The event handle is stored in our per-client data (<c OPENHANDLEINSTANCE>). When MIDI data
|
|
* arrives, the event will be set. This is done using MMDEVLDR, which already has semantics
|
|
* in place to do the same sort of notification for WinMM event callbacks.
|
|
*
|
|
*/
|
|
MMRESULT WINAPI
|
|
MidiInSetEventHandle(
|
|
HANDLE hMidiIn, /* @parm The handle of the input device which desires notification */
|
|
DWORD dwEvent) /* @parm The VxD handle of the event to set when new data arrives */
|
|
{
|
|
NPOPENHANDLEINSTANCE pohi;
|
|
|
|
if (!IsValidHandle(hMidiIn, VA_F_INPUT, &pohi))
|
|
{
|
|
return MMSYSERR_INVALHANDLE;
|
|
}
|
|
|
|
pohi->dwVxDEventHandle = dwEvent;
|
|
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
/* @func Read MIDI input data into a buffer
|
|
*
|
|
* @rdesc Returns one of the following
|
|
*
|
|
* @comm
|
|
*
|
|
* This function is thunked to the 32-bit DLL
|
|
*
|
|
* Take as much data from the given event list as will fit and put it into the buffer.
|
|
*/
|
|
MMRESULT WINAPI
|
|
MidiInRead(
|
|
HANDLE hMidiIn, /* @parm The handle of the input device to read */
|
|
LPBYTE lpBuffer, /* @parm A pointer to memory to pack, in DMEVENT format */
|
|
LPDWORD pcbData, /* @parm On input, the max size of <p lpBuffer> in bytes.
|
|
On return, will contain the number of bytes of data packed into the buffer */
|
|
LPDWORD pmsTime) /* @parm On return, will contain the starting time of the buffer */
|
|
{
|
|
NPOPENHANDLEINSTANCE pohi;
|
|
NPOPENHANDLE poh;
|
|
WORD wCSID;
|
|
LPEVENT pEvent;
|
|
LPEVENT pEventRemoved;
|
|
LPBYTE pbEventData;
|
|
DWORD cbLength;
|
|
DWORD cbPaddedLength;
|
|
DWORD cbLeft;
|
|
LPBYTE lpNextEvent;
|
|
LPDMEVENT pdm;
|
|
DWORD msFirst;
|
|
MMRESULT mmr;
|
|
LPMIDIHDR lpmh;
|
|
|
|
if (!IsValidHandle(hMidiIn, VA_F_INPUT, &pohi))
|
|
{
|
|
return MMSYSERR_INVALHANDLE;
|
|
}
|
|
|
|
poh = pohi->pHandle;
|
|
|
|
lpNextEvent = lpBuffer;
|
|
cbLeft = *pcbData;
|
|
|
|
wCSID = EnterCriticalSection(&poh->wCritSect, CS_BLOCKING);
|
|
assert(wCSID);
|
|
msFirst = 0;
|
|
|
|
while (NULL != (pEvent = QueuePeek(&poh->qDone)))
|
|
{
|
|
lpmh = NULL;
|
|
|
|
if (cbLeft < sizeof(DMEVENT))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (pEvent->wFlags & EVENT_F_MIDIHDR)
|
|
{
|
|
/* This event is a SysEx message starting with a MIDIHDR, which contains
|
|
* the recorded length of the message.
|
|
*/
|
|
lpmh = (LPMIDIHDR)(&pEvent->abEvent[0]);
|
|
|
|
cbLength = lpmh->dwBytesRecorded - lpmh->dwOffset;
|
|
pbEventData = lpmh->lpData + lpmh->dwOffset;
|
|
cbPaddedLength = DMEVENT_SIZE(cbLength);
|
|
|
|
/* For SysEx, split out as much as will fit if the whole message can't.
|
|
*/
|
|
if (cbPaddedLength > cbLeft)
|
|
{
|
|
cbLength = DMEVENT_DATASIZE(cbLeft);
|
|
cbPaddedLength = DMEVENT_SIZE(cbLength);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* The data for this event is directly contained in the event.
|
|
*/
|
|
cbLength = pEvent->cbEvent;
|
|
pbEventData = &pEvent->abEvent[0];
|
|
cbPaddedLength = DMEVENT_SIZE(cbLength);
|
|
|
|
if (cbPaddedLength > cbLeft)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert(cbPaddedLength <= cbLeft);
|
|
|
|
pdm = (LPDMEVENT)lpNextEvent;
|
|
|
|
pdm->cbEvent = cbLength;
|
|
pdm->dwChannelGroup = 1;
|
|
pdm->dwFlags = 0;
|
|
|
|
if (msFirst)
|
|
{
|
|
QuadwordMul( pEvent->msTime - msFirst,
|
|
REFTIME_TO_MS,
|
|
&pdm->rtDelta);
|
|
}
|
|
else
|
|
{
|
|
*pmsTime = pEvent->msTime;
|
|
msFirst = pEvent->msTime;
|
|
|
|
pdm->rtDelta.dwLow = 0;
|
|
pdm->rtDelta.dwHigh = 0;
|
|
}
|
|
|
|
hmemcpy(pdm->abEvent, pbEventData, cbLength);
|
|
|
|
lpNextEvent += cbPaddedLength;
|
|
cbLeft -= cbPaddedLength;
|
|
|
|
if (lpmh)
|
|
{
|
|
lpmh->dwOffset += cbLength;
|
|
assert(lpmh->dwOffset <= lpmh->dwBytesRecorded);
|
|
|
|
if (lpmh->dwOffset == lpmh->dwBytesRecorded)
|
|
{
|
|
pEventRemoved = QueueRemoveFromFront(&poh->qDone);
|
|
assert(pEventRemoved == pEvent);
|
|
|
|
InterlockedIncrement(&poh->wPostedSysExBuffers);
|
|
|
|
lpmh->dwOffset = 0;
|
|
mmr = midiInAddBuffer(poh->hmi, (LPMIDIHDR)(&pEvent->abEvent[0]), sizeof(MIDIHDR));
|
|
if (mmr)
|
|
{
|
|
InterlockedDecrement(&poh->wPostedSysExBuffers);
|
|
DPF(0, "midiInAddBuffer failed with mmr=%d", mmr);
|
|
mmr = midiInUnprepareHeader(poh->hmi, (LPMIDIHDR)(&pEvent->abEvent[0]), sizeof(MIDIHDR));
|
|
if (mmr)
|
|
{
|
|
DPF(0, "...midiInUnprepareHeader failed too %d, memory leak!", mmr);
|
|
}
|
|
else
|
|
{
|
|
FreeEvent(pEvent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pEventRemoved = QueueRemoveFromFront(&poh->qDone);
|
|
assert(pEventRemoved == pEvent);
|
|
|
|
QueueAppend(&poh->qFree, pEvent);
|
|
}
|
|
}
|
|
|
|
*pcbData = lpNextEvent - lpBuffer;
|
|
|
|
DPF(1, "MidiInRead: Returning %ld bytes", (DWORD)*pcbData);
|
|
|
|
LeaveCriticalSection(&poh->wCritSect);
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
/* @func Enable thruing to a MIDI output port
|
|
*
|
|
* @comm For the given channel group and channel, enable (or disable, if the
|
|
* output handle is NULL) thruing to the given output handle, channel group, and
|
|
* channel.
|
|
*/
|
|
MMRESULT WINAPI
|
|
MidiInThru(
|
|
HANDLE hMidiIn, /* @parm The handle of the input device to thru */
|
|
DWORD dwFrom, /* @parm The channel of the input stream to thru */
|
|
DWORD dwTo, /* @parm Desination channel */
|
|
HANDLE hMidiOut) /* The output handle to receive the thru'ed data. */
|
|
{
|
|
NPOPENHANDLEINSTANCE pohiInput;
|
|
NPOPENHANDLEINSTANCE pohiOutput;
|
|
|
|
if (!IsValidHandle(hMidiIn, VA_F_INPUT, &pohiInput) ||
|
|
((hMidiOut != NULL) && !IsValidHandle(hMidiOut, VA_F_OUTPUT, &pohiOutput)))
|
|
{
|
|
return MMSYSERR_INVALHANDLE;
|
|
}
|
|
|
|
/* Note that since only 1 channel group is supported on legacy drivers,
|
|
* we don't need any channel group information.
|
|
*/
|
|
if (dwFrom > 15 || dwTo > 15)
|
|
{
|
|
return MMSYSERR_INVALPARAM;
|
|
}
|
|
|
|
DPF(1, "Thru: Sending <%04X,%u> to <%04X,%u>",
|
|
(WORD)hMidiIn, (UINT)dwFrom, (WORD)hMidiOut, (UINT)dwTo);
|
|
|
|
pohiInput->pThru[(WORD)dwFrom].wChannel = (WORD)dwTo;
|
|
pohiInput->pThru[(WORD)dwFrom].pohi = hMidiOut ? pohiOutput : NULL;
|
|
|
|
return MMSYSERR_NOERROR;
|
|
}
|
|
|
|
/* @func MIDI in data callback
|
|
*
|
|
* @comm
|
|
*
|
|
* This is a standard MIDI input callback from MMSYSYTEM. It calls the correct record routine
|
|
* and notifies the client that data has arrived.
|
|
*
|
|
* For a description of event notification of clients, see <f MidiInSetEventHandle>.
|
|
*/
|
|
VOID CALLBACK _loadds
|
|
midiInProc(
|
|
HMIDIIN hMidiIn, /* @parm The MMSYSTEM handle of the device which received data */
|
|
UINT wMsg, /* @parm The type of callback */
|
|
DWORD dwInstance, /* @parm Instance data; in our case, a pointer to an <c OPENHANDLE> matching <p hMidiIn> */
|
|
DWORD dwParam1, /* @parm Message-specific parameters */
|
|
DWORD dwParam2) /* @parm Message-specific parameters */
|
|
{
|
|
NPOPENHANDLE poh = (NPOPENHANDLE)(WORD)dwInstance;
|
|
BOOL bIsNewData = FALSE;
|
|
|
|
WORD wCSID;
|
|
|
|
|
|
/* If we can get the critical section we can do all sorts of fun stuff like
|
|
* transfer the lists over.
|
|
*/
|
|
wCSID = EnterCriticalSection(&poh->wCritSect, CS_NONBLOCKING);
|
|
if (wCSID)
|
|
{
|
|
/* We now have exclusive access to all the queues.
|
|
*
|
|
* Move any new free events into our internal free list.
|
|
*/
|
|
QueueCat(&poh->qFreeCB, &poh->qFree);
|
|
}
|
|
|
|
switch(wMsg)
|
|
{
|
|
case MIM_DATA:
|
|
DPF(1, "MIM_DATA %08lX %08lX", dwParam1, dwParam2);
|
|
bIsNewData = RecordShortEvent(poh, dwParam1, dwParam2);
|
|
break;
|
|
|
|
case MIM_LONGDATA:
|
|
DPF(1, "MIM_LONGDATA %08lX %08lX", dwParam1, dwParam2);
|
|
bIsNewData = RecordSysExEvent(poh, (LPMIDIHDR)dwParam1, dwParam2);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (wCSID)
|
|
{
|
|
/* It's safe to move events over to the shared list.
|
|
*/
|
|
QueueCat(&poh->qDone, &poh->qDoneCB);
|
|
LeaveCriticalSection(&poh->wCritSect);
|
|
}
|
|
|
|
/* Let clients know there is new data
|
|
*/
|
|
if (bIsNewData && (!(poh->wFlags & OH_F_CLOSING)))
|
|
{
|
|
NotifyClientList(poh);
|
|
}
|
|
}
|
|
|
|
/* @func Record a short message (channel messsage or system message).
|
|
*
|
|
* @comm
|
|
*
|
|
* Queue the incoming data as quickly as possible.
|
|
*
|
|
* For a description of the queues used for incoming data, see the <c OPENHANDLE> struct.
|
|
*
|
|
* @rdesc
|
|
* Returns TRUE if the data was successfully recorded; FALSE otherwise.
|
|
*/
|
|
STATIC BOOL NEAR PASCAL
|
|
RecordShortEvent(
|
|
NPOPENHANDLE poh, /* @parm The handle to record this data to */
|
|
DWORD dwMessage, /* @parm The short message to record */
|
|
DWORD dwTime) /* @parm The time stamp of the message */
|
|
{
|
|
LPEVENT pEvent;
|
|
LPBYTE pb;
|
|
BYTE b;
|
|
|
|
pEvent = QueueRemoveFromFront(&poh->qFreeCB);
|
|
if (pEvent == NULL)
|
|
{
|
|
DPF(0, "midiInProc: Missed a short event!!!");
|
|
return FALSE;
|
|
}
|
|
|
|
pEvent->msTime = poh->msStartTime + dwTime;
|
|
pEvent->wFlags = 0;
|
|
|
|
/* Now we have to parse and rebuild the channel message.
|
|
*
|
|
* NOTE: Endian specific code ahead
|
|
*/
|
|
pb = (LPBYTE)&dwMessage;
|
|
|
|
assert(!IS_SYSEX(*pb)); /* This should *always* be in MIM_LONGDATA */
|
|
assert(IS_STATUS_BYTE(*pb)); /* API guarantees no running status */
|
|
|
|
/* Copying over all the bytes is harmless (we have a DWORD in both
|
|
* source and dest) and is faster than checking to see if we have to.
|
|
*/
|
|
b = pEvent->abEvent[0] = *pb++;
|
|
pEvent->abEvent[1] = *pb++;
|
|
pEvent->abEvent[2] = *pb++;
|
|
|
|
if (IS_CHANNEL_MSG(b))
|
|
{
|
|
/* 8x, 9x, Ax, Bx, Cx, Dx, Ex */
|
|
/* 0x..7x invalid, that would need running status */
|
|
/* Fx handled below */
|
|
|
|
pEvent->cbEvent = cbChanMsg[(b >> 4) & 0x0F];
|
|
|
|
/* This is also our criteria for thruing
|
|
*/
|
|
ThruClientList(poh, dwMessage);
|
|
}
|
|
else
|
|
{
|
|
/* F1..FF */
|
|
/* F0 is sysex, should never see it here */
|
|
pEvent->cbEvent = cbSysCommData[b & 0x0F];
|
|
}
|
|
|
|
/* Now we have something to save
|
|
*/
|
|
QueueAppend(&poh->qDoneCB, pEvent);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* @func Record a SysEx message.
|
|
*
|
|
* @comm
|
|
*
|
|
* Queue the incoming data as quickly as possible.
|
|
*
|
|
* For a description of the queues used for incoming data, see the <c OPENHANDLE> struct.
|
|
*
|
|
* @rdesc
|
|
* Returns TRUE if the data was successfully recorded; FALSE otherwise.
|
|
*/
|
|
STATIC BOOL NEAR PASCAL
|
|
RecordSysExEvent(
|
|
NPOPENHANDLE poh, /* @parm The handle to record this data to */
|
|
LPMIDIHDR lpmh, /* @parm The SysEx message to record */
|
|
DWORD dwTime) /* @parm The time stamp of the message */
|
|
{
|
|
LPEVENT pEvent;
|
|
|
|
/* Get back the event header for this MIDIHDR. While buffers are in MMSYSTEM, they are not
|
|
* in any queue.
|
|
*/
|
|
InterlockedDecrement(&poh->wPostedSysExBuffers);
|
|
|
|
/* dwOffset in the MIDIHDR is used to indicate the start of data to send
|
|
* up to Win32. It is incremented by MidiInRead until the buffer has been
|
|
* emptied, at which time it will be put back into the pool.
|
|
*/
|
|
lpmh->dwOffset = 0;
|
|
|
|
pEvent = (LPEVENT)(lpmh->dwUser);
|
|
pEvent->msTime = poh->msStartTime + dwTime;
|
|
QueueAppend(&poh->qDoneCB, pEvent);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* @func Notify all clients of a device that data has arrived.
|
|
*
|
|
* @comm
|
|
*
|
|
* Walks the list of clients for the device and sets the notification event for each one.
|
|
*
|
|
* This function is now overkill since we no longer support multiple input clients per device.
|
|
*/
|
|
STATIC VOID NEAR PASCAL
|
|
NotifyClientList(
|
|
LPOPENHANDLE poh) /* @parm The handle of the device that has received data */
|
|
{
|
|
NPLINKNODE plink;
|
|
NPOPENHANDLEINSTANCE pohi;
|
|
|
|
for (plink = poh->pInstanceList; plink; plink = plink->pNext)
|
|
{
|
|
pohi = (NPOPENHANDLEINSTANCE)(((PBYTE)plink) - offsetof(OPENHANDLEINSTANCE, linkHandleList));
|
|
|
|
if (!pohi->dwVxDEventHandle)
|
|
{
|
|
/* No notification event registered for this handle yet.
|
|
*/
|
|
continue;
|
|
}
|
|
|
|
SetWin32Event(pohi->dwVxDEventHandle);
|
|
}
|
|
}
|
|
|
|
/* @func Thru this message based on the settings of all clients of a device.
|
|
*
|
|
* @comm
|
|
*
|
|
* Walks the list of clients for the device and looks at the thru settings of each one.
|
|
*
|
|
* This function is now overkill since we no longer support multiple input clients per device.
|
|
*/
|
|
STATIC VOID NEAR PASCAL
|
|
ThruClientList(
|
|
LPOPENHANDLE poh,
|
|
DWORD dwMessage)
|
|
{
|
|
NPLINKNODE plink;
|
|
NPOPENHANDLEINSTANCE pohi;
|
|
NPOPENHANDLEINSTANCE pohiDest;
|
|
int iChannel;
|
|
|
|
iChannel = (int)(dwMessage & 0x0000000Fl);
|
|
dwMessage &= 0xFFFFFFF0l;
|
|
|
|
for (plink = poh->pInstanceList; plink; plink = plink->pNext)
|
|
{
|
|
pohi = (NPOPENHANDLEINSTANCE)(((PBYTE)plink) - offsetof(OPENHANDLEINSTANCE, linkHandleList));
|
|
|
|
pohiDest = pohi->pThru[iChannel].pohi;
|
|
if (pohiDest == NULL || !pohiDest->fActive)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
MidiOutThru(pohiDest,
|
|
dwMessage & 0xFFFFFFF0l | pohi->pThru[iChannel].wChannel);
|
|
}
|
|
}
|
|
|
|
/* @func Refill the free lists
|
|
*
|
|
* @comm
|
|
*
|
|
* This function is called periodically from user mode to ensure that there are enough free
|
|
* events available for the input callback.
|
|
*/
|
|
VOID PASCAL
|
|
MidiInRefillFreeLists(VOID)
|
|
{
|
|
NPLINKNODE plink;
|
|
NPOPENHANDLE poh;
|
|
|
|
for (plink = gOpenHandleList;
|
|
(poh = (NPOPENHANDLE)plink) != NULL;
|
|
plink = plink->pNext)
|
|
{
|
|
/* Only refill MIDI in devices which are not in the process of closing
|
|
*/
|
|
if ((poh->wFlags & (OH_F_MIDIIN | OH_F_CLOSING)) != OH_F_MIDIIN)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
RefillFreeEventList(poh);
|
|
}
|
|
}
|
|
|
|
/* @func Terminate thruing to this output handle
|
|
*
|
|
* @comm
|
|
*
|
|
* This function is called before the given output handle is closed.
|
|
*/
|
|
VOID PASCAL
|
|
MidiInUnthruToInstance(
|
|
NPOPENHANDLEINSTANCE pohiClosing) /* @parm NPOPENHANDLE | pohClosing |
|
|
The handle which is closing. */
|
|
{
|
|
NPLINKNODE plink;
|
|
NPOPENHANDLE poh;
|
|
NPLINKNODE plinkInstance;
|
|
NPOPENHANDLEINSTANCE pohiInstance;
|
|
int iChannel;
|
|
|
|
for (plink = gOpenHandleList; (poh = (NPOPENHANDLE)plink) != NULL; plink = plink->pNext)
|
|
{
|
|
DPF(2, "Unthru: poh <%04X>", (WORD)poh);
|
|
|
|
if (!(poh->wFlags & OH_F_MIDIIN))
|
|
{
|
|
DPF(2, "...not input");
|
|
continue;
|
|
}
|
|
|
|
for (plinkInstance = poh->pInstanceList; plinkInstance; plinkInstance = plinkInstance->pNext)
|
|
{
|
|
pohiInstance = (NPOPENHANDLEINSTANCE)(((PBYTE)plinkInstance) - offsetof(OPENHANDLEINSTANCE, linkHandleList));
|
|
|
|
DPF(2, "pohiInstance <%04X>", (WORD)pohiInstance);
|
|
|
|
for (iChannel = 0; iChannel < MIDI_CHANNELS; iChannel++)
|
|
{
|
|
DPF(2, "Channel 0 @ <%04X>", (WORD)&pohiInstance->pThru[iChannel]);
|
|
if (pohiInstance->pThru[iChannel].pohi == pohiClosing)
|
|
{
|
|
DPF(1, "Thru: Closing output handle %04X which is in use!", (WORD)pohiClosing);
|
|
pohiInstance->pThru[iChannel].pohi = NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* @func Allocate enough free events to refill the pool to CAP_HIGHWATERMARK
|
|
*
|
|
* @comm
|
|
*
|
|
* BUGBUG call this on a window timer callback
|
|
*
|
|
*/
|
|
STATIC VOID NEAR PASCAL
|
|
RefillFreeEventList(
|
|
NPOPENHANDLE poh) /* @parm The device to refill the free list of */
|
|
{
|
|
int idx;
|
|
LPEVENT pEvent;
|
|
UINT cFree;
|
|
WORD wCSID;
|
|
QUADWORD rt = {0, 0};
|
|
int cNewBuffers;
|
|
LPMIDIHDR lpmh;
|
|
MMRESULT mmr;
|
|
WORD wIntStat;
|
|
|
|
wCSID = EnterCriticalSection(&poh->wCritSect, CS_BLOCKING);
|
|
assert(wCSID);
|
|
|
|
/* NOTE: Technically not allowed to access qFreeCB here, but this is an approximation
|
|
*/
|
|
cFree = poh->qFree.cEle + poh->qFreeCB.cEle;
|
|
if (cFree < CAP_HIGHWATERMARK)
|
|
{
|
|
DPF(1, "RefillFreeEventList poh %.4x free %u highwater %u",
|
|
(WORD)poh,
|
|
(UINT)cFree,
|
|
(UINT)CAP_HIGHWATERMARK);
|
|
|
|
for (idx = CAP_HIGHWATERMARK - cFree; idx; --idx)
|
|
{
|
|
pEvent = AllocEvent(0, rt, sizeof(DWORD));
|
|
if (NULL == pEvent)
|
|
{
|
|
DPF(0, "AllocEvent returned NULL in RefillFreeEventList");
|
|
break;
|
|
}
|
|
|
|
QueueAppend(&poh->qFree, pEvent);
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&poh->wCritSect);
|
|
|
|
if (poh->wPostedSysExBuffers < SYSEX_BUFFERS)
|
|
{
|
|
for (idx = SYSEX_BUFFERS - cFree; idx; --idx)
|
|
{
|
|
pEvent = AllocEvent(0, rt, sizeof(MIDIHDR) + SYSEX_SIZE);
|
|
if (NULL == pEvent)
|
|
{
|
|
break;
|
|
}
|
|
|
|
pEvent->wFlags |= EVENT_F_MIDIHDR;
|
|
|
|
lpmh = (LPMIDIHDR)(&pEvent->abEvent[0]);
|
|
lpmh->lpData = (LPSTR)(lpmh + 1);
|
|
lpmh->dwBufferLength = SYSEX_SIZE;
|
|
lpmh->dwUser = (DWORD)pEvent;
|
|
|
|
mmr = midiInPrepareHeader(poh->hmi, lpmh, sizeof(MIDIHDR));
|
|
if (mmr)
|
|
{
|
|
DPF(0, "midiInPrepareHeader: %u\n", mmr);
|
|
FreeEvent(pEvent);
|
|
break;
|
|
}
|
|
|
|
InterlockedIncrement(&poh->wPostedSysExBuffers);
|
|
mmr = midiInAddBuffer(poh->hmi, lpmh, sizeof(MIDIHDR));
|
|
if (mmr)
|
|
{
|
|
InterlockedDecrement(&poh->wPostedSysExBuffers);
|
|
|
|
DPF(0, "midiInAddBuffer: %u\n", mmr);
|
|
midiInUnprepareHeader(poh->hmi, lpmh, sizeof(MIDIHDR));
|
|
FreeEvent(pEvent);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* @func Return all memory from all queues to the free event list.
|
|
*
|
|
* @comm
|
|
*
|
|
*/
|
|
STATIC VOID NEAR PASCAL
|
|
MidiInFlushQueues(
|
|
NPOPENHANDLE poh)
|
|
{
|
|
WORD wCSID;
|
|
|
|
wCSID = EnterCriticalSection(&poh->wCritSect, CS_BLOCKING);
|
|
assert(wCSID);
|
|
|
|
FreeAllQueueEvents(&poh->qDone);
|
|
FreeAllQueueEvents(&poh->qDoneCB);
|
|
FreeAllQueueEvents(&poh->qFree);
|
|
FreeAllQueueEvents(&poh->qFreeCB);
|
|
|
|
LeaveCriticalSection(&poh->wCritSect);
|
|
}
|
|
|
|
/* @func Free all events in the given event queue.
|
|
*
|
|
* @comm
|
|
*
|
|
* Assumes that the queue's critical section has already been taken by the caller.
|
|
*
|
|
*/
|
|
VOID PASCAL
|
|
FreeAllQueueEvents(
|
|
NPEVENTQUEUE peq)
|
|
{
|
|
LPEVENT lpCurr;
|
|
LPEVENT lpNext;
|
|
|
|
lpCurr = peq->pHead;
|
|
while (lpCurr)
|
|
{
|
|
lpNext = lpCurr->lpNext;
|
|
FreeEvent(lpCurr);
|
|
lpCurr = lpNext;
|
|
}
|
|
|
|
peq->pHead = peq->pTail = NULL;
|
|
peq->cEle = 0;
|
|
}
|