windows-server-2003/drivers/wdm/audio/legacy/wdmaud.sys/midi.c

/****************************************************************************
 *
 *   midi.c
 *
 *   Midi routines for wdmaud.sys
 *
 *   Copyright (C) Microsoft Corporation, 1997 - 1999  All Rights Reserved.
 *
 *   History
 *                S.Mohanraj (MohanS)
 *                M.McLaughlin (MikeM)
 *      5-19-97 - Noel Cross (NoelC)
 *
 ***************************************************************************/

#include "wdmsys.h"

#define IRP_LATENCY_100NS   3000

//
// This is just a scratch location that is never used for anything
// but a parameter to core functions.  
//                
IO_STATUS_BLOCK gIoStatusBlock ;

#pragma PAGEABLE_CODE
#pragma PAGEABLE_DATA

ULONGLONG 
GetCurrentMidiTime()
{
    LARGE_INTEGER   liFrequency,liTime;

    PAGED_CODE();
    //  total ticks since system booted
    liTime = KeQueryPerformanceCounter(&liFrequency);

    //  Convert ticks to 100ns units using Ks macro
    //
    return (KSCONVERT_PERFORMANCE_TIME(liFrequency.QuadPart,liTime));
}

//
// This routine gives us a pMidiPin to play with.
//
NTSTATUS 
OpenMidiPin(
    PWDMACONTEXT        pWdmaContext,
    ULONG               DeviceNumber,
    ULONG               DataFlow      //DataFlow is either in or out.
)
{
    PMIDI_PIN_INSTANCE  pMidiPin = NULL;
    NTSTATUS            Status;
    PKSPIN_CONNECT      pConnect = NULL;
    PKSDATARANGE        pDataRange;
    PCONTROLS_LIST      pControlList = NULL;
    ULONG               Device;
    ULONG               PinId;


    PAGED_CODE();
    //
    // Because of the ZERO_FILL_MEMORY flag, are pMidiPin structure will come
    // back zero'd out.
    //
    Status = AudioAllocateMemory_Fixed(sizeof(MIDI_PIN_INSTANCE),
                                       TAG_Audi_PIN,
                                       ZERO_FILL_MEMORY,
                                       &pMidiPin);
    if(!NT_SUCCESS(Status))
    {
        goto exit;
    }

    pMidiPin->dwSig           = MIDI_PIN_INSTANCE_SIGNATURE;
    pMidiPin->DataFlow        = DataFlow;
    pMidiPin->DeviceNumber    = DeviceNumber;
    pMidiPin->PinState        = KSSTATE_STOP;

    KeInitializeSpinLock( &pMidiPin->MidiPinSpinLock );

    KeInitializeEvent ( &pMidiPin->StopEvent,SynchronizationEvent,FALSE ) ;

    if( KSPIN_DATAFLOW_IN == DataFlow )
    {
        pMidiPin->pMidiDevice = &pWdmaContext->MidiOutDevs[DeviceNumber];

        if (NULL == pWdmaContext->MidiOutDevs[DeviceNumber].pMidiPin)
        {
            pWdmaContext->MidiOutDevs[DeviceNumber].pMidiPin = pMidiPin;
        }
        else
        {
            DPF(DL_TRACE|FA_MIDI, ("Midi device in use") );

            AudioFreeMemory( sizeof(MIDI_PIN_INSTANCE),&pMidiPin );
            Status =  STATUS_DEVICE_BUSY;
            goto exit;
        }
    } else {
        //
        // KSPIN_DATAFLOW_OUT
        //
        pMidiPin->pMidiDevice = &pWdmaContext->MidiInDevs[DeviceNumber];

        InitializeListHead(&pMidiPin->MidiInQueueListHead);

        KeInitializeSpinLock(&pMidiPin->MidiInQueueSpinLock);

        if (NULL == pWdmaContext->MidiInDevs[DeviceNumber].pMidiPin)
        {
            pWdmaContext->MidiInDevs[DeviceNumber].pMidiPin = pMidiPin;
        }
        else
        {
            AudioFreeMemory( sizeof(MIDI_PIN_INSTANCE),&pMidiPin );
            Status =  STATUS_DEVICE_BUSY;
            goto exit;
        }
    }

    //
    // We only support one midi client at a time, the check above will
    // only add this structure if there is not already one there.  If there
    // was something there already, we skip all the following code and 
    // go directly to the exit lable.  Thus, fGraphRunning must not be
    // set when we are here.
    //
    ASSERT( !pMidiPin->fGraphRunning );

    pMidiPin->fGraphRunning++;

    //
    // Because of the ZERO_FILL_MEMORY flag our pConnect structure will
    // come back all zero'd out.
    //
    Status = AudioAllocateMemory_Fixed(sizeof(KSPIN_CONNECT) + sizeof(KSDATARANGE),
                                       TAG_Audt_CONNECT,
                                       ZERO_FILL_MEMORY,
                                       &pConnect);
    if(!NT_SUCCESS(Status))
    {
        pMidiPin->fGraphRunning--;
        goto exit ;
    }

    pDataRange = (PKSDATARANGE)(pConnect + 1);

    PinId = pMidiPin->pMidiDevice->PinId;
    Device = pMidiPin->pMidiDevice->Device;

    pConnect->Interface.Set = KSINTERFACESETID_Standard ;
    pConnect->Interface.Id = KSINTERFACE_STANDARD_STREAMING;
    pConnect->Medium.Set = KSMEDIUMSETID_Standard;
    pConnect->Medium.Id = KSMEDIUM_STANDARD_DEVIO;
    pConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
    pConnect->Priority.PrioritySubClass = 1;
    pDataRange->MajorFormat = KSDATAFORMAT_TYPE_MUSIC;
    pDataRange->SubFormat = KSDATAFORMAT_SUBTYPE_MIDI;
    pDataRange->Specifier = KSDATAFORMAT_SPECIFIER_NONE;
    pDataRange->FormatSize = sizeof( KSDATARANGE );
    pDataRange->Reserved = 0 ;

    Status = AudioAllocateMemory_Fixed((sizeof(CONTROLS_LIST) +
                                         ( (MAX_MIDI_CONTROLS - 1) * sizeof(CONTROL_NODE) ) ),
                                       TAG_AudC_CONTROL,
                                       ZERO_FILL_MEMORY,
                                       &pControlList) ;
    if(!NT_SUCCESS(Status))
    {
        pMidiPin->fGraphRunning--;
        AudioFreeMemory( sizeof(KSPIN_CONNECT) + sizeof(KSDATARANGE),&pConnect );
        goto exit ;
    }

    pControlList->Count = MAX_MIDI_CONTROLS ;
    pControlList->Controls[MIDI_CONTROL_VOLUME].Control = KSNODETYPE_VOLUME ;
    pMidiPin->pControlList = pControlList ;


    // Open a pin
    Status = OpenSysAudioPin(Device,
                             PinId,
                             pMidiPin->DataFlow,
                             pConnect,
                             &pMidiPin->pFileObject,
                             &pMidiPin->pDeviceObject,
                             pMidiPin->pControlList);


    AudioFreeMemory( sizeof(KSPIN_CONNECT) + sizeof(KSDATARANGE),&pConnect );

    if (!NT_SUCCESS(Status))
    {
        CloseMidiDevicePin(pMidiPin->pMidiDevice);
        goto exit ;
    }

    //
    // OpenSysAudioPin sets the file object in the pin.  Now that we have
    // successfully returned from the call, validate that we have non-NULL
    // items.
    //
    ASSERT(pMidiPin->pFileObject);
    ASSERT(pMidiPin->pDeviceObject);

    //
    //  For output we put the device in a RUN state on open
    //  For input we have to wait until the device gets told
    //     to start
    //
    if ( KSPIN_DATAFLOW_IN == pMidiPin->DataFlow )
    {
        Status = AttachVirtualSource(pMidiPin->pFileObject, pMidiPin->pMidiDevice->pWdmaContext->VirtualMidiPinId);

        if (NT_SUCCESS(Status))
        {
            Status = StateMidiOutPin(pMidiPin, KSSTATE_RUN);
        }

        if (!NT_SUCCESS(Status))
        {
            CloseMidiDevicePin(pMidiPin->pMidiDevice);
        }
    }
    else
    {
        //
        //  Pause will queue a bunch of IRPs
        //
        Status = StateMidiInPin(pMidiPin, KSSTATE_PAUSE);
        if (!NT_SUCCESS(Status))
        {
            CloseMidiDevicePin(pMidiPin->pMidiDevice);
        }
    }

exit:

    RETURN( Status );
}


