home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / graphics / audio / midiplyr / smf.c < prev    next >
C/C++ Source or Header  |  1997-10-05  |  29KB  |  887 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 - 1997 Microsoft Corporation. All Rights Reserved.
  9. *
  10. ******************************************************************************
  11. *
  12. * SMF.C
  13. *
  14. * MIDI File access routines.
  15. *
  16. *****************************************************************************/
  17. #include <windows.h>
  18. #include <windowsx.h>
  19. #include <mmsystem.h>
  20. #include <memory.h>
  21. #include "muldiv32.h" 
  22. #include "smf.h"
  23. #include "smfi.h"
  24. #include "debug.h"
  25.  
  26. PRIVATE SMFRESULT FNLOCAL smfInsertParmData(
  27.     PSMF                    pSmf,
  28.     TICKS                   tkDelta,                                            
  29.     LPMIDIHDR               lpmh);
  30.  
  31. /*****************************************************************************
  32. *
  33. * smfOpenFile
  34. *
  35. * This function opens a MIDI file for access. 
  36. *
  37. * psofs                     - Specifies the file to open and associated
  38. *                             parameters. Contains a valid HSMF handle
  39. *                             on success.
  40. *
  41. * Returns
  42. *   SMF_SUCCESS The specified file was opened.
  43. *
  44. *   SMF_OPEN_FAILED The specified file could not be opened because it
  45. *     did not exist or could not be created on the disk.
  46. *
  47. *   SMF_INVALID_FILE The specified file was corrupt or not a MIDI file.
  48. * 
  49. *   SMF_NO_MEMORY There was insufficient memory to open the file.
  50. *
  51. *   SMF_INVALID_PARM The given flags or time division in the
  52. *     SMFOPENFILESTRUCT were invalid.
  53. * 
  54. *****************************************************************************/
  55. SMFRESULT FNLOCAL smfOpenFile(
  56.     PSMFOPENFILESTRUCT      psofs)
  57. {
  58.     HMMIO                   hmmio = (HMMIO)NULL;
  59.     PSMF                    pSmf;
  60.     SMFRESULT               smfrc = SMF_SUCCESS;
  61.     MMIOINFO                mmioinfo;
  62.     MMCKINFO                ckRIFF;
  63.     MMCKINFO                ckDATA;
  64.  
  65.     assert(psofs != NULL);
  66.     assert(psofs->pstrName != NULL);
  67.     
  68.     /* Verify that the file can be opened or created
  69.     */
  70.     _fmemset(&mmioinfo, 0, sizeof(mmioinfo));
  71.  
  72.     hmmio = mmioOpen(psofs->pstrName, &mmioinfo, MMIO_READ|MMIO_ALLOCBUF);
  73.     if ((HMMIO)NULL == hmmio)
  74.     {
  75.         DPF(1, "smfOpenFile: mmioOpen failed!");
  76.         return SMF_OPEN_FAILED;
  77.     }
  78.  
  79.     /* Now see if we can create the handle structure
  80.     */
  81.     pSmf = (PSMF)LocalAlloc(LPTR, sizeof(SMF));
  82.     if (NULL == pSmf)
  83.     {
  84.         DPF(1, "smfOpenFile: LocalAlloc failed!");
  85.         smfrc = SMF_NO_MEMORY;
  86.         goto smf_Open_File_Cleanup;
  87.     }
  88.  
  89.     lstrcpy(pSmf->szName, psofs->pstrName);
  90.     pSmf->fdwSMF = 0;
  91.     pSmf->pTempoMap = NULL;
  92.  
  93.     /* Pull the entire file into a block of memory. 
  94.     */
  95.     _fmemset(&ckRIFF, 0, sizeof(ckRIFF));
  96.     
  97.     if (0 == mmioDescend(hmmio, &ckRIFF, NULL, MMIO_FINDRIFF) &&
  98.         ckRIFF.fccType == FOURCC_RMID)
  99.     {
  100.         ckDATA.ckid = FOURCC_data;
  101.         
  102.         if (0 == mmioDescend(hmmio, &ckDATA, &ckRIFF, MMIO_FINDCHUNK))
  103.         {
  104.             pSmf->cbImage   = ckDATA.cksize;
  105.         }
  106.         else
  107.         {
  108.             DPF(1, "smfOpenFile: Could not descend into RIFF DATA chunk!");
  109.             smfrc = SMF_INVALID_FILE;
  110.             goto smf_Open_File_Cleanup;
  111.         }
  112.     }
  113.     else
  114.     {
  115.         mmioSeek(hmmio, 0L, SEEK_SET);
  116.         
  117.         pSmf->cbImage = mmioSeek(hmmio, 0L, SEEK_END);
  118.         mmioSeek(hmmio, 0L, SEEK_SET);
  119.     }
  120.     
  121.     if (NULL == (pSmf->hpbImage = GlobalAllocPtr(GMEM_MOVEABLE|GMEM_SHARE, pSmf->cbImage)))
  122.     {
  123.         DPF(1, "smfOpenFile: No memory for image! [%08lX]", pSmf->cbImage);
  124.         smfrc = SMF_NO_MEMORY;
  125.         goto smf_Open_File_Cleanup;
  126.     }
  127.  
  128.     if (pSmf->cbImage != (DWORD)mmioRead(hmmio, pSmf->hpbImage, pSmf->cbImage))
  129.     {
  130.         DPF(1, "smfOpenFile: Read error on image!");
  131.         smfrc = SMF_INVALID_FILE;
  132.         goto smf_Open_File_Cleanup;
  133.     }
  134.  
  135.     /* If the file exists, parse it just enough to pull out the header and
  136.     ** build a track index.
  137.     */
  138.     smfrc = smfBuildFileIndex((PSMF BSTACK *)&pSmf);
  139.     if (MMSYSERR_NOERROR != smfrc)
  140.     {
  141.         DPF(1, "smfOpenFile: smfBuildFileIndex failed! [%lu]", (DWORD)smfrc);
  142.     }
  143.  
  144. smf_Open_File_Cleanup:
  145.  
  146.     mmioClose(hmmio, 0);
  147.  
  148.     if (SMF_SUCCESS != smfrc)
  149.     {
  150.         if (NULL != pSmf)
  151.         {
  152.             if (NULL != pSmf->hpbImage)
  153.             {
  154.                 GlobalFreePtr(pSmf->hpbImage);
  155.             }
  156.             
  157.             LocalFree((HLOCAL)pSmf);
  158.         }
  159.     }
  160.     else
  161.     {
  162.         psofs->hSmf = (HSMF)pSmf;
  163.     }
  164.     
  165.     return smfrc;
  166. }
  167.  
  168. /*****************************************************************************
  169. *
  170. * smfCloseFile
  171. *
  172. * This function closes an open MIDI file.
  173. *
  174. * hSmf                      - The handle of the open file to close.
  175. *
  176. * Returns
  177. *   SMF_SUCCESS The specified file was closed.
  178. *   SMF_INVALID_PARM The given handle was not valid.
  179. *
  180. * Any track handles opened from this file handle are invalid after this
  181. * call.
  182. *        
  183. *****************************************************************************/
  184. SMFRESULT FNLOCAL smfCloseFile(
  185.     HSMF                    hSmf)
  186. {
  187.     PSMF                    pSmf        = (PSMF)hSmf;
  188.     
  189.     assert(pSmf != NULL);
  190.     
  191.     /*
  192.     ** Free up handle memory 
  193.     */
  194.     
  195.     if (NULL != pSmf->hpbImage)
  196.         GlobalFreePtr(pSmf->hpbImage);
  197.     
  198.     LocalFree((HLOCAL)pSmf);
  199.     
  200.     return SMF_SUCCESS;
  201. }
  202.  
  203. /******************************************************************************
  204. *
  205. * smfGetFileInfo This function gets information about the MIDI file.
  206. *
  207. * hSmf                      - Specifies the open MIDI file to inquire about.
  208. *
  209. * psfi                      - A structure which will be filled in with
  210. *                             information about the file.
  211. *
  212. * Returns
  213. *   SMF_SUCCESS Information was gotten about the file.
  214. *   SMF_INVALID_PARM The given handle was invalid.
  215. *
  216. *****************************************************************************/
  217. SMFRESULT FNLOCAL smfGetFileInfo(
  218.     HSMF                    hSmf,
  219.     PSMFFILEINFO            psfi)
  220. {
  221.     PSMF                    pSmf = (PSMF)hSmf;
  222.  
  223.     assert(pSmf != NULL);
  224.     assert(psfi != NULL);
  225.  
  226.     /* 
  227.     ** Just fill in the structure with useful information.
  228.     */
  229.     psfi->dwTracks      = pSmf->dwTracks;
  230.     psfi->dwFormat      = pSmf->dwFormat;
  231.     psfi->dwTimeDivision= pSmf->dwTimeDivision;
  232.     psfi->tkLength      = pSmf->tkLength;
  233.     
  234.     return SMF_SUCCESS;
  235. }
  236.  
  237. /******************************************************************************
  238. *
  239. * smfTicksToMillisecs
  240. *
  241. * This function returns the millisecond offset into the file given the
  242. * tick offset.
  243. *
  244. * hSmf                      - Specifies the open MIDI file to perform
  245. *                             the conversion on.
  246. *
  247. * tkOffset                  - Specifies the tick offset into the stream
  248. *                             to convert.
  249. *
  250. * Returns the number of milliseconds from the start of the stream.
  251. *
  252. * The conversion is performed taking into account the file's time division and
  253. * tempo map from the first track. Note that the same millisecond value
  254. * might not be valid at a later time if the tempo track is rewritten.
  255. *
  256. *****************************************************************************/
  257. DWORD FNLOCAL smfTicksToMillisecs(
  258.     HSMF                    hSmf,
  259.     TICKS                   tkOffset)
  260. {
  261.     PSMF                    pSmf            = (PSMF)hSmf;
  262.     PTEMPOMAPENTRY          pTempo;
  263.     UINT                    idx;
  264.     UINT                    uSMPTE;
  265.     DWORD                   dwTicksPerSec;
  266.  
  267.     assert(pSmf != NULL);
  268.  
  269.     if (tkOffset > pSmf->tkLength)
  270.     {
  271.         DPF(1, "sTTM: Clipping ticks to file length!");
  272.         tkOffset = pSmf->tkLength;
  273.     }
  274.  
  275.     /* SMPTE time is easy -- no tempo map, just linear conversion
  276.     ** Note that 30-Drop means nothing to us here since we're not
  277.     ** converting to a colonized format, which is where dropping
  278.     ** happens.
  279.     */
  280.     if (pSmf->dwTimeDivision & 0x8000)
  281.     {
  282.         uSMPTE = -(int)(char)((pSmf->dwTimeDivision >> 8)&0xFF);
  283.         if (29 == uSMPTE)
  284.             uSMPTE = 30;
  285.         
  286.         dwTicksPerSec = (DWORD)uSMPTE *
  287.                         (DWORD)(BYTE)(pSmf->dwTimeDivision & 0xFF);
  288.         
  289.         return (DWORD)muldiv32(tkOffset, 1000L, dwTicksPerSec);
  290.     }
  291.        
  292.     /* Walk the tempo map and find the nearest tick position. Linearly
  293.     ** calculate the rest (using MATH.ASM)
  294.     */
  295.  
  296.     pTempo = pSmf->pTempoMap;
  297.     assert(pTempo != NULL);
  298.     
  299.     for (idx = 0; idx < pSmf->cTempoMap; idx++, pTempo++)
  300.         if (tkOffset < pTempo->tkTempo)
  301.             break;
  302.     pTempo--;
  303.  
  304.     /* pTempo is the tempo map entry preceding the requested tick offset.
  305.     */
  306.  
  307.     return pTempo->msBase + muldiv32(tkOffset-pTempo->tkTempo,
  308.                                      pTempo->dwTempo,
  309.                                      1000L*pSmf->dwTimeDivision);
  310.     
  311. }
  312.  
  313.  
  314. /******************************************************************************
  315. *
  316. * smfMillisecsToTicks
  317. *
  318. * This function returns the nearest tick offset into the file given the
  319. * millisecond offset.
  320. *
  321. * hSmf                      - Specifies the open MIDI file to perform the
  322. *                             conversion on.
  323. *
  324. * msOffset                  - Specifies the millisecond offset into the stream
  325. *                             to convert.
  326. *
  327. * Returns the number of ticks from the start of the stream.
  328. *
  329. * The conversion is performed taking into account the file's time division and
  330. * tempo map from the first track. Note that the same tick value
  331. * might not be valid at a later time if the tempo track is rewritten.
  332. * If the millisecond value does not exactly map to a tick value, then
  333. * the tick value will be rounded down.
  334. *
  335. *****************************************************************************/
  336. TICKS FNLOCAL smfMillisecsToTicks(
  337.     HSMF                    hSmf,
  338.     DWORD                   msOffset)
  339. {
  340.     PSMF                    pSmf            = (PSMF)hSmf;
  341.     PTEMPOMAPENTRY          pTempo;
  342.     UINT                    idx;
  343.     UINT                    uSMPTE;
  344.     DWORD                   dwTicksPerSec;
  345.     TICKS                   tkOffset;
  346.  
  347.     assert(pSmf != NULL);
  348.     
  349.     /* SMPTE time is easy -- no tempo map, just linear conversion
  350.     ** Note that 30-Drop means nothing to us here since we're not
  351.     ** converting to a colonized format, which is where dropping
  352.     ** happens.
  353.     */
  354.     if (pSmf->dwTimeDivision & 0x8000)
  355.     {
  356.         uSMPTE = -(int)(char)((pSmf->dwTimeDivision >> 8)&0xFF);
  357.         if (29 == uSMPTE)
  358.             uSMPTE = 30;
  359.         
  360.         dwTicksPerSec = (DWORD)uSMPTE *
  361.                         (DWORD)(BYTE)(pSmf->dwTimeDivision & 0xFF);
  362.  
  363.         return (DWORD)muldiv32(msOffset, dwTicksPerSec, 1000L);
  364.     }
  365.     
  366.     /* Walk the tempo map and find the nearest millisecond position. Linearly
  367.     ** calculate the rest (using MATH.ASM)
  368.     */
  369.     pTempo = pSmf->pTempoMap;
  370.     assert(pTempo != NULL);
  371.     
  372.     for (idx = 0; idx < pSmf->cTempoMap; idx++, pTempo++)
  373.         if (msOffset < pTempo->msBase)
  374.             break;
  375.     pTempo--;
  376.  
  377.     /* pTempo is the tempo map entry preceding the requested tick offset.
  378.     */
  379.  
  380.     tkOffset = pTempo->tkTempo + muldiv32(msOffset-pTempo->msBase,
  381.                                      1000L*pSmf->dwTimeDivision,
  382.                                      pTempo->dwTempo);
  383.     
  384.     if (tkOffset > pSmf->tkLength)
  385.     {
  386.         DPF(1, "sMTT: Clipping ticks to file length!");
  387.         tkOffset = pSmf->tkLength;
  388.     }
  389.  
  390.     return tkOffset;
  391. }
  392.  
  393. /******************************************************************************
  394. *
  395. * smfReadEvents
  396. *
  397. * This function reads events from a track.
  398. *
  399. * hSmf                      - Specifies the file to read data from.
  400. *
  401. * lpmh                      - Contains information about the buffer to fill.
  402. *
  403. * tkMax                     - Specifies a cutoff point in the stream
  404. *                             beyond which events will not be read.        
  405. *
  406. * Return@rdes
  407. *   SMF_SUCCESS The events were successfully read.
  408. *   SMF_END_OF_TRACK There are no more events to read in this track.
  409. *   SMF_INVALID_FILE A disk error occured on the file.
  410. * 
  411. * @xref <f smfWriteEvents>
  412. *****************************************************************************/
  413. SMFRESULT FNLOCAL smfReadEvents(
  414.     HSMF                    hSmf,
  415.     LPMIDIHDR               lpmh,
  416.     TICKS                   tkMax)
  417. {
  418.     PSMF                    pSmf = (PSMF)hSmf;
  419.     SMFRESULT               smfrc;
  420.     EVENT                   event;
  421.     LPDWORD                 lpdw;
  422.     DWORD                   dwTempo;
  423.  
  424.     assert(pSmf != NULL);
  425.     assert(lpmh != NULL);
  426.  
  427.     /* 
  428.     ** Read events from the track and pack them into the buffer in polymsg
  429.     ** format.
  430.     ** 
  431.     ** If a SysEx or meta would go over a buffer boundry, split it.
  432.     */ 
  433.     lpmh->dwBytesRecorded = 0;
  434.     if (pSmf->dwPendingUserEvent)
  435.     {
  436.         smfrc = smfInsertParmData(pSmf, (TICKS)0, lpmh);
  437.         if (SMF_SUCCESS != smfrc)
  438.         {
  439.             DPF(1, "smfInsertParmData() -> %u", (UINT)smfrc);
  440.             return smfrc;
  441.         }
  442.     }
  443.     
  444.     lpdw = (LPDWORD)(lpmh->lpData + lpmh->dwBytesRecorded);
  445.  
  446.     if (pSmf->fdwSMF & SMF_F_EOF)
  447.     {
  448.         return SMF_END_OF_FILE;
  449.     }
  450.  
  451.     while(TRUE)
  452.     {
  453.         assert(lpmh->dwBytesRecorded <= lpmh->dwBufferLength);
  454.         
  455.         /* If we know ahead of time we won't have room for the
  456.         ** event, just break out now. We need 2 DWORD's for the
  457.         ** terminator event and at least 2 DWORD's for any
  458.         ** event we might store - this will allow us a full
  459.         ** short event or the delta time and stub for a long
  460.         ** event to be split.
  461.         */
  462.         if (lpmh->dwBufferLength - lpmh->dwBytesRecorded < 4*sizeof(DWORD))
  463.         {
  464.             break;
  465.         }
  466.  
  467.         smfrc = smfGetNextEvent(pSmf, (SPEVENT)&event, tkMax);
  468.         if (SMF_SUCCESS != smfrc)
  469.         {
  470.             /* smfGetNextEvent doesn't set this because smfSeek uses it
  471.             ** as well and needs to distinguish between reaching the
  472.             ** seek point and reaching end-of-file.
  473.             **
  474.             ** To the user, however, we present the selection between
  475.             ** their given tkBase and tkEnd as the entire file, therefore
  476.             ** we want to translate this into EOF.
  477.             */
  478.             if (SMF_REACHED_TKMAX == smfrc)
  479.             {
  480.                 pSmf->fdwSMF |= SMF_F_EOF;
  481.             }
  482.             
  483.             DPF(1, "smfReadEvents: smfGetNextEvent() -> %u", (UINT)smfrc);
  484.             break;
  485.         }
  486.  
  487.         
  488.         if (MIDI_SYSEX > EVENT_TYPE(event))
  489.         {
  490.             *lpdw++ = (DWORD)event.tkDelta;
  491.             *lpdw++ = 0;
  492.             *lpdw++ = (((DWORD)MEVT_SHORTMSG)<<24) |
  493.                       ((DWORD)EVENT_TYPE(event)) |
  494.                       (((DWORD)EVENT_CH_B1(event)) << 8) |
  495.                       (((DWORD)EVENT_CH_B2(event)) << 16);
  496.             
  497.             lpmh->dwBytesRecorded += 3*sizeof(DWORD);
  498.         }
  499.         else if (MIDI_META == EVENT_TYPE(event) &&
  500.                  MIDI_META_EOT == EVENT_META_TYPE(event))
  501.         {
  502.             /* These are ignoreable since smfReadNextEvent()
  503.             ** takes care of track merging
  504.             */
  505.         }
  506.         else if (MIDI_META == EVENT_TYPE(event) &&
  507.                  MIDI_META_TEMPO == EVENT_META_TYPE(event))
  508.         {
  509.             if (event.cbParm != 3)
  510.             {
  511.                 DPF(1, "smfReadEvents: Corrupt tempo event");
  512.                 return SMF_INVALID_FILE;
  513.             }
  514.  
  515.             dwTempo = (((DWORD)MEVT_TEMPO)<<24)|
  516.                       (((DWORD)event.hpbParm[0])<<16)|
  517.                       (((DWORD)event.hpbParm[1])<<8)|
  518.                       ((DWORD)event.hpbParm[2]);
  519.  
  520.             *lpdw++ = (DWORD)event.tkDelta;
  521.             *lpdw++ = 0;
  522.             *lpdw++ = dwTempo;
  523.  
  524.             lpmh->dwBytesRecorded += 3*sizeof(DWORD);
  525.         }
  526.         else if (MIDI_META != EVENT_TYPE(event))
  527.         {
  528.             /* Must be F0 or F7 system exclusive or FF meta
  529.             ** that we didn't recognize
  530.             */
  531.             pSmf->cbPendingUserEvent = event.cbParm;
  532.             pSmf->hpbPendingUserEvent = event.hpbParm;
  533.             pSmf->fdwSMF &= ~SMF_F_INSERTSYSEX;
  534.  
  535.             switch(EVENT_TYPE(event))
  536.             {
  537.                 case MIDI_SYSEX:
  538.                     pSmf->fdwSMF |= SMF_F_INSERTSYSEX;
  539.             
  540.                     ++pSmf->cbPendingUserEvent;
  541.  
  542.                     /* Falling through...
  543.                     */
  544.  
  545.                 case MIDI_SYSEXEND:
  546.                     pSmf->dwPendingUserEvent = ((DWORD)MEVT_LONGMSG) << 24;
  547.                     break;
  548.             }
  549.  
  550.             smfrc = smfInsertParmData(pSmf, event.tkDelta, lpmh);
  551.             if (SMF_SUCCESS != smfrc)
  552.             {
  553.                 DPF(1, "smfInsertParmData[2] %u", (UINT)smfrc);
  554.                 return smfrc;
  555.             }
  556.  
  557.             lpdw = (LPDWORD)(lpmh->lpData + lpmh->dwBytesRecorded);
  558.         }
  559.     }
  560.  
  561.     return (pSmf->fdwSMF & SMF_F_EOF) ? SMF_END_OF_FILE : SMF_SUCCESS;
  562. }
  563.  
  564. /******************************************************************************
  565. *
  566. * smfInsertParmData
  567. *
  568. * Inserts pending long data from a track into the given buffer.
  569. *
  570. * pSmf                      - Specifies the file to read data from.
  571. *
  572. * tkDelta                   - Specfices the tick delta for the data.
  573. *
  574. * lpmh                      - Contains information about the buffer to fill.
  575. *
  576. * Returns
  577. *   SMF_SUCCESS The events were successfully read.
  578. *   SMF_INVALID_FILE A disk error occured on the file.
  579. * 
  580. * Fills as much data as will fit while leaving room for the buffer
  581. * terminator.
  582. *
  583. * If the long data is depleted, resets pSmf->dwPendingUserEvent so
  584. * that the next event may be read.
  585. *
  586. *****************************************************************************/
  587. PRIVATE SMFRESULT FNLOCAL smfInsertParmData(
  588.     PSMF                    pSmf,
  589.     TICKS                   tkDelta,                                            
  590.     LPMIDIHDR               lpmh)
  591. {
  592.     DWORD                   dwLength;
  593.     DWORD                   dwRounded;
  594.     LPDWORD                 lpdw;
  595.  
  596.     assert(pSmf != NULL);
  597.     assert(lpmh != NULL);
  598.     
  599.     /* Can't fit 4 DWORD's? (tkDelta + stream-id + event + some data)
  600.     ** Can't do anything.
  601.     */
  602.     assert(lpmh->dwBufferLength >= lpmh->dwBytesRecorded);
  603.     
  604.     if (lpmh->dwBufferLength - lpmh->dwBytesRecorded < 4*sizeof(DWORD))
  605.     {
  606.         if (0 == tkDelta)
  607.             return SMF_SUCCESS;
  608.  
  609.         /* If we got here with a real delta, that means smfReadEvents screwed
  610.         ** up calculating left space and we should flag it somehow.
  611.         */
  612.         DPF(1, "Can't fit initial piece of SysEx into buffer!");
  613.         return SMF_INVALID_FILE;
  614.     }
  615.  
  616.     lpdw = (LPDWORD)(lpmh->lpData + lpmh->dwBytesRecorded);
  617.  
  618.     dwLength = lpmh->dwBufferLength - lpmh->dwBytesRecorded - 3*sizeof(DWORD);
  619.     dwLength = min(dwLength, pSmf->cbPendingUserEvent);
  620.  
  621.     *lpdw++ = (DWORD)tkDelta;
  622.     *lpdw++ = 0L;
  623.     *lpdw++ = (pSmf->dwPendingUserEvent & 0xFF000000L) | (dwLength & 0x00FFFFFFL);
  624.  
  625.     dwRounded = (dwLength + 3) & (~3L);
  626.     
  627.     if (pSmf->fdwSMF & SMF_F_INSERTSYSEX)
  628.     {
  629.         *((LPBYTE)lpdw)++ = MIDI_SYSEX;
  630.         pSmf->fdwSMF &= ~SMF_F_INSERTSYSEX;
  631.         --dwLength;
  632.         --pSmf->cbPendingUserEvent;
  633.     }
  634.  
  635.     if (dwLength & 0x80000000L)
  636.     {
  637.         DPF(1, "dwLength %08lX  dwBytesRecorded %08lX  dwBufferLength %08lX", dwLength, lpmh->dwBytesRecorded, lpmh->dwBufferLength);
  638.         DPF(1, "cbPendingUserEvent %08lX  dwPendingUserEvent %08lX dwRounded %08lX", pSmf->cbPendingUserEvent, pSmf->dwPendingUserEvent, dwRounded);
  639.         DPF(1, "Offset into MIDI image %08lX", (DWORD)(pSmf->hpbPendingUserEvent - pSmf->hpbImage));
  640.         DPF(1, "!hmemcpy is about to fault");
  641.     }
  642.  
  643.     hmemcpy(lpdw, pSmf->hpbPendingUserEvent, dwLength);
  644.     if (0 == (pSmf->cbPendingUserEvent -= dwLength))
  645.         pSmf->dwPendingUserEvent = 0;
  646.  
  647.     lpmh->dwBytesRecorded += 3*sizeof(DWORD) + dwRounded;
  648.  
  649.     return SMF_SUCCESS;
  650. }
  651.  
  652. /******************************************************************************
  653. *
  654. * smfSeek
  655. *
  656. * This function moves the file pointer within a track
  657. * and gets the state of the track at the new position. It returns a buffer of
  658. * state information which can be used to set up to play from the new position.
  659. *
  660. * hSmf                      - Handle of file to seek within
  661. *
  662. * tkPosition                - The position to seek to in the track.
  663. *         
  664. * lpmh                      - A buffer to contain the state information.
  665. *
  666. * Returns
  667. *   SMF_SUCCESS | The state was successfully read.
  668. *   SMF_END_OF_TRACK | The pointer was moved to end of track and no state
  669. *     information was returned.
  670. *   SMF_INVALID_PARM | The given handle or buffer was invalid.
  671. *   SMF_NO_MEMORY | There was insufficient memory in the given buffer to
  672. *     contain all of the state data.
  673. *
  674. * The state information in the buffer includes patch changes, tempo changes,
  675. * time signature, key signature, 
  676. * and controller information. Only the most recent of these paramters before
  677. * the current position will be stored. The state buffer will be returned
  678. * in polymsg format so that it may be directly transmitted over the MIDI
  679. * bus to bring the state up to date.
  680. *
  681. * The buffer is mean to be sent as a streaming buffer; i.e. immediately
  682. * followed by the first data buffer. If the requested tick position
  683. * does not exist in the file, the last event in the buffer
  684. * will be a MEVT_NOP with a delta time calculated to make sure that
  685. * the next stream event plays at the proper time.
  686. *
  687. * The meta events (tempo, time signature, key signature) will be the
  688. * first events in the buffer if they exist.
  689. * 
  690. * Use smfGetStateMaxSize to determine the maximum size of the state
  691. * information buffer. State information that will not fit into the given
  692. * buffer will be lost.
  693. *
  694. * On return, the dwBytesRecorded field of lpmh will contain the
  695. * actual number of bytes stored in the buffer.
  696. *
  697. *****************************************************************************/
  698.  
  699. typedef struct tag_keyframe
  700. {
  701.     /*
  702.     ** Meta events. All FF's indicates never seen.
  703.     */
  704.     BYTE        rbTempo[3];
  705.  
  706.     /*
  707.     ** MIDI channel messages. FF indicates never seen.
  708.     */
  709.     BYTE        rbProgram[16];
  710.     BYTE        rbControl[16*120];
  711. }   KEYFRAME,
  712.     FAR *PKEYFRAME;
  713.  
  714. #define KF_EMPTY ((BYTE)0xFF)
  715.  
  716. SMFRESULT FNLOCAL smfSeek(
  717.     HSMF                    hSmf,
  718.     TICKS                   tkPosition,
  719.     LPMIDIHDR               lpmh)
  720. {
  721.     PSMF                    pSmf    = (PSMF)hSmf;
  722.     PTRACK                  ptrk;
  723.     DWORD                   idxTrack;
  724.     SMFRESULT               smfrc;
  725.     EVENT                   event;
  726.     LPDWORD                 lpdw;
  727.     BYTE                    bEvent;
  728.     UINT                    idx;
  729.     UINT                    idxChannel;
  730.     UINT                    idxController;
  731.     
  732.     static KEYFRAME         kf;
  733.  
  734.     _fmemset(&kf, 0xFF, sizeof(kf));
  735.     
  736.     pSmf->tkPosition = 0;
  737.     pSmf->fdwSMF &= ~SMF_F_EOF;
  738.     
  739.     for (ptrk = pSmf->rTracks, idxTrack = pSmf->dwTracks; idxTrack--; ptrk++)
  740.     {
  741.         ptrk->pSmf              = pSmf;
  742.         ptrk->tkPosition        = 0;
  743.         ptrk->cbLeft            = ptrk->smti.cbLength;
  744.         ptrk->hpbImage          = pSmf->hpbImage + ptrk->idxTrack;
  745.         ptrk->bRunningStatus    = 0;
  746.         ptrk->fdwTrack          = 0;
  747.     }
  748.  
  749.     while (SMF_SUCCESS == (smfrc = smfGetNextEvent(pSmf, (SPEVENT)&event, tkPosition)))
  750.     {
  751.         if (MIDI_META == (bEvent = EVENT_TYPE(event)))
  752.         {
  753.             if (EVENT_META_TYPE(event) == MIDI_META_TEMPO)
  754.             {
  755.                 if (event.cbParm != sizeof(kf.rbTempo))
  756.                     return SMF_INVALID_FILE;
  757.  
  758.                 hmemcpy((HPBYTE)kf.rbTempo, event.hpbParm, event.cbParm);
  759.             }
  760.         }
  761.         else switch(bEvent & 0xF0)
  762.         {
  763.             case MIDI_PROGRAMCHANGE:
  764.                 kf.rbProgram[bEvent & 0x0F] = EVENT_CH_B1(event);
  765.                 break;
  766.  
  767.             case MIDI_CONTROLCHANGE:
  768.                 kf.rbControl[(((WORD)bEvent & 0x0F)*120) + EVENT_CH_B1(event)] =
  769.                     EVENT_CH_B2(event);
  770.                 break;
  771.         }
  772.     }
  773.  
  774.     if (SMF_REACHED_TKMAX != smfrc)
  775.     {
  776.         return smfrc;
  777.     }
  778.  
  779.     /* Build lpmh from keyframe
  780.     */
  781.     lpmh->dwBytesRecorded = 0;
  782.     lpdw = (LPDWORD)lpmh->lpData;
  783.  
  784.     /* Tempo change event?
  785.     */
  786.     if (KF_EMPTY != kf.rbTempo[0] ||
  787.         KF_EMPTY != kf.rbTempo[1] ||
  788.         KF_EMPTY != kf.rbTempo[2])
  789.     {
  790.         if (lpmh->dwBufferLength - lpmh->dwBytesRecorded < 3*sizeof(DWORD))
  791.             return SMF_NO_MEMORY;
  792.  
  793.         *lpdw++ = 0;
  794.         *lpdw++ = 0;
  795.         *lpdw++ = (((DWORD)kf.rbTempo[0])<<16)|
  796.                   (((DWORD)kf.rbTempo[1])<<8)|
  797.                   ((DWORD)kf.rbTempo[2])|
  798.                   (((DWORD)MEVT_TEMPO) << 24);
  799.  
  800.         lpmh->dwBytesRecorded += 3*sizeof(DWORD);
  801.     }
  802.  
  803.     /* Program change events?
  804.     */
  805.     for (idx = 0; idx < 16; idx++)
  806.     {
  807.         if (KF_EMPTY != kf.rbProgram[idx])
  808.         {
  809.             if (lpmh->dwBufferLength - lpmh->dwBytesRecorded < 3*sizeof(DWORD))
  810.                 return SMF_NO_MEMORY;
  811.  
  812.             *lpdw++ = 0;
  813.             *lpdw++ = 0;
  814.             *lpdw++ = (((DWORD)MEVT_SHORTMSG) << 24)      |
  815.                       ((DWORD)MIDI_PROGRAMCHANGE)         |
  816.                       ((DWORD)idx)                        |
  817.                       (((DWORD)kf.rbProgram[idx]) << 8);
  818.  
  819.             lpmh->dwBytesRecorded += 3*sizeof(DWORD);
  820.         }
  821.     }
  822.  
  823.     /* Controller events?
  824.     */
  825.     idx = 0;
  826.     for (idxChannel = 0; idxChannel < 16; idxChannel++)
  827.     {
  828.         for (idxController = 0; idxController < 120; idxController++)
  829.         {
  830.             if (KF_EMPTY != kf.rbControl[idx])
  831.             {
  832.                 if (lpmh->dwBufferLength - lpmh->dwBytesRecorded < 3*sizeof(DWORD))
  833.                     return SMF_NO_MEMORY;
  834.  
  835.                 *lpdw++ = 0;
  836.                 *lpdw++ = 0;
  837.                 *lpdw++ = (((DWORD)MEVT_SHORTMSG << 24)     |
  838.                           ((DWORD)MIDI_CONTROLCHANGE)       |
  839.                           ((DWORD)idxChannel)               |
  840.                           (((DWORD)idxController) << 8)     |
  841.                           (((DWORD)kf.rbControl[idx]) << 16));
  842.  
  843.  
  844.                 lpmh->dwBytesRecorded += 3*sizeof(DWORD);
  845.             }
  846.  
  847.             idx++;
  848.         }
  849.     }
  850.  
  851.     /* Force all tracks to be at tkPosition. We are guaranteed that
  852.     ** all tracks will be past the event immediately preceding tkPosition;
  853.     ** this will force correct delta-ticks to be generated so that events
  854.     ** on all tracks will line up properly on a seek into the middle of the
  855.     ** file.
  856.     */
  857.     for (ptrk = pSmf->rTracks, idxTrack = pSmf->dwTracks; idxTrack--; ptrk++)
  858.     {
  859.         ptrk->tkPosition        = tkPosition;
  860.     }
  861.     
  862.     return SMF_SUCCESS;
  863. }
  864.  
  865. /******************************************************************************
  866. *
  867. * smfGetStateMaxSize
  868. *
  869. * This function returns the maximum sizeof buffer that is needed to
  870. * hold the state information returned by f smfSeek.
  871. *
  872. * pdwSize                   - Gets the size in bytes that should be allocated
  873. *                             for the state buffer.
  874. *
  875. * Returns the state size in bytes.
  876. *
  877. *****************************************************************************/
  878. DWORD FNLOCAL smfGetStateMaxSize(
  879.     VOID)
  880. {
  881.     return  3*sizeof(DWORD) +           /* Tempo                */
  882.             3*16*sizeof(DWORD) +        /* Patch changes        */  
  883.             3*16*120*sizeof(DWORD) +    /* Controller changes   */
  884.             3*sizeof(DWORD);            /* Time alignment NOP   */
  885. }
  886.  
  887.