home *** CD-ROM | disk | FTP | other *** search
/ Cutting-Edge 3D Game Programming with C++ / CE3DC++.ISO / TOOLS / MIDIPLYR / SEQUENCE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-02  |  29.7 KB  |  1,013 lines
  1. /*****************************************************************************
  2. *
  3. *  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  4. *  ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
  5. *  TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR
  6. *  A PARTICULAR PURPOSE.
  7. *
  8. *  Copyright (C) 1993, 1994 Microsoft Corporation. All Rights Reserved.
  9. *
  10. ******************************************************************************
  11. *
  12. * Sequence.C
  13. *
  14. * Sequencer engine for MIDI player app
  15. *
  16. *****************************************************************************/
  17.  
  18. #include <windows.h>
  19. #include <windowsx.h>
  20. #include <mmsystem.h>
  21. #include <limits.h>
  22.  
  23. #include "debug.h"
  24. #include "seq.h"
  25.  
  26. PRIVATE VOID FNLOCAL seqFinishPreroll(PSEQ pSeq, LPMIDIHDR lpmh);
  27. PRIVATE MMRESULT FNLOCAL XlatSMFErr(SMFRESULT smfrc);
  28.  
  29. /***************************************************************************
  30. *  
  31. * seqAllocBuffers
  32. *
  33. * Allocate buffers for this instance.
  34. *
  35. * pSeq                      - The sequencer instance to allocate buffers for.
  36. *
  37. * Returns
  38. *   MMSYSERR_NOERROR If the operation was successful.
  39. *
  40. *   MCIERR_OUT_OF_MEMORY  If there is insufficient memory for
  41. *     the requested number and size of buffers.
  42. *
  43. * seqAllocBuffers allocates playback buffers based on the
  44. * cbBuffer and cBuffer fields of pSeq. cbBuffer specifies the
  45. * number of bytes in each buffer, and cBuffer specifies the
  46. * number of buffers to allocate.
  47. *
  48. * seqAllocBuffers must be called before any other sequencer call
  49. * on a newly allocted SEQUENCE structure. It must be paired with
  50. * a call to seqFreeBuffers, which should be the last call made
  51. * before the SEQUENCE structure is discarded.
  52. *
  53. ***************************************************************************/
  54. MMRESULT FNLOCAL seqAllocBuffers(
  55.     PSEQ                    pSeq)
  56. {
  57.     DWORD                   dwEachBufferSize;
  58.     DWORD                   dwAlloc;
  59.     UINT                    i;
  60.     LPBYTE                  lpbWork;
  61.  
  62.     assert(pSeq != NULL);
  63.  
  64.     pSeq->uState    = SEQ_S_NOFILE;
  65.     pSeq->lpmhFree  = NULL;
  66.     pSeq->lpbAlloc  = NULL;
  67.     pSeq->hSmf      = (HSMF)NULL;
  68.     
  69.     /* First make sure we can allocate the buffers they asked for
  70.     */
  71.     dwEachBufferSize = sizeof(MIDIHDR) + (DWORD)(pSeq->cbBuffer);
  72.     dwAlloc          = dwEachBufferSize * (DWORD)(pSeq->cBuffer);
  73.     
  74.     pSeq->lpbAlloc = GlobalAllocPtr(GMEM_MOVEABLE|GMEM_SHARE, dwAlloc);
  75.     if (NULL == pSeq->lpbAlloc)
  76.         return MCIERR_OUT_OF_MEMORY;
  77.  
  78.     /* Initialize all MIDIHDR's and throw them into a free list
  79.     */
  80.     pSeq->lpmhFree = NULL;
  81.  
  82.     lpbWork = pSeq->lpbAlloc;
  83.     for (i=0; i < pSeq->cBuffer; i++)
  84.     {
  85.         ((LPMIDIHDR)lpbWork)->lpNext            = pSeq->lpmhFree;
  86.  
  87.         ((LPMIDIHDR)lpbWork)->lpData            = lpbWork + sizeof(MIDIHDR);
  88.         ((LPMIDIHDR)lpbWork)->dwBufferLength    = pSeq->cbBuffer;
  89.         ((LPMIDIHDR)lpbWork)->dwBytesRecorded   = 0;
  90.         ((LPMIDIHDR)lpbWork)->dwUser            = (DWORD)(UINT)pSeq;
  91.         ((LPMIDIHDR)lpbWork)->dwFlags           = 0;
  92.  
  93.         pSeq->lpmhFree = (LPMIDIHDR)lpbWork;
  94.  
  95.         lpbWork += dwEachBufferSize;
  96.     }
  97.  
  98.     return MMSYSERR_NOERROR;
  99. }
  100.  
  101. /***************************************************************************
  102. *  
  103. * seqFreeBuffers
  104. *
  105. * Free buffers for this instance.
  106. *
  107. * pSeq                      - The sequencer instance to free buffers for.
  108. *   
  109. * seqFreeBuffers frees all allocated memory belonging to the
  110. * given sequencer instance pSeq. It must be the last call
  111. * performed on the instance before it is destroyed.
  112. *       
  113. ****************************************************************************/
  114. VOID FNLOCAL seqFreeBuffers(
  115.     PSEQ                    pSeq)
  116. {
  117.     LPMIDIHDR               lpmh;
  118.     
  119.     assert(pSeq != NULL);
  120.  
  121.     if (NULL != pSeq->lpbAlloc)
  122.     {
  123.         lpmh = (LPMIDIHDR)pSeq->lpbAlloc;
  124.         assert(!(lpmh->dwFlags & MHDR_PREPARED));
  125.         
  126.         GlobalFreePtr(pSeq->lpbAlloc);
  127.     }
  128. }
  129.  
  130. /***************************************************************************
  131. *  
  132. * seqOpenFile
  133. *
  134. * Associates a MIDI file with the given sequencer instance.
  135. *
  136. * pSeq                      - The sequencer instance.
  137. *
  138. * Returns
  139. *   MMSYSERR_NOERROR If the operation is successful.
  140. *    
  141. *   MCIERR_UNSUPPORTED_FUNCTION If there is already a file open
  142. *     on this instance.
  143. *     
  144. *   MCIERR_OUT_OF_MEMORY If there was insufficient memory to
  145. *     allocate internal buffers on the file.
  146. *
  147. *   MCIERR_INVALID_FILE If initial attempts to parse the file
  148. *     failed (such as the file is not a MIDI or RMI file).
  149. *
  150. * seqOpenFile may only be called if there is no currently open file
  151. * on the instance. It must be paired with a call to seqCloseFile
  152. * when operations on this file are complete.
  153. *
  154. * The pstrFile field of pSeq contains the name of the file
  155. * to open. This name will be passed directly to mmioOpen; it may
  156. * contain a specifcation for a custom MMIO file handler. The task
  157. * context used for all I/O will be the task which calls seqOpenFile.
  158. *
  159. ***************************************************************************/
  160. MMRESULT FNLOCAL seqOpenFile(
  161.     PSEQ                    pSeq)
  162. {                            
  163.     MMRESULT                rc      = MMSYSERR_NOERROR;
  164.     SMFOPENFILESTRUCT       sofs;
  165.     SMFFILEINFO             sfi;
  166.     SMFRESULT               smfrc;
  167.     DWORD                   cbBuffer;
  168.  
  169.     assert(pSeq != NULL);
  170.  
  171.     if (pSeq->uState != SEQ_S_NOFILE)
  172.     {
  173.         return MCIERR_UNSUPPORTED_FUNCTION;
  174.     }
  175.  
  176.     assert(pSeq->pstrFile != NULL);
  177.     
  178.     sofs.pstrName     = pSeq->pstrFile;
  179.  
  180.     smfrc = smfOpenFile(&sofs);
  181.     if (SMF_SUCCESS != smfrc)
  182.     {
  183.         rc = XlatSMFErr(smfrc);
  184.         goto Seq_Open_File_Cleanup;
  185.     }
  186.  
  187.     pSeq->hSmf = sofs.hSmf;
  188.     smfGetFileInfo(pSeq->hSmf, &sfi);
  189.     
  190.     pSeq->dwTimeDivision = sfi.dwTimeDivision;
  191.     pSeq->tkLength       = sfi.tkLength;
  192.     pSeq->cTrk           = sfi.dwTracks;
  193.                
  194.     /* Track buffers must be big enough to hold the state data returned
  195.     ** by smfSeek()
  196.     */
  197.     cbBuffer = min(pSeq->cbBuffer, smfGetStateMaxSize());
  198.     
  199.     DPF(1, "seqOpenFile: tkLength %lu", (DWORD)pSeq->tkLength);
  200.  
  201. Seq_Open_File_Cleanup:    
  202.     if (MMSYSERR_NOERROR != rc)
  203.         seqCloseFile(pSeq);
  204.     else
  205.         pSeq->uState = SEQ_S_OPENED;
  206.  
  207.     return rc;
  208. }
  209.  
  210. /***************************************************************************
  211. *  
  212. * seqCloseFile
  213. *
  214. * Deassociates a MIDI file with the given sequencer instance.
  215. *
  216. * pSeq                      -  The sequencer instance.
  217. *
  218. * Returns
  219. *   MMSYSERR_NOERROR If the operation is successful.
  220. *    
  221. *   MCIERR_UNSUPPORTED_FUNCTION If the sequencer instance is not
  222. *     stopped.
  223. *     
  224. * A call to seqCloseFile must be paired with a prior call to
  225. * seqOpenFile. All buffers associated with the file will be
  226. * freed and the file will be closed. The sequencer must be
  227. * stopped before this call will be accepted.
  228. *
  229. ***************************************************************************/
  230. MMRESULT FNLOCAL seqCloseFile(
  231.     PSEQ                    pSeq)
  232. {
  233.     LPMIDIHDR               lpmh;
  234.     
  235.     assert(pSeq != NULL);
  236.     
  237.     if (SEQ_S_PREROLLED != pSeq->uState && SEQ_S_OPENED != pSeq->uState)
  238.         return MCIERR_UNSUPPORTED_FUNCTION;
  239.     
  240.     if ((HSMF)NULL != pSeq->hSmf)
  241.     {
  242.         smfCloseFile(pSeq->hSmf);
  243.         pSeq->hSmf = (HSMF)NULL;
  244.     }
  245.  
  246.     /* If we were prerolled, need to clean up -- have an open MIDI handle
  247.     ** and buffers in the ready queue
  248.     */
  249.  
  250.     while (pSeq->lpmhReadyFront)
  251.     {
  252.         lpmh = pSeq->lpmhReadyFront;
  253.         pSeq->lpmhReadyFront = lpmh->lpNext;
  254.  
  255.         if (pSeq->hmidi != NULL)
  256.             midiOutUnprepareHeader(pSeq->hmidi, lpmh, sizeof(*lpmh));
  257.  
  258.         lpmh->lpNext = pSeq->lpmhFree;
  259.         pSeq->lpmhFree = lpmh;
  260.     }
  261.  
  262.     pSeq->lpmhReadyRear = NULL;
  263.  
  264.     if (pSeq->hmidi != NULL)
  265.     {
  266.         midiStreamClose(pSeq->hmidi);
  267.         pSeq->hmidi = NULL;
  268.     }
  269.  
  270.     pSeq->uState = SEQ_S_NOFILE;
  271.  
  272.     return MMSYSERR_NOERROR;
  273. }
  274.  
  275. /***************************************************************************
  276. *  
  277. * seqPreroll
  278. *
  279. * Prepares the file for playback at the given position.
  280. *
  281. * pSeq                      - The sequencer instance.
  282. *
  283. * lpPreroll                 - Specifies the starting and ending tick
  284. *                             positions to play between.
  285. *
  286. * Returns
  287. *   MMSYSERR_NOERROR If the operation is successful.
  288. *    
  289. *   MCIERR_UNSUPPORTED_FUNCTION If the sequencer instance is not
  290. *     opened or prerolled.
  291. *
  292. * Open the device so we can initialize channels.
  293. *
  294. * Loop through the tracks. For each track, seek to the given position and
  295. * send the init data SMF gives us to the handle.
  296. *
  297. * Wait for all init buffers to finish.
  298. *
  299. * Unprepare the buffers (they're only ever sent here; the sequencer
  300. * engine merges them into a single stream during normal playback) and
  301. * refill them with the first chunk of data from the track. 
  302. *
  303. *     
  304. ****************************************************************************/
  305. MMRESULT FNLOCAL seqPreroll(
  306.     PSEQ                    pSeq,
  307.     LPPREROLL               lpPreroll)
  308. {
  309.     SMFRESULT               smfrc;
  310.     MMRESULT                mmrc        = MMSYSERR_NOERROR;
  311.     MIDIPROPTIMEDIV         mptd;
  312.     LPMIDIHDR               lpmh        = NULL;
  313.     UINT                    uDeviceID;
  314.  
  315.     DPF(1, "seqPreroll Part 1");
  316.     
  317.     assert(pSeq != NULL);
  318.  
  319.     if (pSeq->uState != SEQ_S_OPENED &&
  320.         pSeq->uState != SEQ_S_PREROLLED)
  321.         return MCIERR_UNSUPPORTED_FUNCTION;
  322.  
  323.     pSeq->fdwSeq |= SEQ_F_WAITING;
  324.  
  325.     pSeq->tkBase = lpPreroll->tkBase;
  326.     pSeq->tkEnd  = lpPreroll->tkEnd;
  327.     pSeq->uBuffersInMMSYSTEM = 0;
  328.  
  329.     if (pSeq->uState == SEQ_S_PREROLLED)
  330.     {
  331.         lpmh = pSeq->lpmhReadyFront;
  332.         while (lpmh != NULL)
  333.         {
  334.             pSeq->lpmhReadyFront = pSeq->lpmhReadyFront->lpNext;
  335.  
  336.             lpmh->lpNext = pSeq->lpmhFree;
  337.             pSeq->lpmhFree = lpmh;
  338.             
  339.             lpmh = pSeq->lpmhReadyFront;
  340.         }
  341.  
  342.         pSeq->lpmhReadyRear = NULL;
  343.     }
  344.     
  345.     pSeq->uState = SEQ_S_PREROLLING;
  346.     
  347.     /*
  348.     ** We've successfully opened the file; now
  349.     ** open the MIDI device and set the time division.
  350.     **
  351.     ** NOTE: seqPreroll is equivalent to seek; device might already be open
  352.     */
  353.     if (NULL == pSeq->hmidi)
  354.     {
  355.         DPF(1, "seqPreroll: midiStreamOpen");
  356.         uDeviceID = pSeq->uDeviceID;
  357.         if ((mmrc = midiStreamOpen(&pSeq->hmidi,
  358.                                    &uDeviceID,
  359.                                    1,
  360.                                    (DWORD)(WORD)pSeq->hWnd,
  361.                                    0,
  362.                                    CALLBACK_WINDOW)) != MMSYSERR_NOERROR)
  363.         {
  364.             DPF(1, "midiStreamOpen() -> %lu", (DWORD)mmrc);
  365.             mmrc = MCIERR_DEVICE_NOT_READY;
  366.             goto seq_Preroll_Cleanup;
  367.         }
  368.         
  369.         DPF(1, "seqPreroll: midiStreamOpen done HMIDI=%04X", (WORD)pSeq->hmidi);
  370.         
  371.         mptd.cbStruct  = sizeof(mptd);
  372.         mptd.dwTimeDiv = pSeq->dwTimeDivision;
  373.         if ((mmrc = midiStreamProperty(
  374.                                        (HMIDI)pSeq->hmidi,
  375.                                        (LPBYTE)&mptd,
  376.                                        MIDIPROP_SET|MIDIPROP_TIMEDIV)) != MMSYSERR_NOERROR)
  377.         {
  378.             DPF(1, "midiStreamProperty() -> %04X", (WORD)mmrc);
  379.             midiStreamClose(pSeq->hmidi);
  380.             mmrc = MCIERR_DEVICE_NOT_READY;
  381.             goto seq_Preroll_Cleanup;
  382.         }
  383.  
  384.         DPF(1, "seqPreroll: midiStreamProperty done!");
  385.     }
  386.  
  387.     assert((HMIDIOUT)NULL != pSeq->hmidi);
  388.     assert(NULL != pSeq->lpmhFree);
  389.  
  390.     lpmh = pSeq->lpmhFree;
  391.     pSeq->lpmhFree = lpmh->lpNext;
  392.  
  393.     if (SMF_SUCCESS != (smfrc = smfSeek(pSeq->hSmf, pSeq->tkBase, lpmh)))
  394.     {
  395.         DPF(1, "smfSeek() returned %lu", (DWORD)smfrc);
  396.         mmrc = XlatSMFErr(smfrc);
  397.         goto seq_Preroll_Cleanup;
  398.     }
  399.  
  400.     if (lpmh->dwBytesRecorded)
  401.     {
  402.         DPF(1, "sizeof(*lpmh) %u", sizeof(*lpmh));
  403.         if (MMSYSERR_NOERROR != (mmrc = midiOutPrepareHeader(pSeq->hmidi, lpmh, sizeof(*lpmh))))
  404.         {
  405.             DPF(1, "midiOutPrepare(preroll) -> %lu!", (DWORD)mmrc);
  406.  
  407.             mmrc = MCIERR_DEVICE_NOT_READY;
  408.             goto seq_Preroll_Cleanup;
  409.         }
  410.  
  411.         ++pSeq->uBuffersInMMSYSTEM;
  412.  
  413.         if (MMSYSERR_NOERROR != (mmrc = midiStreamOut(pSeq->hmidi, lpmh, sizeof(*lpmh))))
  414.         {
  415.             DPF(1, "midiStreamOut(preroll) -> %lu!", (DWORD)mmrc);
  416.  
  417.             mmrc = MCIERR_DEVICE_NOT_READY;
  418.             --pSeq->uBuffersInMMSYSTEM;
  419.             goto seq_Preroll_Cleanup;
  420.         }
  421.     }
  422.     else
  423.     {
  424.         // Empty buffer, we'll never get to preroll cleanup
  425.         //
  426.         seqFinishPreroll(pSeq, lpmh);
  427.     }
  428.  
  429. seq_Preroll_Cleanup:
  430.     if (MMSYSERR_NOERROR != mmrc)
  431.     {
  432.         DPF(1, "seqPreroll Part 1 failure");
  433.         if (NULL != lpmh)
  434.         {
  435.             if (lpmh->dwFlags & MHDR_PREPARED)
  436.             {
  437.                 midiOutUnprepareHeader(pSeq->hmidi, lpmh, sizeof(lpmh));
  438.             }
  439.  
  440.             lpmh->lpNext = pSeq->lpmhFree;
  441.             pSeq->lpmhFree = lpmh;
  442.         }
  443.  
  444.         /* Only on success will seqFinishPreroll be called from the
  445.         ** callback to complete -- in any other case, indicate immediate
  446.         ** failure so background task doesn't block waiting for us
  447.         */
  448.         pSeq->uState = SEQ_S_OPENED;
  449.         pSeq->fdwSeq &= ~SEQ_F_WAITING;
  450.     }
  451.     else
  452.     {
  453.         DPF(1, "seqPreroll Part 1 success");
  454.     }
  455.  
  456.     return mmrc;
  457. }
  458.  
  459. /***************************************************************************
  460. *  
  461. * seqFinishPreroll
  462. *
  463. * Completes the preroll operation after the seek buffer has been sent.
  464. *
  465. * pSeq                      - The sequencer instance.
  466. *
  467. * lpPreroll                 - Specifies the starting and ending tick
  468. *                             positions to play between.
  469. *
  470. * Put the seek buffer back into the free list.
  471. *
  472. * Read as much of the file as we can into the buffers from the free list.
  473. * Prepare them and put them into the ready queue.
  474. * Send an MMSG_DONE to the callback to let them know we're ready to play.
  475. *     
  476. ****************************************************************************/
  477. PRIVATE VOID FNLOCAL seqFinishPreroll(
  478.     PSEQ                    pSeq,
  479.     LPMIDIHDR               lpmh)
  480. {
  481.     SMFRESULT               smfrc;
  482.     MMRESULT                mmrc;
  483.  
  484.     /* lpmh is the first header from the free queue -- use it and the
  485.     ** rest to gather the first 'n' buffers of MIDI data and prepare
  486.     ** the headers.
  487.     ** 
  488.     ** NOTE: Preparing the already prepared buffer is benign;
  489.     ** midiOutPrepareHeader() will just succeed if the prepare flag
  490.     ** is already set.
  491.     */
  492.     assert(NULL == pSeq->lpmhReadyRear);
  493.  
  494.     DPF(1, "seqPreroll Part 2");
  495.  
  496.     pSeq->fdwSeq &= ~SEQ_F_EOF;
  497.  
  498.     do
  499.     {
  500.         smfrc = smfReadEvents(pSeq->hSmf, lpmh, pSeq->tkEnd);
  501.  
  502.         if (SMF_SUCCESS != smfrc && SMF_END_OF_FILE != smfrc)
  503.         {
  504.             DPF(1, "SFP: smfReadEvents() -> %u", (UINT)smfrc);
  505.             pSeq->mmrcLastErr = XlatSMFErr(smfrc);
  506.             goto seq_Finish_Preroll_Cleanup;
  507.         }
  508.  
  509.         if (MMSYSERR_NOERROR != midiOutPrepareHeader(pSeq->hmidi, lpmh, sizeof(*lpmh)))
  510.         {
  511.             DPF(1, "SFP: midiOutPrepareHeader failed");
  512.             pSeq->mmrcLastErr = MCIERR_DEVICE_NOT_READY;
  513.             goto seq_Finish_Preroll_Cleanup;
  514.         }
  515.  
  516.         if (NULL == pSeq->lpmhReadyRear)
  517.         {
  518.             pSeq->lpmhReadyRear = pSeq->lpmhReadyFront = lpmh;
  519.         }
  520.         else
  521.         {
  522.             pSeq->lpmhReadyRear->lpNext = lpmh;
  523.             pSeq->lpmhReadyRear         = lpmh;
  524.         }
  525.  
  526.         lpmh->lpNext = NULL;
  527.  
  528.         if (SMF_END_OF_FILE == smfrc)
  529.         {
  530.             pSeq->fdwSeq |= SEQ_F_EOF;
  531.             break;
  532.         }
  533.  
  534.         if (NULL != (lpmh = pSeq->lpmhFree))
  535.         {
  536.             pSeq->lpmhFree = pSeq->lpmhFree->lpNext;
  537.         }
  538.     } while (NULL != lpmh);
  539.  
  540. seq_Finish_Preroll_Cleanup:
  541.  
  542.     if (MMSYSERR_NOERROR != pSeq->mmrcLastErr)
  543.     {
  544.         DPF(1, "seqPreroll Part 2 failure [%lu]", (DWORD)pSeq->mmrcLastErr);
  545.         lpmh = pSeq->lpmhReadyFront;
  546.  
  547.         while (lpmh != NULL)
  548.         {
  549.             pSeq->lpmhReadyFront = lpmh->lpNext;
  550.  
  551.             mmrc = midiOutUnprepareHeader(pSeq->hmidi, lpmh, sizeof(*lpmh));
  552.             if (MMSYSERR_NOERROR != mmrc)
  553.             {
  554.                 DPF(1, "midiOutUnprepareHeader failed in cleanup!! (%lu)", (DWORD)mmrc);
  555.             }
  556.  
  557.             lpmh->lpNext = pSeq->lpmhFree;
  558.             pSeq->lpmhFree = lpmh;
  559.  
  560.             lpmh = pSeq->lpmhReadyFront;
  561.         }
  562.  
  563.         pSeq->lpmhReadyRear = NULL;
  564.  
  565.         pSeq->uState = SEQ_S_OPENED;
  566.     }
  567.     else
  568.     {
  569.         pSeq->uState = SEQ_S_PREROLLED;
  570.         DPF(1, "seqPreroll Part 2 success");
  571.     }
  572.  
  573.     pSeq->fdwSeq &= ~SEQ_F_WAITING;
  574.  
  575.     PostMessage(pSeq->hWnd, MMSG_DONE, (WPARAM)pSeq, 0L);
  576. }
  577.  
  578. /***************************************************************************
  579. *  
  580. * seqStart
  581. *
  582. * Starts playback at the current position.
  583. *
  584. * pSeq                      - The sequencer instance.
  585. *
  586. * Returns
  587. *   MMSYSERR_NOERROR If the operation is successful.
  588. *    
  589. *   MCIERR_UNSUPPORTED_FUNCTION If the sequencer instance is not
  590. *     stopped.
  591. *
  592. *   MCIERR_DEVICE_NOT_READY If the underlying MIDI device could
  593. *     not be opened or fails any call.
  594. * 
  595. * The sequencer must be prerolled before seqStart may be called.
  596. *
  597. * Just feed everything in the ready queue to the device.
  598. *       
  599. ***************************************************************************/
  600. MMRESULT FNLOCAL seqStart(
  601.     PSEQ                    pSeq)
  602. {
  603.     MMRESULT                mmrc;
  604.     LPMIDIHDR               lpmWork;
  605.  
  606.     assert(NULL != pSeq);
  607.  
  608.     if (SEQ_S_PREROLLED != pSeq->uState)
  609.     {
  610.         DPF(1, "seqStart(): State is wrong! [%u]", pSeq->uState);
  611.         return MCIERR_UNSUPPORTED_FUNCTION;
  612.     }
  613.  
  614.     pSeq->uBuffersInMMSYSTEM = 0;
  615.     pSeq->uState = SEQ_S_PLAYING;
  616.     pSeq->fdwSeq |= SEQ_F_WAITING;
  617.  
  618.     DPF(1, "About to feed ready queue to MMSYSTEM [First %08lX]", (DWORD)(pSeq->lpmhReadyFront));
  619.  
  620.     while (pSeq->lpmhReadyFront)
  621.     {
  622.         /* NOTE: Don't need critical section here because no-one will
  623.         ** be reinserting into this queue until after we're stopped again
  624.         */
  625.         lpmWork = pSeq->lpmhReadyFront;
  626.         if (NULL == (pSeq->lpmhReadyFront = lpmWork->lpNext))
  627.             pSeq->lpmhReadyRear = NULL;
  628.  
  629.         ++pSeq->uBuffersInMMSYSTEM;
  630.         #ifdef DEBUG    // this block can be removed when I get midiStreamOut to work
  631.         if( IsBadWritePtr( lpmWork->lpData, lpmWork->dwBufferLength ) )
  632.             MessageBox( NULL, "bad MIDIHDR.lpdata", "debug info", MB_OK );
  633.         if( lpmWork->dwBytesRecorded > lpmWork->dwBufferLength )
  634.             MessageBox( NULL, "lpmWork->dwBytesRecorded > lpmWork->dwBufferLength", "debug info", MB_OK );
  635.         #endif
  636.         if ((mmrc = midiStreamOut(pSeq->hmidi, lpmWork, sizeof(*lpmWork))) != MMSYSERR_NOERROR)
  637.         {
  638.             DPF(1, "midiStreamOut failed!");
  639.             
  640.             --pSeq->uBuffersInMMSYSTEM;
  641.             pSeq->uState = SEQ_S_STOPPING;
  642.             midiOutReset(pSeq->hmidi);
  643.             
  644.             return MCIERR_DEVICE_NOT_READY;
  645.         }
  646.     }
  647.  
  648.     return MMSYSERR_NOERROR;
  649. }
  650.  
  651. /***************************************************************************
  652. *  
  653. * seqPause
  654. *
  655. * Pauses playback of the instance.
  656. *
  657. * pSeq                      - The sequencer instance.
  658. *
  659. * Returns
  660. *   MMSYSERR_NOERROR If the operation is successful.
  661. *    
  662. *   MCIERR_UNSUPPORTED_FUNCTION If the sequencer instance is not
  663. *     playing.
  664. *
  665. * The sequencer must be playing before seqPause may be called.
  666. * Pausing the sequencer will cause all currently on notes to be turned
  667. * off. This may cause playback to be slightly inaccurate on restart
  668. * due to missing notes.
  669. *       
  670. ***************************************************************************/
  671. MMRESULT FNLOCAL seqPause(
  672.     PSEQ                    pSeq)
  673. {
  674.     assert(NULL != pSeq);
  675.     
  676.     if (SEQ_S_PLAYING != pSeq->uState)
  677.         return MCIERR_UNSUPPORTED_FUNCTION;
  678.  
  679.     pSeq->uState = SEQ_S_PAUSED;
  680.     midiStreamPause(pSeq->hmidi);
  681.     
  682.     return MMSYSERR_NOERROR;
  683. }
  684.  
  685. /***************************************************************************
  686. *  
  687. * seqRestart
  688. *
  689. * Restarts playback of an instance after a pause.
  690. *
  691. * pSeq                      - The sequencer instance.
  692. *
  693. * Returns
  694. *    MMSYSERR_NOERROR If the operation is successful.
  695. *    
  696. *    MCIERR_UNSUPPORTED_FUNCTION If the sequencer instance is not
  697. *     paused.
  698. *
  699. * The sequencer must be paused before seqRestart may be called.
  700. *
  701. ***************************************************************************/
  702. MMRESULT FNLOCAL seqRestart(
  703.     PSEQ                    pSeq)
  704. {
  705.     assert(NULL != pSeq);
  706.     
  707.     if (SEQ_S_PAUSED != pSeq->uState)
  708.         return MCIERR_UNSUPPORTED_FUNCTION;
  709.  
  710.     pSeq->uState = SEQ_S_PLAYING;
  711.     midiStreamRestart(pSeq->hmidi);
  712.  
  713.     return MMSYSERR_NOERROR;
  714. }
  715.  
  716. /***************************************************************************
  717. *  
  718. * seqStop
  719. *
  720. * Totally stops playback of an instance.
  721. *
  722. * pSeq                      - The sequencer instance.
  723. *
  724. * Returns
  725. *   MMSYSERR_NOERROR If the operation is successful.
  726. *    
  727. *   MCIERR_UNSUPPORTED_FUNCTION If the sequencer instance is not
  728. *     paused or playing.
  729. *
  730. * The sequencer must be paused or playing before seqStop may be called.
  731. *
  732. ***************************************************************************/
  733. MMRESULT FNLOCAL seqStop(
  734.     PSEQ                    pSeq)
  735. {
  736.     assert(NULL != pSeq);
  737.  
  738.     /* Automatic success if we're already stopped
  739.     */
  740.     if (SEQ_S_PLAYING != pSeq->uState &&
  741.         SEQ_S_PAUSED != pSeq->uState)
  742.     {
  743.         pSeq->fdwSeq &= ~SEQ_F_WAITING;
  744.         return MMSYSERR_NOERROR;
  745.     }
  746.  
  747.     pSeq->uState = SEQ_S_STOPPING;
  748.     pSeq->fdwSeq |= SEQ_F_WAITING;
  749.     
  750.     if (MMSYSERR_NOERROR != (pSeq->mmrcLastErr = midiStreamStop(pSeq->hmidi)))
  751.     {
  752.         DPF(1, "midiOutStop() returned %lu in seqStop()!", (DWORD)pSeq->mmrcLastErr);
  753.         
  754.         pSeq->fdwSeq &= ~SEQ_F_WAITING;
  755.         return MCIERR_DEVICE_NOT_READY;
  756.     }
  757.     
  758.     return MMSYSERR_NOERROR;
  759. }
  760.  
  761. /***************************************************************************
  762. *  
  763. * seqTime
  764. *
  765. * Determine the current position in playback of an instance.
  766. *
  767. * pSeq                      - The sequencer instance.
  768. *
  769. * pTicks                    - A pointer to a DWORD where the current position
  770. *                             in ticks will be returned.
  771. *
  772. * Returns
  773. *   MMSYSERR_NOERROR If the operation is successful.
  774. *
  775. *   MCIERR_DEVICE_NOT_READY If the underlying device fails to report
  776. *     the position.
  777. *    
  778. *   MCIERR_UNSUPPORTED_FUNCTION If the sequencer instance is not
  779. *     paused or playing.
  780. *
  781. * The sequencer must be paused, playing or prerolled before seqTime
  782. * may be called.
  783. *
  784. ***************************************************************************/
  785. MMRESULT FNLOCAL seqTime(
  786.     PSEQ                    pSeq,
  787.     PTICKS                  pTicks)
  788. {
  789.     MMRESULT                mmr;
  790.     MMTIME                  mmt;
  791.     
  792.     assert(pSeq != NULL);
  793.  
  794.     if (SEQ_S_PLAYING != pSeq->uState &&
  795.         SEQ_S_PAUSED != pSeq->uState &&
  796.         SEQ_S_PREROLLING != pSeq->uState &&
  797.         SEQ_S_PREROLLED != pSeq->uState &&
  798.         SEQ_S_OPENED != pSeq->uState)
  799.     {
  800.         DPF(1, "seqTime(): State wrong! [is %u]", pSeq->uState);
  801.         return MCIERR_UNSUPPORTED_FUNCTION;
  802.     }
  803.  
  804.     *pTicks = 0;
  805.     if (SEQ_S_OPENED != pSeq->uState)
  806.     {
  807.         *pTicks = pSeq->tkBase;
  808.         if (SEQ_S_PREROLLED != pSeq->uState)
  809.         {
  810.             mmt.wType = TIME_TICKS;
  811.             mmr = midiStreamPosition(pSeq->hmidi, &mmt, sizeof(mmt));
  812.             if (MMSYSERR_NOERROR != mmr)
  813.             {
  814.                 DPF(1, "midiStreamPosition() returned %lu", (DWORD)mmr);
  815.                 return MCIERR_DEVICE_NOT_READY;
  816.             }
  817.  
  818.             *pTicks += mmt.u.ticks;
  819.         }
  820.     }
  821.  
  822.     return MMSYSERR_NOERROR;
  823. }
  824.                               
  825. /***************************************************************************
  826. *  
  827. * seqMillisecsToTicks
  828. *
  829. * Given a millisecond offset in the output stream, returns the associated
  830. * tick position.
  831. *
  832. * pSeq                      - The sequencer instance.
  833. *
  834. * msOffset                  - The millisecond offset into the stream.
  835. *
  836. * Returns the number of ticks into the stream.
  837. *
  838. ***************************************************************************/
  839. TICKS FNLOCAL seqMillisecsToTicks(
  840.     PSEQ                    pSeq,
  841.     DWORD                   msOffset)
  842. {
  843.     return smfMillisecsToTicks(pSeq->hSmf, msOffset);
  844. }
  845.  
  846. /***************************************************************************
  847. *  
  848. * seqTicksToMillisecs
  849. *
  850. * Given a tick offset in the output stream, returns the associated
  851. * millisecond position.
  852. *
  853. * pSeq                      - The sequencer instance.
  854. *
  855. * tkOffset                  - The tick offset into the stream.
  856. *
  857. * Returns the number of milliseconds into the stream.
  858. *
  859. ***************************************************************************/
  860. DWORD FNLOCAL seqTicksToMillisecs(
  861.     PSEQ                    pSeq,
  862.     TICKS                   tkOffset)
  863. {
  864.     return smfTicksToMillisecs(pSeq->hSmf, tkOffset);
  865. }
  866.  
  867. /***************************************************************************
  868. *  
  869. * seqBufferDone
  870. *
  871. * Specifies that the given buffer has completed playback.
  872. *
  873. * lpmh                      - The buffer that has completed playback.
  874. *
  875. * This function should be called by the user whenever he receives an
  876. * MM_MOM_DONE message. 
  877. *
  878. ***************************************************************************/
  879. VOID FNLOCAL seqBufferDone(
  880.     LPMIDIHDR               lpmh)
  881. {
  882.     PSEQ                    pSeq;
  883.     MMRESULT                mmrc;
  884.     SMFRESULT               smfrc;
  885.  
  886.     assert(lpmh != NULL);
  887.     
  888.     pSeq = (PSEQ)(lpmh->dwUser);
  889.  
  890.     assert(pSeq != NULL);
  891.  
  892.     --pSeq->uBuffersInMMSYSTEM;
  893.     
  894.     /* If we're SEQ_S_PREROLLING, we're doing a preroll -- don't try to refill
  895.     ** the buffer
  896.     */
  897.     if (SEQ_S_PREROLLING == pSeq->uState)
  898.     {
  899.         /* If all buffers have completed, we've completed the preroll --
  900.         ** call the completion routine to clean up and notify foreground.
  901.         **
  902.         ** This should only ever be one buffer
  903.         */
  904.         if (0 == pSeq->uBuffersInMMSYSTEM)
  905.             seqFinishPreroll(pSeq, lpmh);
  906.         
  907.         return;
  908.     }
  909.  
  910.     if ((SEQ_S_STOPPING == pSeq->uState) || (pSeq->fdwSeq & SEQ_F_EOF))
  911.     {
  912.         DPF(1, "EOF set or stopping");
  913.         /*
  914.         ** Reached EOF, just put the buffer back on the free
  915.         ** list 
  916.         */
  917.         lpmh->lpNext   = pSeq->lpmhFree;
  918.         pSeq->lpmhFree = lpmh;
  919.  
  920.         if (MMSYSERR_NOERROR != (mmrc = midiOutUnprepareHeader(pSeq->hmidi, lpmh, sizeof(*lpmh))))
  921.         {
  922.             DPF(1, "midiOutUnprepareHeader failed in seqBufferDone! (%lu)", (DWORD)mmrc);
  923.         }
  924.  
  925.         if (0 == pSeq->uBuffersInMMSYSTEM)
  926.         {
  927.             DPF(1, "seqBufferDone: normal sequencer shutdown.");
  928.             
  929.             /* Totally done! Free device and notify.
  930.             */
  931.             midiOutReset(pSeq->hmidi);
  932.             midiStreamClose(pSeq->hmidi);
  933.             
  934.             pSeq->hmidi = NULL;
  935.             pSeq->uState = SEQ_S_OPENED;
  936.             pSeq->mmrcLastErr = MMSYSERR_NOERROR;
  937.             pSeq->fdwSeq &= ~SEQ_F_WAITING;
  938.             
  939.             PostMessage(pSeq->hWnd, MMSG_DONE, (WPARAM)pSeq, 0L);
  940.         }
  941.     }
  942.     else
  943.     {
  944.         /*
  945.         ** Not EOF yet; attempt to fill another buffer
  946.         */
  947.         smfrc = smfReadEvents(pSeq->hSmf, lpmh, pSeq->tkEnd);
  948.         
  949.         switch(smfrc)
  950.         {
  951.             case SMF_SUCCESS:
  952.                 break;
  953.  
  954.             case SMF_END_OF_FILE:
  955.                 pSeq->fdwSeq |= SEQ_F_EOF;
  956.                 smfrc = SMF_SUCCESS;
  957.                 break;
  958.  
  959.             default:
  960.                 DPF(1, "smfReadEvents returned %lu in callback!", (DWORD)smfrc);
  961.                 pSeq->uState = SEQ_S_STOPPING;
  962.                 break;
  963.         }
  964.  
  965.         if (SMF_SUCCESS == smfrc)
  966.         {
  967.             ++pSeq->uBuffersInMMSYSTEM;
  968.             mmrc = midiStreamOut(pSeq->hmidi, lpmh, sizeof(*lpmh));
  969.             if (MMSYSERR_NOERROR != mmrc)
  970.             {
  971.                 DPF(1, "seqBufferDone(): midiStreamOut() returned %lu!", (DWORD)mmrc);
  972.                 
  973.                 --pSeq->uBuffersInMMSYSTEM;
  974.                 pSeq->uState = SEQ_S_STOPPING;
  975.             }
  976.         }
  977.     }
  978. }
  979.  
  980. /***************************************************************************
  981. *  
  982. * XlatSMFErr
  983. *
  984. * Translates an error from the SMF layer into an appropriate MCI error.
  985. *
  986. * smfrc                     - The return code from any SMF function.
  987. *
  988. * Returns
  989. *   A parallel error from the MCI error codes.   
  990. *
  991. ***************************************************************************/
  992. PRIVATE MMRESULT FNLOCAL XlatSMFErr(
  993.     SMFRESULT               smfrc)
  994. {
  995.     switch(smfrc)
  996.     {
  997.         case SMF_SUCCESS:
  998.             return MMSYSERR_NOERROR;
  999.  
  1000.         case SMF_NO_MEMORY:
  1001.             return MCIERR_OUT_OF_MEMORY;
  1002.  
  1003.         case SMF_INVALID_FILE:
  1004.         case SMF_OPEN_FAILED:
  1005.         case SMF_INVALID_TRACK:
  1006.             return MCIERR_INVALID_FILE;
  1007.  
  1008.         default:
  1009.             return MCIERR_UNSUPPORTED_FUNCTION;
  1010.     }
  1011. }
  1012.  
  1013.