//
// This routine is called from multiple places.  As long as it's not reentrant, it should be
// ok.  Should check for that.
//
// This routine gets called from RemoveDevNode.  RemoveDevNode gets called from user mode
// or from the ContextCleanup routine.  Both routines are in the global mutex.
//
VOID 
CloseMidiDevicePin(
    PMIDIDEVICE pMidiDevice
)
{
    PAGED_CODE();
    if (NULL != pMidiDevice->pMidiPin )
    {
        //
        // CloseMidiPin must not fail.
        //
        CloseMidiPin ( pMidiDevice->pMidiPin ) ;
        //
        // AudioFreeMemory Nulls out this memory location.
        //
        AudioFreeMemory( sizeof(MIDI_PIN_INSTANCE),&pMidiDevice->pMidiPin ) ;
    }
}

#pragma LOCKED_CODE
#pragma LOCKED_DATA

//
// The idea behind this SpinLock is that we want to protect the NumPendingIos
// value in the Irp completion routine.  There, there is a preemption issue
// that we can't have an InterlockedIncrement or InterlockedDecrement interfer
// with.
//
void
LockedMidiIoCount(
    PMIDI_PIN_INSTANCE  pCurMidiPin,
    BOOL bIncrease
    )
{
    KIRQL OldIrql;

    KeAcquireSpinLock(&pCurMidiPin->MidiPinSpinLock,&OldIrql);

    if( bIncrease )
        pCurMidiPin->NumPendingIos++;
    else 
        pCurMidiPin->NumPendingIos--;
    
    KeReleaseSpinLock(&pCurMidiPin->MidiPinSpinLock, OldIrql);
}

VOID 
FreeIrpMdls(
    PIRP pIrp
    )
{
    if (pIrp->MdlAddress != NULL)
    {
        PMDL Mdl, nextMdl;

        for (Mdl = pIrp->MdlAddress; Mdl != (PMDL) NULL; Mdl = nextMdl)
        {
            nextMdl = Mdl->Next;
            MmUnlockPages( Mdl );
            AudioFreeMemory_Unknown( &Mdl );
        }

        pIrp->MdlAddress = NULL;
    }
}


#pragma PAGEABLE_CODE
#pragma PAGEABLE_DATA

