windows-server-2003/multimedia/media/mciseq/mciseq.c

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

   Copyright (c) 1985-1999 Microsoft Corporation

   Title:   mciseq.c - Multimedia Systems Media Control Interface
            Sequencer driver for MIDI files.

   Version: 1.00

   Date:    24-Apr-1992

   Author:  Greg Simons

------------------------------------------------------------------------------

   Change log:

      DATE        REV            DESCRIPTION
   -----------   ----- -----------------------------------------------------------
   24-APR-1990   GregSi Original
   1 -OCT-1990   GregSi Merge with MMSEQ
   10-MAR-1992   RobinSp Move to Windows NT

*****************************************************************************/
#define UNICODE
//MMSYSTEM
#define MMNOSOUND        - Sound support
#define MMNOWAVE         - Waveform support
#define MMNOAUX          - Auxiliary output support
#define MMNOJOY          - Joystick support

//MMDDK
#define NOWAVEDEV         - Waveform support
#define NOAUXDEV          - Auxiliary output support
#define NOJOYDEV          - Joystick support


#include <stdlib.h>
#include <windows.h>
#include <mmsystem.h>
#include <mmddk.h>
#include <string.h>
#include <wchar.h>
#include "mmsys.h"
#include "list.h"
#include "mciseq.h"

#define CONFIG_ID   0xFFFFFFFF  // Use this value to identify config. opens

#define GETMOTDWORD(lpd)        ((((DWORD)GETMOTWORD(lpd)) << (8 * sizeof(WORD))) + GETMOTWORD((LPBYTE)(lpd) + sizeof(WORD)))
#define ASYNCMESSAGE(w)         (((w) == MCI_PLAY) || ((w) == MCI_SEEK))

/***************************************************************************
 *
 *                         Globals
 *
 **************************************************************************/

ListHandle      SeqStreamListHandle;
HINSTANCE       hInstance;
UINT            MINPERIOD;              // Minimum timer period supported.

int MIDIConfig (HWND hwndParent);

/***************************************************************************
 *
 * @doc INTERNAL MCISEQ
 *
 * @api DWORD | mciDriverEntry | Single entry point for MCI drivers
 *
 * @parm MCIDEVICEID | wDeviceID | The MCI device ID
 *
 * @parm UINT | wMessage | The requested action to be performed.
 *
 * @parm DWORD | dwParam1 | Data for this message.  Defined seperately for
 * each message
 *
 * @parm DWORD | dwParam2 | Data for this message.  Defined seperately for
 * each message
 *
 * @rdesc Defined separately for each message.
 *
 * @comm This may not be called at interrupt time.
 *
 ***************************************************************************/
