// Copyright (c) 1998-2001 Microsoft Corporation
//
// midifile.cpp
//
// original author: Dave Miller
// original project: AudioActive
// modified by: Mark Burton
// project: DirectMusic
//
#include <windows.h>
#include <mmsystem.h>
#include <dsoundp.h>
#include "debug.h"
#define ASSERT assert
#include "Template.h"
#include "dmusici.h"
#include "dmperf.h"
#include "dmusicf.h"
#include "..\dmusic\dmcollec.h"
#include "alist.h"
#include "tlist.h"
#include "dmime.h"
#include "..\dmband\dmbndtrk.h"
#include "..\dmband\bandinst.h"
typedef struct _DMUS_IO_BANKSELECT_ITEM
{
BYTE byLSB;
BYTE byMSB;
BYTE byPad[2];
} DMUS_IO_BANKSELECT_ITEM;
#define EVENT_VOICE 1 // Performance event
#define EVENT_REALTIME 2 // qevent() must invoke interrupt
#define EVENT_ONTIME 3 // event should be handled on time
/* MIDI status bytes ==================================================*/
#define MIDI_NOTEOFF 0x80
#define MIDI_NOTEON 0x90
#define MIDI_PTOUCH 0xA0
#define MIDI_CCHANGE 0xB0
#define MIDI_PCHANGE 0xC0
#define MIDI_MTOUCH 0xD0
#define MIDI_PBEND 0xE0
#define MIDI_SYSX 0xF0
#define MIDI_MTC 0xF1
#define MIDI_SONGPP 0xF2
#define MIDI_SONGS 0xF3
#define MIDI_EOX 0xF7
#define MIDI_CLOCK 0xF8
#define MIDI_START 0xFA
#define MIDI_CONTINUE 0xFB
#define MIDI_STOP 0xFC
#define MIDI_SENSE 0xFE
#define ET_NOTEOFF ( MIDI_NOTEOFF >> 4 ) // 0x08
#define ET_NOTEON ( MIDI_NOTEON >> 4 ) // 0x09
#define ET_PTOUCH ( MIDI_PTOUCH >> 4 ) // 0x0A
#define ET_CCHANGE ( MIDI_CCHANGE >> 4 ) // 0x0B
#define ET_PCHANGE ( MIDI_PCHANGE >> 4 ) // 0x0C
#define ET_MTOUCH ( MIDI_MTOUCH >> 4 ) // 0x0D
#define ET_PBEND ( MIDI_PBEND >> 4 ) // 0x0E
#define ET_SYSX ( MIDI_SYSX >> 4 ) // 0x0F
#define ET_PBCURVE 0x03
#define ET_CCCURVE 0x04
#define ET_MATCURVE 0x05
#define ET_PATCURVE 0x06
#define ET_TEMPOEVENT 0x01
#define ET_NOTDEFINED 0
#define NUM_MIDI_CHANNELS 16
struct FSEBlock;
/* FullSeqEvent is SeqEvent plus next pointers*/
typedef struct FullSeqEvent : DMUS_IO_SEQ_ITEM
{
struct FullSeqEvent* pNext;
struct FullSeqEvent* pTempNext; /* used in the compresseventlist routine */
long pos; /* used to keep track of the order of events in the file */
private:
DWORD dwPosInBlock;
static FSEBlock* sm_pBlockList;
public:
static void CleanUp();
void* operator new(size_t n);
void operator delete(void* p);
} FullSeqEvent;
#define BITMAPSPERBLOCK 8
struct FSEBlock
{
FSEBlock()
{
for(int i = 0 ; i < BITMAPSPERBLOCK ; ++i)
{
m_dwBitMap[i] = 0;
}
};
FSEBlock* m_pNext;
DWORD m_dwBitMap[BITMAPSPERBLOCK];
FullSeqEvent m_Event[BITMAPSPERBLOCK][32];
};
FSEBlock* FullSeqEvent::sm_pBlockList;
void FullSeqEvent::CleanUp()
{
FSEBlock* pBlock;
FSEBlock* pNext;
for(pBlock = sm_pBlockList ; pBlock != NULL ; pBlock = pNext)
{
#ifdef DEBUG
for(int i = 0 ; i < BITMAPSPERBLOCK ; ++i)
{
if(pBlock->m_dwBitMap[i] != 0)
{
DebugBreak();
}
}
#endif
pNext = pBlock->m_pNext;
delete pBlock;
}
sm_pBlockList = NULL;
}
void* FullSeqEvent::operator new(size_t n)
{
if(sm_pBlockList == NULL)
{
sm_pBlockList = new FSEBlock;
if(sm_pBlockList == NULL)
{
return NULL;
}
sm_pBlockList->m_pNext = NULL;
sm_pBlockList->m_dwBitMap[0] = 1;
sm_pBlockList->m_Event[0][0].dwPosInBlock = 0;
return &sm_pBlockList->m_Event[0][0];
}
FSEBlock* pBlock;
int i;
DWORD dw;
for(pBlock = sm_pBlockList ; pBlock != NULL ; pBlock = pBlock->m_pNext)
{
for(i = 0 ; i < BITMAPSPERBLOCK ; ++i)
{
if(pBlock->m_dwBitMap[i] != 0xffff)
{
break;
}
}
if(i < BITMAPSPERBLOCK)
{
break;
}
}
if(pBlock == NULL)
{
pBlock = new FSEBlock;
if(pBlock == NULL)
{
return NULL;
}
pBlock->m_pNext = sm_pBlockList;
sm_pBlockList = pBlock;
pBlock->m_dwBitMap[0] = 1;
pBlock->m_Event[0][0].dwPosInBlock = 0;
return &pBlock->m_Event[0][0];
}
for(dw = 0 ; (pBlock->m_dwBitMap[i] & (1 << dw)) != 0 ; ++dw);
pBlock->m_dwBitMap[i] |= (1 << dw);
pBlock->m_Event[i][dw].dwPosInBlock = (i << 6) | dw;
return &pBlock->m_Event[i][dw];
}
void FullSeqEvent::operator delete(void* p)
{
FSEBlock* pBlock;
int i;
DWORD dw;
FullSeqEvent* pEvent = (FullSeqEvent*)p;
dw = pEvent->dwPosInBlock & 0x1f;
i = pEvent->dwPosInBlock >> 6;
for(pBlock = sm_pBlockList ; pBlock != NULL ; pBlock = pBlock->m_pNext)
{
if(p == &pBlock->m_Event[i][dw])
{
pBlock->m_dwBitMap[i] &= ~(1 << dw);
return;
}
}
}
TList<StampedGMGSXG> gMidiModeList;
// One for each MIDI channel 0-15
DMUS_IO_BANKSELECT_ITEM gBankSelect[NUM_MIDI_CHANNELS];
DWORD gPatchTable[NUM_MIDI_CHANNELS];
long gPos; // Keeps track of order of events in the file
DWORD gdwLastControllerTime[NUM_MIDI_CHANNELS]; // Holds the time of the last CC event.
DWORD gdwControlCollisionOffset[NUM_MIDI_CHANNELS]; // Holds the index of the last CC.
DWORD gdwLastPitchBendValue[NUM_MIDI_CHANNELS]; // Holds the value of the last pbend event.
long glLastSysexTime;
void CreateChordFromKey(char cSharpsFlats, BYTE bMode, DWORD dwTime, DMUS_CHORD_PARAM& rChord);
void InsertMidiMode( TListItem<StampedGMGSXG>* pPair )
{
TListItem<StampedGMGSXG>* pScan = gMidiModeList.GetHead();
if( NULL == pScan )
{
gMidiModeList.AddHead(pPair);
}
else
{
if( pPair->GetItemValue().mtTime < pScan->GetItemValue().mtTime )
{
gMidiModeList.AddHead(pPair);
}
else
{
pScan = pScan->GetNext();
while( pScan )
{
if( pPair->GetItemValue().mtTime < pScan->GetItemValue().mtTime )
{
gMidiModeList.InsertBefore( pScan, pPair );
break;
}
pScan = pScan->GetNext();
}
if( NULL == pScan )
{
gMidiModeList.AddTail(pPair);
}
}
}
}
HRESULT LoadCollection(IDirectMusicCollection** ppIDMCollection,
IDirectMusicLoader* pIDMLoader)
{
// Any changes made to this function should also be made to CDirectMusicBand::LoadCollection
// in dmband.dll
assert(ppIDMCollection);
assert(pIDMLoader);
DMUS_OBJECTDESC desc;
memset(&desc, 0, sizeof(desc));
desc.dwSize = sizeof(desc);
desc.guidClass = CLSID_DirectMusicCollection;
desc.guidObject = GUID_DefaultGMCollection;
desc.dwValidData |= (DMUS_OBJ_CLASS | DMUS_OBJ_OBJECT);
HRESULT hr = pIDMLoader->GetObject(&desc,IID_IDirectMusicCollection, (void**)ppIDMCollection);
return hr;
}
// seeks to a 32-bit position in a stream.
HRESULT __inline StreamSeek( LPSTREAM pStream, long lSeekTo, DWORD dwOrigin )
{
LARGE_INTEGER li;
if( lSeekTo < 0 )
{
li.HighPart = -1;
}
else
{
li.HighPart = 0;
}
li.LowPart = lSeekTo;
return pStream->Seek( li, dwOrigin, NULL );
}
// this function gets a long that is formatted the correct way
// i.e. the motorola way as opposed to the intel way
BOOL __inline GetMLong( LPSTREAM pStream, DWORD& dw )
{
union uLong
{
unsigned char buf[4];
DWORD dw;
} u;
unsigned char ch;
if( S_OK != pStream->Read( u.buf, 4, NULL ) )
{
return FALSE;
}
#ifndef _MAC
// swap bytes
ch = u.buf[0];
u.buf[0] = u.buf[3];
u.buf[3] = ch;
ch = u.buf[1];
u.buf[1] = u.buf[2];
u.buf[2] = ch;
#endif
dw = u.dw;
return TRUE;
}
// this function gets a short that is formatted the correct way
// i.e. the motorola way as opposed to the intel way
BOOL __inline GetMShort( LPSTREAM pStream, short& n )
{
union uShort
{
unsigned char buf[2];
short n;
} u;
unsigned char ch;
if( S_OK != pStream->Read( u.buf, 2, NULL ) )
{
return FALSE;
}
#ifndef _MAC
// swap bytes
ch = u.buf[0];
u.buf[0] = u.buf[1];
u.buf[1] = ch;
#endif
n = u.n;
return TRUE;
}
static short snPPQN;
static IStream* gpTempoStream = NULL;
static IStream* gpSysExStream = NULL;
static IStream* gpTimeSigStream = NULL;
static DWORD gdwSizeTimeSigStream = 0;
static DWORD gdwSizeSysExStream = 0;
static DWORD gdwSizeTempoStream = 0;
static DMUS_IO_TIMESIGNATURE_ITEM gTimeSig; // holds the latest time sig
long glTimeSig = 1; // flag to see if we should be paying attention to time sigs.
// this is needed because we only care about the time sigs on the first track to
// contain them that we read
static IDirectMusicTrack* g_pChordTrack = NULL;
static DMUS_CHORD_PARAM g_Chord; // Holds the latest chord
static DMUS_CHORD_PARAM g_DefaultChord; // in case no chords are extracted from the track
static WORD GetVarLength( LPSTREAM pStream, DWORD& rfdwValue )
{
BYTE b;
WORD wBytes;
if( S_OK != pStream->Read( &b, 1, NULL ) )
{
rfdwValue = 0;
return 0;
}
wBytes = 1;
rfdwValue = b & 0x7f;
while( ( b & 0x80 ) != 0 )
{
if( S_OK != pStream->Read( &b, 1, NULL ) )
{
break;
}
++wBytes;
rfdwValue = ( rfdwValue << 7 ) + ( b & 0x7f );
}
return wBytes;
}
#ifdef _MAC
static DWORD ConvertTime( DWORD dwTime )
{
wide d;
long l; // storage for the remainder
if( snPPQN == DMUS_PPQ ) {
return dwTime;
}
WideMultiply( dwTime, DMUS_PPQ, &d );
return WideDivide( &d, snPPQN, &l );
}
#else
static DWORD ConvertTime( DWORD dwTime )
{
__int64 d;
if( snPPQN == DMUS_PPQ )
{
return dwTime;
}
d = dwTime;
d *= DMUS_PPQ;
d /= snPPQN;
return (DWORD)d;
}
#endif
static FullSeqEvent* ScanForDuplicatePBends( FullSeqEvent* lstEvent )
{
FullSeqEvent* pEvent;
FullSeqEvent* pNextEvent;
MUSIC_TIME mtCurrentTime = 0x7FFFFFFF; // We are scanning backwards in time, so start way in the future.
WORD wDupeBits = 0; // Keep a bit array of all channels that have active PBends at mtCurrentTime.
if( NULL == lstEvent ) return NULL;
// Scan through the list of events. This list is in backwards order, with the first item read at the end
// of the list. This makes it very easy to scan through and remove pitch bends that occur at the same time, since
// we can remove the latter events (which occured earlier in the midi file.)
for( pEvent = lstEvent ; pEvent ; pEvent = pNextEvent )
{
pNextEvent = pEvent->pNext;
if( pNextEvent )
{
// If the time is not the same as the last, reset.
if (pNextEvent->mtTime != mtCurrentTime)
{
// Reset the time.
mtCurrentTime = pNextEvent->mtTime;
// No duplicate pbends at this time.
wDupeBits = 0;
}
if ((pNextEvent->bStatus & 0xf0) == MIDI_PBEND)
{
DWORD dwChannel = pNextEvent->dwPChannel;
if (wDupeBits & (1 << dwChannel))
{
// There was a previous (therefore later in the file) pbend at this time. Delete this one.
pEvent->pNext = pNextEvent->pNext;
delete pNextEvent;
pNextEvent = pEvent;
}
else
{
// This is the last instance of a pbend on this channel at this time, so hang on to it.
wDupeBits |= (1 << dwChannel);
}
}
}
}
return lstEvent;
}
static FullSeqEvent* CompressEventList( FullSeqEvent* lstEvent )
{
static FullSeqEvent* paNoteOnEvent[16][128];
FullSeqEvent* pEvent;
FullSeqEvent* pPrevEvent;
FullSeqEvent* pNextEvent;
FullSeqEvent* pHoldEvent;
FullSeqEvent tempEvent;
int nChannel;
if( NULL == lstEvent ) return NULL;
memset( paNoteOnEvent, 0, sizeof( paNoteOnEvent ) );
pPrevEvent = NULL;
// add an event to the beginning of the list as a place holder
memset( &tempEvent, 0, sizeof(FullSeqEvent) );
tempEvent.mtTime = -1;
tempEvent.pNext = lstEvent;
lstEvent = &tempEvent;
// make sure that any events with the same time are sorted in order
// they were read
for( pEvent = lstEvent ; pEvent != NULL ; pEvent = pNextEvent )
{
pNextEvent = pEvent->pNext;
if( pNextEvent )
{
BOOL fSwap = TRUE;
// bubble sort
while( fSwap )
{
fSwap = FALSE;
pPrevEvent = pEvent;
pNextEvent = pEvent->pNext;
while( pNextEvent->pNext && ( pNextEvent->mtTime == pNextEvent->pNext->mtTime ))
{
if( pNextEvent->pNext->pos < pNextEvent->pos )
{
fSwap = TRUE;
pHoldEvent = pNextEvent->pNext;
pPrevEvent->pNext = pHoldEvent;
pNextEvent->pNext = pHoldEvent->pNext;
pHoldEvent->pNext = pNextEvent;
pPrevEvent = pHoldEvent;
continue;
}
pPrevEvent = pNextEvent;
pNextEvent = pNextEvent->pNext;
}
}
}
}
// remove the first, temporary event, added above
lstEvent = lstEvent->pNext;
pPrevEvent = NULL;
// combine note on and note offs
for( pEvent = lstEvent ; pEvent != NULL ; pEvent = pNextEvent )
{
pEvent->pTempNext = NULL;
pNextEvent = pEvent->pNext;
//nChannel = pEvent->bStatus & 0xf;
nChannel = pEvent->dwPChannel;
if( ( pEvent->bStatus & 0xf0 ) == MIDI_NOTEON )
{
// add this event to the end of the list of events based
// on the event's pitch. Keeping track of multiple events
// of the same pitch allows us to have overlapping notes
// of the same pitch, choosing that note on's and note off's
// follow in the same order.
if( NULL == paNoteOnEvent[nChannel][pEvent->bByte1] )
{
paNoteOnEvent[nChannel][pEvent->bByte1] = pEvent;
}
else
{
FullSeqEvent* pScan;
for( pScan = paNoteOnEvent[nChannel][pEvent->bByte1];
pScan->pTempNext != NULL; pScan = pScan->pTempNext );
pScan->pTempNext = pEvent;
}
}
else if( ( pEvent->bStatus & 0xf0 ) == MIDI_NOTEOFF )
{
if( paNoteOnEvent[nChannel][pEvent->bByte1] != NULL )
{
paNoteOnEvent[nChannel][pEvent->bByte1]->mtDuration =
pEvent->mtTime - paNoteOnEvent[nChannel][pEvent->bByte1]->mtTime;
paNoteOnEvent[nChannel][pEvent->bByte1] =
paNoteOnEvent[nChannel][pEvent->bByte1]->pTempNext;
}
if( pPrevEvent == NULL )
{
lstEvent = pNextEvent;
}
else
{
pPrevEvent->pNext = pNextEvent;
}
delete pEvent;
continue;
}
pPrevEvent = pEvent;
}
for( pEvent = lstEvent ; pEvent != NULL ; pEvent = pEvent->pNext )
{
pEvent->mtTime = pEvent->mtTime;
if( ( pEvent->bStatus & 0xf0 ) == MIDI_NOTEON )
{
pEvent->mtDuration = pEvent->mtDuration;
if( pEvent->mtDuration == 0 ) pEvent->mtDuration = 1;
}
}
return lstEvent;
}
static int CompareEvents( FullSeqEvent* pEvent1, FullSeqEvent* pEvent2 )
{
BYTE bEventType1 = static_cast<BYTE>( pEvent1->bStatus >> 4 );
BYTE bEventType2 = static_cast<BYTE>( pEvent2->bStatus >> 4 );
if( pEvent1->mtTime < pEvent2->mtTime )
{
return -1;
}
else if( pEvent1->mtTime > pEvent2->mtTime )
{
return 1;
}
else if( bEventType1 != ET_SYSX && bEventType2 != ET_SYSX )
{
BYTE bStatus1;
BYTE bStatus2;
bStatus1 = (BYTE)( pEvent1->bStatus & 0xf0 );
bStatus2 = (BYTE)( pEvent2->bStatus & 0xf0 );
if( bStatus1 == bStatus2 )
{
return 0;
}
else if( bStatus1 == MIDI_NOTEON )
{
return -1;
}
else if( bStatus2 == MIDI_NOTEON )
{
return 1;
}
else if( bStatus1 > bStatus2 )
{
return 1;
}
else if( bStatus1 < bStatus2 )
{
return -1;
}
}
return 0;
}
static FullSeqEvent* MergeEvents( FullSeqEvent* lstLeftEvent, FullSeqEvent* lstRightEvent )
{
FullSeqEvent anchorEvent;
FullSeqEvent* pEvent;
anchorEvent.pNext = NULL;
pEvent = &anchorEvent;
do
{
if( CompareEvents( lstLeftEvent, lstRightEvent ) < 0 )
{
pEvent->pNext = lstLeftEvent;
pEvent = lstLeftEvent;
lstLeftEvent = lstLeftEvent->pNext;
if( lstLeftEvent == NULL )
{
pEvent->pNext = lstRightEvent;
}
}
else
{
pEvent->pNext = lstRightEvent;
pEvent = lstRightEvent;
lstRightEvent = lstRightEvent->pNext;
if( lstRightEvent == NULL )
{
pEvent->pNext = lstLeftEvent;
lstLeftEvent = NULL;
}
}
} while( lstLeftEvent != NULL );
return anchorEvent.pNext;
}
static FullSeqEvent* SortEventList( FullSeqEvent* lstEvent )
{
FullSeqEvent* pMidEvent;
FullSeqEvent* pRightEvent;
if( lstEvent != NULL && lstEvent->pNext != NULL )
{
pMidEvent = lstEvent;
pRightEvent = pMidEvent->pNext->pNext;
if( pRightEvent != NULL )
{
pRightEvent = pRightEvent->pNext;
}
while( pRightEvent != NULL )
{
pMidEvent = pMidEvent->pNext;
pRightEvent = pRightEvent->pNext;
if( pRightEvent != NULL )
{
pRightEvent = pRightEvent->pNext;
}
}
pRightEvent = pMidEvent->pNext;
pMidEvent->pNext = NULL;
return MergeEvents( SortEventList( lstEvent ),
SortEventList( pRightEvent ) );
}
return lstEvent;
}
static DWORD ReadEvent( LPSTREAM pStream, DWORD dwTime, FullSeqEvent** plstEvent, DMUS_IO_PATCH_ITEM** pplstPatchEvent )
{
static BYTE bRunningStatus;
gPos++;
dwTime = ConvertTime(dwTime);
DWORD dwBytes;
DWORD dwLen;
FullSeqEvent* pEvent;
DMUS_IO_PATCH_ITEM* pPatchEvent;
DMUS_IO_SYSEX_ITEM* pSysEx;
BYTE b;
BYTE* pbSysExData = NULL;
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
return 0;
}
if( b < 0x80 )
{
StreamSeek( pStream, -1, STREAM_SEEK_CUR );
b = bRunningStatus;
dwBytes = 0;
}
else
{
dwBytes = 1;
}
if( b < 0xf0 )
{
bRunningStatus = (BYTE)b;
switch( b & 0xf0 )
{
case MIDI_CCHANGE:
case MIDI_PTOUCH:
case MIDI_PBEND:
case MIDI_NOTEOFF:
case MIDI_NOTEON:
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
return dwBytes;
}
++dwBytes;
pEvent = new FullSeqEvent;
if( pEvent == NULL )
{
return 0;
}
pEvent->mtTime = dwTime;
pEvent->nOffset = 0;
pEvent->pos = gPos;
pEvent->mtDuration = 0;
pEvent->bStatus = bRunningStatus & 0xf0;
pEvent->dwPChannel = bRunningStatus & 0xf;
pEvent->bByte1 = b;
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
delete pEvent;
return dwBytes;
}
++dwBytes;
pEvent->bByte2 = b;
if( ( pEvent->bStatus & 0xf0 ) == MIDI_NOTEON &&
pEvent->bByte2 == 0 )
{
pEvent->bStatus = (BYTE)( MIDI_NOTEOFF );
}
/* If there are multiple controller events at the same time, seperate
them by clock ticks.
gdwLastControllerTime holds the time of the last CC event.
gdwControlCollisionOffset holds the number of colliding CCs.
*/
if ((pEvent->bStatus & 0xf0) == MIDI_CCHANGE)
{
DWORD dwChannel = pEvent->dwPChannel;
if (dwTime == gdwLastControllerTime[dwChannel])
{
pEvent->mtTime += ++gdwControlCollisionOffset[dwChannel];
}
else
{
gdwControlCollisionOffset[dwChannel] = 0;
gdwLastControllerTime[dwChannel] = dwTime;
}
}
if(((pEvent->bStatus & 0xf0) == MIDI_CCHANGE) && (pEvent->bByte1 == 0 || pEvent->bByte1 == 0x20))
{
// We have a bank select or its LSB either of which are not added to event list
if(pEvent->bByte1 == 0x20)
{
gBankSelect[pEvent->dwPChannel].byLSB = pEvent->bByte2;
}
else // pEvent->bByte1 == 0
{
gBankSelect[pEvent->dwPChannel].byMSB = pEvent->bByte2;
}
// We no longer need the event so we can free it
delete pEvent;
}
else // Add to event list
{
pEvent->pNext = *plstEvent;
*plstEvent = pEvent;
}
break;
case MIDI_PCHANGE:
if(FAILED(pStream->Read(&b, 1, NULL)))
{
return dwBytes;
}
++dwBytes;
pPatchEvent = new DMUS_IO_PATCH_ITEM;
if(pPatchEvent == NULL)
{
return 0;
}
memset(pPatchEvent, 0, sizeof(DMUS_IO_PATCH_ITEM));
pPatchEvent->lTime = dwTime - 1;
pPatchEvent->byStatus = bRunningStatus;
pPatchEvent->byPChange = b;
pPatchEvent->byMSB = gBankSelect[bRunningStatus & 0xF].byMSB;
pPatchEvent->byLSB = gBankSelect[bRunningStatus & 0xF].byLSB;
pPatchEvent->dwFlags |= DMUS_IO_INST_PATCH;
if((pPatchEvent->byMSB != 0xFF) && (pPatchEvent->byLSB != 0xFF))
{
pPatchEvent->dwFlags |= DMUS_IO_INST_BANKSELECT;
}
gPatchTable[bRunningStatus & 0xF] = 1;
pPatchEvent->pNext = *pplstPatchEvent;
pPatchEvent->pIDMCollection = NULL;
*pplstPatchEvent = pPatchEvent;
break;
case MIDI_MTOUCH:
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
return dwBytes;
}
++dwBytes;
pEvent = new FullSeqEvent;
if( pEvent == NULL )
{
return 0;
}
pEvent->mtTime = dwTime;
pEvent->nOffset = 0;
pEvent->pos = gPos;
pEvent->mtDuration = 0;
pEvent->bStatus = bRunningStatus & 0xf0;
pEvent->dwPChannel = bRunningStatus & 0xf;
pEvent->bByte1 = b;
pEvent->pNext = *plstEvent;
*plstEvent = pEvent;
break;
default:
// this should NOT be possible - unknown midi note event type
ASSERT(FALSE);
break;
}
}
else
{
switch( b )
{
case 0xf0:
dwBytes += GetVarLength( pStream, dwLen );
pSysEx = new DMUS_IO_SYSEX_ITEM;
if( pSysEx != NULL )
{
pbSysExData = new BYTE[dwLen + 1];
if( pbSysExData != NULL )
{
MUSIC_TIME mt = dwTime;
if (mt == 0)
{
mt = glLastSysexTime++;
if (mt > 0) mt = 0;
}
pbSysExData[0] = 0xf0;
if( FAILED( pStream->Read( pbSysExData + 1, dwLen, NULL ) ) )
{
delete [] pbSysExData;
delete pSysEx;
return dwBytes;
}
if( pbSysExData[1] == 0x43 )
{
// check for XG files
BYTE abXG[] = { 0xF0, 0x43, 0x10, 0x4C, 0x00, 0x00, 0x7E, 0x00, 0xF7 };
int i;
for( i = 0; i < 8; i++ )
{
if( i == 2 )
{
if( ( pbSysExData[i] & 0xF0 ) != abXG[i] )
break;
}
else
{
if( pbSysExData[i] != abXG[i] )
break;
}
}
if( i == 8 ) // we have an XG!
{
TListItem<StampedGMGSXG>* pPair = new TListItem<StampedGMGSXG>;
if (!pPair) return dwBytes;
pPair->GetItemValue().mtTime = mt;
pPair->GetItemValue().dwMidiMode = DMUS_MIDIMODEF_XG;
InsertMidiMode(pPair);
}
}
else if( pbSysExData[1] == 0x41 )
{
// check for GS files
BYTE abGS[] = { 0xF0,0x41,0x00,0x42,0x12,0x40,0x00,0x7F,0x00,0x41,0xF7 };
int i;
for( i = 0; i < 10; i++ )
{
if( i != 2 )
{
if( pbSysExData[i] != abGS[i] )
break;
}
}
if( i == 10 ) // we have a GS!
{
TListItem<StampedGMGSXG>* pPair = new TListItem<StampedGMGSXG>;
if (!pPair) return dwBytes;
pPair->GetItemValue().mtTime = mt;
pPair->GetItemValue().dwMidiMode = DMUS_MIDIMODEF_GS;
InsertMidiMode(pPair);
}
}
else if (( pbSysExData[1] == 0x7E ) && (pbSysExData[3] == 0x09))
{
TListItem<StampedGMGSXG>* pPair = new TListItem<StampedGMGSXG>;
if (!pPair) return dwBytes;
pPair->GetItemValue().mtTime = mt;
pPair->GetItemValue().dwMidiMode = DMUS_MIDIMODEF_GM;
InsertMidiMode(pPair);
}
pSysEx->mtTime = mt;
pSysEx->dwPChannel = 0;
DWORD dwTempLen = dwLen + 1;
pSysEx->dwSysExLength = dwTempLen;
if( NULL == gpSysExStream )
{
// create a stream to hold sysex events
CreateStreamOnHGlobal( NULL, TRUE, &gpSysExStream );
if( gpSysExStream )
{
DWORD dwTemp;
// write the chunk header
dwTemp = DMUS_FOURCC_SYSEX_TRACK;
gpSysExStream->Write( &dwTemp, sizeof(DWORD), NULL );
// write the overall size. (Replace this later with the
// true overall size.)
dwTemp = sizeof(DMUS_IO_TIMESIGNATURE_ITEM);
// overall size (to be replaced later)
gpSysExStream->Write( &dwTemp, sizeof(DWORD), NULL );
}
}
if( gpSysExStream )
{
gpSysExStream->Write( &pSysEx->mtTime, sizeof(MUSIC_TIME), NULL );
gpSysExStream->Write( &pSysEx->dwPChannel, sizeof(DWORD), NULL );
gpSysExStream->Write( &pSysEx->dwSysExLength, sizeof(DWORD), NULL );
gpSysExStream->Write( pbSysExData, dwTempLen, NULL );
gdwSizeSysExStream += (sizeof(long) + sizeof(DWORD) + dwTempLen);
}
delete [] pbSysExData;
delete pSysEx;
}
else
{
StreamSeek( pStream, dwLen, STREAM_SEEK_CUR );
}
}
else
{
StreamSeek( pStream, dwLen, STREAM_SEEK_CUR );
}
dwBytes += dwLen;
break;
case 0xf7:
// ignore sysex f7 chunks
dwBytes += GetVarLength( pStream, dwLen );
StreamSeek( pStream, dwLen, STREAM_SEEK_CUR );
dwBytes += dwLen;
break;
case 0xff:
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
return dwBytes;
}
++dwBytes;
dwBytes += GetVarLength( pStream, dwLen );
if( b == 0x51 ) // tempo change
{
DWORD dw = 0;
DMUS_IO_TEMPO_ITEM tempo;
while( dwLen > 0 )
{
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
return dwBytes;
}
++dwBytes;
--dwLen;
dw <<= 8;
dw += b;
}
if (dw < 1) dw = 1;
tempo.dblTempo = 60000000.0 / ((double)dw);
tempo.lTime = dwTime;
if( NULL == gpTempoStream )
{
// create a stream to hold tempo events
CreateStreamOnHGlobal( NULL, TRUE, &gpTempoStream );
if( gpTempoStream )
{
DWORD dwTemp;
// write the chunk header
dwTemp = DMUS_FOURCC_TEMPO_TRACK;
gpTempoStream->Write( &dwTemp, sizeof(DWORD), NULL );
// write the overall size. (Replace this later with the
// true overall size.) Also write the size of the individual
// structure.
dwTemp = sizeof(DMUS_IO_TEMPO_ITEM);
// overall size (to be replaced later)
gpTempoStream->Write( &dwTemp, sizeof(DWORD), NULL );
// individual structure.
gpTempoStream->Write( &dwTemp, sizeof(DWORD), NULL );
}
}
if( gpTempoStream )
{
gpTempoStream->Write( &tempo, sizeof(DMUS_IO_TEMPO_ITEM), NULL );
gdwSizeTempoStream += sizeof(DMUS_IO_TEMPO_ITEM);
}
}
else if( b == 0x58 && glTimeSig )
{
// glTimeSig will be set to 0 inside the main calling function
// once we no longer care about time sigs.
DMUS_IO_TIMESIGNATURE_ITEM timesig;
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
return dwBytes;
}
// set glTimeSig to 2 to signal to the main function that we've
// read a time sig on this track
glTimeSig = 2;
gTimeSig.lTime = timesig.lTime = dwTime;
gTimeSig.bBeatsPerMeasure = timesig.bBeatsPerMeasure = b;
++dwBytes;
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
return dwBytes;
}
gTimeSig.bBeat = timesig.bBeat = (BYTE)( 1 << b ); // 0 means 256th note
gTimeSig.wGridsPerBeat = timesig.wGridsPerBeat = 4; // this is irrelavent for MIDI files
if( NULL == gpTimeSigStream )
{
CreateStreamOnHGlobal( NULL, TRUE, &gpTimeSigStream );
if( gpTimeSigStream )
{
DWORD dwTemp;
// write the chunk header
dwTemp = DMUS_FOURCC_TIMESIGNATURE_TRACK;
gpTimeSigStream->Write( &dwTemp, sizeof(DWORD), NULL );
// write the overall size. (Replace this later with the
// true overall size.) Also write the size of the individual
// structure.
dwTemp = sizeof(DMUS_IO_TIMESIGNATURE_ITEM);
// overall size (to be replaced later)
gpTimeSigStream->Write( &dwTemp, sizeof(DWORD), NULL );
// individual structure.
gpTimeSigStream->Write( &dwTemp, sizeof(DWORD), NULL );
gdwSizeTimeSigStream += sizeof(DWORD);
}
}
if( gpTimeSigStream )
{
gpTimeSigStream->Write( ×ig, sizeof(DMUS_IO_TIMESIGNATURE_ITEM), NULL );
gdwSizeTimeSigStream += sizeof(DMUS_IO_TIMESIGNATURE_ITEM);
}
++dwBytes;
StreamSeek( pStream, dwLen - 2, STREAM_SEEK_CUR );
dwBytes += ( dwLen - 2 );
}
else if( b == 0x59 )
{
// Read sharps/flats and major/minor bytes
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
return dwBytes;
}
char cSharpsFlats = b;
++dwBytes;
if( FAILED( pStream->Read( &b, 1, NULL ) ) )
{
return dwBytes;
}
BYTE bMode = b;
++dwBytes;
// Create a chord (with one subchord) from the key info
CreateChordFromKey(cSharpsFlats, bMode, dwTime, g_Chord);
// If the chord track is empty, create it.
if (!g_pChordTrack)
{
HRESULT hr = CoCreateInstance(
CLSID_DirectMusicChordTrack, NULL, CLSCTX_INPROC,
IID_IDirectMusicTrack,
(void**)&g_pChordTrack );
if (!SUCCEEDED(hr)) return dwBytes;
// If dwTime > 0, use SetParam to insert the default chord at time 0
if (dwTime > 0)
{
g_pChordTrack->SetParam(GUID_ChordParam, 0, &g_DefaultChord);
}
}
// Use SetParam to insert the new chord into the chord track
g_pChordTrack->SetParam(GUID_ChordParam, dwTime, &g_Chord);
}
else
{
StreamSeek( pStream, dwLen, STREAM_SEEK_CUR );
dwBytes += dwLen;
}
break;
default:
break;
}
}
return dwBytes;
}
static void AddOffsets(FullSeqEvent* lstEvent, IDirectMusicTrack* pTimeSigTrack)
{
HRESULT hr;
MUSIC_TIME mtNext = 0;
DMUS_IO_TIMESIGNATURE_ITEM timesig;
timesig.bBeat = gTimeSig.bBeat ? gTimeSig.bBeat : 4;
timesig.bBeatsPerMeasure = gTimeSig.bBeatsPerMeasure ? gTimeSig.bBeatsPerMeasure : 4;
timesig.wGridsPerBeat = gTimeSig.wGridsPerBeat ? gTimeSig.wGridsPerBeat : 4;
timesig.lTime = 0;
short nClocksPerGrid = ((DMUS_PPQ * 4) / timesig.bBeat) / timesig.wGridsPerBeat;
if (pTimeSigTrack)
{
hr = pTimeSigTrack->GetParam(GUID_TimeSignature, 0, &mtNext, (void*)×ig);
if (FAILED(hr))
{
mtNext = 0;
}
else
{
nClocksPerGrid = ((DMUS_PPQ * 4) / timesig.bBeat) / timesig.wGridsPerBeat;
}
}
for( FullSeqEvent* pEvent = lstEvent; pEvent; pEvent = pEvent->pNext )
{
if ( ( pEvent->bStatus & 0xf0 ) == MIDI_NOTEON )
{
if (mtNext && pTimeSigTrack && mtNext < pEvent->mtTime)
{
hr = pTimeSigTrack->GetParam(GUID_TimeSignature, mtNext, &mtNext, (void*)×ig);
if (FAILED(hr))
{
mtNext = 0;
}
else
{
nClocksPerGrid = ((DMUS_PPQ * 4) / timesig.bBeat) / timesig.wGridsPerBeat;
}
}
ASSERT(nClocksPerGrid);
if( 0 == nClocksPerGrid ) nClocksPerGrid = 1; // this should never happen, but just in case.
pEvent->nOffset = (short) ((pEvent->mtTime - timesig.lTime) % nClocksPerGrid);
pEvent->mtTime -= pEvent->nOffset;
if (pEvent->nOffset > (nClocksPerGrid / 2))
{
// make it a negative offset and bump the time a corresponding amount
pEvent->nOffset -= nClocksPerGrid;
pEvent->mtTime += nClocksPerGrid;
}
}
}
}
/*
@method HRESULT | IDirectMusicPerformance | CreateSegmentFromMIDIStream |
Given a MIDI stream, creates a Segment that can be played via
<im IDirectMusicPerformance.PlaySegment>.
@parm LPSTREAM | pStream |
[in] The MIDI stream. It should be set to the correct seek to begin reading.
@parm IDirectMusicSegment* | pSegment |
[out] A pointer to contain the created Segment.
@rvalue DMUS_E_CANNOTREAD | There was an error attempting to read the MIDI file.
@rvalue S_OK
*/
HRESULT CreateSegmentFromMIDIStream(LPSTREAM pStream,
IDirectMusicSegment* pSegment)
{
if(pSegment == NULL || pStream == NULL)
{
return E_POINTER;
}
HRESULT hr = DMUS_E_CANNOTREAD;
DWORD dwID;
DWORD dwCurTime;
DWORD dwLength;
DWORD dwSize;
short nFormat;
short nNumTracks;
short nTracksRead;
FullSeqEvent* lstEvent;
DMUS_IO_PATCH_ITEM* lstPatchEvent;
FullSeqEvent* lstTrackEvent;
HRESULT hrGM = S_OK;
EnterCriticalSection(&g_CritSec);
gpTempoStream = NULL;
gpSysExStream = NULL;
gpTimeSigStream = NULL;
gdwSizeTimeSigStream = 0;
gdwSizeSysExStream = 0;
gdwSizeTempoStream = 0;
glTimeSig = 1; // flag to see if we should be paying attention to time sigs.
// this is needed because we only care about the time sigs on the first track to
// contain them that we read
g_pChordTrack = NULL;
lstEvent = NULL;
lstPatchEvent = NULL;
nNumTracks = nTracksRead = 0;
dwLength = 0;
gPos = 0;
gMidiModeList.CleanUp();
if (g_pChordTrack)
{
g_pChordTrack->Release();
g_pChordTrack = NULL;
}
CreateChordFromKey(0, 0, 0, g_Chord);
CreateChordFromKey(0, 0, 0, g_DefaultChord);
memset(&gBankSelect, 0xFF, (sizeof(DMUS_IO_BANKSELECT_ITEM) * NUM_MIDI_CHANNELS));
memset(&gPatchTable, 0, (sizeof(DWORD) * NUM_MIDI_CHANNELS));
memset(&gTimeSig, 0, sizeof(DMUS_IO_TIMESIGNATURE_ITEM));
memset(&gdwLastControllerTime, 0xFF, (sizeof(DWORD) * NUM_MIDI_CHANNELS));
memset(&gdwControlCollisionOffset, 0, (sizeof(DWORD) * NUM_MIDI_CHANNELS));
glLastSysexTime = -5;
if( ( S_OK != pStream->Read( &dwID, sizeof( FOURCC ), NULL ) ) ||
!GetMLong( pStream, dwSize ) )
{
Trace(1,"Error: Failure parsing MIDI file.\n");
LeaveCriticalSection(&g_CritSec);
return DMUS_E_CANNOTREAD;
}
// check for RIFF MIDI files
if( dwID == mmioFOURCC( 'R', 'I', 'F', 'F' ) )
{
StreamSeek( pStream, 12, STREAM_SEEK_CUR );
if( ( S_OK != pStream->Read( &dwID, sizeof( FOURCC ), NULL ) ) ||
!GetMLong( pStream, dwSize ) )
{
Trace(1,"Error: Failure parsing MIDI file.\n");
LeaveCriticalSection(&g_CritSec);
return DMUS_E_CANNOTREAD;
}
}
// check for normal MIDI files
if( dwID != mmioFOURCC( 'M', 'T', 'h', 'd' ) )
{
LeaveCriticalSection(&g_CritSec);
Trace(1,"Error: Failure parsing MIDI file - can't find a valid header.\n");
return DMUS_E_CANNOTREAD;
}
GetMShort( pStream, nFormat );
GetMShort( pStream, nNumTracks );
GetMShort( pStream, snPPQN );
if( dwSize > 6 )
{
StreamSeek( pStream, dwSize - 6, STREAM_SEEK_CUR );
}
pStream->Read( &dwID, sizeof( FOURCC ), NULL );
while( dwID == mmioFOURCC( 'M', 'T', 'r', 'k' ) )
{
GetMLong( pStream, dwSize );
dwCurTime = 0;
lstTrackEvent = NULL;
long lSize = (long)dwSize;
while( lSize > 0 )
{
long lReturn;
lSize -= GetVarLength( pStream, dwID );
dwCurTime += dwID;
if (lSize > 0)
{
lReturn = ReadEvent( pStream, dwCurTime, &lstTrackEvent, &lstPatchEvent );
if( lReturn )
{
lSize -= lReturn;
}
else
{
Trace(1,"Error: Failure parsing MIDI file.\n");
hr = DMUS_E_CANNOTREAD;
goto END;
}
}
}
dwSize = lSize;
if( glTimeSig > 1 )
{
// if glTimeSig is greater than 1, it means we've read some time sigs
// from this track (it was set to 2 inside ReadEvent.) This means that
// we no longer want ReadEvent to pay any attention to time sigs, so
// we set this to 0.
glTimeSig = 0;
}
if( dwCurTime > dwLength )
{
dwLength = dwCurTime;
}
lstTrackEvent = ScanForDuplicatePBends( lstTrackEvent );
lstTrackEvent = SortEventList( lstTrackEvent );
lstTrackEvent = CompressEventList( lstTrackEvent );
lstEvent = List_Cat( lstEvent, lstTrackEvent );
if( FAILED( pStream->Read( &dwID, sizeof( FOURCC ), NULL ) ) )
{
break;
}
}
dwLength = ConvertTime(dwLength);
lstEvent = SortEventList( lstEvent );
// if( lstEvent ) Removed: this might be just a band, or sysex data, or whatever.
{
if(pSegment)
{
IPersistStream* pIPSTrack;
IDirectMusicTrack* pDMTrack;
hr = S_OK;
if (!g_pChordTrack)
{
hr = CoCreateInstance(
CLSID_DirectMusicChordTrack, NULL, CLSCTX_INPROC,
IID_IDirectMusicTrack,
(void**)&g_pChordTrack );
if (SUCCEEDED(hr))
{
g_pChordTrack->SetParam(GUID_ChordParam, 0, &g_DefaultChord);
}
}
if (SUCCEEDED(hr))
{
pSegment->InsertTrack( g_pChordTrack, 1 );
g_pChordTrack->Release();
g_pChordTrack = NULL;
}
// Note: We could be checking to see if there are actually tempo events,
// sysex events, etc. to see if it's really necessary to create these
// tracks...
// Create a Tempo Track in which to store the tempo events
if( gpTempoStream )
{
if( SUCCEEDED( CoCreateInstance( CLSID_DirectMusicTempoTrack,
NULL, CLSCTX_INPROC, IID_IPersistStream,
(void**)&pIPSTrack )))
{
StreamSeek( gpTempoStream, sizeof(DWORD), STREAM_SEEK_SET );
gpTempoStream->Write( &gdwSizeTempoStream, sizeof(DWORD), NULL );
StreamSeek( gpTempoStream, 0, STREAM_SEEK_SET );
pIPSTrack->Load( gpTempoStream );
if( SUCCEEDED( pIPSTrack->QueryInterface( IID_IDirectMusicTrack,
(void**)&pDMTrack ) ) )
{
pSegment->InsertTrack( pDMTrack, 1 );
pDMTrack->Release();
}
pIPSTrack->Release();
}
}
// Add a patch event for each MIDI channel that does not have one
DMUS_IO_PATCH_ITEM* pPatchEvent = NULL;
for(DWORD i = 0; i < 16; i++)
{
if(gPatchTable[i] == 0)
{
pPatchEvent = new DMUS_IO_PATCH_ITEM;
if(pPatchEvent == NULL)
{
continue;
}
memset(pPatchEvent, 0, sizeof(DMUS_IO_PATCH_ITEM));
pPatchEvent->lTime = ConvertTime(0);
pPatchEvent->byStatus = 0xC0 + (BYTE)(i & 0xf);
pPatchEvent->dwFlags |= (DMUS_IO_INST_PATCH);
pPatchEvent->pIDMCollection = NULL;
pPatchEvent->fNotInFile = TRUE;
pPatchEvent->pNext = lstPatchEvent;
lstPatchEvent = pPatchEvent;
}
}
if(lstPatchEvent)
{
// Create Band Track in which to store patch change events
IDirectMusicBandTrk* pBandTrack;
if(SUCCEEDED(CoCreateInstance(CLSID_DirectMusicBandTrack,
NULL,
CLSCTX_INPROC,
IID_IDirectMusicBandTrk,
(void**)&pBandTrack)))
{
// Get the loader from stream so we can open a required collections
IDirectMusicGetLoader* pIDMGetLoader = NULL;
IDirectMusicLoader* pIDMLoader = NULL;
hr = pStream->QueryInterface(IID_IDirectMusicGetLoader, (void**)&pIDMGetLoader);
if( SUCCEEDED(hr) )
{
hr = pIDMGetLoader->GetLoader(&pIDMLoader);
pIDMGetLoader->Release();
}
// IStream needs a loader attached
assert(SUCCEEDED(hr));
// Populate the the Band Track with patch change events
for(DMUS_IO_PATCH_ITEM* pEvent = lstPatchEvent; pEvent; pEvent = lstPatchEvent)
{
// Remove instrument from head of list and give to band
DMUS_IO_PATCH_ITEM* temp = pEvent->pNext;
pEvent->pNext = NULL;
lstPatchEvent = temp;
// We will try to load the collection but if we can not we will continure
// and use the default GM on the card
if(pIDMLoader)
{
HRESULT hrTemp = LoadCollection(&pEvent->pIDMCollection, pIDMLoader);
if (FAILED(hrTemp))
{
hrGM = hrTemp;
}
}
hr = pBandTrack->AddBand(pEvent);
// Release reference to collection
if(pEvent->pIDMCollection)
{
(pEvent->pIDMCollection)->Release();
pEvent->pIDMCollection = NULL;
}
delete pEvent;
if(FAILED(hr))
{
break;
}
}
if(SUCCEEDED(hr))
{
TListItem<StampedGMGSXG>* pPair = gMidiModeList.GetHead();
if( NULL == pPair )
{
// if we had nothing, generate a GM one so the band knows
// it was loaded from a midi file
// since the first band is set to play at -1,
// this is when the default midi mode must occur.
pBandTrack->SetGMGSXGMode(-1, DMUS_MIDIMODEF_GM);
}
for ( ; pPair; pPair = pPair->GetNext() )
{
StampedGMGSXG& rPair = pPair->GetItemValue();
pBandTrack->SetGMGSXGMode(rPair.mtTime, rPair.dwMidiMode);
}
gMidiModeList.CleanUp();
if(SUCCEEDED(pBandTrack->QueryInterface(IID_IDirectMusicTrack,
(void**)&pDMTrack)))
{
pSegment->InsertTrack(pDMTrack, 1);
pDMTrack->Release();
}
}
if(pBandTrack)
{
pBandTrack->Release();
}
if(pIDMLoader)
{
pIDMLoader->Release();
}
}
}
if( gpTimeSigStream )
{
// Create a TimeSig Track to store the TimeSig events
if( SUCCEEDED( CoCreateInstance( CLSID_DirectMusicTimeSigTrack,
NULL, CLSCTX_INPROC, IID_IPersistStream,
(void**)&pIPSTrack )))
{
// set the overall size to the correct size
StreamSeek( gpTimeSigStream, sizeof(DWORD), STREAM_SEEK_SET );
gpTimeSigStream->Write( &gdwSizeTimeSigStream, sizeof(DWORD), NULL );
// reset to beginning and persist to track.
StreamSeek( gpTimeSigStream, 0, STREAM_SEEK_SET );
pIPSTrack->Load( gpTimeSigStream );
if( SUCCEEDED( pIPSTrack->QueryInterface( IID_IDirectMusicTrack,
(void**)&pDMTrack ) ) )
{
pSegment->InsertTrack( pDMTrack, 1 );
AddOffsets(lstEvent, pDMTrack);
pDMTrack->Release();
}
pIPSTrack->Release();
}
}
else
{
AddOffsets(lstEvent, NULL);
}
lstEvent = SortEventList( lstEvent );
// Create a Sequence Track in which to store the notes, curves,
// and SysEx events.
//
if( SUCCEEDED( CoCreateInstance( CLSID_DirectMusicSeqTrack,
NULL, CLSCTX_INPROC, IID_IPersistStream,
(void**)&pIPSTrack )))
{
// Create a stream in which to place the events so we can
// give it to the SeqTrack.Load.
IStream* pEventStream;
if( S_OK == CreateStreamOnHGlobal( NULL, TRUE, &pEventStream ) )
{
// angusg: The implementation of memory IStream interface on
// CE can be inefficient if the stream memory isn't allocated
// before. It will call LocalRealloc on every IStream->Write
// for the amount that is written (in this case a small amount)
// this is incredible inefficient here as Realloc can be called
// thousands of times....
// The solution is to pre calculate the size of the stream and
// call ISteam->SetSize(), which calls LocalAlloc, to alloc the
// memory in one call.
// calculate the size of the stream storage
DWORD dwStreamStorageSize;
FullSeqEvent* pEvent;
// add the size of the chunk id's written below
dwStreamStorageSize = 5 * sizeof(DWORD);
// now count how many events need to be stored in the stream
for( pEvent = lstEvent; pEvent; pEvent = pEvent->pNext )
{
dwStreamStorageSize += sizeof(DMUS_IO_SEQ_ITEM);
}
ULARGE_INTEGER liSize;
liSize.QuadPart = dwStreamStorageSize;
// make the stream allocate the complete amount of memory
pEventStream->SetSize(liSize);
// Save the events into the stream
ULONG cb, cbWritten;
// Save the chunk id
DWORD dwTemp = DMUS_FOURCC_SEQ_TRACK;
pEventStream->Write( &dwTemp, sizeof(DWORD), NULL );
// Save the overall size. Count the number of events to determine.
dwSize = 0;
for( pEvent = lstEvent; pEvent; pEvent = pEvent->pNext )
{
dwSize++;
}
dwSize *= sizeof(DMUS_IO_SEQ_ITEM);
// add 8 for the subchunk
dwSize += 8;
pEventStream->Write( &dwSize, sizeof(DWORD), NULL );
// Save the subchunk id
dwTemp = DMUS_FOURCC_SEQ_LIST;
pEventStream->Write( &dwTemp, sizeof(DWORD), NULL );
// Subtract the previously added 8
dwSize -= 8;
// Save the size of the subchunk
pEventStream->Write( &dwSize, sizeof(DWORD), NULL );
// Save the structure size.
dwTemp = sizeof(DMUS_IO_SEQ_ITEM);
pEventStream->Write( &dwTemp, sizeof(DWORD), NULL );
// Save the events.
cb = sizeof(DMUS_IO_SEQ_ITEM); // doesn't have the next pointers
for( pEvent = lstEvent; pEvent; pEvent = pEvent->pNext )
{
if( dwLength < (DWORD)(pEvent->mtTime + pEvent->mtDuration) )
{
dwLength = pEvent->mtTime + pEvent->mtDuration;
}
pEventStream->Write( pEvent, cb, &cbWritten );
if( cb != cbWritten ) // error!
{
pEventStream->Release();
pEventStream = NULL;
hr = DMUS_E_CANNOTREAD;
break;
}
}
if( pEventStream ) // may be NULL
{
StreamSeek( pEventStream, 0, STREAM_SEEK_SET );
pIPSTrack->Load( pEventStream );
pEventStream->Release();
}
}
if( SUCCEEDED( pIPSTrack->QueryInterface( IID_IDirectMusicTrack,
(void**)&pDMTrack ) ) )
{
pSegment->InsertTrack( pDMTrack, 1 );
pDMTrack->Release();
}
pIPSTrack->Release();
}
// set the length of the segment. Set it to the measure boundary
// past the last note.
DWORD dwResolvedLength = gTimeSig.lTime;
if( 0 == gTimeSig.bBeat ) gTimeSig.bBeat = 4;
if( 0 == gTimeSig.bBeatsPerMeasure ) gTimeSig.bBeatsPerMeasure = 4;
if( 0 == gTimeSig.wGridsPerBeat ) gTimeSig.wGridsPerBeat = 4;
while( dwResolvedLength < dwLength )
{
dwResolvedLength += (((DMUS_PPQ * 4) / gTimeSig.bBeat) * gTimeSig.bBeatsPerMeasure);
}
pSegment->SetLength( dwResolvedLength );
if( gpSysExStream )
{
// Create a SysEx Track in which to store the SysEx events
if( SUCCEEDED( CoCreateInstance( CLSID_DirectMusicSysExTrack,
NULL, CLSCTX_INPROC, IID_IPersistStream,
(void**)&pIPSTrack )))
{
// write overall length
StreamSeek( gpSysExStream, sizeof(DWORD), STREAM_SEEK_SET );
gpSysExStream->Write( &gdwSizeSysExStream, sizeof(DWORD), NULL );
// seek to beginning and persist to track
StreamSeek( gpSysExStream, 0, STREAM_SEEK_SET );
pIPSTrack->Load( gpSysExStream );
if( SUCCEEDED( pIPSTrack->QueryInterface( IID_IDirectMusicTrack,
(void**)&pDMTrack ) ) )
{
pSegment->InsertTrack( pDMTrack, 1 );
pDMTrack->Release();
}
pIPSTrack->Release();
}
}
}
else
{
hr = E_POINTER;
}
}
END:
List_Free( lstEvent );
List_Free( lstPatchEvent );
FullSeqEvent::CleanUp();
// release our hold on the streams
RELEASE( gpTempoStream );
RELEASE( gpSysExStream );
RELEASE( gpTimeSigStream );
gpTempoStream = NULL;
gpSysExStream = NULL;
gpTimeSigStream = NULL;
gdwSizeTimeSigStream = 0;
gdwSizeSysExStream = 0;
gdwSizeTempoStream = 0;
LeaveCriticalSection(&g_CritSec);
if (SUCCEEDED(hrGM) || hr != S_OK )
{
return hr;
}
else
{
return DMUS_S_PARTIALLOAD;
}
}
// Creates and returns (in rChord) a DMUS_CHORD_PARAM given the three input params.
// the new chord will have one subchord containing the root, third, fifth, and seventh
// of the key (as indicated by the sharps/flats and mode). Scale will be either
// major or minor, depending on the mode (mode is 0 if major, 1 if minor).
void CreateChordFromKey(char cSharpsFlats, BYTE bMode, DWORD dwTime, DMUS_CHORD_PARAM& rChord)
{
static DWORD dwMajorScale = 0xab5ab5; // 1010 1011 0101 1010 1011 0101
static DWORD dwMinorScale = 0x5ad5ad; // 0101 1010 1101 0101 1010 1101
static DWORD dwMajor7Chord = 0x891; // 1000 1001 0001
static DWORD dwMinor7Chord = 0x489; // 0100 1000 1001
BYTE bScaleRoot = 0;
switch (cSharpsFlats)
{
case 0: bScaleRoot = bMode ? 9 : 0; break;
case 1: bScaleRoot = bMode ? 4 : 7; break;
case 2: bScaleRoot = bMode ? 11 : 2; break;
case 3: bScaleRoot = bMode ? 6 : 9; break;
case 4: bScaleRoot = bMode ? 1 : 4; break;
case 5: bScaleRoot = bMode ? 8 : 11; break;
case 6: bScaleRoot = bMode ? 3 : 6; break;
case 7: bScaleRoot = bMode ? 10 : 1; break;
case -1: bScaleRoot = bMode ? 2 : 5; break;
case -2: bScaleRoot = bMode ? 7 : 10; break;
case -3: bScaleRoot = bMode ? 0 : 3; break;
case -4: bScaleRoot = bMode ? 5 : 8; break;
case -5: bScaleRoot = bMode ? 10 : 1; break;
case -6: bScaleRoot = bMode ? 3 : 6; break;
case -7: bScaleRoot = bMode ? 8 : 11; break;
}
if (bMode)
{
wcscpy(rChord.wszName, L"m7");
}
else
{
wcscpy(rChord.wszName, L"M7");
}
DMUS_IO_TIMESIGNATURE_ITEM timesig;
timesig.bBeat = gTimeSig.bBeat ? gTimeSig.bBeat : 4;
timesig.bBeatsPerMeasure = gTimeSig.bBeatsPerMeasure ? gTimeSig.bBeatsPerMeasure : 4;
timesig.wGridsPerBeat = gTimeSig.wGridsPerBeat ? gTimeSig.wGridsPerBeat : 4;
DWORD dwAbsBeat = dwTime / ((DMUS_PPQ * 4) / timesig.bBeat);
rChord.wMeasure = (WORD)(dwAbsBeat / timesig.bBeatsPerMeasure);
rChord.bBeat = (BYTE)(dwAbsBeat % timesig.bBeatsPerMeasure);
rChord.bSubChordCount = 1;
rChord.SubChordList[0].dwChordPattern = bMode ? dwMinor7Chord : dwMajor7Chord;
rChord.SubChordList[0].dwScalePattern = bMode ? dwMinorScale : dwMajorScale;
rChord.SubChordList[0].dwInversionPoints = 0xffffff; // inversions allowed everywhere
rChord.SubChordList[0].dwLevels = 0xffffffff; // supports all levels
rChord.SubChordList[0].bChordRoot = bScaleRoot;
rChord.SubChordList[0].bScaleRoot = bScaleRoot;
}