//
// This routine can not fail.  When it returns, pMidiPin will be freed.  
//
VOID 
CloseMidiPin(
    PMIDI_PIN_INSTANCE pMidiPin
)
{
    PMIDIINHDR pHdr;
    PMIDIINHDR pTemp;
    KSSTATE    State;

    PAGED_CODE();

    // This is designed to bring us back to square one, even
    // if we were not completely opened
    if( !pMidiPin->fGraphRunning )
    {
        ASSERT(pMidiPin->fGraphRunning == 1);
        return ;
    }

    pMidiPin->fGraphRunning--;

    // Close the file object (pMidiPin->pFileObject, if it exists)
    if(pMidiPin->pFileObject)
    {
        //
        //  For Midi Input we need to flush the queued up scratch IRPs by
        //  issuing a STOP command.
        //
        //  We don't want to do that for Midi Output because we might loose
        //  the "all notes off" sequence that needs to get to the device.
        //
        //  Regardless, in both cases we need to wait until we have
        //  compeletely flushed the device before we can close it.
        //
        if ( KSPIN_DATAFLOW_OUT == pMidiPin->DataFlow )
        {
            PLIST_ENTRY ple;

            //
            //  This is kind of a catch-22.  We need to release
            //  the mutex which was grabbed when we entered the
            //  ioctl dispatch routine to allow the midi input
            //  irps which are queued up in a work item waiting
            //  until the mutex is free in order to be send
            //  down to portcls.
            //
            WdmaReleaseMutex(pMidiPin->pMidiDevice->pWdmaContext);
 
            //
            // This loop removes an entry and frees it until the list is empty.
            //
            while((ple = ExInterlockedRemoveHeadList(&pMidiPin->MidiInQueueListHead,
                                                     &pMidiPin->MidiInQueueSpinLock)) != NULL) 
            {
                LPMIDIDATA              pMidiData;
                PIRP                    UserIrp;
                PWDMAPENDINGIRP_CONTEXT pPendingIrpContext;

                pHdr = CONTAINING_RECORD(ple,MIDIINHDR,Next);
                //
                //  Get into locals and zero out midi data
                //
                UserIrp             = pHdr->pIrp;
                pMidiData           = pHdr->pMidiData;
                pPendingIrpContext  = pHdr->pPendingIrpContext;
                ASSERT(pPendingIrpContext);
                RtlZeroMemory(pMidiData, sizeof(MIDIDATA));

                //
                //  unlock memory before completing the Irp
                //
                wdmaudUnmapBuffer(pHdr->pMdl);
                AudioFreeMemory_Unknown(&pHdr);

                //
                //  Now complete the Irp for wdmaud.drv to process
                //
                DPF(DL_TRACE|FA_MIDI, ("CloseMidiPin: Freeing pending UserIrp: 0x%08lx",UserIrp));
                wdmaudUnprepareIrp ( UserIrp,
                                     STATUS_CANCELLED,
                                     sizeof(DEVICEINFO),
                                     pPendingIrpContext );
            }
        }

        //
        // At this point we know that the list is empty, but there
        // still might be an Irp in the completion process.  We have
        // to call the standard wait routine to make sure it gets completed.
        //
        pMidiPin->StoppingSource = TRUE ;

        if ( KSPIN_DATAFLOW_OUT == pMidiPin->DataFlow )
        {            
            StatePin ( pMidiPin->pFileObject, KSSTATE_STOP, &pMidiPin->PinState ) ;
        }

        //
        // Need to wait for all in and out data to complete.
        //
        MidiCompleteIo( pMidiPin, FALSE );

        if ( KSPIN_DATAFLOW_OUT == pMidiPin->DataFlow )
        {
            //
            //  Grab back the mutex which was freed before we started
            //  waiting on the I/O to complete.
            //
            WdmaGrabMutex(pMidiPin->pMidiDevice->pWdmaContext);
        }

        CloseSysAudio(pMidiPin->pMidiDevice->pWdmaContext, pMidiPin->pFileObject);
        pMidiPin->pFileObject = NULL;
    }

    //
    // AudioFreeMemory_Unknown Nulls out this location
    //
    AudioFreeMemory_Unknown ( &pMidiPin->pControlList ) ;
}

#pragma LOCKED_CODE
#pragma LOCKED_DATA
//
// This is the IRP completion routine.
//
NTSTATUS 
WriteMidiEventCallBack(
    PDEVICE_OBJECT          pDeviceObject,
    PIRP                    pIrp,
    IN PSTREAM_HEADER_EX    pStreamHeader
)
{
    KIRQL               OldIrql;
    PMIDI_PIN_INSTANCE  pMidiOutPin;

    pMidiOutPin = pStreamHeader->pMidiPin;

    if (pMidiOutPin)
    {
        KeAcquireSpinLock(&pMidiOutPin->MidiPinSpinLock,&OldIrql);
        //
        // One less Io packet outstanding, thus we always decrement the 
        // outstanding count.  Then, we compare to see if we're the last
        // packet and we're stopping then we signal the saiting thead.
        //
        if( ( 0 == --pMidiOutPin->NumPendingIos ) && pMidiOutPin->StoppingSource )
        {
            KeSetEvent ( &pMidiOutPin->StopEvent, 0, FALSE ) ;
        }

        //
        // Upon releasing this spin lock pMidiOutPin will no longer be valid.  
        // Thus we must not touch it.
        //
        KeReleaseSpinLock(&pMidiOutPin->MidiPinSpinLock,OldIrql);
    }

    //
    // If there are any Mdls, free them here otherwise IoCompleteRequest will do it after the
    // freeing of our data buffer below.
    //
    FreeIrpMdls(pIrp);
    AudioFreeMemory(sizeof(STREAM_HEADER_EX),&pStreamHeader);
    return STATUS_SUCCESS;
}

#pragma PAGEABLE_CODE
#pragma PAGEABLE_DATA


