able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/media/drivers/drvlib/mididd.c

1602 lines
50 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/****************************************************************************
*
* mididd.c
*
* Multimedia kernel driver support component (mmdrv)
*
* Copyright (c) 1991-1995 Microsoft Corporation
*
* Driver for midi input and output devices
*
* -- Midi driver entry points (modMessage, midMessage)
* -- Auxiliary task (necessary for receiving Apcs and generating
* callbacks ASYNCRHONOUSLY)
* -- Interface to kernel driver (NtDeviceIoControlFile)
* -- Midi parsing code (ported from Windows 3.1).
*
* History
* 01-Feb-1992 - Robin Speed (RobinSp) wrote it
*
***************************************************************************/
#include <drvlib.h>
#include <ntddmidi.h>
/*****************************************************************************
internal declarations
****************************************************************************/
//
// Stack size for our auxiliary task
//
#define MIDI_STACK_SIZE 300
#define SYSEX_ERROR 0xFF // internal error for sysex's on input
//
// Functions for auxiliary thread to perform
//
typedef enum {
MidiThreadInvalid,
MidiThreadAddBuffer,
MidiThreadSetState,
MidiThreadSetData,
MidiThreadClose,
MidiThreadTerminate
} MIDITHREADFUNCTION;
//
// Our local buffers for interfacing to midi input
//
#define LOCAL_MIDI_DATA_SIZE 20
typedef struct _LOCALMIDIHDR {
OVERLAPPED Ovl;
DWORD BytesReturned;
struct _LOCALMIDIHDR *lpNext; // Queueing (really debug only)
BOOL Done; // Driver completed buffer
PVOID pClient; // Our instance data for Apcs
MIDI_DD_INPUT_DATA MidiData; // What the driver wants to process
BYTE ExtraData[LOCAL_MIDI_DATA_SIZE - sizeof(ULONG)];
// The rest of our input buffer
} LOCALMIDIHDR, *PLOCALMIDIHDR;
//
// Midi input data
//
#define NUMBER_OF_LOCAL_MIDI_BUFFERS 8
typedef struct {
//
// Static data for managing midi input
//
BOOL fMidiInStarted; // Do we think midi in is running ?
DWORD dwMsg; // Current short msg
DWORD dwCurData; // Position in long message
BYTE status; // Running status byte
BOOLEAN fSysex; // Processing extended message
BOOLEAN Bad; // Input not working properly
BYTE bBytesLeft; // Bytes left in short message
BYTE bBytePos; // Position in short message
DWORD dwCurTime; // Latest time from driver
DWORD dwMsgTime; // Time to insert into message
// in milliseconds since device
// was opened
PLOCALMIDIHDR DeviceQueue; // Keep track of what the device
// has (debugging only)
LOCALMIDIHDR // Driver interface buffers
Bufs[NUMBER_OF_LOCAL_MIDI_BUFFERS];// When input is active these
// are queued on the device
// except while data is being
// processed from them
} LOCALMIDIDATA, *PLOCALMIDIDATA;
//
// per allocation structure for Midi
//
typedef struct tag_MIDIALLOC {
struct tag_MIDIALLOC *Next; // Chain of devices
UINT DeviceNumber; // Number of device
UINT DeviceType; // MidiInput or MidiOutput
DWORD_PTR dwCallback; // client's callback
DWORD_PTR dwInstance; // client's instance data
HMIDI hMidi; // handle for stream
HANDLE hDev; // Midi device handle
LPMIDIHDR lpMIQueue; // Buffers sent to device
// This is only required so that
// CLOSE knows when things have
// really finished.
// notify. This is only accessed
// on the device thread and its
// apcs so does not need any
// synchronized access.
HANDLE Event; // Event for driver syncrhonization
// and notification of auxiliary
// task operation completion.
MIDITHREADFUNCTION AuxFunction; // Function for thread to perform
union {
LPMIDIHDR pHdr; // Buffer to pass in aux task
ULONG State; // State to set
struct {
ULONG Function; // IOCTL to use
PBYTE pData; // Data to set or get
ULONG DataLen; // Length of data
} GetSetData;
} AuxParam;
// 0 means terminate task.
HANDLE ThreadHandle; // Handle for termination ONLY
HANDLE AuxEvent1; // Aux thread waits on this
HANDLE AuxEvent2; // Aux thread caller waits on this
DWORD AuxReturnCode; // Return code from Aux task
DWORD dwFlags; // Open flags
PLOCALMIDIDATA Mid; // Extra midi input structures
int l; // Helper global for modMidiLength
} MIDIALLOC, *PMIDIALLOC;
PMIDIALLOC MidiHandleList; // Our chain of wave handles
/*****************************************************************************
internal function prototypes
****************************************************************************/
STATIC DWORD midiThread(LPVOID lpParameter);
STATIC void midiCleanUp(PMIDIALLOC pClient);
STATIC DWORD midiThreadCall(MIDITHREADFUNCTION Function, PMIDIALLOC pClient);
STATIC DWORD midiSetState(PMIDIALLOC pClient, ULONG State);
STATIC void midiInOvl(DWORD dwRet, DWORD dwBytes, LPOVERLAPPED pOverlap);
STATIC DWORD midiInWrite(LPMIDIHDR pHdr, PMIDIALLOC pClient);
STATIC DWORD midiOutWrite(PBYTE pData, ULONG Len, PMIDIALLOC pClient);
STATIC void midiBlockFinished(LPMIDIHDR lpHdr, DWORD MsgId);
STATIC void midiCallback(PMIDIALLOC pMidi, DWORD msg, DWORD_PTR dw1, DWORD_PTR dw2);
STATIC int modMIDIlength(PMIDIALLOC pClient, BYTE b);
STATIC void midByteRec(PMIDIALLOC pClient, BYTE byte);
STATIC void midSendPartBuffer(PMIDIALLOC pClient);
STATIC void midFreeQ(PMIDIALLOC pClient);
STATIC void midiFlush(PMIDIALLOC pClient);
/****************************************************************************
* @doc INTERNAL
*
* @api VOID | TerminateMidi | Free all midi resources for mmdrv.dll
*
* @rdesc None
***************************************************************************/
VOID TerminateMidi(VOID)
{
//
// Don't do any cleanup - Midi input resources cleaned up on Close.
//
}
/****************************************************************************
* @doc INTERNAL
*
* @api void | midiGetDevCaps | Get the device capabilities.
*
* @parm DWORD | id | Device id
*
* @parm UINT | DeviceType | type of device
*
* @parm LPBYTE | lpCaps | Far pointer to a MIDIOUTCAPS structure to
* receive the information.
*
* @parm DWORD | dwSize | Size of the MIDIOUTCAPS structure.
*
* @rdesc There is no return value.
***************************************************************************/
STATIC DWORD midiGetDevCaps(DWORD id, UINT DeviceType,
LPBYTE lpCaps, DWORD dwSize)
{
MMRESULT mrc;
if (DeviceType != MIDI_IN) {
MIDIOUTCAPSW mc;
mrc = sndGetData(DeviceType, id, sizeof(mc), (LPBYTE)&mc,
IOCTL_MIDI_GET_CAPABILITIES);
if (mrc != MMSYSERR_NOERROR) {
return mrc;
}
InternalLoadString((UINT)*(LPDWORD)mc.szPname, mc.szPname,
sizeof(mc.szPname) / sizeof(WCHAR));
CopyMemory(lpCaps, &mc, min(sizeof(mc), dwSize));
} else {
MIDIINCAPSW mc;
mrc = sndGetData(DeviceType, id, sizeof(mc), (LPBYTE)&mc,
IOCTL_MIDI_GET_CAPABILITIES);
if (mrc != MMSYSERR_NOERROR) {
return mrc;
}
InternalLoadString((UINT)*(LPDWORD)mc.szPname, mc.szPname,
sizeof(mc.szPname) / sizeof(WCHAR));
CopyMemory(lpCaps, &mc, min(sizeof(mc), dwSize));
}
return MMSYSERR_NOERROR;
}
/****************************************************************************
* @doc INTERNAL
*
* @api DWORD | midiOpen | Open midi device and set up logical device data
* and auxilary task for issuing requests and servicing Apc's
*
* @parm MIDIDEVTYPE | DeviceType | Whether it's a midi input or output device
*
* @parm DWORD | id | The device logical id
*
* @parm DWORD | msg | Input parameter to modMessage
*
* @parm DWORD | dwUser | Input parameter to modMessage - pointer to
* application's handle (generated by this routine)
*
* @parm DWORD | dwParam1 | Input parameter to modMessage
*
* @parm DWORD | dwParam2 | Input parameter to modMessage
*
* @rdesc modMessage return code.
***************************************************************************/
STATIC DWORD midiOpen(UINT DeviceType,
DWORD id,
DWORD_PTR dwUser,
DWORD_PTR dwParam1,
DWORD_PTR dwParam2)
{
PMIDIALLOC pClient; // pointer to client information structure
MMRESULT mRet;
// dwParam1 contains a pointer to a MIDIOPENDESC
// dwParam2 contains midi driver specific flags in the LOWORD
// and generic driver flags in the HIWORD
//
// allocate my per-client structure
//
if (DeviceType == MIDI_OUT) {
pClient = (PMIDIALLOC)HeapAlloc(hHeap, 0, sizeof(MIDIALLOC));
if (pClient != NULL) {
memset(pClient, 0, sizeof(MIDIALLOC));
}
} else {
WinAssert(DeviceType == MIDI_IN);
pClient = (PMIDIALLOC)HeapAlloc(hHeap, 0,
sizeof(struct _xx {MIDIALLOC S1; LOCALMIDIDATA S2;}));
if (pClient != NULL) {
memset(pClient, 0, sizeof(struct _xx {MIDIALLOC S1; LOCALMIDIDATA S2;}));
}
}
if (pClient == NULL) {
return MMSYSERR_NOMEM;
}
if (DeviceType == MIDI_IN) {
PLOCALMIDIDATA pMid;
int i;
pMid = pClient->Mid = (PLOCALMIDIDATA)(pClient + 1);
for (i = 0 ;i < NUMBER_OF_LOCAL_MIDI_BUFFERS ; i++) {
pMid->Bufs[i].pClient = pClient;
}
}
//
// and fill it with info
//
// (note that setting everything to 0 correctly initialized our
// midi input processing static data).
pClient->DeviceType = DeviceType;
pClient->dwCallback = ((LPMIDIOPENDESC)dwParam1)->dwCallback;
pClient->dwInstance = ((LPMIDIOPENDESC)dwParam1)->dwInstance;
pClient->hMidi = ((LPMIDIOPENDESC)dwParam1)->hMidi;
pClient->dwFlags = (DWORD)dwParam2;
//
// See if we can open our device
// If it's only a query be sure only to open for read, otherwise
// we could get STATUS_BUSY if someone else is writing to the
// device.
//
mRet = sndOpenDev(DeviceType,
id,
&pClient->hDev,
(GENERIC_READ | GENERIC_WRITE));
if (mRet != MMSYSERR_NOERROR) {
midiCleanUp(pClient);
return mRet;
}
//
// Create our event for syncrhonization with the device driver
//
pClient->Event = CreateEvent(NULL, FALSE, FALSE, NULL);
if (pClient->Event == NULL) {
midiCleanUp(pClient);
return MMSYSERR_NOMEM;
}
if (DeviceType == MIDI_IN) {
//
// Create our event pair for synchronization with the auxiliary
// thread
//
pClient->AuxEvent1 = CreateEvent(NULL, FALSE, FALSE, NULL);
if (pClient->AuxEvent1 == NULL) {
midiCleanUp(pClient);
return MMSYSERR_NOMEM;
}
pClient->AuxEvent2 = CreateEvent(NULL, FALSE, FALSE, NULL);
if (pClient->AuxEvent2 == NULL) {
midiCleanUp(pClient);
return MMSYSERR_NOMEM;
}
//
// Create our auxiliary thread for sending buffers to the driver
// and collecting Apcs
//
mRet = mmTaskCreate((LPTASKCALLBACK)midiThread,
&pClient->ThreadHandle,
(DWORD_PTR)pClient);
if (mRet != MMSYSERR_NOERROR) {
midiCleanUp(pClient);
return MMSYSERR_NOMEM;
}
//
// Make sure the thread has really started
//
WaitForSingleObject(pClient->AuxEvent2, INFINITE);
}
//
// give the client my driver dw
//
{
PMIDIALLOC *pUserHandle;
pUserHandle = (PMIDIALLOC *)dwUser;
*pUserHandle = pClient;
}
//
// sent client his OPEN callback message
//
midiCallback(pClient, DeviceType == MIDI_OUT ? MOM_OPEN : MIM_OPEN,
0L, 0L);
return MMSYSERR_NOERROR;
}
/****************************************************************************
* @doc INTERNAL
*
* @api void | midiCleanUp | Free resources for a midi device
*
* @parm PMIDIALLOC | pClient | Pointer to a MIDIALLOC structure describing
* resources to be freed.
*
* @rdesc There is no return value.
*
* @comm If the pointer to the resource is NULL then the resource has not
* been allocated.
***************************************************************************/
STATIC void midiCleanUp(PMIDIALLOC pClient)
{
if (pClient->hDev != INVALID_HANDLE_VALUE) {
CloseHandle(pClient->hDev);
}
if (pClient->AuxEvent1) {
CloseHandle(pClient->AuxEvent1);
}
if (pClient->AuxEvent2) {
CloseHandle(pClient->AuxEvent2);
}
if (pClient->Event) {
CloseHandle(pClient->Event);
}
HeapFree(hHeap, 0, (LPSTR)pClient);
}
/****************************************************************************
* @doc INTERNAL
*
* @api DWORD | midiOutWrite | Synchronously process a midi output
* buffer.
*
* @parm LPMIDIHDR | pHdr | Pointer to a midi buffer
*
* @parm PMIDIALLOC | pClient | The data associated with the logical midi
* device.
*
* @rdesc A MMSYS... type return code for the application.
***************************************************************************/
STATIC DWORD midiOutWrite(PBYTE pData, ULONG Len, PMIDIALLOC pClient)
{
DWORD BytesReturned;
//
// Try passing the request to our driver
// We operate synchronously but allow for the driver to operate
// asynchronously by waiting on an event.
//
if (!DeviceIoControl(
pClient->hDev,
IOCTL_MIDI_PLAY,
(PVOID)pData, // Input buffer
Len, // Input buffer size
NULL, // Output buffer
0, // Output buffer size
&BytesReturned,
NULL)) {
return sndTranslateStatus();
}
return MMSYSERR_NOERROR;
}
/****************************************************************************
* @doc INTERNAL
*
* @api DWORD | midiInPutBuffer | Pass a buffer to receive midi input
*
* @parm LPMIDIHDR | pHdr | Pointer to a midi buffer
*
* @parm PMIDIALLOC | pClient | The data associated with the logical midi
* device.
*
* @rdesc A MMSYS... type return code for the application.
***************************************************************************/
STATIC MMRESULT midiInPutBuffer(PLOCALMIDIHDR pHdr, PMIDIALLOC pClient)
{
DWORD BytesReturned;
BOOL Result;
WinAssert(!pHdr->Done); // Flag should be clear ready for setting by Apc
//
// BUGBUG - nice to have a semaphore for some of this !
//
//
// Try passing the request to our driver
// We operate synchronously but allow for the driver to operate
// asynchronously by waiting on an event.
//
Result = ReadFileEx(
pClient->hDev,
(LPVOID)&pHdr->MidiData,
sizeof(pHdr->ExtraData) +
sizeof(MIDI_DD_INPUT_DATA),
&pHdr->Ovl,
midiInOvl);
//
// Put the buffer in our queue
//
if (Result || GetLastError() == ERROR_IO_PENDING) {
PLOCALMIDIHDR *ppHdr;
pHdr->lpNext = NULL;
ppHdr = &pClient->Mid->DeviceQueue;
while (*ppHdr) {
ppHdr = &(*ppHdr)->lpNext;
}
*ppHdr = pHdr;
return MMSYSERR_NOERROR;
}
return sndTranslateStatus();
}
/****************************************************************************
* @doc INTERNAL
*
* @api DWORD | midiInWrite | Pass a new buffer to the Auxiliary thread for
* a midi device.
*
* @parm LPMIDIHDR | pHdr | Pointer to a midit buffer
*
* @parm PMIDIALLOC | pClient | The data associated with the logical midi
* device.
*
* @rdesc A MMSYS... type return code for the application.
*
* @comm The buffer flags are set and the buffer is passed to the auxiliary
* device task for processing.
***************************************************************************/
STATIC DWORD midiInWrite(LPMIDIHDR pHdr, PMIDIALLOC pClient)
{
//
// Put the request at the end of our queue.
//
pHdr->dwFlags |= MHDR_INQUEUE;
pHdr->dwFlags &= ~MHDR_DONE;
pClient->AuxParam.pHdr = pHdr;
return midiThreadCall(MidiThreadAddBuffer, pClient);
}
/****************************************************************************
* @doc INTERNAL
*
* @api DWORD | midiSetState | Set a midi device to a given state
*
* @parm PMIDIALLOC | pClient | The data associated with the logical midi
* output device.
*
* @parm ULONG | State | The new state
*
* @rdesc A MMSYS... type return code for the application.
***************************************************************************/
STATIC DWORD midiSetState(PMIDIALLOC pClient, ULONG State)
{
MMRESULT mRc;
mRc = sndSetHandleData(pClient->hDev,
sizeof(State),
&State,
IOCTL_MIDI_SET_STATE,
pClient->Event);
midiFlush(pClient);
return mRc;
}
/****************************************************************************
* @doc INTERNAL
*
* @api DWORD | midiThreadCall | Set the function for the thread to perform
* and 'call' the thread using the event pair mechanism.
*
* @parm MIDITHREADFUNCTION | Function | The function to perform
*
* @parm PMIDIALLOC | Our logical device data
*
* @rdesc An MMSYS... type return value suitable for returning to the
* application
*
* @comm The AuxParam field in the device data is the 'input' to
* the function processing loop in MidiThread().
***************************************************************************/
STATIC DWORD midiThreadCall(MIDITHREADFUNCTION Function, PMIDIALLOC pClient)
{
//
// Set the function code
//
pClient->AuxFunction = Function;
//
// Kick off the thread
//
SetEvent(pClient->AuxEvent1);
//
// Wait for it to complete
//
WaitForSingleObject(pClient->AuxEvent2, INFINITE);
//
// Return the return code that our task set.
//
return pClient->AuxReturnCode;
}
/****************************************************************************
* @doc INTERNAL
*
* @api void | midiInApc | Apc routine. Called when a kernel sound driver
* completes processing of a midi buffer.
*
* @parm PVOID | ApcContext | The Apc parameter. In our case this is a
* pointer to our midi device data.
*
* @parm PIO_STATUS_BLOCK | pIosb | Pointer to the Io status block
* used for the request.
*
* @rdesc There is no return code.
***************************************************************************/
STATIC void midiInOvl(DWORD dwRet, DWORD dwBytesReturned, LPOVERLAPPED pOverlap)
{
PLOCALMIDIHDR pHdr;
pHdr = ((PLOCALMIDIHDR)pOverlap);
WinAssert(((PMIDIALLOC)pHdr->pClient)->DeviceType == MIDI_IN);
//
// Note that the buffer is complete. We don't do anything else here
// because funny things happen if we call the client's callback
// routine from within an Apc.
//
pHdr->BytesReturned = dwBytesReturned;
pHdr->Done = TRUE;
}
/****************************************************************************
* @doc INTERNAL
*
* @api void | midiFlush | Buffer completion routine. This completes
* the work of the Apc routine at below Apc priority. This gets
* round the nasty situations arising when the user's callback
* causes more apcs to run (I strongly suspect this is a kernel
* but).
*
* @parm PMIDIALLOC | pClient | The client's handle data
*
* @rdesc There is no return code.
***************************************************************************/
STATIC void midiFlush(PMIDIALLOC pClient)
{
//
// Process any completed buffers - the Apc routine
// set the 'Done' flag in any completed requests.
// Note that the call to the user's callback can
// cause more requests to become complete
//
if (pClient->DeviceType == MIDI_IN) { // Output is synchronous
while (pClient->Mid->DeviceQueue &&
pClient->Mid->DeviceQueue->Done) {
PLOCALMIDIHDR pHdr;
pHdr = pClient->Mid->DeviceQueue;
//
// Clear our flag ready for next time
//
pHdr->Done = FALSE;
//
// Take buffer off the device queue
//
pClient->Mid->DeviceQueue = pHdr->lpNext;
//
// Grab the latest time estimate - convert from 100ns units
// to milliseconds
//
pClient->Mid->dwCurTime =
(DWORD)(pHdr->MidiData.Time.QuadPart / 10000);
//
// Complete our buffer
//
if (!pClient->Mid->Bad) {
int i;
for (i = 0;
i + sizeof(LARGE_INTEGER) < pHdr->BytesReturned;
i++) {
midByteRec(pClient, pHdr->MidiData.Data[i]);
}
//
// Requeue our buffer if we're still recording
//
if (pClient->Mid->fMidiInStarted) {
if (midiInPutBuffer(pHdr, pClient) != MMSYSERR_NOERROR) {
pClient->Mid->Bad = TRUE;
}
}
}
} // End of processing completed buffers
}
}
/****************************************************************************
* @doc INTERNAL
*
* @api DWORD | midiThread | Midi device auxiliary thread.
*
* @parm LPVOID | lpParameter | The thread parameter. In our case this is a
* pointer to our midi device data.
*
* @rdesc Thread return code.
***************************************************************************/
STATIC DWORD midiThread(LPVOID lpParameter)
{
PMIDIALLOC pClient;
BOOL Close;
Close = FALSE;
pClient = (PMIDIALLOC)lpParameter;
//
// Set our thread to high priority so we don't fail to pass
// new buffers to the device when we get them back. Also
// we don't want any gaps if callbacks are meant to play
// notes just received.
//
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
//
// We start notifying our creator we have started and
// waiting for something to do.
//
SetEvent(pClient->AuxEvent2);
WaitForSingleObject(pClient->AuxEvent1, INFINITE);
//
// Now we're going
//
for(;;) {
//
// Initialize our return code
//
pClient->AuxReturnCode = MMSYSERR_NOERROR;
//
// Decode function number to perform
//
switch (pClient->AuxFunction) {
case MidiThreadAddBuffer:
//
// Add the buffer to our list to be processed
//
{
LPMIDIHDR *pHdrSearch;
pClient->AuxParam.pHdr->lpNext = NULL;
pHdrSearch = &pClient->lpMIQueue;
while (*pHdrSearch) {
pHdrSearch = &(*pHdrSearch)->lpNext;
}
*pHdrSearch = pClient->AuxParam.pHdr;
}
break;
case MidiThreadSetState:
switch (pClient->AuxParam.State) {
case MIDI_DD_RECORD:
//
// Start means we must add our buffers to the driver's list
//
if (!pClient->Mid->fMidiInStarted && !pClient->Mid->Bad) {
int i;
for (i = 0; i < NUMBER_OF_LOCAL_MIDI_BUFFERS; i++) {
pClient->AuxReturnCode =
midiInPutBuffer(&pClient->Mid->Bufs[i], pClient);
if (pClient->AuxReturnCode != MMSYSERR_NOERROR) {
//
// Failed to add our buffer so give up and
// get our buffers back !
//
pClient->Mid->Bad = TRUE;
break;
}
}
//
// Set Device state. By issuing state changes on THIS
// thread the calling thread can be sure that all Apc's
// generated by buffer completions will complete
// BEFORE this function completes.
//
pClient->AuxReturnCode =
midiSetState(pClient, pClient->AuxParam.State);
//
// If this failed then get our buffers back,
// otherwise set our new state
//
if (pClient->AuxReturnCode != MMSYSERR_NOERROR) {
pClient->Mid->Bad = TRUE;
} else {
pClient->Mid->fMidiInStarted = TRUE;
}
} else {
//
// Already started or bad
//
}
break;
case MIDI_DD_STOP:
//
// Set Device state. By issuing state changes on THIS
// thread the calling thread can be sure that all Apc's
// generated by buffer completions will complete
// BEFORE this function completes.
//
if (pClient->Mid->fMidiInStarted) {
pClient->Mid->fMidiInStarted = FALSE;
//
// RESET so we get our buffers back
//
pClient->AuxReturnCode =
midiSetState(pClient, MIDI_DD_RESET);
WinAssert(!pClient->Mid->DeviceQueue);
if (pClient->AuxReturnCode == MMSYSERR_NOERROR) {
midSendPartBuffer(pClient);
}
}
break;
case MIDI_DD_RESET:
//
// Set Device state. By issuing state changes on THIS
// thread the calling thread can be sure that all Apc's
// generated by buffer completions will complete
// BEFORE this function completes.
//
if (pClient->Mid->fMidiInStarted) {
pClient->Mid->fMidiInStarted = FALSE;
pClient->AuxReturnCode =
midiSetState(pClient, pClient->AuxParam.State);
WinAssert(!pClient->Mid->DeviceQueue);
if (pClient->AuxReturnCode == MMSYSERR_NOERROR) {
pClient->Mid->Bad = FALSE; // Recovered !!
midSendPartBuffer(pClient);
}
}
//
// We zero the input queue anyway - compatibility with
// windows 3.1
//
midFreeQ(pClient);
break;
}
break;
case MidiThreadSetData:
{
pClient->AuxReturnCode =
sndSetHandleData(pClient->hDev,
pClient->AuxParam.GetSetData.DataLen,
pClient->AuxParam.GetSetData.pData,
pClient->AuxParam.GetSetData.Function,
pClient->Event);
}
break;
case MidiThreadClose:
//
// Try to complete.
// If we're completed all our buffers then we can.
// otherwise we can't
//
if (pClient->lpMIQueue == NULL) {
pClient->AuxReturnCode = MMSYSERR_NOERROR;
Close = TRUE;
} else {
pClient->AuxReturnCode = MIDIERR_STILLPLAYING;
}
break;
default:
WinAssert(FALSE); // Invalid call
break;
}
//
// Trap invalid callers
//
pClient->AuxFunction = MidiThreadInvalid;
//
// See if apcs completed
//
midiFlush(pClient);
//
// Release the caller
//
SetEvent(pClient->AuxEvent2);
//
// Complete ?
//
if (Close) {
break;
}
//
// Wait for more !
//
while (WaitForSingleObjectEx(pClient->AuxEvent1, INFINITE, TRUE) ==
WAIT_IO_COMPLETION) {
//
// Complete buffers whose Apcs ran
//
midiFlush(pClient);
}
}
//
// We've been asked to terminte
//
return 1;
}
/****************************************************************************
* @doc INTERNAL
*
* @api void | midiCallback | This calls DriverCallback for a MIDIHDR.
*
* @parm PMIDIALLOC | pMidi | Pointer to midi device.
*
* @parm DWORD | msg | The message.
*
* @parm DWORD | dw1 | message DWORD (dw2 is always set to 0).
*
* @rdesc There is no return value.
***************************************************************************/
void midiCallback(PMIDIALLOC pMidi, DWORD msg, DWORD_PTR dw1, DWORD_PTR dw2)
{
// invoke the callback function, if it exists. dwFlags contains
// midi driver specific flags in the LOWORD and generic driver
// flags in the HIWORD
if (pMidi->dwCallback)
DriverCallback(pMidi->dwCallback, // user's callback DWORD
HIWORD(pMidi->dwFlags), // callback flags
(HDRVR)pMidi->hMidi, // handle to the midi device
msg, // the message
pMidi->dwInstance, // user's instance data
dw1, // first DWORD
dw2); // second DWORD
}
/****************************************************************************
This function conforms to the standard Midi input driver message proc
(midMessage), which is documented in mmddk.d.
****************************************************************************/
DWORD APIENTRY midMessage(DWORD id, DWORD msg, DWORD_PTR dwUser, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
PMIDIALLOC pInClient;
switch (msg) {
case MIDM_GETNUMDEVS:
D2(("MIDM_GETNUMDEVS"));
return sndGetNumDevs(MIDI_IN);
case MIDM_GETDEVCAPS:
D2(("MIDM_GETDEVCAPS"));
return midiGetDevCaps(id, MIDI_IN, (LPBYTE)dwParam1,
(DWORD)dwParam2);
case MIDM_OPEN:
D2(("MIDM_OPEN"));
return midiOpen(MIDI_IN, id, dwUser, dwParam1, dwParam2);
case MIDM_CLOSE:
D2(("MIDM_CLOSE"));
pInClient = (PMIDIALLOC)dwUser;
//
// Call our task to see if it's ready to complete
//
if (midiThreadCall(MidiThreadClose, pInClient) != 0L) {
return MIDIERR_STILLPLAYING;
}
//
// Wait for our thread to terminate and close our device
//
WaitForSingleObject(pInClient->ThreadHandle, INFINITE);
CloseHandle(pInClient->ThreadHandle);
//
// Tell the caller we're done
//
midiCallback(pInClient, MIM_CLOSE, 0L, 0L);
midiCleanUp(pInClient);
return MMSYSERR_NOERROR;
case MIDM_ADDBUFFER:
D2(("MIDM_ADDBUFFER"));
// check if it's been prepared
if (!(((LPMIDIHDR)dwParam1)->dwFlags & MHDR_PREPARED))
return MIDIERR_UNPREPARED;
WinAssert(!(((LPMIDIHDR)dwParam1)->dwFlags & MHDR_INQUEUE));
// if it is already in our Q, then we cannot do this
if ( ((LPMIDIHDR)dwParam1)->dwFlags & MHDR_INQUEUE )
return ( MIDIERR_STILLPLAYING );
// store the pointer to my MIDIALLOC structure in the midihdr
pInClient = (PMIDIALLOC)dwUser;
((LPMIDIHDR)dwParam1)->reserved = (DWORD_PTR)(LPSTR)pInClient;
return midiInWrite((LPMIDIHDR)dwParam1, pInClient);
case MIDM_STOP:
D2(("MIDM_PAUSE"));
pInClient = (PMIDIALLOC)dwUser;
pInClient->AuxParam.State = MIDI_DD_STOP;
return midiThreadCall(MidiThreadSetState, pInClient);
case MIDM_START:
D2(("MIDM_RESTART"));
pInClient = (PMIDIALLOC)dwUser;
pInClient->AuxParam.State = MIDI_DD_RECORD;
return midiThreadCall(MidiThreadSetState, pInClient);
case MIDM_RESET:
D2(("MIDM_RESET"));
pInClient = (PMIDIALLOC)dwUser;
pInClient->AuxParam.State = MIDI_DD_RESET;
return midiThreadCall(MidiThreadSetState, pInClient);
default:
return MMSYSERR_NOTSUPPORTED;
}
//
// Should not get here
//
WinAssert(0);
return MMSYSERR_NOTSUPPORTED;
}
/****************************************************************************
This function conforms to the standard Midi output driver message proc
(modMessage), which is documented in mmddk.d.
****************************************************************************/
DWORD APIENTRY modMessage(DWORD id, DWORD msg, DWORD_PTR dwUser, DWORD_PTR dwParam1,
DWORD_PTR dwParam2)
{
PMIDIALLOC pOutClient;
switch (msg) {
case MODM_GETNUMDEVS:
D2(("MODM_GETNUMDEVS"));
return sndGetNumDevs(MIDI_OUT);
case MODM_GETDEVCAPS:
D2(("MODM_GETDEVCAPS"));
return midiGetDevCaps(id, MIDI_OUT, (LPBYTE)dwParam1,
(DWORD)dwParam2);
case MODM_OPEN:
D2(("MODM_OPEN"));
return midiOpen(MIDI_OUT, id, dwUser, dwParam1, dwParam2);
case MODM_CLOSE:
D2(("MODM_CLOSE"));
pOutClient = (PMIDIALLOC)dwUser;
midiCallback(pOutClient, MOM_CLOSE, 0L, 0L);
//
// Close our device
//
midiCleanUp(pOutClient);
return MMSYSERR_NOERROR;
case MODM_DATA:
D2(("MODM_DATA"));
{
int i;
BYTE b[4];
for (i = 0; i < 4; i ++) {
b[i] = (BYTE)(dwParam1 % 256);
dwParam1 /= 256;
}
return midiOutWrite(b, modMIDIlength((PMIDIALLOC)dwUser, b[0]),
(PMIDIALLOC)dwUser);
}
case MODM_LONGDATA:
D2(("MODM_LONGDATA"));
pOutClient = (PMIDIALLOC)dwUser;
{
LPMIDIHDR lpHdr;
MMRESULT mRet;
//
// check if it's been prepared
//
lpHdr = (LPMIDIHDR)dwParam1;
if (!(lpHdr->dwFlags & MHDR_PREPARED)) {
return MIDIERR_UNPREPARED;
}
//
//
//
mRet = midiOutWrite((LPBYTE)lpHdr->lpData, lpHdr->dwBufferLength,
pOutClient);
// note that clearing the done bit or setting the inqueue bit
// isn't necessary here since this function is synchronous -
// the client will not get control back until it's done.
lpHdr->dwFlags |= MHDR_DONE;
// notify client
if (mRet == MMSYSERR_NOERROR) {
midiCallback(pOutClient, MOM_DONE, (DWORD_PTR)lpHdr, 0L);
}
return mRet;
}
case MODM_RESET:
D2(("MODM_RESET"));
return midiSetState((PMIDIALLOC)dwUser, MIDI_DD_RESET);
case MODM_SETVOLUME:
D2(("MODM_SETVOLUME"));
//pOutClient = (PMIDIALLOC)dwUser;
//pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
//pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
//pOutClient->AuxParam.GetSetData.Function = IOCTL_MIDI_SET_VOLUME;
//return midiThreadCall(MidiThreadSetData, pOutClient);
return sndSetData(MIDI_OUT, id, sizeof(DWORD),
(PBYTE)&dwParam1, IOCTL_MIDI_SET_VOLUME);
case MODM_GETVOLUME:
D2(("MODM_GETVOLUME"));
//pOutClient = (PMIDIALLOC)dwUser;
//pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
//pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
//pOutClient->AuxParam.GetSetData.Function = IOCTL_MIDI_GET_VOLUME;
//return midiThreadCall(MidiThreadGetData, pOutClient);
return sndGetData(MIDI_OUT, id, sizeof(DWORD),
(PBYTE)dwParam1, IOCTL_MIDI_GET_VOLUME);
case MODM_CACHEPATCHES:
D2(("MODM_CACHEPATCHES"));
pOutClient = (PMIDIALLOC)dwUser;
{
MIDI_DD_CACHE_PATCHES AppData;
DWORD BytesReturned;
AppData.Bank = HIWORD(dwParam2);
AppData.Flags = LOWORD(dwParam2);
memcpy(AppData.Patches, (PVOID)dwParam1, sizeof(AppData.Patches));
return DeviceIoControl(
pOutClient->hDev,
IOCTL_MIDI_CACHE_PATCHES,
(PVOID)&AppData,
sizeof(AppData),
NULL,
0,
&BytesReturned,
NULL) ?
MMSYSERR_NOERROR :
sndTranslateStatus();
}
case MODM_CACHEDRUMPATCHES:
D2(("MODM_CACHEDRUMPATCHES"));
pOutClient = (PMIDIALLOC)dwUser;
{
MIDI_DD_CACHE_DRUM_PATCHES AppData;
DWORD BytesReturned;
AppData.Patch = HIWORD(dwParam2);
AppData.Flags = LOWORD(dwParam2);
memcpy(AppData.DrumPatches, (PVOID)dwParam1,
sizeof(AppData.DrumPatches));
return DeviceIoControl(
pOutClient->hDev,
IOCTL_MIDI_CACHE_DRUM_PATCHES,
(PVOID)&AppData,
sizeof(AppData),
NULL,
0,
&BytesReturned,
NULL) ?
MMSYSERR_NOERROR :
sndTranslateStatus();
}
default:
return MMSYSERR_NOTSUPPORTED;
}
//
// Should not get here
//
WinAssert(0);
return MMSYSERR_NOTSUPPORTED;
}
/***********************************************************************
UTILITY ROUTINES PORTED DIRECTLY FROM WIN 3.1
***********************************************************************/
/****************************************************************************
* @doc INTERNAL
*
* @api int | modMIDIlength | Get the length of a short midi message.
*
* @parm DWORD | dwMessage | The message.
*
* @rdesc Returns the length of the message.
***************************************************************************/
STATIC int modMIDIlength(PMIDIALLOC pClient, BYTE b)
{
if (b >= 0xF8) { // system realtime
/* for realtime messages, leave running status untouched */
return 1; // write one byte
}
switch (b) {
case 0xF0: case 0xF4: case 0xF5: case 0xF6: case 0xF7:
pClient->l = 1;
return pClient->l;
case 0xF1: case 0xF3:
pClient->l = 2;
return pClient->l;
case 0xF2:
pClient->l = 3;
return pClient->l;
}
switch (b & 0xF0) {
case 0x80: case 0x90: case 0xA0: case 0xB0: case 0xE0:
pClient->l = 3;
return pClient->l;
case 0xC0: case 0xD0:
pClient->l = 2;
return pClient->l;
}
return (pClient->l - 1); // uses previous value if data byte (running status)
}
/****************************************************************************
* @doc INTERNAL
*
* @api void | midBufferWrite | This function writes a byte into the long
* message buffer. If the buffer is full or a SYSEX_ERROR or
* end-of-sysex byte is received, the buffer is marked as 'done' and
* it's owner is called back.
*
* @parm BYTE | byte | The byte received.
*
* @rdesc There is no return value
***************************************************************************/
STATIC void midBufferWrite(PMIDIALLOC pClient, BYTE byte)
{
LPMIDIHDR lpmh;
UINT msg;
// if no buffers, nothing happens
if (pClient->lpMIQueue == NULL)
return;
lpmh = pClient->lpMIQueue;
if (byte == SYSEX_ERROR) {
D2(("sysexerror"));
msg = MIM_LONGERROR;
}
else {
D2(("bufferwrite"));
msg = MIM_LONGDATA;
*((LPSTR)(lpmh->lpData) + pClient->Mid->dwCurData++) = byte;
}
// if end of sysex, buffer full or error, send them back the buffer
if ((byte == SYSEX_ERROR) || (byte == 0xF7) || (pClient->Mid->dwCurData >= lpmh->dwBufferLength)) {
D2(("bufferdone"));
pClient->lpMIQueue = pClient->lpMIQueue->lpNext;
lpmh->dwBytesRecorded = pClient->Mid->dwCurData;
pClient->Mid->dwCurData = 0L;
lpmh->dwFlags |= MHDR_DONE;
lpmh->dwFlags &= ~MHDR_INQUEUE;
midiCallback(pClient, msg, (DWORD_PTR)lpmh, pClient->Mid->dwMsgTime);
}
return;
}
/****************************************************************************
* @doc INTERNAL
*
* @api void | midByteRec | This function constructs the complete midi
* messages from the individual bytes received and passes the message
* to the client via his callback.
*
* @parm WORD | word | The byte received is in the low order byte.
*
* @rdesc There is no return value
*
* @comm Note that currently running status isn't turned off on errors.
***************************************************************************/
STATIC void midByteRec(PMIDIALLOC pClient, BYTE byte)
{
if (!pClient->Mid->fMidiInStarted)
return;
// if it's a system realtime message, send it
// this does not affect running status or any current message
if (byte >= 0xF8) {
D2((" rt"));
midiCallback(pClient, MIM_DATA, (DWORD)byte, pClient->Mid->dwCurTime);
}
// else if it's a system common message
else if (byte >= 0xF0) {
if (pClient->Mid->fSysex) { // if we're in a sysex
pClient->Mid->fSysex = FALSE; // status byte during sysex ends it
if (byte == 0xF7)
{
midBufferWrite(pClient, 0xF7); // write in long message buffer
return;
}
else
midBufferWrite(pClient, SYSEX_ERROR); // secret code indicating error
}
if (pClient->Mid->dwMsg) { // throw away any incomplete short data
midiCallback(pClient, MIM_ERROR, pClient->Mid->dwMsg, pClient->Mid->dwMsgTime);
pClient->Mid->dwMsg = 0L;
}
pClient->Mid->status = 0; // kill running status
pClient->Mid->dwMsgTime = pClient->Mid->dwCurTime; // save timestamp
switch(byte) {
case 0xF0:
D2((" F0"));
pClient->Mid->fSysex = TRUE;
midBufferWrite(pClient, 0xF0);
break;
case 0xF7:
D2((" F7"));
if (!pClient->Mid->fSysex)
midiCallback(pClient, MIM_ERROR, (DWORD)byte, pClient->Mid->dwMsgTime);
// else already took care of it above
break;
case 0xF4: // system common, no data bytes
case 0xF5:
case 0xF6:
D2((" status0"));
midiCallback(pClient, MIM_DATA, (DWORD)byte, pClient->Mid->dwMsgTime);
pClient->Mid->bBytePos = 0;
break;
case 0xF1: // system common, one data byte
case 0xF3:
D2((" status1"));
pClient->Mid->dwMsg |= byte;
pClient->Mid->bBytesLeft = 1;
pClient->Mid->bBytePos = 1;
break;
case 0xF2: // system common, two data bytes
D2((" status2"));
pClient->Mid->dwMsg |= byte;
pClient->Mid->bBytesLeft = 2;
pClient->Mid->bBytePos = 1;
break;
}
}
// else if it's a channel message
else if (byte >= 0x80) {
if (pClient->Mid->fSysex) { // if we're in a sysex
pClient->Mid->fSysex = FALSE; // status byte during sysex ends it
midBufferWrite(pClient, SYSEX_ERROR); // secret code indicating error
}
if (pClient->Mid->dwMsg) { // throw away any incomplete data
midiCallback(pClient, MIM_ERROR, pClient->Mid->dwMsg, pClient->Mid->dwMsgTime);
pClient->Mid->dwMsg = 0L;
}
pClient->Mid->status = byte; // save for running status
pClient->Mid->dwMsgTime = pClient->Mid->dwCurTime; // save timestamp
pClient->Mid->dwMsg |= byte;
pClient->Mid->bBytePos = 1;
switch(byte & 0xF0) {
case 0xC0: // channel message, one data byte
case 0xD0:
D2((" status1"));
pClient->Mid->bBytesLeft = 1;
break;
case 0x80: // channel message, two data bytes
case 0x90:
case 0xA0:
case 0xB0:
case 0xE0:
D2((" status2"));
pClient->Mid->bBytesLeft = 2;
break;
}
}
// else if it's an expected data byte for a long message
else if (pClient->Mid->fSysex) {
D2((" sxdata"));
midBufferWrite(pClient, byte); // write in long message buffer
}
// else if it's an expected data byte for a short message
else if (pClient->Mid->bBytePos != 0) {
D2((" data"));
if ((pClient->Mid->status) && (pClient->Mid->bBytePos == 1)) { // if running status
pClient->Mid->dwMsg |= pClient->Mid->status;
pClient->Mid->dwMsgTime = pClient->Mid->dwCurTime; // save timestamp
}
pClient->Mid->dwMsg += (DWORD)byte << ((pClient->Mid->bBytePos++) * 8);
if (--pClient->Mid->bBytesLeft == 0) {
midiCallback(pClient, MIM_DATA, pClient->Mid->dwMsg, pClient->Mid->dwMsgTime);
pClient->Mid->dwMsg = 0L;
if (pClient->Mid->status) {
pClient->Mid->bBytesLeft = pClient->Mid->bBytePos - (BYTE)1;
pClient->Mid->bBytePos = 1;
}
else {
pClient->Mid->bBytePos = 0;
}
}
}
// else if it's an unexpected data byte
else {
D2((" baddata"));
midiCallback(pClient, MIM_ERROR, (DWORD)byte, pClient->Mid->dwMsgTime);
}
return;
}
/****************************************************************************
* @doc INTERNAL
*
* @api void | midFreeQ | Free all buffers in the MIQueue.
*
* @comm Currently this is only called after sending off any partially filled
* buffers, so all buffers here are empty. The timestamp value is 0 in
* this case.
*
* @rdesc There is no return value.
***************************************************************************/
STATIC void midFreeQ(PMIDIALLOC pClient)
{
LPMIDIHDR lpH, lpN;
lpH = pClient->lpMIQueue; // point to top of the queue
pClient->lpMIQueue = NULL; // mark the queue as empty
pClient->Mid->dwCurData = 0L;
while (lpH) {
lpN = lpH->lpNext;
lpH->dwFlags |= MHDR_DONE;
lpH->dwFlags &= ~MHDR_INQUEUE;
lpH->dwBytesRecorded = 0;
midiCallback(pClient, MIM_LONGDATA, (DWORD_PTR)lpH,
pClient->Mid->dwCurTime);
lpH = lpN;
}
}
/****************************************************************************
* @doc INTERNAL
*
* @api void | midSendPartBuffer | This function is called from midStop().
* It looks at the buffer at the head of the queue and, if it contains
* any data, marks it as done as sends it back to the client.
*
* @rdesc The return value is the number of bytes transfered. A value of zero
* indicates that there was no more data in the input queue.
***************************************************************************/
STATIC void midSendPartBuffer(PMIDIALLOC pClient)
{
LPMIDIHDR lpH;
if (pClient->lpMIQueue && pClient->Mid->dwCurData) {
lpH = pClient->lpMIQueue;
pClient->lpMIQueue = pClient->lpMIQueue->lpNext;
lpH->dwFlags |= MHDR_DONE;
lpH->dwFlags &= ~MHDR_INQUEUE;
pClient->Mid->dwCurData = 0L;
midiCallback(pClient, MIM_LONGERROR, (DWORD_PTR)lpH,
pClient->Mid->dwMsgTime);
}
}

Reference in a new issue Copy permalink