PUBLIC DWORD FAR PASCAL mciDriverEntry (MCIDEVICEID wDeviceID, UINT wMessage,
                                 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
    pSeqStreamType   pStream;
    DWORD       dwError;

    // get the sequence stream handle for the given ID
    pStream = (pSeqStreamType) mciGetDriverData (wDeviceID);

    // (unless it's irrelevent to the command)
    if (!pStream &&
       (!((wMessage == MCI_OPEN_DRIVER) || (wMessage == MCI_GETDEVCAPS) ||
       (wMessage == MCI_INFO) || (wMessage == MCI_CLOSE_DRIVER))))
       return MCIERR_UNSUPPORTED_FUNCTION;

    switch (wMessage)
    {
        case MCI_OPEN_DRIVER:
            dwError = msOpen(&pStream, wDeviceID, (DWORD)dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
            break;

        case MCI_CLOSE_DRIVER: // close file
            dwError = msClose(pStream, wDeviceID, (DWORD)dwParam1);
            pStream = NULL;
            break;

        case MCI_PLAY:  // play a file (pass thru to sequencer)
            dwError = msPlay(pStream, wDeviceID, (DWORD)dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
            break;

        case MCI_PAUSE:
        case MCI_STOP:
            if (wMessage == MCI_PAUSE) // remember pause status for "mci_mode"
                pStream->bLastPaused = TRUE;
            else
                pStream->bLastPaused = FALSE;
            if (!(dwError = (DWORD)midiSeqMessage(pStream->hSeq, SEQ_STOP, 0L, 0L)))
                midiSeqMessage(pStream->hSeq, SEQ_SETPORTOFF, TRUE, 0L);
            break;

        case MCI_SEEK:  // pass thru as song ptr
            pStream->bLastPaused = FALSE;
            dwError = msSeek(pStream, wDeviceID, (DWORD)dwParam1, (LPMCI_SEEK_PARMS)dwParam2);
            break;

        case MCI_STATUS:
            dwError = msStatus(pStream, wDeviceID, (DWORD)dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
            break;

        case MCI_GETDEVCAPS:
            dwError = msGetDevCaps(pStream, wDeviceID, (DWORD)dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
            break;

        case MCI_INFO: // TBD:  use resource for string
            dwError = msInfo(pStream, wDeviceID, (DWORD)dwParam1, (LPMCI_INFO_PARMS)dwParam2);
            break;

        case MCI_SET:
            dwError = msSet(pStream, wDeviceID, (DWORD)dwParam1, (LPMCI_SEQ_SET_PARMS)dwParam2);
            break;

        case MCI_STEP:
        case MCI_RECORD:
        case MCI_SAVE:
        case MCI_CUE:
        case MCI_REALIZE:
        case MCI_WINDOW:
        case MCI_PUT:
        case MCI_WHERE:
        case MCI_FREEZE:
        case MCI_UNFREEZE:
        case MCI_LOAD:
        case MCI_CUT:
        case MCI_COPY:
        case MCI_PASTE:
        case MCI_UPDATE:
        case MCI_DELETE:
        case MCI_RESUME:
            return MCIERR_UNSUPPORTED_FUNCTION;

        default:
        //case MCI_SOUND:   This is obsolete and has been removed from the public headers
            return MCIERR_UNRECOGNIZED_COMMAND;

    } // switch


    // NOTIFY HANDLED HERE
    if (!LOWORD(dwError))
    {
        MIDISEQINFO seqInfo;
        DWORD       dwTo;

        // first derive info crucial for play abort
        if (wMessage == MCI_PLAY)
        {
            // get info to aid in possible time format conversions (from & to)
            midiSeqMessage((HMIDISEQ) pStream->hSeq,
                SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO) &seqInfo, 0L);
            if (dwParam1 & MCI_TO)
            {
                // is the user typing in what he believes to be the end?
                if (((LPMCI_PLAY_PARMS)dwParam2)->dwTo == CnvtTimeFromSeq(pStream, seqInfo.dwLength, &seqInfo))
                    dwTo = seqInfo.dwLength; // if so, let him have it
                else
                    dwTo = CnvtTimeToSeq(pStream,   // else straight cnvt
                        ((LPMCI_PLAY_PARMS)dwParam2)->dwTo, &seqInfo);
            }
            else
                dwTo = seqInfo.dwLength; // already in native format
        }

        if (pStream) {
            // HANDLE ABORT/SUPERSEDE OF ANY OUTSTANDING DELAYED NOTIFY
            if (pStream->hNotifyCB)
            {
                if (bMutex(wMessage, pStream->wNotifyMsg,
                  (DWORD)dwParam1 /*flags*/, dwTo, pStream->dwNotifyOldTo))
                      // if msg cancels old notify (regardless of whether
                      // it notifies) abort pending notify
                    Notify(pStream, MCI_NOTIFY_ABORTED);
                else if (dwParam1 & MCI_NOTIFY)  // else if this one notifies,
                                                // that supersedes old one
                    Notify(pStream, MCI_NOTIFY_SUPERSEDED);
            }
            // HANDLE THIS MESSAGE'S NOTIFY
            if (dwParam1 & MCI_NOTIFY)
            {
                // HANDLE THIS NOTIFY
                PrepareForNotify(pStream, wMessage,
                    (LPMCI_GENERIC_PARMS) dwParam2, dwTo);

                if (!ASYNCMESSAGE(wMessage) || ((wMessage == MCI_PLAY) && (seqInfo.dwCurrentTick == dwTo)))
                    Notify(pStream, MCI_NOTIFY_SUCCESSFUL);
            }
        } else if (dwParam1 & MCI_NOTIFY)
            mciDriverNotify((HWND)((LPMCI_GENERIC_PARMS)dwParam2)->dwCallback, wDeviceID, MCI_NOTIFY_SUCCESSFUL);
    }
    return dwError;
}

/****************************************************************************
 *
 *                Helper Functions
 *
 ***************************************************************************/

PRIVATE BOOL NEAR PASCAL bMutex(UINT wNewMsg, UINT wOldMsg, DWORD wNewFlags,
    DWORD dwNewTo, DWORD dwOldTo)
{
    switch (wOldMsg)
    {
        case MCI_PLAY:
            switch (wNewMsg)
            {
                case MCI_STOP:
                case MCI_PAUSE:
                case MCI_SEEK:
                case MCI_CLOSE_DRIVER:
                    return TRUE;

                case MCI_PLAY:
                    if ((wNewFlags & MCI_FROM) || (dwNewTo != dwOldTo))
                        return TRUE;
                    else
                        return FALSE;

                default:
                    return FALSE;
            }
            break;
        case MCI_SEEK:
            switch (wNewMsg)
            {
                case MCI_CLOSE_DRIVER:
                case MCI_SEEK:
                    return TRUE;

                case MCI_PLAY:
                    if (wNewFlags & MCI_FROM)
                        return TRUE;
                    else
                        return FALSE;

                default:
                    return FALSE;
            }
            break;

            default:   // should never get here
                return FALSE;
    }
}

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

PUBLIC VOID FAR PASCAL PrepareForNotify(pSeqStreamType pStream,
    UINT wMessage, LPMCI_GENERIC_PARMS lpParms, DWORD dwTo)
/*  This function's purpose is to setup for notify in cases where
 *  an asynchronous message is about to be sent to the sequencer --
 *  e.g.  before a 'play,' where the sequencer must call back to tell you
 *  it's done (then you, in turn, call back the client).
 *  This funtion sets up the MCISEQ -> CLIENT interface.
 */
{
    // remember this notify's dwCallback, and message
    //   which notify was for
        //mci client's notify callback handle
    pStream->hNotifyCB = (HWND)lpParms->dwCallback;
    pStream->wNotifyMsg = wMessage; // remember for possible supersed/abort

    pStream->dwNotifyOldTo = dwTo; // save to position for possible
                                   // subsequent abort/supersede
}

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

PUBLIC VOID NEAR PASCAL EndStreamCycle(SeqStreamType* seqStream)
{
    // signal on all tracks' buffers
    // as a result, the Stream Cycle process will finish (i.e. die)
    // account for cases where stream or part of it wasn't allocated
    TrackStreamType* trackStream;
    int i;

    if (!seqStream)
        return;

    seqStream->streaming = FALSE; // first let it exit

    if (seqStream->trackStreamListHandle == NULLLIST)
        return;

    // now signal on all to let it escape
    trackStream = (TrackStreamType*) List_Get_First(seqStream->trackStreamListHandle);
    while(trackStream)
    {
        for(i = 0; i < NUMHDRS; i++) // signal on all buffers
        {
            if (seqStream->streamTaskHandle)
            {
                dprintf2(("about to signal in EndStreamCycle"));
                if (seqStream->streamTaskHandle) {
                    TaskSignal(seqStream->streamTaskHandle, WTM_QUITTASK);

#ifdef WIN32
                    TaskWaitComplete(seqStream->streamThreadHandle);
#else
                    Yield();
#endif // WIN32
                }
            }
            else
                break;
        }
        trackStream = (TrackStreamType*) List_Get_Next(seqStream->trackStreamListHandle, trackStream);
    }
}

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

PUBLIC DWORD NEAR PASCAL EndFileStream(pSeqStreamType pStream)
/* Closes the file and frees all stream memory.  Handles cases where
   allocation failed part way through. */
{
    if (!pStream)
        return 0;
    EndStreamCycle(pStream);
    if (pStream->hSeq)
        midiSeqMessage(pStream->hSeq, SEQ_CLOSE, 0L, 0L); //directly close it

    if (pStream->trackStreamListHandle != NULLLIST)
    {
        TrackStreamType *trackStream;

        trackStream = (TrackStreamType*) List_Get_First(pStream->trackStreamListHandle);
        while (trackStream)
        {
            int i;

            for(i = 0; i < NUMHDRS; i++)    // unlock two midihdr buffers for it
            {
                if (trackStream->fileHeaders[i])
                {
#ifdef WIN16
                    GlobalFreePtr(trackStream->fileHeaders[i]);
#else
                    GlobalFree(trackStream->fileHeaders[i]);
#endif
                }
                else
                    break;
            }
            trackStream = (TrackStreamType*) List_Get_Next(pStream->trackStreamListHandle, trackStream);
        }
        List_Destroy(pStream->trackStreamListHandle);
    }
    List_Deallocate(SeqStreamListHandle, (NPSTR) pStream);

    return 0;
}

/*****************************************************************************/
PRIVATE void PASCAL NEAR InitMMIOOpen(LPMMIOPROC pIOProc, LPMMIOINFO lpmmioInfo)
{
    _fmemset(lpmmioInfo, 0, sizeof(MMIOINFO));
    if (pIOProc)
        lpmmioInfo->pIOProc = pIOProc;
    else
        lpmmioInfo->fccIOProc = FOURCC_DOS;
}

/*****************************************************************************/
PRIVATE HMMIO NEAR PASCAL msOpenFile(LPWSTR szName, LPMMCKINFO lpmmckData, LPMMIOPROC pIOProc)
     /* Returns hmmio.  This value will be null if failure.
        Reads both RIFF and dos midifiles.
        Sets the current file position to the start of MIDI data. */
{
#define RMIDFORMTYPE            mmioFOURCC('R', 'M', 'I', 'D')
#define DATACKID                mmioFOURCC('d', 'a', 't', 'a')

    MMIOINFO    mmioInfo;
    HMMIO       hmmio;
    MMCKINFO    mmckRiff;

    InitMMIOOpen(pIOProc, &mmioInfo);
    hmmio = mmioOpen(szName, &mmioInfo, MMIO_READ | MMIO_DENYWRITE);
    if (hmmio == NULL)
        return NULL;
    mmckRiff.fccType = RMIDFORMTYPE;
    lpmmckData->ckid = DATACKID;
    if (mmioDescend(hmmio, &mmckRiff, NULL, MMIO_FINDRIFF) || mmioDescend(hmmio, lpmmckData, &mmckRiff, MMIO_FINDCHUNK))
    {
        lpmmckData->cksize = mmioSeek(hmmio, 0, SEEK_END);
        lpmmckData->fccType = 0;
        lpmmckData->dwDataOffset = 0;
        lpmmckData->dwFlags = 0;
        mmioSeek(hmmio, 0, SEEK_SET);
    }
    return hmmio;
}

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

PUBLIC DWORD NEAR PASCAL msOpenStream(pSeqStreamType FAR * lppStream, LPCWSTR szName, LPMMIOPROC pIOProc)
    /* opens file, sets up streaming variables and buffers, calls routine
    to load them and send them to the sequencer.  Returns stream handle in
    pStream var pointed to by lppStream.  Returns error code */

{
#define MAXHDRSIZE  0x100
#define MThd            mmioFOURCC('M', 'T', 'h', 'd')
#define MTrk            mmioFOURCC('M', 'T', 'r', 'k')

    UINT        wTracks;
    UINT        wFormat;
    HMMIO       hmmio;
    SeqStreamType   *thisSeqStream = NULL;
    TrackStreamType *thisTrackStream;
    BYTE        fileHeader[MAXHDRSIZE];
    int         iTrackNum;
    DWORD       smErrCode, errCode;
    MIDISEQOPENDESC open;
    MMCKINFO    mmckData;
    MMCKINFO    mmck;
    MMIOINFO    mmioInfo;
    WCHAR       szPathName[128];

    wcsncpy(szPathName, szName, (sizeof(szPathName)/sizeof(WCHAR)) - 1);
    InitMMIOOpen(pIOProc, &mmioInfo);
    if (!mmioOpen(szPathName, &mmioInfo, MMIO_PARSE)) {
        hmmio = NULL;
        errCode = MCIERR_FILE_NOT_FOUND;
        goto ERROR_HDLR;
    }

    // check if it's a RIFF file or not -- if so, descend into RMID chunk
    // if not, just open it and assume that it's a MIDI file

    hmmio = msOpenFile(szPathName, &mmckData, pIOProc);
    if (!hmmio)   // open the MIDI file
    {
        errCode = MCIERR_FILE_NOT_FOUND;
        goto ERROR_HDLR;
    }
    mmck.ckid = MThd;
    if (mmioDescend(hmmio, &mmck, &mmckData, MMIO_FINDCHUNK))
    {
        errCode = MCIERR_INVALID_FILE;
        goto ERROR_HDLR;
    }
    mmck.cksize = GETMOTDWORD(&mmck.cksize);
    if (mmck.cksize < 3 * sizeof(WORD))
    {
        errCode = MCIERR_INVALID_FILE;
        goto ERROR_HDLR;
    }

    // allocate sequence stream structure & its track stream list
    if (! (thisSeqStream = (SeqStreamType*) List_Allocate(SeqStreamListHandle)))
    {
        errCode = MCIERR_OUT_OF_MEMORY;
        goto ERROR_HDLR;
    }
    List_Attach_Tail(SeqStreamListHandle, (NPSTR) thisSeqStream);

    thisSeqStream->trackStreamListHandle = NULLLIST;

    thisSeqStream->hmmio = hmmio;
    thisSeqStream->pIOProc = pIOProc;
    lstrcpy(thisSeqStream->szFilename, szPathName);
    Yield();
    thisSeqStream->dwFileLength = mmckData.cksize;
    open.dwLen = min(mmck.cksize, MAXHDRSIZE);
    mmioRead(hmmio, (HPSTR)fileHeader, open.dwLen); // read the header info now
    wFormat = GETMOTWORD(fileHeader);
    wTracks = GETMOTWORD(fileHeader + sizeof(WORD));
    if (((wFormat == 0) && (wTracks > 1)) ||  // illegal format 0
        (wFormat > 1))                        // illegal format
    {
        errCode = MCIERR_INVALID_FILE;
        goto ERROR_HDLR;
    }

    thisSeqStream->wPortNum = MIDI_MAPPER;

    /*  Create a sequence given the header data (will add stream as param) */

    open.lpMIDIFileHdr = (LPBYTE) fileHeader;  // step over mhdr+len
    open.dwCallback = (DWORD_PTR) mciSeqCallback;
    open.dwInstance = (DWORD_PTR) thisSeqStream;
    open.hStream = (HANDLE)thisSeqStream;

    smErrCode = (DWORD)midiSeqMessage(NULL,           // open sequence
                          SEQ_OPEN,
                          (DWORD_PTR)(LPVOID)&open,
                          (DWORD_PTR)(LPVOID)&(thisSeqStream->hSeq));

    if (smErrCode != MIDISEQERR_NOERROR)
    {
        // N.B.  at this point if failed in sequencer, sequence is invalid
        //  thisSeqStream->hSeq should be NULL
        if (smErrCode == MIDISEQERR_NOMEM)
            errCode = MCIERR_OUT_OF_MEMORY;
        else
            errCode = MCIERR_INVALID_FILE;
        goto ERROR_HDLR;
    }

    thisSeqStream->trackStreamListHandle = List_Create((LONG) sizeof(TrackStreamType),0l);
    if (thisSeqStream->trackStreamListHandle == NULLLIST)
    {
        errCode = MCIERR_OUT_OF_MEMORY; // not a memory problem
        goto ERROR_HDLR;
    }

    mmioAscend(hmmio, &mmck, 0);
    // MIDI track data does not have RIFF even byte restriction
    if (mmck.cksize & 1L)
        mmioSeek(hmmio, -1L, SEEK_CUR);
    mmck.ckid = MTrk;
    iTrackNum = 0;
    while (wTracks-- > 0)
    {
        int         i;

        // allocate trackstream record and put it in list
        if (! (thisTrackStream = (TrackStreamType*)
          List_Allocate(thisSeqStream->trackStreamListHandle)))
        {
            errCode = MCIERR_OUT_OF_MEMORY;
            goto ERROR_HDLR;
        }
        List_Attach_Tail(thisSeqStream->trackStreamListHandle,
             (NPSTR) thisTrackStream);

        for(i = 0; i < NUMHDRS; i++)    // alloc and lock two midihdr buffers for it
        {
           if (! (thisTrackStream->fileHeaders[i] = (LPMIDISEQHDR)
#ifdef WIN16
             GlobalAllocPtr(GMEM_MOVEABLE | GMEM_SHARE, (LONG) (sizeof(MIDISEQHDR) + BUFFSIZE))))
#else
             GlobalAlloc(GPTR, (LONG) (sizeof(MIDISEQHDR) + BUFFSIZE))))
#endif // WIN16
                {
                    errCode = MCIERR_OUT_OF_MEMORY;
                    goto ERROR_HDLR;
                }
           thisTrackStream->fileHeaders[i]->lpData =
                (LPSTR) (((DWORD_PTR) thisTrackStream->fileHeaders[i]) +
                sizeof(MIDISEQHDR));

           thisTrackStream->fileHeaders[i]->wTrack = (WORD)iTrackNum;
           thisTrackStream->fileHeaders[i]->lpNext = NULL;
           thisTrackStream->fileHeaders[i]->wFlags = MIDISEQHDR_DONE;
        };

        Yield();
        // set up to read this track's 'Mtrk' & length
        if (mmioDescend(hmmio, &mmck, &mmckData, MMIO_FINDCHUNK))
        {
            errCode = MCIERR_INVALID_FILE;
            goto ERROR_HDLR;
        }
        mmck.cksize = GETMOTDWORD(&mmck.cksize);

        // set up beginning, current, and end
        thisTrackStream->beginning = mmck.dwDataOffset;
        thisTrackStream->current = thisTrackStream->beginning;
        thisTrackStream->end = thisTrackStream->beginning + mmck.cksize - 1;

        // minimum track length is 3 bytes

        // verify track ends with "End Of Track" meta event
        mmioSeek(hmmio, (LONG)thisTrackStream->end - 2, SEEK_SET);
        mmioRead(hmmio, (HPSTR)fileHeader, 3L);  // read EOT
        if ((fileHeader[0] != 0xFF) || (fileHeader[1] != 0x2F) ||
            (fileHeader[2] != 0x00))
        {
            errCode = MCIERR_INVALID_FILE;
            goto ERROR_HDLR;
        }
        mmioAscend(hmmio, &mmck, 0);
        // MIDI track data does not have RIFF even byte restriction
        if (mmck.cksize & 1L)
            mmioSeek(hmmio, -1L, SEEK_CUR);
        iTrackNum++;
    }
    mmioClose(hmmio, 0); // don't need in this task context any longer
    hmmio = NULL;
    // create cycle task
    thisSeqStream->streaming = TRUE;
    thisSeqStream->streamTaskHandle = 0; // don't know it yet
    if (mmTaskCreate(mciStreamCycle, &thisSeqStream->streamThreadHandle,
                     (DWORD_PTR)thisSeqStream))
      //mmTaskCreate returns 0 if successful
    {
        errCode = MCIERR_OUT_OF_MEMORY;
        goto ERROR_HDLR;
    }
    thisSeqStream->bLastPaused = FALSE; // never paused
    thisSeqStream->hNotifyCB = NULL;  // no notify pending
    *lppStream = thisSeqStream;
    return 0;

ERROR_HDLR:
    if (hmmio)                    // close file if it was opened
        mmioClose(hmmio, 0);
    if (thisSeqStream)
    {
        midiSeqMessage((HMIDISEQ) thisSeqStream->hSeq, SEQ_SETPORTOFF, FALSE, 0L);
        EndFileStream(thisSeqStream); //dealloc it and everything it owns
    }
    return errCode;
}

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

PUBLIC VOID FAR PASCAL StreamTrackReset(pSeqStreamType pStream, UINT wTrackNum)
/* Find track stream struct within pStream as specified by wTrackNum & reset
   it to start over. */
{
    TrackStreamType *trackStream;
    int iTrackNum;

    if (pStream->trackStreamListHandle == NULLLIST)
        return;

    trackStream = (TrackStreamType*) List_Get_First(pStream->trackStreamListHandle);
    iTrackNum = 0;
    while ((trackStream) && ((int)wTrackNum != iTrackNum++))
    {
        trackStream = (TrackStreamType*) List_Get_Next(pStream->trackStreamListHandle, trackStream);
    }

    if (trackStream)
    {
        int i;

        trackStream->current = trackStream->beginning; // reset stream

        // now signal on all buffers that have been blocked on
        //    (have done bit set)
        for(i = 0; i < NUMHDRS; i++)  // fill any of these that're MT
            if (!(trackStream->fileHeaders[i]->wFlags & MIDISEQHDR_DONE))
            {
                trackStream->fileHeaders[i]->wFlags |= MIDISEQHDR_DONE; //set it
                TaskSignal(pStream->streamTaskHandle, WTM_FILLBUFFER);
            }
    }
}

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

PUBLIC VOID FAR PASCAL _LOADDS mciStreamCycle(DWORD_PTR dwInst)
/*  Fills any buffers for this track that are empty.  Rule:  at any time, the
    block count = the number of buffers - number of buffers with done bit clr
    (i.e. sent) - 1.  Note that this will normally be -1 (asleep).  When a
    buffer is freed, the done bit is set and we signal (block count++).

    Important:  when a buffer is available, but we've run out of data to send
    on that track, we clr the done bit and block anyway (otherwise we wouldn't
    go back to sleep properly).  The only thing is that we must properly regain
    our original status if the sequence is ever reset.  This is accomplished by
    signaling on every buffer with its done bit cleared.   (This is like
    signaling on every buffer that's been sent but not returned + any buffers
    ignored becuase there was no data to send on their track.)

    Whenever we signal for a buffer, we must be SURE that its done bit is set
    -- this is to maintain our rule above.  Otherwise it will break badly! */
{
    TrackStreamType *trackStream;
    SeqStreamType   *seqStream = (SeqStreamType*)dwInst;
    MMCKINFO        mmckData;
    HMMIO           hmmio;

    EnterSeq();

    /*
    ** Make a safe "user" call so that user knows about our thread.
    */
    GetDesktopWindow();

    if (!seqStream->streamTaskHandle) {
        seqStream->streamTaskHandle = mmGetCurrentTask(); // fill it in asap
    }


    hmmio = msOpenFile(seqStream->szFilename, &mmckData, seqStream->pIOProc);   // open the MIDI file
    seqStream->hmmio = hmmio;

    // block count = 0
    // first signal on all

    trackStream = (TrackStreamType*) List_Get_First(seqStream->trackStreamListHandle);
    while(trackStream)
    {
        int    i;

        for(i = 0; i < NUMHDRS; i++)  // fill any of these that're MT
        {
            trackStream->fileHeaders[i]->wFlags |= MIDISEQHDR_DONE;  //set it
            TaskSignal(seqStream->streamTaskHandle, WTM_FILLBUFFER);
        }
        trackStream = (TrackStreamType*) List_Get_Next(seqStream->trackStreamListHandle, trackStream);
    }

    // block count = number of buffers
    TaskBlock();
    // block count == number of buffers - 1

    do
    {
        trackStream = (TrackStreamType*) List_Get_First(seqStream->trackStreamListHandle);
        while ((trackStream) && (seqStream->streaming))
        {
           int    i;

           for(i = 0; i < NUMHDRS; i++)  // fill any of these that're MT
            {
                /* if the header isn't being used, fill it and send it to
                   the sequencer */
                if ((trackStream->fileHeaders[i]->wFlags & MIDISEQHDR_DONE) &&
                   (seqStream->streaming))
                {
                    int    iDataToRead;

                    mmioSeek(seqStream->hmmio, (LONG) trackStream->current, SEEK_SET);
                    iDataToRead = (int) min((DWORD) BUFFSIZE,
                         (trackStream->end - trackStream->current) + 1);

                    trackStream->fileHeaders[i]->wFlags &=
                        ~(MIDISEQHDR_DONE + MIDISEQHDR_EOT + MIDISEQHDR_BOT);
                         // clr the done beginning and end regardless

                    if (iDataToRead > 0)
                    {
                      if (trackStream->current == trackStream->beginning)
                          trackStream->fileHeaders[i]->wFlags |=
                              MIDISEQHDR_BOT; // set the beginning of track flag
                      mmioRead(seqStream->hmmio,
                          (HPSTR) trackStream->fileHeaders[i]->lpData, iDataToRead);

                      trackStream->fileHeaders[i]->dwLength = iDataToRead;
                      trackStream->current += iDataToRead;
                      trackStream->fileHeaders[i]->reserved =
                          ((trackStream->current - trackStream->beginning) - 1);
                      if (trackStream->current > trackStream->end)
                          trackStream->fileHeaders[i]->wFlags |=
                              MIDISEQHDR_EOT; // set the end of track flag

                      if (seqStream->streaming)
                          midiSeqMessage((HMIDISEQ) seqStream->hSeq, SEQ_TRACKDATA,
                            (DWORD_PTR) trackStream->fileHeaders[i], 0L); // send it
                    } // if data to read
                    while (seqStream->streaming) {
                        MIDISEQINFO seqInfo;

                        switch (TaskBlock()) {
                        case WTM_DONEPLAY:
                                midiSeqMessage((HMIDISEQ)seqStream->hSeq, SEQ_GETINFO, (DWORD_PTR)(LPMIDISEQINFO)&seqInfo, 0L);
                                if (!seqInfo.bPlaying)
                                        midiSeqMessage((HMIDISEQ)seqStream->hSeq, SEQ_SETPORTOFF, FALSE, 0L);
                                continue;
                        case WTM_QUITTASK:
                        case WTM_FILLBUFFER:
                                break;
                        }
                        break;
                    }
                    //BLOCK even if data wasn't available (buffer still "used")
                    // when all buffers have been blocked, we'll sleep here
                    if (seqStream->streaming)
                        // don't yield to close, 'cause it deallocs seq
                        Yield(); // yield in case cpu bound
                } // if done bit set and streaming
            } // for i
            if (seqStream->streaming)
                trackStream = (TrackStreamType*) List_Get_Next(seqStream->trackStreamListHandle, trackStream);

        } // while (trackStream)

    } while(seqStream->streaming);
    mmioClose(seqStream->hmmio, 0);
    seqStream->streamTaskHandle = 0;
    LeaveSeq();
}


/***************************************************************************
 *
 * @doc     INTERNAL
 *
 * @api     LRESULT | DriverProc | The entry point for an installable driver.
 *
 * @parm    DWORD | dwDriverId | For most messages, dwDriverId is the DWORD
 *          value that the driver returns in response to a DRV_OPEN message.
 *          Each time that the driver is opened, through the DrvOpen API,
 *          the driver receives a DRV_OPEN message and can return an
 *          arbitrary, non-zero, value. The installable driver interface
 *          saves this value and returns a unique driver handle to the
 *          application. Whenever the application sends a message to the
 *          driver using the driver handle, the interface routes the message
 *          to this entry point and passes the corresponding dwDriverId.
 *
 *          This mechanism allows the driver to use the same or different
 *          identifiers for multiple opens but ensures that driver handles
 *          are unique at the application interface layer.
 *
 *          The following messages are not related to a particular open
 *          instance of the driver. For these messages, the dwDriverId
 *          will always be  ZERO.
 *
 *              DRV_LOAD, DRV_FREE, DRV_ENABLE, DRV_DISABLE, DRV_OPEN
 *
 * @parm    UINT | wMessage | The requested action to be performed. Message
 *          values below DRV_RESERVED are used for globally defined messages.
 *          Message values from DRV_RESERVED to DRV_USER are used for
 *          defined driver portocols. Messages above DRV_USER are used
 *          for driver specific messages.
 *
 * @parm    LPARAM | lParam1 | Data for this message.  Defined separately for
 *          each message
 *
 * @parm    LPARAM | lParam2 | Data for this message.  Defined separately for
 *          each message
 *
 * @rdesc Defined separately for each message.
 *
 ***************************************************************************/
PUBLIC LRESULT FAR PASCAL _LOADDS DriverProc (DWORD_PTR dwDriverID, HDRVR hDriver, UINT wMessage, LPARAM lParam1, LPARAM lParam2)
{
    DWORD_PTR dwRes = 0L;

    switch (wMessage)
        {
            TIMECAPS timeCaps;

        // Standard, globally used messages.

        case DRV_LOAD:
            /*
               Sent to the driver when it is loaded. Always the first
               message received by a driver.
            */

            /*
               Find the minimum period we can support
            */


            if (timeGetDevCaps(&timeCaps, sizeof(timeCaps)) == MMSYSERR_NOERROR)
            {
                MINPERIOD = timeCaps.wPeriodMin;

                /* create a list of seq streams */
                SeqStreamListHandle = List_Create((LONG) sizeof(SeqStreamType), 0L);
                // following sets up command table to enable subsequent commands

                dwRes = 1L;
            }
            break;

        case DRV_FREE:

            /*
               Sent to the driver when it is about to be discarded. This
               will always be the last message received by a driver before
               it is freed.

               dwDriverID is 0L.
               lParam1 is 0L.
               lParam2 is 0L.

               Return value is IGNORED.
            */

            //dwReturn = midiSeqTerminate();

            dwRes = 1L;
            break;

        case DRV_OPEN:

            /*
               Sent to the driver when it is opened.

               dwDriverID is 0L.

               lParam1 is a far pointer to a zero-terminated string
               containing the name used to open the driver.

               lParam2 is passed through from the drvOpen call.

               Return 0L to FAIL the open.
            */

            if (!lParam2)
                dwRes = CONFIG_ID;

            else
                {
                ((LPMCI_OPEN_DRIVER_PARMS)lParam2)->wCustomCommandTable = MCI_TABLE_NOT_PRESENT;
                ((LPMCI_OPEN_DRIVER_PARMS)lParam2)->wType = MCI_DEVTYPE_SEQUENCER;
                dwRes = ((LPMCI_OPEN_DRIVER_PARMS)lParam2)->wDeviceID;
                }

            break;

        case DRV_CLOSE:

            /*
               Sent to the driver when it is closed. Drivers are unloaded
               when the close count reaches zero.

               dwDriverID is the driver identifier returned from the
               corresponding DRV_OPEN.

               lParam1 is passed through from the drvOpen call.

               lParam2 is passed through from the drvOpen call.

               Return 0L to FAIL the close.
            */

            dwRes = 1L;
            break;

        case DRV_ENABLE:

            /*
               Sent to the driver when the driver is loaded or reloaded
               and whenever windows is enabled. Drivers should only
               hook interrupts or expect ANY part of the driver to be in
               memory between enable and disable messages

               dwDriverID is 0L.
               lParam1 is 0L.
               lParam2 is 0L.

               Return value is ignored.

            */

            dwRes = 1L;
            break;

        case DRV_DISABLE:

            /*
               Sent to the driver before the driver is freed.
               and whenever windows is disabled

               dwDriverID is 0L.
               lParam1 is 0L.
               lParam2 is 0L.

               Return value is ignored.

            */

            dwRes = 1L;
            break;

       case DRV_QUERYCONFIGURE:

            /*
                Sent to the driver so that applications can
                determine whether the driver supports custom
                configuration. The driver should return a
                non-zero value to indicate that configuration
                is supported.

                dwDriverID is the value returned from the DRV_OPEN
                call that must have succeeded before this message
                was sent.

                lParam1 is passed from the app and is undefined.
                lParam2 is passed from the app and is undefined.

                return 1L to indicate configuration supported.

            */

            dwRes = 1L;
            break;

       case DRV_CONFIGURE:

            /*
                Sent to the driver so that it can display a custom
                configuration dialog box.

                lParam1 is passed from the app. and should contain
                the parent window handle in the loword.
                lParam2 is passed from the app and is undefined.

                return value is undefined.

                Drivers should create their own section in
                system.ini. The section name should be the driver
                name.


            */

            if ( lParam1 )
                dwRes = MIDIConfig((HWND)LOWORD (lParam1));
            else
               dwRes = (LRESULT)DRVCNF_CANCEL;
            break;

        case DRV_INSTALL:
        case DRV_REMOVE:
            dwRes = DRVCNF_OK;
            break;

        default:
            if (CONFIG_ID != dwDriverID &&
                wMessage >= DRV_MCI_FIRST && wMessage <= DRV_MCI_LAST) {
                    EnterSeq();
                    dwRes = mciDriverEntry ((MCIDEVICEID)dwDriverID, wMessage,
                                            (DWORD_PTR)lParam1, (DWORD_PTR)lParam2);
                    LeaveSeq();
                }
            else
                dwRes = (DWORD_PTR)DefDriverProc(dwDriverID, hDriver, wMessage, lParam1, lParam2);
            break;
     }
     return (LRESULT)dwRes;
}

#ifdef WIN32

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

    @doc EXTERNAL

    @api BOOL | DllInstanceInit | This procedure is called whenever a
        process attaches or detaches from the DLL.

    @parm PVOID | hModule | Handle of the DLL.

    @parm ULONG | Reason | What the reason for the call is.

    @parm PCONTEXT | pContext | Some random other information.

    @rdesc The return value is TRUE if the initialisation completed ok,
        FALSE if not.

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

BOOL DllInstanceInit(PVOID hModule, ULONG Reason, PCONTEXT pContext)
{
    UNREFERENCED_PARAMETER(pContext);

    if (Reason == DLL_PROCESS_ATTACH) {
        /*
           Initialize our critical section
        */
        InitCrit();
        hInstance = hModule;
        DisableThreadLibraryCalls(hModule);

    } else if (Reason == DLL_PROCESS_DETACH) {
        DeleteCrit();
    }
    return TRUE;
}

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

#endif


/*****************************************************************************
 @doc INTERNAL MCISEQ

 @api   int |   MIDIConfig |

 @parm  HWND | hwndParent  |

 @rdesc

 @comm
*****************************************************************************/
typedef BOOL (WINAPI *SHOWMMCPLPROPSHEETW)(HWND hwndParent,
                                           LPCWSTR szPropSheetID,
                                           LPWSTR szTabName,
                                           LPWSTR szCaption);
int MIDIConfig (HWND hwndParent)
{
    static HWND     hwndPrevParent = NULL;
    WCHAR           szCaptionW[ 128 ];

    // We need only a unicode version of the caption (for FindWindow()
    // and ShowMMCPLPropertySheetW(), which are unicode-enabled).
    //
    LoadStringW(hInstance,IDS_MIDICAPTION,szCaptionW,cchLENGTH(szCaptionW));

    if (hwndPrevParent)
    {
        BringWindowToTop(FindWindowW(NULL, szCaptionW));
    }
    else
    {
        HINSTANCE h;
        SHOWMMCPLPROPSHEETW fn;
        static TCHAR aszMMSystemW[] = TEXT("MMSYS.CPL");
        static char aszShowPropSheetA[] = "ShowMMCPLPropertySheetW";
        static WCHAR aszMIDIW[] = L"MIDI";
        WCHAR   szTabNameW[64];
        LoadStringW(hInstance, IDS_MIDITAB, szTabNameW, cchLENGTH(szTabNameW));

        h = LoadLibrary (aszMMSystemW);
        if (h)
        {
            fn = (SHOWMMCPLPROPSHEETW)GetProcAddress(h, aszShowPropSheetA);
            if (fn)
            {
                BOOL f;

                hwndPrevParent = hwndParent;
                f = fn(hwndParent, aszMIDIW, szTabNameW, szCaptionW);
                hwndPrevParent = NULL;
            }
            FreeLibrary(h);
        }
    }
    return DRVCNF_OK;
}