NTSTATUS 
WriteMidiEventPin(
    PMIDIDEVICE pMidiOutDevice,
    ULONG       ulEvent
)
{
    PKSMUSICFORMAT      pMusicFormat;
    PSTREAM_HEADER_EX   pStreamHeader = NULL;
    PMIDI_PIN_INSTANCE  pMidiPin;
    NTSTATUS            Status = STATUS_SUCCESS;
    BYTE                bEvent;
    ULONG               TheEqualizer;
    ULONGLONG           nsPlayTime;
    KEVENT              keEventObject;
    PWDMACONTEXT        pWdmaContext;

    PAGED_CODE();
    pMidiPin = pMidiOutDevice->pMidiPin;

    if (!pMidiPin ||!pMidiPin->fGraphRunning || !pMidiPin->pFileObject )
    {
        DPF(DL_WARNING|FA_MIDI,("Not ready pMidiPin=%X",pMidiPin) );
        RETURN( STATUS_DEVICE_NOT_READY );
    }

    //
    // allocate enough memory for the stream header
    // the midi/music header, the data, the work item,
    // and the DeviceNumber.  The memroy allocation
    // is zero'd with the ZERO_FILL_MEMORY flag
    //
    Status = AudioAllocateMemory_Fixed(sizeof(STREAM_HEADER_EX) + sizeof(KSMUSICFORMAT) +
                                           sizeof(ULONG),
                                       TAG_Audh_STREAMHEADER,
                                       ZERO_FILL_MEMORY,
                                       &pStreamHeader);   // ulEvent

    if(!NT_SUCCESS(Status))
    {
        return Status;
    }

    // Get a pointer to the music header
    pMusicFormat = (PKSMUSICFORMAT)(pStreamHeader + 1);

    // Play 0 ms from the time-stamp in the KSSTREAM_HEADER
    pMusicFormat->TimeDeltaMs = 0;
    RtlCopyMemory((BYTE *)(pMusicFormat + 1), // the actual data
                  &ulEvent,
                  sizeof(ulEvent));

    // setup the stream header
    pStreamHeader->Header.Data = pMusicFormat;

    pStreamHeader->Header.FrameExtent  = sizeof(KSMUSICFORMAT) + sizeof(ULONG);
    pStreamHeader->Header.Size = sizeof( KSSTREAM_HEADER );
    pStreamHeader->Header.DataUsed     = pStreamHeader->Header.FrameExtent;

    nsPlayTime = GetCurrentMidiTime() - pMidiPin->LastTimeNs + IRP_LATENCY_100NS;
    pStreamHeader->Header.PresentationTime.Time        = nsPlayTime;
    pStreamHeader->Header.PresentationTime.Numerator   = 1;
    pStreamHeader->Header.PresentationTime.Denominator = 1;

    pStreamHeader->pMidiPin = pMidiPin;

    //
    // Figure out how many bytes in this
    // event are valid.
    //
    bEvent = (BYTE)ulEvent;
    TheEqualizer = 0;
    if(!IS_STATUS(bEvent))
    {
        if (pMidiPin->bCurrentStatus)
        {
            bEvent = pMidiPin->bCurrentStatus;
            TheEqualizer = 1;
        }
        else
        {
            // Bad MIDI Stream didn't have a running status
            DPF(DL_WARNING|FA_MIDI,("No running status") );
            AudioFreeMemory(sizeof(STREAM_HEADER_EX),&pStreamHeader);
            RETURN( STATUS_UNSUCCESSFUL );
        }
    }

    if(IS_SYSTEM(bEvent))
    {
        if( IS_REALTIME(bEvent)    ||
            bEvent == MIDI_TUNEREQ ||
            bEvent == MIDI_SYSX    ||
            bEvent == MIDI_EOX )
        {
            pMusicFormat->ByteCount = 1;
        }
        else if(bEvent == MIDI_SONGPP)
        {
            pMusicFormat->ByteCount = 3;
        }
        else
        {
            pMusicFormat->ByteCount = 2;
        }
    }
    // Check for three byte messages
    else if((bEvent < MIDI_PCHANGE) || (bEvent >= MIDI_PBEND))
    {
        pMusicFormat->ByteCount = 3 - TheEqualizer;
    }
    else
    {
        pMusicFormat->ByteCount = 2 - TheEqualizer;
    }

    //
    //  Cache the running status
    //
    if ( (bEvent >= MIDI_NOTEOFF) && (bEvent < MIDI_CLOCK) )
    {
        pMidiPin->bCurrentStatus = (BYTE)((bEvent < MIDI_SYSX) ? bEvent : 0);
    }

    //
    // Initialize our wait event, in case we need to wait.
    //
    KeInitializeEvent(&keEventObject,
                      SynchronizationEvent,
                      FALSE);

    LockedMidiIoCount(pMidiPin,INCREASE);

    //
    //  Need to release the mutex so that during full-duplex
    //  situations, we can get the midi input buffers down
    //  to the device without blocking.
    //
    pWdmaContext = pMidiPin->pMidiDevice->pWdmaContext;
    WdmaReleaseMutex(pWdmaContext);

    // Set the packet to the device.
    Status = KsStreamIo(
        pMidiPin->pFileObject,
        &keEventObject,             // Event
        NULL,                   // PortContext
        WriteMidiEventCallBack,
        pStreamHeader,              // CompletionContext
        KsInvokeOnSuccess | KsInvokeOnCancel | KsInvokeOnError,
        &gIoStatusBlock,
        pStreamHeader,
        sizeof( KSSTREAM_HEADER ),
        KSSTREAM_WRITE | KSSTREAM_SYNCHRONOUS,
        KernelMode
    );

    if ( (Status != STATUS_PENDING) && (Status != STATUS_SUCCESS) )
    {
        DPF(DL_WARNING|FA_MIDI, ("KsStreamIO failed: 0x%08lx",Status));
    }

    //
    // Wait a minute here!!!  If the Irp comes back pending, we
    // can NOT complete our user mode Irp!  But, there is no
    // infastructure for storing the Irp in this call stack.  The
    // other routines use wdmaudPrepareIrp to complete that user
    // Irp.  Also, pPendingIrpContext is stored in the Irp context
    // so that the completion routine has the list to get the
    // user mode Irp from.
    //
    // .... Or, we need to make this routine synchronous and 
    // wait like WriteMidiOutPin.  I believe that this is bug
    // #551052.  It should be fixed eventually.
    //
    //
    // Here is the fix.  Wait if it is pending.
    //
    if ( STATUS_PENDING == Status )
    {
        //
        // Wait for the completion.
        //
        Status = KeWaitForSingleObject( &keEventObject,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        (PLARGE_INTEGER) NULL );
    }
    //
    //  Now grab the mutex again
    //
    WdmaGrabMutex(pWdmaContext);

    RETURN( Status );
}

#pragma LOCKED_CODE
#pragma LOCKED_DATA

//
// This is an IRP completion routine.
//
NTSTATUS 
WriteMidiCallBack(
    PDEVICE_OBJECT          pDeviceObject,
    PIRP                    pIrp,
    IN PSTREAM_HEADER_EX    pStreamHeader
)
{
    //
    // If there are any Mdls, free them here otherwise IoCompleteRequest will do it after the
    // freeing of our data buffer below.
    //
    FreeIrpMdls(pIrp);
    //
    // Cleanup after this synchronous write
    //
    AudioFreeMemory_Unknown(&pStreamHeader->Header.Data);  // Music data

    wdmaudUnmapBuffer(pStreamHeader->pBufferMdl);
    AudioFreeMemory_Unknown(&pStreamHeader->pMidiHdr);

    AudioFreeMemory(sizeof(STREAM_HEADER_EX),&pStreamHeader);
    return STATUS_SUCCESS;
}

#pragma PAGEABLE_CODE
#pragma PAGEABLE_DATA

