windows-xp/Source/XPSP1/NT/drivers/wdm/audio/legacy/wdmaud.drv/midiin.c

/****************************************************************************
 *
 *   midiin.c
 *
 *   WDM Audio support for Midi Input devices
 *
 *   Copyright (C) Microsoft Corporation, 1997 - 1999  All Rights Reserved.
 *
 *   History
 *      5-12-97 - Noel Cross (NoelC)
 *
 ***************************************************************************/

#include "wdmdrv.h"
#include <stdarg.h>

#ifndef UNDER_NT
#pragma alloc_text(FIXCODE, midiCallback)
#pragma alloc_text(FIXCODE, midiInCompleteHeader)
#endif

/****************************************************************************

    This function conforms to the standard Midi input driver message proc
    (midMessage), which is documented in mmddk.h

****************************************************************************/
DWORD FAR PASCAL _loadds midMessage
(
    UINT      id,
    UINT      msg,
    DWORD_PTR dwUser,
    DWORD_PTR dwParam1,
    DWORD_PTR dwParam2
)
{
    LPDEVICEINFO  DeviceInfo;
    LPDEVICEINFO  pInClient;
    MMRESULT      mmr;

    switch (msg)
    {
        case MIDM_INIT:
            DPF(DL_TRACE|FA_MIDI, ("MIDM_INIT") );
            return wdmaudAddRemoveDevNode(MidiInDevice, (LPCWSTR)dwParam2, TRUE);

        case DRVM_EXIT:
            DPF(DL_TRACE|FA_MIDI, ("DRVM_EXIT: MidiIn") );
            return wdmaudAddRemoveDevNode(MidiInDevice, (LPCWSTR)dwParam2, FALSE);

        case MIDM_GETNUMDEVS:
            DPF(DL_TRACE|FA_MIDI, ("MIDM_GETNUMDEVS") );
            return wdmaudGetNumDevs(MidiInDevice, (LPCWSTR)dwParam1);

        case MIDM_GETDEVCAPS:
            DPF(DL_TRACE|FA_MIDI, ("MIDM_GETDEVCAPS") );
            if (DeviceInfo = GlobalAllocDeviceInfo((LPWSTR)dwParam2))
            {
                DeviceInfo->DeviceType = MidiInDevice;
                DeviceInfo->DeviceNumber = id;
                mmr = wdmaudGetDevCaps(DeviceInfo, (MDEVICECAPSEX FAR*)dwParam1);
                GlobalFreeDeviceInfo(DeviceInfo);
                return mmr;
            } else {
                MMRRETURN( MMSYSERR_NOMEM );
            }

        case MIDM_OPEN:
        {
            LPMIDIOPENDESC pmod = (LPMIDIOPENDESC)dwParam1;

            DPF(DL_TRACE|FA_MIDI, ("MIDM_OPEN") );
            if (DeviceInfo = GlobalAllocDeviceInfo((LPWSTR)pmod->dnDevNode))
            {
                DeviceInfo->DeviceType = MidiInDevice;
                DeviceInfo->DeviceNumber = id;
                mmr = midiOpen(DeviceInfo, dwUser, pmod, (DWORD)dwParam2);
                DPF(DL_TRACE|FA_MIDI,("dwUser(DI)=%08X",dwUser) );
                GlobalFreeDeviceInfo(DeviceInfo);
                return mmr;
            } else {
                MMRRETURN( MMSYSERR_NOMEM );
            }
        }

        case MIDM_CLOSE:
            DPF(DL_TRACE|FA_MIDI, ("MIDM_CLOSE dwUser(DI)=%08X",dwUser) );
            pInClient = (LPDEVICEINFO)dwUser;

            if( (mmr=IsValidDeviceInfo(pInClient)) != MMSYSERR_NOERROR )
            {
                MMRRETURN( mmr );
            }

            mmr = wdmaudCloseDev( pInClient );

            if (MMSYSERR_NOERROR == mmr)
            {
#ifdef UNDER_NT
                //
                //  Wait for all of the queued up I/O to come back from
                //  wdmaud.sys.
                //
                wdmaudDestroyCompletionThread ( pInClient );
#endif

                //
                // Tell the caller we're done
                //
                midiCallback( pInClient, MIM_CLOSE, 0L, 0L);

                ISVALIDDEVICEINFO(pInClient);
                ISVALIDDEVICESTATE(pInClient->DeviceState,FALSE);

                midiCleanUp( pInClient );
            }

            return mmr;

        case MIDM_ADDBUFFER:
            DPF(DL_TRACE|FA_MIDI, ("MIDM_ADDBUFFER") );

            //
            // Don't touch bad pointers!
            //
            pInClient = (LPDEVICEINFO)dwUser;

            if( ( (mmr=IsValidDeviceInfo(pInClient)) != MMSYSERR_NOERROR) ||
                ( (mmr=IsValidDeviceState(pInClient->DeviceState,FALSE)) != MMSYSERR_NOERROR ) ||
                ( (mmr=IsValidMidiHeader((LPMIDIHDR)dwParam1)) != MMSYSERR_NOERROR)
                )
            {
                MMRRETURN( mmr );
            }

            // check if it's been prepared
            if (!(((LPMIDIHDR)dwParam1)->dwFlags & MHDR_PREPARED))
                MMRRETURN( MIDIERR_UNPREPARED );

            DPFASSERT(!(((LPMIDIHDR)dwParam1)->dwFlags & MHDR_INQUEUE));

            // if it is already in our Q, then we cannot do this
            if ( ((LPMIDIHDR)dwParam1)->dwFlags & MHDR_INQUEUE )
                MMRRETURN( MIDIERR_STILLPLAYING );

            DPF(DL_TRACE|FA_MIDI,("dwUser(DI)=%08X,dwParam1(HDR)=%08X",pInClient,dwParam1) );
            return midiInRead( pInClient, (LPMIDIHDR)dwParam1);

        case MIDM_STOP:
            DPF(DL_TRACE|FA_MIDI, ("MIDM_STOP dwUser(DI)=%08X",dwUser) );

            pInClient = (LPDEVICEINFO)dwUser;
            return wdmaudSetDeviceState(pInClient,
                                        IOCTL_WDMAUD_MIDI_IN_STOP);

        case MIDM_START:
            DPF(DL_TRACE|FA_MIDI, ("MIDM_START dwUser(DI)=%08X",dwUser) );

            pInClient = (LPDEVICEINFO)dwUser;
            return wdmaudSetDeviceState(pInClient,
                                        IOCTL_WDMAUD_MIDI_IN_RECORD);

        case MIDM_RESET:
            DPF(DL_TRACE|FA_MIDI, ("MIDM_RESET dwUser(DI)=%08X",dwUser) );

            pInClient = (LPDEVICEINFO)dwUser;
            return wdmaudSetDeviceState(pInClient,
                                        IOCTL_WDMAUD_MIDI_IN_RESET);
#ifdef MIDI_THRU
        case DRVM_ADD_THRU:
        case DRVM_REMOVE_THRU:
#endif

        default:
            MMRRETURN( MMSYSERR_NOTSUPPORTED );
    }

    //
    // Should not get here
    //

    DPFASSERT(0);
    MMRRETURN( MMSYSERR_NOTSUPPORTED );
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | midiCallback | This calls DriverCallback for a MIDIHDR.
 *
 * @parm LPDEVICEINFO | pMidiDevice | pointer to midi device.
 *
 * @parm UINT | msg | The message.
 *
 * @parm DWORD | dw1 | message DWORD (dw2 is always set to 0).
 *
 * @rdesc There is no return value.
 ***************************************************************************/
VOID FAR midiCallback
(
    LPDEVICEINFO pMidiDevice,
    UINT         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 (pMidiDevice->dwCallback)
        DriverCallback(pMidiDevice->dwCallback,                       // user's callback DWORD
                       HIWORD(pMidiDevice->dwFlags),                  // callback flags
                       (HDRVR)pMidiDevice->DeviceHandle,              // handle to the midi device
                       msg,                                           // the message
                       pMidiDevice->dwInstance,                       // user's instance data
                       dw1,                                           // first DWORD
                       dw2);                                          // second DWORD
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api DWORD | midiOpen | Open midi device and set up logical device data
 *
 * @parm LPDEVICEINFO | DeviceInfo | Specifies if it's a midi input or output
 *                                   device
 *
 * @parm DWORD | dwUser | Input parameter to modMessage - pointer to
 *   application's handle (generated by this routine)
 *
 * @parm DWORD | pmod | pointer to MIDIOPENDESC, was dwParam1 parameter
 *                      to modMessage
 *
 * @parm DWORD | dwParam2 | Input parameter to modMessage
 *
 * @rdesc modMessage return code.
 ***************************************************************************/
MMRESULT FAR midiOpen
(
    LPDEVICEINFO   DeviceInfo,
    DWORD_PTR      dwUser,
    LPMIDIOPENDESC pmod,
    DWORD          dwParam2
)
{
    LPDEVICEINFO  pClient;  // pointer to client information structure
    MMRESULT      mmr;
#ifndef UNDER_NT
    DWORD        dwCallback16;
#else
    ULONG        BufferCount;
#endif


    // pmod 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
    //
    pClient = GlobalAllocDeviceInfo(DeviceInfo->wstrDeviceInterface);
    if (NULL == pClient)
    {
        MMRRETURN( MMSYSERR_NOMEM );
    }

    pClient->DeviceState = (LPVOID) GlobalAllocPtr( GPTR, sizeof( DEVICESTATE ) );
    if (NULL == pClient->DeviceState)
    {
        GlobalFreeDeviceInfo( pClient );
        MMRRETURN( MMSYSERR_NOMEM );
    }

#ifdef UNDER_NT
    //
    // Allocate memory for our critical section
    //
    pClient->DeviceState->csQueue = (LPVOID) GlobalAllocPtr( GPTR, sizeof( CRITICAL_SECTION ) );
    if (NULL == pClient->DeviceState->csQueue)
    {
        GlobalFreePtr( pClient->DeviceState );
        GlobalFreeDeviceInfo( pClient );
        MMRRETURN( MMSYSERR_NOMEM );
    }

    try
    {
        InitializeCriticalSection( (LPCRITICAL_SECTION)pClient->DeviceState->csQueue );
    }
    except(EXCEPTION_EXECUTE_HANDLER)
    {
        GlobalFreePtr( pClient->DeviceState->csQueue );
        GlobalFreePtr( pClient->DeviceState );
        GlobalFreeDeviceInfo( pClient );
        MMRRETURN( MMSYSERR_NOMEM );
    }
#endif

    //
    //  fill out context data
    //
    pClient->DeviceNumber= DeviceInfo->DeviceNumber;
    pClient->DeviceType  = DeviceInfo->DeviceType;
    pClient->dwInstance  = pmod->dwInstance;
    pClient->dwCallback  = pmod->dwCallback;
#ifdef UNDER_NT
    pClient->DeviceHandle= (HANDLE32)pmod->hMidi;
#else
    pClient->DeviceHandle= (HANDLE32)MAKELONG(pmod->hMidi,0);
    _asm
    {
        mov ax, offset MidiEventDeviceCallback
        mov word ptr [dwCallback16], ax
        mov ax, seg MidiEventDeviceCallback
        mov word ptr [dwCallback16+2], ax
    }
    pClient->dwCallback16= dwCallback16;
#endif
    pClient->dwFlags     = dwParam2;

    //
    //  initialize the device state
    //
    DPF(DL_TRACE|FA_SYNC,("DI=%08X New DeviceState",pClient) );
    pClient->DeviceState->lpMidiInQueue= NULL;
    pClient->DeviceState->fPaused     = FALSE;
    pClient->DeviceState->fRunning    = FALSE;
    pClient->DeviceState->fExit       = FALSE;

    pClient->DeviceState->bMidiStatus = 0;
    pClient->DeviceState->lpNoteOnMap = NULL;
#ifdef DEBUG
    pClient->DeviceState->dwSig = DEVICESTATE_SIGNATURE;
#endif
    if (pClient->DeviceType == MidiOutDevice)
    {
        //
        // For MIDI out, allocate one byte per note per channel to track
        // what's been played. This is used to avoid doing a brute-force
        // all notes off on MODM_RESET.
        //
        pClient->DeviceState->lpNoteOnMap = GlobalAllocPtr( GPTR, MIDI_NOTE_MAP_SIZE );
        if (NULL == pClient->DeviceState->lpNoteOnMap)
        {
#ifdef UNDER_NT
            GlobalFreePtr( pClient->DeviceState->csQueue );
#endif
            GlobalFreePtr( pClient->DeviceState );
            GlobalFreeDeviceInfo( pClient );
            MMRRETURN( MMSYSERR_NOMEM );
        }
    }

    //
    // See if we can open our device
    //
    mmr = wdmaudOpenDev( pClient, NULL );

    if (mmr != MMSYSERR_NOERROR)
    {
        if ( pClient->DeviceState->lpNoteOnMap )
        {
            GlobalFreePtr( pClient->DeviceState->lpNoteOnMap );
        }
#ifdef UNDER_NT
        DeleteCriticalSection( (LPCRITICAL_SECTION)pClient->DeviceState->csQueue );
        GlobalFreePtr( pClient->DeviceState->csQueue );
#endif
        GlobalFreePtr( pClient->DeviceState );
        GlobalFreeDeviceInfo( pClient ) ;
        return mmr;
    }

    //
    // Add instance to chain of devices
    //
    EnterCriticalSection(&wdmaudCritSec);
    pClient->Next = pMidiDeviceList;
    pMidiDeviceList = pClient;
    LeaveCriticalSection(&wdmaudCritSec);

    //
    // give the client my driver dw
    //
    {
        LPDEVICEINFO FAR *pUserHandle;

        pUserHandle = (LPDEVICEINFO FAR *)dwUser;
        *pUserHandle = pClient;
    }

#ifndef UNDER_NT
    // If this is a MIDI output device, page lock the memory because it can
    // be accessed at interrupt time.
    //
    GlobalSmartPageLock( (HGLOBAL)HIWORD( pClient ));
    GlobalSmartPageLock( (HGLOBAL)HIWORD( pClient->DeviceState ));
    GlobalSmartPageLock( (HGLOBAL)HIWORD( pClient->DeviceState->lpNoteOnMap ));
#endif

#ifdef UNDER_NT
    //
    //  If this is a MIDI input device on NT, send some buffers
    //  down to the device in order so that once recording starts
    //  we can get some data back.  The pin is paused after
    //  the call to wdmaudOpenDev.
    //
    if ( MidiInDevice == pClient->DeviceType )
    {
        for (BufferCount = 0; BufferCount < STREAM_BUFFERS; BufferCount++)
        {
            mmr = wdmaudGetMidiData( pClient, NULL );
            if ( MMSYSERR_NOERROR != mmr )
            {
                //
                //  We hope that this doesn't happen, but if it does
                //  we need to try to close down the device.
                //
                if ( MMSYSERR_NOERROR == wdmaudCloseDev( pClient ) )
                {
                    wdmaudDestroyCompletionThread ( pClient );
                    midiCleanUp( pClient );
                }
                DPF( 2, ("midiInOpen failed: returning mmr = %d", mmr ) );
                return mmr;
            }
        }
    }
#endif

    //
    // sent client his OPEN callback message
    //
    midiCallback(pClient, DeviceInfo->DeviceType == MidiOutDevice ? MOM_OPEN : MIM_OPEN,
                 0L, 0L);

    return MMSYSERR_NOERROR;
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api void | midiCleanUp | Free resources for a midi device
 *
 * @parm LPDEVICEINFO | pClient | Pointer to a DEVICEINFO 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.
 ***************************************************************************/
VOID FAR midiCleanUp
(
    LPDEVICEINFO pClient
)
{
    LPDEVICEINFO FAR *ppCur ;

    //
    //  remove from device chain
    //
    EnterCriticalSection(&wdmaudCritSec);
    for (ppCur = &pMidiDeviceList;
         *ppCur != NULL;
         ppCur = &(*ppCur)->Next)
    {
       if (*ppCur == pClient)
       {
          *ppCur = (*ppCur)->Next;
          break;
       }
    }
    LeaveCriticalSection(&wdmaudCritSec);

    DPF(DL_TRACE|FA_SYNC,("DI=%08X Freed DeviceState",pClient) );

#ifdef UNDER_NT
    DeleteCriticalSection( (LPCRITICAL_SECTION)pClient->DeviceState->csQueue );
    GlobalFreePtr( pClient->DeviceState->csQueue );
#endif

    if (pClient->DeviceState->lpNoteOnMap)
    {
#ifndef UNDER_NT
        GlobalSmartPageUnlock( (HGLOBAL)HIWORD( pClient->DeviceState->lpNoteOnMap ));
#endif
        GlobalFreePtr( pClient->DeviceState->lpNoteOnMap );
    }

#ifndef UNDER_NT
    GlobalSmartPageUnlock( (HGLOBAL)HIWORD( pClient->DeviceState ));
    GlobalSmartPageUnlock( (HGLOBAL)HIWORD( pClient ));
#endif
#ifdef DEBUG
    //
    // In debug, let's set all the values in the DEVICESTATE structure to bad
    // values.
    //
    pClient->DeviceState->cSampleBits=0xDEADBEEF;
    pClient->DeviceState->hThread=NULL;
    pClient->DeviceState->dwThreadId=0xDEADBEEF;
    pClient->DeviceState->lpWaveQueue=NULL;
    pClient->DeviceState->csQueue=NULL;
    pClient->DeviceState->hevtQueue=NULL;
    pClient->DeviceState->hevtExitThread=NULL;

#endif                       
    GlobalFreePtr( pClient->DeviceState );
    pClient->DeviceState=NULL;
#ifdef DEBUG
    //
    // Now set all the values in the DEVICEINFO structure to bad values.
    //
//    pClient->Next=(LPDEVICEINFO)0xDEADBEEF;
    pClient->DeviceNumber=-1;
    pClient->DeviceType=0xDEADBEEF;
    pClient->DeviceHandle=NULL;
    pClient->dwInstance=(DWORD_PTR)NULL;
    pClient->dwCallback=(DWORD_PTR)NULL;
    pClient->dwCallback16=0xDEADBEEF;
    pClient->dwFlags=0xDEADBEEF;
    pClient->DataBuffer=NULL;
    pClient->HardwareCallbackEventHandle=NULL;
    pClient->dwCallbackType=0xDEADBEEF;
    pClient->dwLineID=0xDEADBEEF;
    pClient->dwFormat=0xDEADBEEF;
//    pClient->DeviceState=(LPDEVICESTATE)0xDEADBEEF;

#endif
    GlobalFreeDeviceInfo( pClient ) ;
    pClient=NULL;
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api DWORD | midiInRead | Pass a new buffer to the Auxiliary thread for
 *       a midi device.
 *
 * @parm LPDEVICEINFO | pClient | The data associated with the logical midi
 *     device.
 *
 * @parm LPMIDIHDR | pHdr | Pointer to a midi buffer
 *
 * @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.
 ***************************************************************************/
MMRESULT midiInRead
(
    LPDEVICEINFO  DeviceInfo,
    LPMIDIHDR     pHdr
)
{
    MMRESULT     mmr = MMSYSERR_NOERROR;
    LPMIDIHDR    pTemp;
    DWORD        dwCallback16;

    //
    // Put the request at the end of our queue.
    //
    pHdr->dwFlags |= MHDR_INQUEUE;
    pHdr->dwFlags &= ~MHDR_DONE;
    pHdr->dwBytesRecorded = 0;
    pHdr->lpNext = NULL;

    //
    // Store the context for this write in the header so that
    // we know which client to send this back to on completion.
    //
    pHdr->reserved = (DWORD_PTR)DeviceInfo;

#ifndef UNDER_NT
    //
    //  Put the long message callback handler into the
    //  DeviceInfo structure.
    //
    _asm
    {
        mov ax, offset MidiInDeviceCallback
        mov word ptr [dwCallback16], ax
        mov ax, seg MidiInDeviceCallback
        mov word ptr [dwCallback16+2], ax
    }
    DeviceInfo->dwCallback16 = dwCallback16;
#endif

    //
    //  Add the MIDI header to the queue
    //
    CRITENTER ;

    if (!DeviceInfo->DeviceState->lpMidiInQueue)
    {
        DeviceInfo->DeviceState->lpMidiInQueue = pHdr;
        pTemp = NULL;
#ifdef UNDER_NT
        if( (DeviceInfo->DeviceState->hevtQueue) &&
            (DeviceInfo->DeviceState->hevtQueue != (HANDLE)FOURTYTHREE) &&
            (DeviceInfo->DeviceState->hevtQueue != (HANDLE)FOURTYTWO) )
        {
            DPF(DL_TRACE|FA_SYNC,("REMOVED: SetEvent on hevtQueue") );
//            SetEvent( DeviceInfo->DeviceState->hevtQueue );
        }
#endif
    }
    else
    {
        for (pTemp = DeviceInfo->DeviceState->lpMidiInQueue;
             pTemp->lpNext != NULL;
             pTemp = pTemp->lpNext);

        pTemp->lpNext = pHdr;
    }

    CRITLEAVE ;

#ifndef UNDER_NT
    //
    //  Call the 16 routine to send the buffer down
    //  to the kernel.  On NT, do all the processing
    //  of the MIDI data in User mode.
    //
    mmr = wdmaudSubmitMidiInHeader(DeviceInfo, pHdr);
    if (mmr != MMSYSERR_NOERROR)
    {
        // Unlink...
        GlobalFreePtr( pHdr );

        if (pTemp)
        {
            pTemp->lpNext = NULL;
        }
        else
            DeviceInfo->DeviceState->lpMidiInQueue = NULL;
        pHdr->dwFlags &= ~WHDR_INQUEUE;

        DbgBreak();
        MMRRETURN( mmr );  // used to return MMSYSERR_INVALPARAM for all errors!
    }
#endif

    return mmr;
}

/****************************************************************************
 * @doc INTERNAL
 *
 * @api VOID | midiInCompleteHeader |
 *
 * @parm LPDEVICEINFO | DeviceInfo | The data associated with the logical midi
 *     device.
 *
 * @comm The buffer flags are set and the buffer is passed to the auxiliary
 *     device task for processing.
 ****************************************************************************/
VOID midiInCompleteHeader
(
    LPDEVICEINFO  DeviceInfo,
    DWORD         dwTimeStamp,
    WORD          wDataType
)
{
    LPMIDIHDR   pHdr;

    DPFASSERT(DeviceInfo);

    //
    //  Only remove headers from the front of the queue
    //  so that order is maintained.
    //
    if (pHdr = DeviceInfo->DeviceState->lpMidiInQueue)
    {
        DeviceInfo->DeviceState->lpMidiInQueue = DeviceInfo->DeviceState->lpMidiInQueue->lpNext;

        DPF(DL_TRACE|FA_MIDI, ("Pulling header out of queue") );
        pHdr->dwFlags &= ~MHDR_INQUEUE;
        pHdr->dwFlags |= MHDR_DONE;
        pHdr->lpNext = NULL;

        midiCallback((LPDEVICEINFO)pHdr->reserved,
                     wDataType,  // MIM_LONGDATA or MIM_LONGERROR
                     (DWORD_PTR)pHdr,
                     dwTimeStamp);
    }
}