开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
MIDI.CPP
资源名称：media-file.rar　[点击查看]
上传用户：lianyisd
上传日期：2019-11-03
资源大小：5188k
文件大小：34k
源码类别：

midi

开发平台：

Visual C++

MIDI.CPP：源码内容
  1. // Midi.cpp
  2. //
  4. #include "stdafx.h"
  5. #include "Midi.h"
  7. #ifdef _DEBUG
  8. #define new DEBUG_NEW
  9. #undef THIS_FILE
  10. static char THIS_FILE[] = __FILE__;
  11. #endif
  14. #define MThd 0x6468544D // Start of file
  15. #define MTrk 0x6B72544D // Start of track
  18. #define BUFFER_TIME_LENGTH 60   // Amount to fill in milliseconds
  21. // These structures are stored in MIDI files; they need to be byte aligned.
  22. //
  23. #pragma pack(1)
  25. // Contents of MThd chunk.
  26. struct MIDIFILEHDR
  27. {
  28.     WORD wFormat; // Format (hi-lo)
  29.     WORD wTrackCount; // # tracks (hi-lo)
  30.     WORD wTimeDivision; // Time division (hi-lo)
  31. };
  33. #pragma pack() // End of need for byte-aligned structures
  36. // Macros for swapping hi/lo-endian data
  37. //
  38. #define WORDSWAP(w) (((w) >> 8) | 
  39. (((w) << 8) & 0xFF00))
  41. #define DWORDSWAP(dw) (((dw) >> 24) | 
  42. (((dw) >> 8) & 0x0000FF00) | 
  43. (((dw) << 8) & 0x00FF0000) | 
  44. (((dw) << 24) & 0xFF000000))
  47. static char gteBadRunStat[]  = "Reference to missing running status.";
  48. static char gteRunStatMsgTrunc[]= "Running status message truncated";
  49. static char gteChanMsgTrunc[] = "Channel message truncated";
  50. static char gteSysExLenTrunc[] = "SysEx event truncated (length)";
  51. static char gteSysExTrunc[] = "SysEx event truncated";
  52. static char gteMetaNoClass[] = "Meta event truncated (no class byte)";
  53. static char gteMetaLenTrunc[] = "Meta event truncated (length)";
  54. static char gteMetaTrunc[] = "Meta event truncated";
  55. static char gteNoMem[] = "Out of memory during malloc call";
  58. //////////////////////////////////////////////////////////////////////
  59. // CMIDI -- Construction/Destruction
  60. //////////////////////////////////////////////////////////////////////
  62. CMIDI::CMIDI()
  63. : m_dwSoundSize(0)
  64. , m_pSoundData(0)
  65. , m_dwFormat(0)
  66. , m_dwTrackCount(0)
  67. , m_dwTimeDivision(0)
  68. , m_bPlaying(FALSE)
  69. , m_hStream(0)
  70. , m_dwProgressBytes(0)
  71. , m_bLooped(FALSE)
  72. , m_tkCurrentTime(0)
  73. , m_dwBufferTickLength(0)
  74. , m_dwCurrentTempo(0)
  75. , m_dwTempoMultiplier(100)
  76. , m_bInsertTempo(FALSE)
  77. , m_bBuffersPrepared(FALSE)
  78. , m_nCurrentBuffer(0)
  79. , m_uMIDIDeviceID(MIDI_MAPPER)
  80. , m_nEmptyBuffers(0)
  81. , m_bPaused(FALSE)
  82. , m_uCallbackStatus(0)
  83. , m_hBufferReturnEvent(0)
  85. , m_ptsTrack(0)
  86. , m_ptsFound(0)
  87. , m_dwStatus(0)
  88. , m_tkNext(0)
  89. , m_dwMallocBlocks(0)
  90. {
  91. m_hBufferReturnEvent = ::CreateEvent(0, FALSE, FALSE, TEXT("Wait For Buffer Return"));
  92. ASSERT(m_hBufferReturnEvent != 0);
  93. }
  95. CMIDI::~CMIDI()
  96. {
  97. Stop(FALSE);
  99. if(m_hBufferReturnEvent)
  100. ::CloseHandle(m_hBufferReturnEvent);
  101. }
  104. BOOL CMIDI::Create(UINT uResID, CWnd * pWndParent /* = NULL */)
  105. {
  106. return Create(MAKEINTRESOURCE(uResID), pWndParent);
  107. }
  110. BOOL CMIDI::Create(LPCTSTR pszResID, CWnd * pWndParent /* = NULL */)
  111. {
  112. //////////////////////////////////////////////////////////////////
  113. // load resource
  114. HINSTANCE hApp = ::GetModuleHandle(0);
  115. ASSERT(hApp);
  117. HRSRC hResInfo = ::FindResource(hApp, pszResID, TEXT("MIDI"));
  118. if(hResInfo == 0)
  119. return FALSE;
  121. HGLOBAL hRes = ::LoadResource(hApp, hResInfo);
  122. if(hRes == 0)
  123. return FALSE;
  125. LPVOID pTheSound = ::LockResource(hRes);
  126. if(pTheSound == 0)
  127. return FALSE;
  129. DWORD dwTheSound = ::SizeofResource(hApp, hResInfo);
  131. return Create(pTheSound, dwTheSound, pWndParent);
  132. }
  135. BOOL CMIDI::Create(LPVOID pSoundData, DWORD dwSize, CWnd * pWndParent /* = NULL */)
  136. {
  137. if( m_pSoundData ) {
  138. // already created
  139. ASSERT(FALSE);
  140. return FALSE;
  141. }
  143. ASSERT(pSoundData != 0);
  144. ASSERT(dwSize > 0);
  146. register LPBYTE p = LPBYTE(pSoundData);
  148. // check header of MIDI
  149. if(*(DWORD*)p != MThd) {
  150. ASSERT(FALSE);
  151. return FALSE;
  152. }
  153. p += sizeof(DWORD);
  155. // check header size
  156. DWORD dwHeaderSize = DWORDSWAP(*(DWORD*)p);
  157. if( dwHeaderSize != sizeof(MIDIFILEHDR) ) {
  158. ASSERT(FALSE);
  159. return FALSE;
  160. }
  161. p += sizeof(DWORD);
  163. // get header
  164. MIDIFILEHDR hdr;
  165. ::CopyMemory(&hdr, p, dwHeaderSize);
  166. m_dwFormat = DWORD(WORDSWAP(hdr.wFormat));
  167. m_dwTrackCount = DWORD(WORDSWAP(hdr.wTrackCount));
  168. m_dwTimeDivision = DWORD(WORDSWAP(hdr.wTimeDivision));
  169. p += dwHeaderSize;
  171. // create the array of tracks
  172. m_Tracks.resize(m_dwTrackCount);
  173. for(register DWORD i = 0; i < m_dwTrackCount; ++i) {
  174. // check header of track
  175. if(*(DWORD*)p != MTrk) {
  176. ASSERT(FALSE);
  177. return FALSE;
  178. }
  179. p += sizeof(DWORD);
  181. m_Tracks[i].dwTrackLength = DWORDSWAP(*(DWORD*)p);
  182. p += sizeof(DWORD);
  184. m_Tracks[i].pTrackStart = m_Tracks[i].pTrackCurrent = p;
  185. p += m_Tracks[i].dwTrackLength;
  187.         // Handle bozo MIDI files which contain empty track chunks
  188. if( !m_Tracks[i].dwTrackLength ) {
  189. m_Tracks[i].fdwTrack |= ITS_F_ENDOFTRK;
  190. continue;
  191. }
  193. // We always preread the time from each track so the mixer code can
  194. // determine which track has the next event with a minimum of work
  195. if( !GetTrackVDWord( &m_Tracks[i], &m_Tracks[i].tkNextEventDue )) {
  196. TRACE0("Error in MIDI datan");
  197. ASSERT(FALSE);
  198. return FALSE;
  199. }
  200. }
  203. m_pSoundData = pSoundData;
  204. m_dwSoundSize = dwSize;
  205. m_pWndParent = pWndParent;
  207. // allocate volume channels and initialise them
  208. m_Volumes.resize(NUM_CHANNELS, VOLUME_INIT);
  210. if( ! StreamBufferSetup() ) {
  211. ASSERT(FALSE);
  212. return FALSE;
  213. }
  215. return TRUE;
  216. }
  219. BOOL CMIDI :: Play(BOOL bInfinite /* = FALSE */) {
  220. if( IsPaused() ) {
  221. Continue();
  222. return TRUE;
  223. }
  225. // calling Play() while it is already playing will restart from scratch
  226. if( IsPlaying() )
  227. Stop();
  229. // Clear the status of our callback so it will handle
  230. // MOM_DONE callbacks once more
  231. m_uCallbackStatus = 0;
  233. if( !m_bLooped )
  234. m_bInsertTempo = TRUE;
  236. MMRESULT mmResult;
  237. if( (mmResult = midiStreamRestart(m_hStream)) != MMSYSERR_NOERROR ) {
  238. MidiError(mmResult);
  239. return FALSE;
  240. }
  242. m_bPlaying = TRUE;
  243. m_bLooped = bInfinite;
  245. return m_bPlaying;
  246. }
  249. BOOL CMIDI :: Stop(BOOL bReOpen /*=TRUE*/) {
  250. MMRESULT mmrRetVal;
  252. if( IsPlaying() || (m_uCallbackStatus != STATUS_CALLBACKDEAD) ) {
  253. m_bPlaying = m_bPaused = FALSE;
  254. if( m_uCallbackStatus != STATUS_CALLBACKDEAD && m_uCallbackStatus != STATUS_WAITINGFOREND )
  255. m_uCallbackStatus = STATUS_KILLCALLBACK;
  257. if( (mmrRetVal = midiStreamStop(m_hStream) ) != MMSYSERR_NOERROR ) {
  258. MidiError(mmrRetVal);
  259. return FALSE;
  260. }
  261. if( (mmrRetVal = midiOutReset((HMIDIOUT)m_hStream)) != MMSYSERR_NOERROR ) {
  262. MidiError(mmrRetVal);
  263. return FALSE;
  264. }
  265. // Wait for the callback thread to release this thread, which it will do by
  266. // calling SetEvent() once all buffers are returned to it
  267. if( WaitForSingleObject( m_hBufferReturnEvent, DEBUG_CALLBACK_TIMEOUT ) == WAIT_TIMEOUT ) {
  268. // Note, this is a risky move because the callback may be genuinely busy, but
  269. // when we're debugging, it's safer and faster than freezing the application,
  270. // which leaves the MIDI device locked up and forces a system reset...
  271. TRACE0("Timed out waiting for MIDI callbackn");
  272. m_uCallbackStatus = STATUS_CALLBACKDEAD;
  273. }
  274. }
  276. if( m_uCallbackStatus == STATUS_CALLBACKDEAD ) {
  277. m_uCallbackStatus = 0;
  278. FreeBuffers();
  279. if( m_hStream ) {
  280. if( (mmrRetVal = midiStreamClose(m_hStream) ) != MMSYSERR_NOERROR ) {
  281. MidiError(mmrRetVal);
  282. }
  283. m_hStream = 0;
  284. }
  286. if( bReOpen ) {
  287. if( !StreamBufferSetup() ) {
  288. // Error setting up for MIDI file
  289. // Notification is already taken care of...
  290. return FALSE;
  291. }
  292. if( ! m_bLooped ) {
  293. Rewind();
  294. m_dwProgressBytes = 0;
  295. m_dwStatus = 0;
  296. }
  297. }
  298. }
  299. return TRUE;
  300. }
  303. BOOL CMIDI :: Pause() {
  304. if( ! m_bPaused && m_bPlaying && m_pSoundData && m_hStream ) {
  305. midiStreamPause(m_hStream);
  306. m_bPaused = TRUE;
  307. }
  308. return FALSE;
  309. }
  312. BOOL CMIDI :: Continue() {
  313. if( m_bPaused && m_bPlaying && m_pSoundData && m_hStream ) {
  314. midiStreamRestart(m_hStream);
  315. m_bPaused = FALSE;
  316. }
  317. return FALSE;
  318. }
  321. BOOL CMIDI :: Rewind() {
  322. if( ! m_pSoundData )
  323. return FALSE;
  325. for(register DWORD i = 0; i < m_dwTrackCount; ++i) {
  326. m_Tracks[i].pTrackCurrent = m_Tracks[i].pTrackStart;
  327. m_Tracks[i].byRunningStatus = 0;
  328. m_Tracks[i].tkNextEventDue = 0;
  329. m_Tracks[i].fdwTrack = 0;
  331.         // Handle bozo MIDI files which contain empty track chunks
  332. if( !m_Tracks[i].dwTrackLength ) {
  333. m_Tracks[i].fdwTrack |= ITS_F_ENDOFTRK;
  334. continue;
  335. }
  337. // We always preread the time from each track so the mixer code can
  338. // determine which track has the next event with a minimum of work
  339. if( !GetTrackVDWord( &m_Tracks[i], &m_Tracks[i].tkNextEventDue )) {
  340. TRACE0("Error in MIDI datan");
  341. ASSERT(FALSE);
  342. return FALSE;
  343. }
  344. }
  346. return TRUE;
  347. }
  350. DWORD CMIDI :: GetChannelCount() const {
  351. return m_Volumes.size();
  352. }
  355. void CMIDI :: SetVolume(DWORD dwPercent) {
  356. const DWORD dwSize = m_Volumes.size();
  357. for( register DWORD i = 0; i < dwSize; ++i )
  358. SetChannelVolume(i, dwPercent);
  359. }
  362. DWORD CMIDI :: GetVolume() const {
  363. DWORD dwVolume = 0;
  364. const DWORD dwSize = m_Volumes.size();
  365. for( register DWORD i = 0; i < dwSize; ++i )
  366. dwVolume += GetChannelVolume(i);
  368. return dwVolume / GetChannelCount();
  369. }
  372. void CMIDI :: SetChannelVolume(DWORD dwChannel, DWORD dwPercent) {
  373. ASSERT(dwChannel < m_Volumes.size());
  375. if( !m_bPlaying )
  376. return;
  378. m_Volumes[dwChannel] = (dwPercent > 100) ? 100 : dwPercent;
  379. DWORD dwEvent = MIDI_CTRLCHANGE | dwChannel | ((DWORD)MIDICTRL_VOLUME << 8) | ((DWORD)(m_Volumes[dwChannel]*VOLUME_MAX/100) << 16);
  380. MMRESULT mmrRetVal;
  381. if(( mmrRetVal = midiOutShortMsg((HMIDIOUT)m_hStream, dwEvent)) != MMSYSERR_NOERROR ) {
  382. MidiError(mmrRetVal);
  383. return;
  384. }
  385. }
  388. DWORD CMIDI :: GetChannelVolume(DWORD dwChannel) const {
  389. ASSERT(dwChannel < GetChannelCount());
  390. return m_Volumes[dwChannel];
  391. }
  394. void CMIDI :: SetTempo(DWORD dwPercent) {
  395. m_dwTempoMultiplier = dwPercent ? dwPercent : 1;
  396. m_bInsertTempo = TRUE;
  397. }
  400. DWORD CMIDI :: GetTempo() const {
  401. return m_dwTempoMultiplier;
  402. }
  405. void CMIDI :: SetInfinitePlay(BOOL bSet) {
  406. m_bLooped = bSet;
  407. }
  409. //////////////////////////////////////////////////////////////////////
  410. // CMIDI -- implementation
  411. //////////////////////////////////////////////////////////////////////
  413. // This function converts MIDI data from the track buffers setup by a
  414. // previous call to ConverterInit().  It will convert data until an error is
  415. // encountered or the output buffer has been filled with as much event data
  416. // as possible, not to exceed dwMaxLength. This function can take a couple
  417. // bit flags, passed through dwFlags. Information about the success/failure
  418. // of this operation and the number of output bytes actually converted will
  419. // be returned in the CONVERTINFO structure pointed at by lpciInfo.
  420. int CMIDI :: ConvertToBuffer(DWORD dwFlags, CONVERTINFO * lpciInfo) {
  421. int     nChkErr;
  423. lpciInfo->dwBytesRecorded = 0;
  425. if( dwFlags & CONVERTF_RESET ) {
  426. m_dwProgressBytes = 0;
  427. m_dwStatus = 0;
  428. memset( &m_teTemp, 0, sizeof(TEMPEVENT));
  429. m_ptsTrack = m_ptsFound = 0;
  430. }
  432. // If we were already done, then return with a warning...
  433. if( m_dwStatus & CONVERTF_STATUS_DONE ) {
  434. if( m_bLooped ) {
  435. Rewind();
  436. m_dwProgressBytes = 0;
  437. m_dwStatus = 0;
  438. } else
  439. return CONVERTERR_DONE;
  440. } else if( m_dwStatus & CONVERTF_STATUS_STUCK ) {
  441. // The caller is asking us to continue, but we're already hosed because we
  442. // previously identified something as corrupt, so complain louder this time.
  443. return( CONVERTERR_STUCK );
  444. } else if( m_dwStatus & CONVERTF_STATUS_GOTEVENT ) {
  445. // Turn off this bit flag
  446. m_dwStatus ^= CONVERTF_STATUS_GOTEVENT;
  448. // The following code for this case is duplicated from below, and is
  449. // designed to handle a "straggler" event, should we have one left over
  450. // from previous processing the last time this function was called.
  452. // Don't add end of track event 'til we're done
  453. if( m_teTemp.byShortData[0] == MIDI_META && m_teTemp.byShortData[1] == MIDI_META_EOT ) {
  454. if( m_dwMallocBlocks ) {
  455. delete [] m_teTemp.pLongData;
  456. --m_dwMallocBlocks;
  457. }
  458. } else if(( nChkErr = AddEventToStreamBuffer( &m_teTemp, lpciInfo )) != CONVERTERR_NOERROR ) {
  459. if( nChkErr == CONVERTERR_BUFFERFULL ) {
  460. // Do some processing and tell caller that this buffer's full
  461. m_dwStatus |= CONVERTF_STATUS_GOTEVENT;
  462. return CONVERTERR_NOERROR;
  463. } else if( nChkErr == CONVERTERR_METASKIP ) {
  464. // We skip by all meta events that aren't tempo changes...
  465. } else {
  466. TRACE0("Unable to add event to stream buffer.n");
  467. if( m_dwMallocBlocks ) {
  468. delete [] m_teTemp.pLongData;
  469. m_dwMallocBlocks--;
  470. }
  471. return( TRUE );
  472. }
  473. }
  474. }
  476. for(;;) {
  477. m_ptsFound = 0;
  478. m_tkNext = 0xFFFFFFFFL;
  479. // Find nearest event due
  480. for( register DWORD idx = 0; idx < m_Tracks.size(); ++idx ) {
  481. m_ptsTrack = &m_Tracks[idx];
  482. if( !(m_ptsTrack->fdwTrack & ITS_F_ENDOFTRK) && (m_ptsTrack->tkNextEventDue < m_tkNext) ) {
  483. m_tkNext = m_ptsTrack->tkNextEventDue;
  484. m_ptsFound = m_ptsTrack;
  485. }
  486. }
  488. // None found?  We must be done, so return to the caller with a smile.
  489. if( !m_ptsFound ) {
  490. m_dwStatus |= CONVERTF_STATUS_DONE;
  491. // Need to set return buffer members properly
  492. return CONVERTERR_NOERROR;
  493. }
  495. // Ok, get the event header from that track
  496. if( !GetTrackEvent( m_ptsFound, &m_teTemp )) {
  497. // Warn future calls that this converter is stuck at a corrupt spot
  498. // and can't continue
  499. m_dwStatus |= CONVERTF_STATUS_STUCK;
  500. return CONVERTERR_CORRUPT;
  501. }
  503. // Don't add end of track event 'til we're done
  504. if( m_teTemp.byShortData[0] == MIDI_META && m_teTemp.byShortData[1] == MIDI_META_EOT ) {
  505. if( m_dwMallocBlocks ) {
  506. delete [] m_teTemp.pLongData;
  507. --m_dwMallocBlocks;
  508. }
  509. continue;
  510. }
  512. if(( nChkErr = AddEventToStreamBuffer( &m_teTemp, lpciInfo )) != CONVERTERR_NOERROR ) {
  513. if( nChkErr == CONVERTERR_BUFFERFULL ) {
  514. // Do some processing and tell somebody this buffer is full...
  515. m_dwStatus |= CONVERTF_STATUS_GOTEVENT;
  516. return CONVERTERR_NOERROR;
  517. } else if( nChkErr == CONVERTERR_METASKIP ) {
  518. // We skip by all meta events that aren't tempo changes...
  519. } else {
  520. TRACE0("Unable to add event to stream buffer.n");
  521. if( m_dwMallocBlocks ) {
  522. delete [] m_teTemp.pLongData;
  523. m_dwMallocBlocks--;
  524. }
  525. return TRUE;
  526. }
  527. }
  528. }
  530. return CONVERTERR_NOERROR;
  531. }
  533. // GetTrackEvent
  534. //
  535. // Fills in the event struct with the next event from the track
  536. //
  537. // pteTemp->tkEvent will contain the absolute tick time of the event
  538. // pteTemp->byShortData[0] will contain
  539. //  MIDI_META if the event is a meta event;
  540. //   in this case pteTemp->byShortData[1] will contain the meta class
  541. //  MIDI_SYSEX or MIDI_SYSEXEND if the event is a SysEx event
  542. //  Otherwise, the event is a channel message and pteTemp->byShortData[1]
  543. //   and pteTemp->byShortData[2] will contain the rest of the event.
  544. //
  545. // pteTemp->dwEventLength will contain
  546. //  The total length of the channel message in pteTemp->byShortData if
  547. //   the event is a channel message
  548. //  The total length of the paramter data pointed to by
  549. //   pteTemp->pLongData otherwise
  550. //
  551. // pteTemp->pLongData will point at any additional paramters if the 
  552. //  event is a SysEx or meta event with non-zero length; else
  553. //  it will contain NULL
  554. //
  555. // Returns TRUE on success or FALSE on any kind of parse error
  556. // Prints its own error message ONLY in the debug version
  557. //
  558. // Maintains the state of the input track (i.e. 
  559. // ptsTrack->pTrackPointers, and ptsTrack->byRunningStatus).
  560. //
  561. BOOL CMIDI :: GetTrackEvent(TRACK * ptsTrack, TEMPEVENT * pteTemp) {
  562. DWORD   idx;
  563. UINT    dwEventLength;
  565. // Clear out the temporary event structure to get rid of old data...
  566. memset( pteTemp, 0, sizeof(TEMPEVENT));
  568. // Already at end of track? There's nothing to read.
  569.     if( ptsTrack->fdwTrack & ITS_F_ENDOFTRK )
  570. return FALSE;
  572. // Get the first byte, which determines the type of event.
  573. BYTE byByte;
  574. if( !GetTrackByte(ptsTrack, &byByte) )
  575. return FALSE;
  577. // If the high bit is not set, then this is a channel message
  578. // which uses the status byte from the last channel message
  579. // we saw. NOTE: We do not clear running status across SysEx or
  580. // meta events even though the spec says to because there are
  581. // actually files out there which contain that sequence of data.
  582. if( !(byByte & 0x80) ) {
  583. // No previous status byte? We're hosed.
  584. if( !ptsTrack->byRunningStatus ) {
  585. TrackError(ptsTrack, gteBadRunStat);
  586. return FALSE;
  587. }
  589. pteTemp->byShortData[0] = ptsTrack->byRunningStatus;
  590. pteTemp->byShortData[1] = byByte;
  592. byByte = pteTemp->byShortData[0] & 0xF0;
  593. pteTemp->dwEventLength = 2;
  595. // Only program change and channel pressure events are 2 bytes long;
  596. // the rest are 3 and need another byte
  597. if(( byByte != MIDI_PRGMCHANGE ) && ( byByte != MIDI_CHANPRESS )) {
  598. if( !GetTrackByte( ptsTrack, &pteTemp->byShortData[2] ))
  599. return FALSE;
  600. ++pteTemp->dwEventLength;
  601. }
  602. } else if(( byByte & 0xF0 ) != MIDI_SYSEX ) {
  603. // Not running status, not in SysEx range - must be
  604. // normal channel message (0x80-0xEF)
  605. pteTemp->byShortData[0] = byByte;
  606. ptsTrack->byRunningStatus = byByte;
  608. // Strip off channel and just keep message type
  609. byByte &= 0xF0;
  611. dwEventLength = ( byByte == MIDI_PRGMCHANGE || byByte == MIDI_CHANPRESS ) ? 1 : 2;
  612. pteTemp->dwEventLength = dwEventLength + 1;
  614. if( !GetTrackByte( ptsTrack, &pteTemp->byShortData[1] ))
  615. return FALSE;
  616. if( dwEventLength == 2 )
  617. if( !GetTrackByte( ptsTrack, &pteTemp->byShortData[2] ))
  618. return FALSE;
  619. } else if(( byByte == MIDI_SYSEX ) || ( byByte == MIDI_SYSEXEND )) {
  620. // One of the SysEx types. (They are the same as far as we're concerned;
  621. // there is only a semantic difference in how the data would actually
  622. // get sent when the file is played. We must take care to put the proper
  623. // event type back on the output track, however.)
  624. //
  625. // Parse the general format of:
  626. //  BYTE  bEvent (MIDI_SYSEX or MIDI_SYSEXEND)
  627. //  VDWORD  cbParms
  628. //  BYTE    abParms[cbParms]
  629. pteTemp->byShortData[0] = byByte;
  630. if( !GetTrackVDWord( ptsTrack, &pteTemp->dwEventLength )) {
  631. TrackError( ptsTrack, gteSysExLenTrunc );
  632. return FALSE;
  633. }
  635. // Malloc a temporary memory block to hold the parameter data
  636. pteTemp->pLongData = new BYTE [pteTemp->dwEventLength];
  637. if( pteTemp->pLongData == 0 ) {
  638. TrackError( ptsTrack, gteNoMem );
  639. return FALSE;
  640. }
  641. // Increment our counter, which tells the program to look around for
  642. // a malloc block to free, should it need to exit or reset before the
  643. // block would normally be freed
  644. ++m_dwMallocBlocks;
  646. // Copy from the input buffer to the parameter data buffer
  647. for( idx = 0; idx < pteTemp->dwEventLength; idx++ )
  648. if( !GetTrackByte( ptsTrack, pteTemp->pLongData + idx )) {
  649. TrackError( ptsTrack, gteSysExTrunc );
  650. return FALSE;
  651. }
  652. } else if( byByte == MIDI_META ) {
  653. // It's a meta event. Parse the general form:
  654. //  BYTE bEvent (MIDI_META)
  655. //  BYTE bClass
  656. //  VDWORD cbParms
  657. //  BYTE abParms[cbParms]
  658. pteTemp->byShortData[0] = byByte;
  660. if( !GetTrackByte( ptsTrack, &pteTemp->byShortData[1] ))
  661. return FALSE;
  663. if( !GetTrackVDWord( ptsTrack, &pteTemp->dwEventLength )) {
  664. TrackError( ptsTrack, gteMetaLenTrunc );
  665. return FALSE;
  666. }
  668. // NOTE: It's perfectly valid to have a meta with no data
  669. // In this case, dwEventLength == 0 and pLongData == NULL
  670. if( pteTemp->dwEventLength ) {
  671. // Malloc a temporary memory block to hold the parameter data
  672. pteTemp->pLongData = new BYTE [pteTemp->dwEventLength];
  673. if( pteTemp->pLongData == 0 ) {
  674. TrackError( ptsTrack, gteNoMem );
  675. return FALSE;
  676. }
  677. // Increment our counter, which tells the program to look around for
  678. // a malloc block to free, should it need to exit or reset before the
  679. // block would normally be freed
  680. ++m_dwMallocBlocks;
  682. // Copy from the input buffer to the parameter data buffer
  683. for( idx = 0; idx < pteTemp->dwEventLength; idx++ )
  684. if( !GetTrackByte( ptsTrack, pteTemp->pLongData + idx )) {
  685. TrackError( ptsTrack, gteMetaTrunc );
  686. return FALSE;
  687. }
  688. }
  690. if( pteTemp->byShortData[1] == MIDI_META_EOT )
  691. ptsTrack->fdwTrack |= ITS_F_ENDOFTRK;
  692. } else {
  693. // Messages in this range are system messages and aren't supposed to
  694. // be in a normal MIDI file. If they are, we've either misparsed or the
  695. // authoring software is stupid.
  696. return FALSE;
  697. }
  699. // Event time was already stored as the current track time
  700. pteTemp->tkEvent = ptsTrack->tkNextEventDue;
  702. // Now update to the next event time. The code above MUST properly
  703. // maintain the end of track flag in case the end of track meta is
  704. // missing.  NOTE: This code is a continuation of the track event
  705. // time pre-read which is done at the end of track initialization.
  706. if( !( ptsTrack->fdwTrack & ITS_F_ENDOFTRK )) {
  707. DWORD tkDelta;
  709. if( !GetTrackVDWord( ptsTrack, &tkDelta ))
  710. return FALSE;
  712. ptsTrack->tkNextEventDue += tkDelta;
  713. }
  715. return TRUE;
  716. }
  719. // GetTrackVDWord
  720. //
  721. // Attempts to parse a variable length DWORD from the given track. A VDWord
  722. // in a MIDI file
  723. //  (a) is in lo-hi format 
  724. //  (b) has the high bit set on every byte except the last
  725. //
  726. // Returns the DWORD in *lpdw and TRUE on success; else
  727. // FALSE if we hit end of track first.
  728. BOOL CMIDI :: GetTrackVDWord(TRACK * ptsTrack, LPDWORD lpdw) {
  729. ASSERT(ptsTrack != 0);
  730. ASSERT(lpdw != 0);
  732. if( ptsTrack->fdwTrack & ITS_F_ENDOFTRK )
  733. return FALSE;
  735. BYTE byByte;
  736. DWORD dw = 0;
  738. do {
  739. if( !GetTrackByte( ptsTrack, &byByte ))
  740. return FALSE;
  742. dw = ( dw << 7 ) | ( byByte & 0x7F );
  743. } while( byByte & 0x80 );
  745. *lpdw = dw;
  747. return TRUE;
  748. }
  751. // AddEventToStreamBuffer
  752. //
  753. // Put the given event into the given stream buffer at the given location
  754. // pteTemp must point to an event filled out in accordance with the
  755. // description given in GetTrackEvent
  756. //
  757. // Handles its own error notification by displaying to the appropriate
  758. // output device (either our debugging window, or the screen).
  759. int CMIDI :: AddEventToStreamBuffer( TEMPEVENT * pteTemp, CONVERTINFO *lpciInfo ) {
  760. MIDIEVENT * pmeEvent = (MIDIEVENT *)( lpciInfo->mhBuffer.lpData
  761. + lpciInfo->dwStartOffset
  762. + lpciInfo->dwBytesRecorded );
  764. // When we see a new, empty buffer, set the start time on it...
  765. if( !lpciInfo->dwBytesRecorded )
  766. lpciInfo->tkStart = m_tkCurrentTime;
  768. // Use the above set start time to figure out how much longer we should fill
  769. // this buffer before officially declaring it as "full"
  770. if( m_tkCurrentTime - lpciInfo->tkStart > m_dwBufferTickLength )
  771. if( lpciInfo->bTimesUp ) {
  772. lpciInfo->bTimesUp = FALSE;
  773. return CONVERTERR_BUFFERFULL;
  774. } else
  775. lpciInfo->bTimesUp = TRUE;
  777. DWORD tkNow = m_tkCurrentTime;
  779. // Delta time is absolute event time minus absolute time
  780. // already gone by on this track
  781. DWORD tkDelta = pteTemp->tkEvent - m_tkCurrentTime;
  783. // Event time is now current time on this track
  784. m_tkCurrentTime = pteTemp->tkEvent;
  786. if( m_bInsertTempo ) {
  787. m_bInsertTempo = FALSE;
  789. if( lpciInfo->dwMaxLength-lpciInfo->dwBytesRecorded < 3*sizeof(DWORD)) {
  790. // Cleanup from our write operation
  791. return CONVERTERR_BUFFERFULL;
  792. }
  793. if( m_dwCurrentTempo ) {
  794. pmeEvent->dwDeltaTime = 0;
  795. pmeEvent->dwStreamID = 0;
  796. pmeEvent->dwEvent = ( m_dwCurrentTempo * 100 ) / m_dwTempoMultiplier;
  797. pmeEvent->dwEvent |= (((DWORD)MEVT_TEMPO ) << 24 ) | MEVT_F_SHORT;
  799. lpciInfo->dwBytesRecorded += 3 * sizeof(DWORD);
  800. pmeEvent += 3 * sizeof(DWORD);
  801. }
  802. }
  804. if( pteTemp->byShortData[0] < MIDI_SYSEX ) {
  805. // Channel message. We know how long it is, just copy it.
  806. // Need 3 DWORD's: delta-t, stream-ID, event
  807. if( lpciInfo->dwMaxLength-lpciInfo->dwBytesRecorded < 3*sizeof(DWORD)) {
  808. // Cleanup from our write operation
  809. return CONVERTERR_BUFFERFULL;
  810. }
  812. pmeEvent->dwDeltaTime = tkDelta;
  813. pmeEvent->dwStreamID = 0;
  814. pmeEvent->dwEvent = ( pteTemp->byShortData[0] )
  815. | (((DWORD)pteTemp->byShortData[1] ) << 8 )
  816. | (((DWORD)pteTemp->byShortData[2] ) << 16 )
  817. | MEVT_F_SHORT;
  819. if((( pteTemp->byShortData[0] & 0xF0) == MIDI_CTRLCHANGE ) && ( pteTemp->byShortData[1] == MIDICTRL_VOLUME )) {
  820. // If this is a volume change, generate a callback so we can grab
  821. // the new volume for our cache
  822. pmeEvent->dwEvent |= MEVT_F_CALLBACK;
  823. }
  824. lpciInfo->dwBytesRecorded += 3 *sizeof(DWORD);
  825. } else if(( pteTemp->byShortData[0] == MIDI_SYSEX ) || ( pteTemp->byShortData[0] == MIDI_SYSEXEND )) {
  826. TRACE0("AddEventToStreamBuffer: Ignoring SysEx event.n");
  827. if( m_dwMallocBlocks ) {
  828. delete [] pteTemp->pLongData;
  829. --m_dwMallocBlocks;
  830. }
  831. } else {
  832. // Better be a meta event.
  833. //  BYTE byEvent
  834. //  BYTE byEventType
  835. //  VDWORD dwEventLength
  836. //  BYTE pLongEventData[dwEventLength]
  837. ASSERT( pteTemp->byShortData[0] == MIDI_META );
  839. // The only meta-event we care about is change tempo
  840. if( pteTemp->byShortData[1] != MIDI_META_TEMPO ) {
  841. if( m_dwMallocBlocks ) {
  842. delete [] pteTemp->pLongData;
  843. --m_dwMallocBlocks;
  844. }
  845. return CONVERTERR_METASKIP;
  846. }
  848. // We should have three bytes of parameter data...
  849. ASSERT(pteTemp->dwEventLength == 3);
  851. // Need 3 DWORD's: delta-t, stream-ID, event data
  852. if( lpciInfo->dwMaxLength - lpciInfo->dwBytesRecorded < 3 *sizeof(DWORD)) {
  853. // Cleanup the temporary event if necessary and return
  854. if( m_dwMallocBlocks ) {
  855. delete [] pteTemp->pLongData;
  856. --m_dwMallocBlocks;
  857. }
  858. return CONVERTERR_BUFFERFULL;
  859. }
  861. pmeEvent->dwDeltaTime = tkDelta;
  862. pmeEvent->dwStreamID = 0;
  863. // Note: this is backwards from above because we're converting a single
  864. //  data value from hi-lo to lo-hi format...
  865. pmeEvent->dwEvent = ( pteTemp->pLongData[2] )
  866. | (((DWORD)pteTemp->pLongData[1] ) << 8 )
  867. | (((DWORD)pteTemp->pLongData[0] ) << 16 );
  869. // This next step has absolutely nothing to do with the conversion of a
  870. // MIDI file to a stream, it's simply put here to add the functionality
  871. // of the tempo slider. If you don't need this, be sure to remove the
  872. // next two lines.
  873. m_dwCurrentTempo = pmeEvent->dwEvent;
  874. pmeEvent->dwEvent = (pmeEvent->dwEvent * 100 ) / m_dwTempoMultiplier;
  876. pmeEvent->dwEvent |= (((DWORD)MEVT_TEMPO ) << 24 ) | MEVT_F_SHORT;
  878. m_dwBufferTickLength = (m_dwTimeDivision * 1000 * BUFFER_TIME_LENGTH) / m_dwCurrentTempo;
  879. TRACE1("m_dwBufferTickLength = %lun", m_dwBufferTickLength);
  881. if( m_dwMallocBlocks ) {
  882. delete [] pteTemp->pLongData;
  883. --m_dwMallocBlocks;
  884. }
  885. lpciInfo->dwBytesRecorded += 3 *sizeof(DWORD);
  886. }
  888. return CONVERTERR_NOERROR;
  889. }
  892. // StreamBufferSetup()
  893. //
  894. // Opens a MIDI stream. Then it goes about converting the data into a midiStream buffer for playback.
  895. BOOL CMIDI :: StreamBufferSetup() {
  896. int nChkErr;
  897. BOOL bFoundEnd = FALSE;
  899. MMRESULT mmrRetVal;
  901. if( !m_hStream )
  902. if(( mmrRetVal = midiStreamOpen( &m_hStream,
  903. &m_uMIDIDeviceID,
  904. DWORD(1), DWORD(MidiProc),
  905. DWORD(this),
  906. CALLBACK_FUNCTION )) != MMSYSERR_NOERROR ) {
  907. MidiError(mmrRetVal);
  908. return FALSE;
  909. }
  911. // allocate stream buffers and initialise them
  912. m_StreamBuffers.resize(NUM_STREAM_BUFFERS);
  914. MIDIPROPTIMEDIV mptd;
  915. mptd.cbStruct = sizeof(mptd);
  916. mptd.dwTimeDiv = m_dwTimeDivision;
  917. if(( mmrRetVal = midiStreamProperty( m_hStream, (LPBYTE)&mptd,
  918.     MIDIPROP_SET | MIDIPROP_TIMEDIV )) != MMSYSERR_NOERROR ) {
  919. MidiError( mmrRetVal );
  920. return FALSE;
  921. }
  923. m_nEmptyBuffers = 0;
  924. DWORD dwConvertFlag = CONVERTF_RESET;
  926. for( m_nCurrentBuffer = 0; m_nCurrentBuffer < NUM_STREAM_BUFFERS; m_nCurrentBuffer++ ) {
  927. m_StreamBuffers[m_nCurrentBuffer].mhBuffer.dwBufferLength = OUT_BUFFER_SIZE;
  928. m_StreamBuffers[m_nCurrentBuffer].mhBuffer.lpData = new char [OUT_BUFFER_SIZE];
  929. if( m_StreamBuffers[m_nCurrentBuffer].mhBuffer.lpData == 0 )
  930. return FALSE;
  932. // Tell the converter to convert up to one entire buffer's length of output
  933. // data. Also, set a flag so it knows to reset any saved state variables it
  934. // may keep from call to call.
  935. m_StreamBuffers[m_nCurrentBuffer].dwStartOffset = 0;
  936. m_StreamBuffers[m_nCurrentBuffer].dwMaxLength = OUT_BUFFER_SIZE;
  937. m_StreamBuffers[m_nCurrentBuffer].tkStart = 0;
  938. m_StreamBuffers[m_nCurrentBuffer].bTimesUp = FALSE;
  940. if(( nChkErr = ConvertToBuffer( dwConvertFlag, &m_StreamBuffers[m_nCurrentBuffer] )) != CONVERTERR_NOERROR ) {
  941. if( nChkErr == CONVERTERR_DONE ) {
  942. bFoundEnd = TRUE;
  943. } else {
  944. TRACE0("Initial conversion pass failedn");
  945. return FALSE;
  946. }
  947. }
  948. m_StreamBuffers[m_nCurrentBuffer].mhBuffer.dwBytesRecorded = m_StreamBuffers[m_nCurrentBuffer].dwBytesRecorded;
  950. if( !m_bBuffersPrepared )
  951. if(( mmrRetVal = midiOutPrepareHeader( (HMIDIOUT)m_hStream,
  952. &m_StreamBuffers[m_nCurrentBuffer].mhBuffer,
  953. sizeof(MIDIHDR))) != MMSYSERR_NOERROR ) {
  954. MidiError( mmrRetVal );
  955. return FALSE;
  956. }
  958. if(( mmrRetVal = midiStreamOut( m_hStream,
  959. &m_StreamBuffers[m_nCurrentBuffer].mhBuffer,
  960. sizeof(MIDIHDR))) != MMSYSERR_NOERROR ) {
  961. MidiError(mmrRetVal);
  962. break;
  963. }
  964. dwConvertFlag = 0;
  966. if( bFoundEnd )
  967. break;
  968. }
  970. m_bBuffersPrepared = TRUE;
  971. m_nCurrentBuffer = 0;
  972. return TRUE;
  973. }
  975. // This function unprepares and frees all our buffers -- something we must
  976. // do to work around a bug in MMYSYSTEM that prevents a device from playing
  977. // back properly unless it is closed and reopened after each stop.
  978. void CMIDI :: FreeBuffers() {
  979. DWORD idx;
  980. MMRESULT mmrRetVal;
  982. if( m_bBuffersPrepared ) {
  983. for( idx = 0; idx < NUM_STREAM_BUFFERS; idx++ )
  984. if(( mmrRetVal = midiOutUnprepareHeader( (HMIDIOUT)m_hStream,
  985. &m_StreamBuffers[idx].mhBuffer,
  986. sizeof(MIDIHDR))) != MMSYSERR_NOERROR ) {
  987. MidiError(mmrRetVal);
  988. }
  989. m_bBuffersPrepared = FALSE;
  990. }
  991. // Free our stream buffers...
  992. for( idx = 0; idx < NUM_STREAM_BUFFERS; idx++ )
  993. if( m_StreamBuffers[idx].mhBuffer.lpData ) {
  994. delete [] m_StreamBuffers[idx].mhBuffer.lpData;
  995. m_StreamBuffers[idx].mhBuffer.lpData = 0;
  996. }
  997. }
  999. //////////////////////////////////////////////////////////////////////
  1000. // CMIDI -- error handling
  1001. //////////////////////////////////////////////////////////////////////
  1003. void CMIDI :: MidiError(MMRESULT mmResult) {
  1004. #ifdef _DEBUG
  1005. char chText[512];
  1006. midiOutGetErrorText(mmResult, chText, sizeof(chText));
  1007. TRACE1("Midi error: %hsn", chText);
  1008. #endif
  1009. }
  1012. void CMIDI :: TrackError(TRACK * ptsTrack, LPSTR lpszErr ) {
  1013. TRACE1("Track buffer offset %lun", (DWORD)(ptsTrack->pTrackCurrent - ptsTrack->pTrackStart));
  1014.     TRACE1("Track total length %lun", ptsTrack->dwTrackLength);
  1015. TRACE1("%hsn", lpszErr);
  1016. }
  1018. //////////////////////////////////////////////////////////////////////
  1019. // CMIDI -- overridables
  1020. //////////////////////////////////////////////////////////////////////
  1022. void CMIDI :: OnMidiOutOpen() {
  1023. }
  1026. void CMIDI :: OnMidiOutDone(MIDIHDR & rHdr) {
  1027. if( m_uCallbackStatus == STATUS_CALLBACKDEAD )
  1028. return;
  1030. ++m_nEmptyBuffers;
  1032. if( m_uCallbackStatus == STATUS_WAITINGFOREND ) {
  1033. if( m_nEmptyBuffers < NUM_STREAM_BUFFERS )
  1034. return;
  1035. else {
  1036. m_uCallbackStatus = STATUS_CALLBACKDEAD;
  1037. Stop();
  1038. SetEvent(m_hBufferReturnEvent);
  1039. return;
  1040. }
  1041. }
  1043. // This flag is set whenever the callback is waiting for all buffers to
  1044. // come back.
  1045. if( m_uCallbackStatus == STATUS_KILLCALLBACK ) {
  1046. // Count NUM_STREAM_BUFFERS-1 being returned for the last time
  1047. if( m_nEmptyBuffers < NUM_STREAM_BUFFERS )
  1048. return;
  1049. else {
  1050. // Change the status to callback dead
  1051. m_uCallbackStatus = STATUS_CALLBACKDEAD;
  1052. SetEvent(m_hBufferReturnEvent);
  1053. return;
  1054. }
  1055. }
  1057. m_dwProgressBytes += m_StreamBuffers[m_nCurrentBuffer].mhBuffer.dwBytesRecorded;
  1059. ///////////////////////////////////////////////////////////////////////////////
  1060. // Fill an available buffer with audio data again...
  1062. if( m_bPlaying && m_nEmptyBuffers ) {
  1063. m_StreamBuffers[m_nCurrentBuffer].dwStartOffset = 0;
  1064. m_StreamBuffers[m_nCurrentBuffer].dwMaxLength = OUT_BUFFER_SIZE;
  1065. m_StreamBuffers[m_nCurrentBuffer].tkStart = 0;
  1066. m_StreamBuffers[m_nCurrentBuffer].dwBytesRecorded = 0;
  1067. m_StreamBuffers[m_nCurrentBuffer].bTimesUp = FALSE;
  1069. int nChkErr;
  1071. if(( nChkErr = ConvertToBuffer( 0, &m_StreamBuffers[m_nCurrentBuffer] )) != CONVERTERR_NOERROR ) {
  1072. if( nChkErr == CONVERTERR_DONE ) {
  1073. m_uCallbackStatus = STATUS_WAITINGFOREND;
  1074. return;
  1075. } else {
  1076. TRACE0("MidiProc() conversion pass failed!n");
  1077. return;
  1078. }
  1079. }
  1081. m_StreamBuffers[m_nCurrentBuffer].mhBuffer.dwBytesRecorded = m_StreamBuffers[m_nCurrentBuffer].dwBytesRecorded;
  1083. MMRESULT mmrRetVal;
  1084. if( (mmrRetVal = midiStreamOut(m_hStream, &m_StreamBuffers[m_nCurrentBuffer].mhBuffer, sizeof(MIDIHDR))) != MMSYSERR_NOERROR ) {
  1085. MidiError(mmrRetVal);
  1086. return;
  1087. }
  1088. m_nCurrentBuffer = ( m_nCurrentBuffer + 1 ) % NUM_STREAM_BUFFERS;
  1089. m_nEmptyBuffers--;
  1090. }
  1091. }
  1094. void CMIDI :: OnMidiOutPositionCB(MIDIHDR & rHdr, MIDIEVENT & rEvent) {
  1095. if( MIDIEVENT_TYPE(rEvent.dwEvent) == MIDI_CTRLCHANGE )
  1096. {
  1097. if( MIDIEVENT_DATA1(rEvent.dwEvent) == MIDICTRL_VOLUME ) {
  1098. // Mask off the channel number and cache the volume data byte
  1099. m_Volumes[MIDIEVENT_CHANNEL(rEvent.dwEvent)] = DWORD(MIDIEVENT_VOLUME(rEvent.dwEvent)*100/VOLUME_MAX);
  1100. if( m_pWndParent && ::IsWindow(m_pWndParent->GetSafeHwnd()) )
  1101. // Do not use SendMessage(), because a change of the midi stream has no effect
  1102. // during callback handling, so if the owner wants to adjust the volume, as a
  1103. // result of the windows message, (s)he will not hear that change.
  1104. m_pWndParent->PostMessage(
  1105. WM_MIDI_VOLUMECHANGED,
  1106. WPARAM(this),
  1107. LPARAM(
  1108. MAKELONG(
  1109. WORD(MIDIEVENT_CHANNEL(rEvent.dwEvent)),
  1110. WORD(MIDIEVENT_VOLUME(rEvent.dwEvent)*100/VOLUME_MAX)
  1111. )
  1112. )
  1113. );
  1114. }
  1115. }
  1116. }
  1119. void CMIDI :: OnMidiOutClose() {
  1120. }
  1122. //////////////////////////////////////////////////////////////////////
  1123. // CMIDI -- static members
  1124. //////////////////////////////////////////////////////////////////////
  1126. void CMIDI :: MidiProc(HMIDIOUT hMidi, UINT uMsg, DWORD dwInstanceData, DWORD dwParam1, DWORD dwParam2) {
  1127. CMIDI * pMidi = (CMIDI *) dwInstanceData;
  1128. ASSERT(pMidi != 0);
  1129. MIDIHDR * pHdr = (MIDIHDR*) dwParam1;
  1131. switch(uMsg) {
  1132. case MOM_OPEN:
  1133. pMidi->OnMidiOutOpen();
  1134. break;
  1136. case MOM_CLOSE:
  1137. pMidi->OnMidiOutClose();
  1138. break;
  1140. case MOM_DONE:
  1141. ASSERT(pHdr != 0);
  1142. pMidi->OnMidiOutDone(*pHdr);
  1143. break;
  1145. case MOM_POSITIONCB:
  1146. ASSERT(pHdr != 0);
  1147. pMidi->OnMidiOutPositionCB(*pHdr, *((MIDIEVENT*)(pHdr->lpData + pHdr->dwOffset)));
  1148. break;
  1150. default:
  1151. break;
  1152. }
  1153. }