NTSTATUS 
WriteMidiOutPin(
    LPMIDIHDR           pMidiHdr,
    PSTREAM_HEADER_EX   pStreamHeader,
    BOOL               *pCompletedIrp
)
{
    NTSTATUS       Status = STATUS_INVALID_DEVICE_REQUEST;
    PKSMUSICFORMAT pMusicFormat = NULL;
    KEVENT         keEventObject;
    ULONG          AlignedLength;
    ULONGLONG      nsPlayTime;
    PMIDI_PIN_INSTANCE  pMidiPin;
    PWDMACONTEXT   pWdmaContext;

    PAGED_CODE();

    pMidiPin = pStreamHeader->pMidiPin;

    if (!pMidiPin ||!pMidiPin->fGraphRunning || !pMidiPin->pFileObject )
    {
        DPF(DL_WARNING|FA_MIDI,("Not Ready") );
        wdmaudUnmapBuffer(pStreamHeader->pBufferMdl);
        AudioFreeMemory_Unknown( &pMidiHdr );
        AudioFreeMemory( sizeof(STREAM_HEADER_EX),&pStreamHeader );
        RETURN( STATUS_DEVICE_NOT_READY );
    }

    //
    //  FrameExtent contains dwBufferLength right now
    //
    AlignedLength = ((pStreamHeader->Header.FrameExtent + 3) & ~3);

    Status = AudioAllocateMemory_Fixed(sizeof(KSMUSICFORMAT) + AlignedLength,
                                       TAG_Audm_MUSIC,
                                       ZERO_FILL_MEMORY,
                                       &pMusicFormat);

    if(!NT_SUCCESS(Status))
    {
        wdmaudUnmapBuffer(pStreamHeader->pBufferMdl);
        AudioFreeMemory_Unknown( &pMidiHdr );
        AudioFreeMemory( sizeof(STREAM_HEADER_EX),&pStreamHeader );
        return Status;
    }

    // Play 0 ms from the time-stamp in the KSSTREAM_HEADER
    pMusicFormat->TimeDeltaMs = 0;

    //
    //  the system mapped data was stored in the data field
    //  of the stream header
    //
    RtlCopyMemory((BYTE *)(pMusicFormat + 1), // the actual data
                  pStreamHeader->Header.Data,
                  pStreamHeader->Header.FrameExtent);

    //
    // Setup the number of bytes of midi data we're sending
    //
    pMusicFormat->ByteCount = pStreamHeader->Header.FrameExtent;

    // setup the stream header
    pStreamHeader->Header.Data        = pMusicFormat;

    // Now overwrite FrameExtent with the correct rounded up dword aligned value
    pStreamHeader->Header.FrameExtent = sizeof(KSMUSICFORMAT) + AlignedLength;
    pStreamHeader->Header.OptionsFlags= 0;
    pStreamHeader->Header.Size = sizeof( KSSTREAM_HEADER );
    pStreamHeader->Header.TypeSpecificFlags = 0;
    pStreamHeader->Header.DataUsed    = pStreamHeader->Header.FrameExtent;
    pStreamHeader->pMidiHdr           = pMidiHdr;

    nsPlayTime = GetCurrentMidiTime() - pStreamHeader->pMidiPin->LastTimeNs + IRP_LATENCY_100NS;
    pStreamHeader->Header.PresentationTime.Time        = nsPlayTime;
    pStreamHeader->Header.PresentationTime.Numerator   = 1;
    pStreamHeader->Header.PresentationTime.Denominator = 1;

    //
    // Initialize our wait event, in case we need to wait.
    //
    KeInitializeEvent(&keEventObject,
                      SynchronizationEvent,
                      FALSE);

    //
    //  Need to release the mutex so that during full-duplex
    //  situations, we can get the midi input buffers down
    //  to the device without blocking.
    //
    pWdmaContext = pMidiPin->pMidiDevice->pWdmaContext;
    WdmaReleaseMutex(pWdmaContext);

    // Send the packet to the device.
    Status = KsStreamIo(
        pMidiPin->pFileObject,
        &keEventObject,             // Event
        NULL,                       // PortContext
        WriteMidiCallBack,
        pStreamHeader,              // CompletionContext
        KsInvokeOnSuccess | KsInvokeOnCancel | KsInvokeOnError,
        &gIoStatusBlock,
        &pStreamHeader->Header,
        sizeof( KSSTREAM_HEADER ),
        KSSTREAM_WRITE | KSSTREAM_SYNCHRONOUS,
        KernelMode
    );

    //
    // Wait if it is pending.
    //
    if ( STATUS_PENDING == Status )
    {

        //
        // Wait for the completion.
        //
        Status = KeWaitForSingleObject( &keEventObject,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        (PLARGE_INTEGER) NULL );
    }
    //
    // From the Wait above, we can see that this routine is
    // always synchronous.  Thus, any Irp that we passed down
    // in the KsStreamIo call will have been completed and KS
    // will have signaled keEventObject.  Thus, we can 
    // now complete our Irp.  
    //
    // ... Thus we leave pCompletedIrp set to FALSE.
    //

    //
    //  Now grab the mutex again
    //
    WdmaGrabMutex(pWdmaContext);

    RETURN( Status );
}

NTSTATUS 
ResetMidiInPin(
    PMIDI_PIN_INSTANCE pMidiPin
)
{
    NTSTATUS    Status;

    PAGED_CODE();

    if (!pMidiPin || !pMidiPin->fGraphRunning)
    {
        DPF(DL_WARNING|FA_MIDI,("Not Ready") );
        RETURN( STATUS_DEVICE_NOT_READY );
    }

    Status = StateMidiInPin ( pMidiPin, KSSTATE_PAUSE );

    RETURN( Status );
}

NTSTATUS 
StateMidiOutPin(
    PMIDI_PIN_INSTANCE pMidiPin,
    KSSTATE State
)
{
    NTSTATUS  Status;

    PAGED_CODE();

    if (!pMidiPin || !pMidiPin->fGraphRunning)
    {
        DPF(DL_WARNING|FA_MIDI,("Not Ready") );
        RETURN( STATUS_DEVICE_NOT_READY );
    }

    if (State == KSSTATE_RUN)
    {
        pMidiPin->LastTimeNs = GetCurrentMidiTime();
    }
    else if (State == KSSTATE_STOP)
    {
        pMidiPin->LastTimeNs = 0;
    }

    Status = StatePin ( pMidiPin->pFileObject, State, &pMidiPin->PinState ) ;

    RETURN( Status );
}

//
// Waits for all the Irps to complete.
//
void
MidiCompleteIo(
    PMIDI_PIN_INSTANCE pMidiPin,
    BOOL Yield
    )
{
    PAGED_CODE();

    if ( pMidiPin->NumPendingIos )
    {
        DPF(DL_TRACE|FA_MIDI, ("Waiting on %d I/Os to flush Midi device",
                                      pMidiPin->NumPendingIos ));
        if( Yield )
        {
            //
            //  This is kind of a catch-22.  We need to release
            //  the mutex which was grabbed when we entered the
            //  ioctl dispatch routine to allow the midi input
            //  irps which are queued up in a work item waiting
            //  until the mutex is free in order to be send
            //  down to portcls.
            //
            WdmaReleaseMutex(pMidiPin->pMidiDevice->pWdmaContext);

        }
        //
        // Wait for all the Irps to complete.  The last one will
        // signal us to wake.
        //
        KeWaitForSingleObject ( &pMidiPin->StopEvent,
                                Executive,
                                KernelMode,
                                FALSE,
                                NULL ) ;

        if( Yield )
        {
            WdmaGrabMutex(pMidiPin->pMidiDevice->pWdmaContext);
        }

        DPF(DL_TRACE|FA_MIDI, ("Done waiting to flush Midi device"));
    }

    //
    // Why do we have this?
    //
    KeClearEvent ( &pMidiPin->StopEvent );

    //
    // All the IRPs have completed. We now restore the StoppingSource
    // variable so that we can recycle the pMidiPin.
    //
    pMidiPin->StoppingSource = FALSE;

}
//
// If the driver failed the KSSTATE_STOP request, we return that error
// code to the caller.
//
NTSTATUS 
StopMidiPinAndCompleteIo(
    PMIDI_PIN_INSTANCE pMidiPin,
    BOOL Yield
    )
{
    NTSTATUS Status;

    PAGED_CODE();
    //
    // Indicate to the completion routine that we are stopping now.
    //
    pMidiPin->StoppingSource = TRUE;

    //
    // Tell the driver to stop.  Regardless, we will wait for the 
    // IRPs to complete if there are any outstanding.
    //
    Status = StatePin( pMidiPin->pFileObject, KSSTATE_STOP, &pMidiPin->PinState ) ;
    //
    // NOTE: On success, the pMidiPin->PinState value will be
    // KSSTATE_STOP.  On Error it will be the old state.
    //
    // This raises the question - Do we hang on failure?
    //
    MidiCompleteIo( pMidiPin,Yield );

    return Status;
}

NTSTATUS
StateMidiInPin(
    PMIDI_PIN_INSTANCE pMidiPin,
    KSSTATE State
)
{
    NTSTATUS           Status;

    PAGED_CODE();

    if (!pMidiPin || !pMidiPin->fGraphRunning)
    {
        DPF(DL_WARNING|FA_MIDI,("Not Ready") );
        RETURN( STATUS_DEVICE_NOT_READY );
    }

    //
    //  We need to complete any pending SysEx buffers on a midiInStop
    //
    //
    // Here, if we're asked to go to the paused state and we're not
    // already in the paused state, we have to go through a stop.
    // Thus we stop the driver, wait for it to complete all the outstanding
    // IRPs and then place the driver in pause and place buffers
    // down on it again.
    //
    if( (KSSTATE_PAUSE == State) &&
        (KSSTATE_PAUSE != pMidiPin->PinState) )
    {
        Status = StopMidiPinAndCompleteIo(pMidiPin,TRUE);

        //
        // If we were successful at stopping the driver, we set
        // the pin back up in the pause state.
        //
        if (NT_SUCCESS(Status))
        {
            ULONG BufferCount;

            //
            // Put the driver back in the pause state.
            //
            Status = StatePin ( pMidiPin->pFileObject, State, &pMidiPin->PinState ) ;

            if (NT_SUCCESS(Status))
            {
                //
                // This loop places STREAM_BUFFERS (128) of them down on the
                // device.  NumPendingIos should be 128 when this is done.
                //
                for (BufferCount = 0; BufferCount < STREAM_BUFFERS; BufferCount++)
                {
                    Status = ReadMidiPin( pMidiPin );
                    if (!NT_SUCCESS(Status))
                    {
                        CloseMidiPin( pMidiPin );
                        //
                        // Appears that this error path is not correct.  If we
                        // call CloseMidiPin fGraphRunning will get reduced to 0.
                        // Then, on the next close call CloseMidiPin will assert
                        // because the pin is not running.  We need to be able to
                        // error out of this path without messing up the fGraphRunning
                        // state.
                        //
                        break;
                    }
                }
            }
        }

    } else {

        //
        // Else we're not going to the pause state, so just make the state
        // change.
        //
        Status = StatePin ( pMidiPin->pFileObject, State, &pMidiPin->PinState ) ;
    }

    RETURN( Status );
}

#pragma LOCKED_CODE
#pragma LOCKED_DATA


NTSTATUS 
ReadMidiCallBack(
    PDEVICE_OBJECT          pDeviceObject,
    PIRP                    pIrp,
    IN PSTREAM_HEADER_EX    pStreamHeader
)
{
    WRITE_CONTEXT       *pwc;
    PMIDI_PIN_INSTANCE  pMidiInPin;
    PMIDIINHDR          pMidiInHdr;
    PKSMUSICFORMAT      IrpMusicHdr;
    ULONG               IrpDataLeft;
    LPBYTE              IrpData;
    ULONG               RunningTimeMs;
    BOOL                bResubmit = TRUE;
    BOOL                bDataError = FALSE;
    NTSTATUS            Status = STATUS_SUCCESS;
    KIRQL               OldIrql;
    PLIST_ENTRY         ple;

    DPF(DL_TRACE|FA_MIDI, ("Irp.Status = 0x%08lx",pIrp->IoStatus.Status));

    pMidiInPin = pStreamHeader->pMidiPin;

    //
    // No pin should ever be closed before all the Io comes back.  So
    // we'll sanity check that here.
    //
    ASSERT(pMidiInPin);

    if( pMidiInPin )
    {
        DPF(DL_TRACE|FA_MIDI, ("R%d: 0x%08x", pMidiInPin->NumPendingIos, pStreamHeader));

        //
        // This routine should do an ExInterlockedRemoveHeadList to get the
        // head of the list.
        //
        if((ple = ExInterlockedRemoveHeadList(&pMidiInPin->MidiInQueueListHead,
                                                 &pMidiInPin->MidiInQueueSpinLock)) != NULL) 
        {
            PWDMAPENDINGIRP_CONTEXT pPendingIrpContext;
            LPMIDIDATA              pMidiData;
            PIRP                    UserIrp;

            //
            // We have something to do.
            //
            pMidiInHdr = CONTAINING_RECORD(ple, MIDIINHDR, Next);

            //
            //  Pull some information into locals
            //
            IrpData             = (LPBYTE)((PKSMUSICFORMAT)(pStreamHeader->Header.Data) + 1);
            UserIrp             = pMidiInHdr->pIrp;
            pMidiData           = pMidiInHdr->pMidiData;
            pPendingIrpContext  = pMidiInHdr->pPendingIrpContext;
            ASSERT(pPendingIrpContext);

            //
            //  Let's see what we have here
            //
            DPF(DL_TRACE|FA_MIDI, ("IrpData = 0x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
                                          *(LPBYTE)IrpData,*(LPBYTE)IrpData+1,*(LPBYTE)IrpData+2,
                                          *(LPBYTE)IrpData+3,*(LPBYTE)IrpData+4,*(LPBYTE)IrpData+5,
                                          *(LPBYTE)IrpData+6,*(LPBYTE)IrpData+7,*(LPBYTE)IrpData+8,
                                          *(LPBYTE)IrpData+9,*(LPBYTE)IrpData+10,*(LPBYTE)IrpData+11) );
            //
            //  Copy over the good stuff...
            //
            RtlCopyMemory(&pMidiData->StreamHeader,
                          &pStreamHeader->Header,
                          sizeof(KSSTREAM_HEADER));
            RtlCopyMemory(&pMidiData->MusicFormat,
                          pStreamHeader->Header.Data,
                          sizeof(KSMUSICFORMAT));
            RtlCopyMemory(&pMidiData->MusicData,
                          ((PKSMUSICFORMAT)(pStreamHeader->Header.Data) + 1),
                          3 * sizeof( DWORD )); // cheesy

            //
            //  unlock memory before completing the Irp
            //
            wdmaudUnmapBuffer(pMidiInHdr->pMdl);
            AudioFreeMemory_Unknown(&pMidiInHdr);

            //
            //  Now complete the Irp for wdmaud.drv to process
            //
            wdmaudUnprepareIrp( UserIrp,
                                pIrp->IoStatus.Status,
                                sizeof(MIDIDATA),
                                pPendingIrpContext );
        } else {
            //  !!! Break here to catch underflow !!!
            if (pIrp->IoStatus.Status == STATUS_SUCCESS)
            {
                DPF(DL_TRACE|FA_MIDI, ("!!! Underflowing MIDI Input !!!"));
                //_asm { int 3 };
            }
        }
    }
    //
    // If there are any Mdls, free them here otherwise IoCompleteRequest will do it after the
    // freeing of our data buffer below.
    //
    FreeIrpMdls(pIrp);

    AudioFreeMemory(sizeof(STREAM_HEADER_EX),&pStreamHeader);

    if(pMidiInPin)
    {
        KeAcquireSpinLock(&pMidiInPin->MidiPinSpinLock,&OldIrql);

        pMidiInPin->NumPendingIos--;

        if ( pMidiInPin->StoppingSource || (pIrp->IoStatus.Status == STATUS_CANCELLED) ||
             (pIrp->IoStatus.Status == STATUS_NO_SUCH_DEVICE) || (pIrp->Cancel) )
        {
            bResubmit = FALSE;

            if ( 0 == pMidiInPin->NumPendingIos )
            {
                 KeSetEvent ( &pMidiInPin->StopEvent, 0, FALSE ) ;
            }
        }
        //
        // We need to be careful about using pMidiPin after releasing the spinlock.
        // if we are closing down and the NumPendingIos goes to zero the pMidiPin
        // can be freed.  In that case we must not touch pMidiPin.  bResubmit
        // protects us below.
        //
        KeReleaseSpinLock(&pMidiInPin->MidiPinSpinLock, OldIrql);

        //
        //  Resubmit to keep the cycle going...and going. Note that bResubmit
        //  must be first in this comparison.  If bResubmit is FALSE, then pMidiInPin
        //  could be freed.  
        //
        if (bResubmit && pMidiInPin->fGraphRunning )
        {
            //
            // This call to ReadMidiPin causes wdmaud.sys to place another
            // buffer down on the device.  One call, one buffer.
            //
            ReadMidiPin(pMidiInPin);
        }
    }

    return STATUS_SUCCESS;
}

//
// Called from Irp completion routine, thus this code must be locked.
//
NTSTATUS 
ReadMidiPin(
    PMIDI_PIN_INSTANCE  pMidiPin
)
{
    PKSMUSICFORMAT      pMusicFormat;
    PSTREAM_HEADER_EX   pStreamHeader = NULL;
    PWORK_QUEUE_ITEM    pWorkItem;
    NTSTATUS            Status = STATUS_SUCCESS;

    DPF(DL_TRACE|FA_MIDI, ("Entered"));

    if (!pMidiPin->fGraphRunning)
    {
        DPF(DL_WARNING|FA_MIDI,("Bad fGraphRunning") );
        RETURN( STATUS_DEVICE_NOT_READY );
    }

    Status = AudioAllocateMemory_Fixed(sizeof(STREAM_HEADER_EX) + sizeof(WORK_QUEUE_ITEM) +
                                          MUSICBUFFERSIZE,
                                       TAG_Audh_STREAMHEADER,
                                       ZERO_FILL_MEMORY,
                                       &pStreamHeader);

    if(!NT_SUCCESS(Status))
    {
        RETURN( Status );
    }

    pWorkItem = (PWORK_QUEUE_ITEM)(pStreamHeader + 1);

    pStreamHeader->Header.Size = sizeof( KSSTREAM_HEADER );
    pStreamHeader->Header.PresentationTime.Numerator   = 10000;
    pStreamHeader->Header.PresentationTime.Denominator = 1;

    pMusicFormat = (PKSMUSICFORMAT)((BYTE *)pWorkItem + sizeof(WORK_QUEUE_ITEM));
    pStreamHeader->Header.Data         = pMusicFormat;
    pStreamHeader->Header.FrameExtent  = MUSICBUFFERSIZE;

    pStreamHeader->pMidiPin = pMidiPin;

    ASSERT( pMidiPin->pFileObject );

    //
    // Increase the number of outstanding IRPs as we get ready to add
    // this one to the list.
    //
    LockedMidiIoCount( pMidiPin,INCREASE );
    ObReferenceObject( pMidiPin->pFileObject );

    Status = QueueWorkList( pMidiPin->pMidiDevice->pWdmaContext,
                            ReadMidiEventWorkItem,
                            pStreamHeader,
                            0 );
    if (!NT_SUCCESS(Status))
    {
        //
        // If the memory allocation fails in QueueWorkItem then it can fail.  We
        // will need to free our memory and unlock things.
        //
        LockedMidiIoCount(pMidiPin,DECREASE);
        ObDereferenceObject(pMidiPin->pFileObject);
        AudioFreeMemory( sizeof(STREAM_HEADER_EX),&pStreamHeader );
    }

    RETURN( Status );
}

#pragma PAGEABLE_CODE
#pragma PAGEABLE_DATA
//
// This is a work item that midi schedules.  Notice that the caller did a reference
// on the file object so that it would still be valid when we're here. We should never
// get called and find that the file object is invalid.  Same holds for the StreamHeader
// and the corresponding pMidiPin.
//
VOID 
ReadMidiEventWorkItem(
    PSTREAM_HEADER_EX   pStreamHeader,
    PVOID               NotUsed
)
{
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    PFILE_OBJECT    MidiFileObject;

    PAGED_CODE();

    ASSERT( pStreamHeader->pMidiPin->pFileObject );

    DPF(DL_TRACE|FA_MIDI, ("A%d: 0x%08x", pStreamHeader->pMidiPin->NumPendingIos, pStreamHeader));

    //
    // We need to store the MidiFileObject here because the pStreamHeader
    // will/may get freed during the KsStreamIo call.  Basically, when
    // you call KsStreamIo the Irp may get completed and the pStreamHeader
    // will get freed.  But, it's safe to store the file object because of
    // this reference count.
    //
    MidiFileObject = pStreamHeader->pMidiPin->pFileObject;

    Status = KsStreamIo(
        pStreamHeader->pMidiPin->pFileObject,
        NULL,                   // Event
        NULL,                   // PortContext
        ReadMidiCallBack,
        pStreamHeader,              // CompletionContext
        KsInvokeOnSuccess | KsInvokeOnCancel | KsInvokeOnError,
        &gIoStatusBlock,
        &pStreamHeader->Header,
        sizeof( KSSTREAM_HEADER ),
        KSSTREAM_READ,
        KernelMode
    );

    //
    // We are done with the file object.
    //
    ObDereferenceObject( MidiFileObject );

    // WorkItem: shouldn't this be if( !NTSUCCESS(Status) )?
    if ( STATUS_UNSUCCESSFUL == Status )
        DPF(DL_WARNING|FA_MIDI, ("KsStreamIo failed2: Status = 0x%08lx", Status));

    //
    // Warning: If, for any reason, the completion routine is not called
    // for this Irp, wdmaud.sys will hang.  It's been discovered that 
    // KsStreamIo may error out in low memory conditions.  There is an
    // outstanding bug to address this.
    //

    return;
}

//
// pNewMidiHdr will always be valid.  The caller just allocated it!
//
NTSTATUS 
AddBufferToMidiInQueue(
    PMIDI_PIN_INSTANCE  pMidiPin,
    PMIDIINHDR          pNewMidiInHdr
)
{
    NTSTATUS    Status = STATUS_SUCCESS;
    PMIDIINHDR  pTemp;

    PAGED_CODE();

    if (!pMidiPin || !pMidiPin->fGraphRunning)
    {
        DPF(DL_WARNING|FA_MIDI,("Bad fGraphRunning") );
        RETURN( STATUS_DEVICE_NOT_READY ); 
    }

    DPF(DL_TRACE|FA_MIDI, ("received sysex buffer"));

    ExInterlockedInsertTailList(&pMidiPin->MidiInQueueListHead,
                                &pNewMidiInHdr->Next,
                                &pMidiPin->MidiInQueueSpinLock);

    Status = STATUS_PENDING;

    RETURN( Status );
}


VOID 
CleanupMidiDevices(
    IN  PWDMACONTEXT pWdmaContext
)
{
    DWORD               DeviceNumber;
    DWORD               DeviceType;
    PMIDI_PIN_INSTANCE  pMidiPin=NULL;

    PAGED_CODE();
    for (DeviceNumber = 0; DeviceNumber < MAXNUMDEVS; DeviceNumber++)
    {
        for (DeviceType = MidiInDevice; DeviceType < MixerDevice; DeviceType++)
        {
            if (DeviceType == MidiInDevice)
            {
                pMidiPin = pWdmaContext->MidiInDevs[DeviceNumber].pMidiPin;
            }
            else if (DeviceType == MidiOutDevice)
            {
                pMidiPin = pWdmaContext->MidiOutDevs[DeviceNumber].pMidiPin;
            }
            else
            {
                ASSERT(!"CleanupMidiDevices: Out of range!");
            }

            if (pWdmaContext->apCommonDevice[DeviceType][DeviceNumber]->Device != UNUSED_DEVICE)
            {
                if (pMidiPin != NULL)
                {
                    NTSTATUS    Status;
                    KSSTATE     State;

                    StopMidiPinAndCompleteIo( pMidiPin, FALSE );

                    //
                    //  Probably redundant, but this frees memory associated
                    //  with the MIDI device.
                    //
                    if( DeviceType == MidiInDevice )
                    {
                        CloseMidiDevicePin(&pWdmaContext->MidiInDevs[DeviceNumber]);
                    }
                    if( DeviceType == MidiOutDevice )
                    {
                        CloseMidiDevicePin(&pWdmaContext->MidiOutDevs[DeviceNumber]);
                    }

                }  // end for active pins

            }  // end for valid Device

        } // end for DeviceTypes

    } // end for DeviceNumber

} // CleanupMidiDevices