mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
588 lines
19 KiB
588 lines
19 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (c) 1999-1999 Microsoft Corporation
|
|
//
|
|
// File: mgentrk.h
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MelodyFragment
|
|
|
|
#ifndef __MELGENTRK_H_
|
|
#define __MELGENTRK_H_
|
|
|
|
#include "dmusici.h"
|
|
#include "TList.h"
|
|
//#include "dmpublic.h" // remove when this gets incorporated into dmusici.h/dmusicf.h
|
|
#include "dmstyle.h"
|
|
|
|
#define DMUS_TRANSITIONF_GHOST_FOUND 1
|
|
#define DMUS_TRANSITIONF_OVERLAP_FOUND 2
|
|
#define DMUS_TRANSITIONF_LAST_FOUND 4
|
|
#define DMUS_TRANSITIONF_GHOST_OK 8
|
|
#define DMUS_TRANSITIONF_OVERLAP_OK 0x10
|
|
#define DMUS_TRANSITIONF_LAST_OK 0x20
|
|
|
|
// overlap delta is largest value less than a 128th note triplet
|
|
#define OVERLAP_DELTA 15
|
|
|
|
HRESULT CopyMelodyFragment(DMUS_MELODY_FRAGMENT& rTo, const DMUS_MELODY_FRAGMENT& rFrom);
|
|
|
|
HRESULT CopyMelodyFragment(DMUS_MELODY_FRAGMENT& rTo, const DMUS_IO_MELODY_FRAGMENT& rFrom);
|
|
|
|
HRESULT CopyMelodyFragment(DMUS_IO_MELODY_FRAGMENT& rTo, const DMUS_MELODY_FRAGMENT& rFrom);
|
|
|
|
HRESULT CopyMelodyFragment(DMUS_IO_MELODY_FRAGMENT& rTo, const DMUS_IO_MELODY_FRAGMENT& rFrom);
|
|
|
|
struct CompositionFragment;
|
|
struct EventWrapper;
|
|
|
|
BOOL Less(DMUS_IO_SEQ_ITEM& SeqItem1, DMUS_IO_SEQ_ITEM& SeqItem2);
|
|
|
|
BOOL Greater(DMUS_IO_SEQ_ITEM& SeqItem1, DMUS_IO_SEQ_ITEM& SeqItem2);
|
|
|
|
BOOL Less(EventWrapper& SeqItem1, EventWrapper& SeqItem2);
|
|
|
|
BOOL Greater(EventWrapper& SeqItem1, EventWrapper& SeqItem2);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MelodyFragment
|
|
struct MelodyFragment
|
|
{
|
|
MelodyFragment() {}
|
|
|
|
MelodyFragment(DMUS_MELODY_FRAGMENT& rSource) :
|
|
m_mtTime(rSource.mtTime),
|
|
m_dwID(rSource.dwID),
|
|
m_dwVariationFlags(rSource.dwVariationFlags),
|
|
m_dwRepeatFragmentID(rSource.dwRepeatFragmentID),
|
|
m_dwFragmentFlags(rSource.dwFragmentFlags),
|
|
m_dwPlayModeFlags(rSource.dwPlayModeFlags),
|
|
m_dwTransposeIntervals(rSource.dwTransposeIntervals),
|
|
m_ConnectionArc(rSource.ConnectionArc),
|
|
m_Command(rSource.Command)
|
|
{
|
|
wcscpy(m_wszVariationLabel, rSource.wszVariationLabel);
|
|
}
|
|
|
|
MelodyFragment(MelodyFragment& rSource) :
|
|
m_mtTime(rSource.m_mtTime),
|
|
m_dwID(rSource.m_dwID),
|
|
m_dwVariationFlags(rSource.m_dwVariationFlags),
|
|
m_dwRepeatFragmentID(rSource.m_dwRepeatFragmentID),
|
|
m_dwFragmentFlags(rSource.m_dwFragmentFlags),
|
|
m_dwPlayModeFlags(rSource.m_dwPlayModeFlags),
|
|
m_dwTransposeIntervals(rSource.m_dwTransposeIntervals),
|
|
m_ConnectionArc(rSource.m_ConnectionArc),
|
|
m_Command(rSource.m_Command)
|
|
{
|
|
wcscpy(m_wszVariationLabel, rSource.m_wszVariationLabel);
|
|
for (int i = 0; i < INVERSIONGROUPLIMIT; i++)
|
|
{
|
|
m_aInversionGroups[i] = rSource.m_aInversionGroups[i];
|
|
}
|
|
}
|
|
|
|
HRESULT GetPattern(DMStyleStruct* pStyleStruct,
|
|
CDirectMusicPattern*& rPattern,
|
|
TListItem<CompositionFragment>* pLastFragment);
|
|
|
|
HRESULT GetVariations(CompositionFragment& rCompFragment,
|
|
CompositionFragment& rfragmentRepeat,
|
|
CompositionFragment& rfragmentLast,
|
|
DMUS_CHORD_PARAM& rCurrentChord,
|
|
DMUS_CHORD_PARAM& rNextChord,
|
|
MUSIC_TIME mtNextChord,
|
|
TListItem<CompositionFragment>* pLastFragment);
|
|
|
|
/* HRESULT GetVariation(DirectMusicPartRef& rPartRef,
|
|
DMUS_CHORD_PARAM& rCurrentChord,
|
|
MUSIC_TIME mtNext,
|
|
MUSIC_TIME mtNextChord,
|
|
IDirectMusicTrack* pChordTrack,
|
|
DWORD& rdwVariation);
|
|
*/
|
|
|
|
HRESULT GetChord(IDirectMusicSegment* pTempSeg,
|
|
IDirectMusicSong* pSong,
|
|
DWORD dwTrackGroup,
|
|
MUSIC_TIME& rmtNext,
|
|
DMUS_CHORD_PARAM& rCurrentChord,
|
|
MUSIC_TIME& rmtCurrent,
|
|
DMUS_CHORD_PARAM& rRealCurrentChord);
|
|
|
|
HRESULT GetChord(MUSIC_TIME mtTime,
|
|
IDirectMusicSegment* pTempSeg,
|
|
IDirectMusicSong* pSong,
|
|
DWORD dwTrackGroup,
|
|
MUSIC_TIME& rmtNext,
|
|
DMUS_CHORD_PARAM& rCurrentChord);
|
|
|
|
HRESULT TestTransition(BYTE bMIDI,
|
|
MUSIC_TIME mtTime,
|
|
DMUS_CHORD_PARAM& rCurrentChord,
|
|
int nPartIndex,
|
|
DirectMusicPartRef& rPartRef,
|
|
TListItem<CompositionFragment>* pLastFragment);
|
|
|
|
HRESULT TestHarmonicConstraints(TListItem<EventWrapper>* pOldEventHead,
|
|
TList<EventWrapper>& rNewEventList);
|
|
|
|
HRESULT GetFirstNote(int nVariation,
|
|
DMUS_CHORD_PARAM& rCurrentChord,
|
|
CompositionFragment& rCompFragment,
|
|
DirectMusicPartRef& rPartRef,
|
|
BYTE& rbMidi,
|
|
MUSIC_TIME& rmtNote);
|
|
|
|
HRESULT GetNote(CDirectMusicEventItem* pEvent,
|
|
DMUS_CHORD_PARAM& rCurrentChord,
|
|
DirectMusicPartRef& rPartRef,
|
|
BYTE& rbMidi);
|
|
|
|
HRESULT GetEvent(CDirectMusicEventItem* pEvent,
|
|
DMUS_CHORD_PARAM& rCurrentChord,
|
|
DMUS_CHORD_PARAM& rRealCurrentChord,
|
|
MUSIC_TIME mtNow,
|
|
DirectMusicPartRef& rPartRef,
|
|
TListItem<EventWrapper>*& rpEventItem);
|
|
|
|
HRESULT TransposeEventList(int nInterval,
|
|
CompositionFragment& rfragmentRepeat,
|
|
DMUS_CHORD_PARAM& rCurrentChord,
|
|
DMUS_CHORD_PARAM& rRealCurrentChord,
|
|
BYTE bPlaymode,
|
|
DirectMusicPartRef& rPartRef,
|
|
TListItem<EventWrapper>*& rpOldEventHead,
|
|
TList<EventWrapper>& rNewEventList,
|
|
BYTE& rbFirstMIDI,
|
|
MUSIC_TIME& rmtFirstTime);
|
|
|
|
HRESULT GetRepeatedEvents(CompositionFragment& rfragmentRepeat,
|
|
DMUS_CHORD_PARAM& rCurrentChord,
|
|
DMUS_CHORD_PARAM& rRealCurrentChord,
|
|
BYTE bPlaymode,
|
|
int nPartIndex,
|
|
DirectMusicPartRef& rPartRef,
|
|
TListItem<CompositionFragment>* pLastFragment,
|
|
MUSIC_TIME& rmtFirstNote,
|
|
TList<EventWrapper>& rEventList);
|
|
|
|
bool UsesRepeat()
|
|
{
|
|
return (m_dwFragmentFlags & DMUS_FRAGMENTF_USE_REPEAT) ? true : false;
|
|
}
|
|
|
|
bool UsesTransitionRules()
|
|
{
|
|
return (m_ConnectionArc.dwFlags & (DMUS_CONNECTIONF_GHOST | DMUS_CONNECTIONF_INTERVALS | DMUS_CONNECTIONF_OVERLAP)) ? true : false;
|
|
}
|
|
|
|
bool RepeatsWithConstraints()
|
|
{
|
|
return
|
|
UsesRepeat() &&
|
|
( (m_dwFragmentFlags & (DMUS_FRAGMENTF_SCALE | DMUS_FRAGMENTF_CHORD)) ? true : false );
|
|
}
|
|
|
|
DWORD GetID()
|
|
{
|
|
return m_dwID;
|
|
}
|
|
|
|
DWORD GetRepeatID()
|
|
{
|
|
return m_dwRepeatFragmentID;
|
|
}
|
|
|
|
MUSIC_TIME GetTime()
|
|
{
|
|
return m_mtTime;
|
|
}
|
|
|
|
DMUS_COMMAND_PARAM GetCommand()
|
|
{
|
|
return m_Command;
|
|
}
|
|
|
|
DMUS_CONNECTION_RULE GetConnectionArc()
|
|
{
|
|
return m_ConnectionArc;
|
|
}
|
|
|
|
DWORD GetVariationFlags()
|
|
{
|
|
return m_dwVariationFlags;
|
|
}
|
|
|
|
void ClearInversionGroups()
|
|
{
|
|
for (int i = 0; i < INVERSIONGROUPLIMIT; i++)
|
|
m_aInversionGroups[i].m_wGroupID = 0;
|
|
}
|
|
|
|
protected:
|
|
|
|
MUSIC_TIME m_mtTime;
|
|
DWORD m_dwID; // This fragment's ID
|
|
WCHAR m_wszVariationLabel[DMUS_MAX_FRAGMENTLABEL]; // Each style translates this into a set of variations (held in part ref)
|
|
DWORD m_dwVariationFlags; // A set of variations
|
|
DWORD m_dwRepeatFragmentID; // ID of a fragment to repeat
|
|
DWORD m_dwFragmentFlags; // including things like: invert the fragment, transpose it...
|
|
DWORD m_dwPlayModeFlags; // including new playmodes (only use 8 bits of this)
|
|
DWORD m_dwTransposeIntervals; // Legal transposition intervals (first 24 bits; two-octave range)
|
|
DMUS_COMMAND_PARAM m_Command;
|
|
DMUS_CONNECTION_RULE m_ConnectionArc;
|
|
InversionGroup m_aInversionGroups[INVERSIONGROUPLIMIT]; // Inversion Groups for composing melodies
|
|
};
|
|
|
|
// TransitionConstraint (for keeping track of transition constraints)
|
|
struct TransitionConstraint
|
|
{
|
|
TransitionConstraint() : dwFlags(0), bGhost(0), bOverlap(0), bLastPlayed(0)
|
|
{
|
|
}
|
|
|
|
DWORD dwFlags;
|
|
BYTE bGhost;
|
|
BYTE bOverlap;
|
|
BYTE bLastPlayed;
|
|
};
|
|
|
|
// EventOverlap (for remembering events that might overlap succeeding fragments)
|
|
struct EventOverlap
|
|
{
|
|
~EventOverlap()
|
|
{
|
|
ZeroMemory(&m_PartRef, sizeof(m_PartRef));
|
|
m_pEvent = NULL;
|
|
}
|
|
|
|
DirectMusicPartRef m_PartRef;
|
|
MUSIC_TIME m_mtTime;
|
|
MUSIC_TIME m_mtDuration;
|
|
CDirectMusicEventItem* m_pEvent;
|
|
DMUS_CHORD_PARAM m_Chord;
|
|
DMUS_CHORD_PARAM m_RealChord;
|
|
};
|
|
|
|
struct EventWrapper
|
|
{
|
|
EventWrapper() : m_pEvent(NULL), m_mtTime(0), m_bMIDI(0), m_dwPChannel(0), m_wMusic(0), m_bPlaymode(DMUS_PLAYMODE_NONE)
|
|
{
|
|
}
|
|
|
|
~EventWrapper()
|
|
{
|
|
m_pEvent = NULL;
|
|
}
|
|
|
|
CDirectMusicEventItem* m_pEvent;
|
|
MUSIC_TIME m_mtTime;
|
|
DWORD m_dwPChannel;
|
|
WORD m_wMusic;
|
|
BYTE m_bMIDI;
|
|
BYTE m_bScaleFlat;
|
|
BYTE m_bScaleSharp;
|
|
BYTE m_bChordFlat;
|
|
BYTE m_bChordSharp;
|
|
BYTE m_bPlaymode;
|
|
};
|
|
|
|
// FragmentPartRecord (for keeping track of previously generated melody fragment parts)
|
|
// (in addition to sequence events, may also want to keep track of note events)
|
|
struct FragmentPartRecord
|
|
{
|
|
FragmentPartRecord()
|
|
{
|
|
}
|
|
|
|
~FragmentPartRecord()
|
|
{
|
|
m_listEvents.CleanUp();
|
|
}
|
|
|
|
TList<EventWrapper> m_listEvents;
|
|
|
|
};
|
|
|
|
// CompositionFragment (melody fragment used in the composition process)
|
|
struct CompositionFragment : MelodyFragment
|
|
{
|
|
CompositionFragment()
|
|
{
|
|
m_aFragmentParts = NULL;
|
|
m_abVariations = NULL;
|
|
m_pStyle = NULL;
|
|
m_pPattern = NULL;
|
|
}
|
|
|
|
CompositionFragment(MelodyFragment& rFragment) : MelodyFragment(rFragment)
|
|
{
|
|
m_aFragmentParts = NULL;
|
|
m_abVariations = NULL;
|
|
m_pStyle = NULL;
|
|
m_pPattern = NULL;
|
|
}
|
|
|
|
~CompositionFragment()
|
|
{
|
|
if (m_aFragmentParts) delete [] m_aFragmentParts;
|
|
if (m_abVariations) delete [] m_abVariations;
|
|
}
|
|
|
|
HRESULT Init(CDirectMusicPattern* pPattern, DMStyleStruct* pStyleStruct, int nParts)
|
|
{
|
|
m_pStyle = pStyleStruct;
|
|
m_pPattern = pPattern;
|
|
m_abVariations = new BYTE [nParts];
|
|
if (!m_abVariations)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
m_aFragmentParts = new FragmentPartRecord[nParts];
|
|
if (!m_aFragmentParts)
|
|
{
|
|
delete [] m_abVariations;
|
|
m_abVariations = NULL;
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
void SetPattern(CDirectMusicPattern* pPattern)
|
|
{
|
|
m_pPattern = pPattern;
|
|
}
|
|
|
|
void SetStyle(DMStyleStruct* pStyle)
|
|
{
|
|
m_pStyle = pStyle;
|
|
}
|
|
|
|
TListItem<EventOverlap>* GetOverlapHead()
|
|
{
|
|
return m_listEventOverlaps.GetHead();
|
|
}
|
|
|
|
TList<EventWrapper>& EventList(int i)
|
|
{
|
|
return m_aFragmentParts[i].m_listEvents;
|
|
}
|
|
|
|
void AddOverlap(TListItem<EventOverlap>* pOverlap)
|
|
{
|
|
m_listEventOverlaps.AddHead(pOverlap);
|
|
}
|
|
|
|
TListItem<EventWrapper>* GetEventHead(int i)
|
|
{
|
|
return m_aFragmentParts[i].m_listEvents.GetHead();
|
|
}
|
|
|
|
TListItem<EventWrapper>* RemoveEventHead(int i)
|
|
{
|
|
return m_aFragmentParts[i].m_listEvents.RemoveHead();
|
|
}
|
|
|
|
void AddEvent(int i, TListItem<EventWrapper>* pEvent)
|
|
{
|
|
m_aFragmentParts[i].m_listEvents.AddHead(pEvent);
|
|
}
|
|
|
|
void InsertEvent(int i, TListItem<EventWrapper>* pEvent)
|
|
{
|
|
TListItem<EventWrapper>* pScan = m_aFragmentParts[i].m_listEvents.GetHead();
|
|
TListItem<EventWrapper>* pPrevious = NULL;
|
|
for (; pScan; pScan = pScan->GetNext() )
|
|
{
|
|
if ( Greater(pEvent->GetItemValue(), pScan->GetItemValue()) ) break;
|
|
pPrevious = pScan;
|
|
}
|
|
if (!pPrevious)
|
|
{
|
|
m_aFragmentParts[i].m_listEvents.AddHead(pEvent);
|
|
}
|
|
else
|
|
{
|
|
pPrevious->SetNext(pEvent);
|
|
pEvent->SetNext(pScan);
|
|
}
|
|
}
|
|
|
|
void SortEvents(int i)
|
|
{
|
|
m_aFragmentParts[i].m_listEvents.MergeSort(Greater);
|
|
}
|
|
|
|
BOOL IsEmptyEvents(int i)
|
|
{
|
|
return m_aFragmentParts[i].m_listEvents.IsEmpty();
|
|
}
|
|
|
|
void CleanupEvents(int i)
|
|
{
|
|
m_aFragmentParts[i].m_listEvents.CleanUp();
|
|
}
|
|
|
|
DirectMusicTimeSig& GetTimeSig(DirectMusicPart* pPart)
|
|
{
|
|
if (pPart && pPart->m_timeSig.m_bBeat != 0)
|
|
{
|
|
return pPart->m_timeSig;
|
|
}
|
|
else if (m_pPattern && m_pPattern->m_timeSig.m_bBeat != 0)
|
|
{
|
|
return m_pPattern->m_timeSig;
|
|
}
|
|
else if (m_pStyle && m_pStyle->m_TimeSignature.m_bBeat != 0)
|
|
{
|
|
return m_pStyle->m_TimeSignature;
|
|
}
|
|
else
|
|
{
|
|
return m_staticTimeSig;
|
|
}
|
|
}
|
|
|
|
CDirectMusicPattern* m_pPattern;
|
|
FragmentPartRecord* m_aFragmentParts;
|
|
BYTE* m_abVariations;
|
|
TList<EventOverlap> m_listEventOverlaps;
|
|
DMStyleStruct* m_pStyle;
|
|
static DirectMusicTimeSig m_staticTimeSig;
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMelodyFormulationTrack
|
|
|
|
class CMelodyFormulationTrack :
|
|
public IDirectMusicTrack8,
|
|
public IPersistStream
|
|
{
|
|
public:
|
|
CMelodyFormulationTrack();
|
|
CMelodyFormulationTrack(const CMelodyFormulationTrack& rTrack, MUSIC_TIME mtStart, MUSIC_TIME mtEnd);
|
|
~CMelodyFormulationTrack();
|
|
void Clear();
|
|
|
|
// IUnknown
|
|
//
|
|
virtual STDMETHODIMP QueryInterface(const IID &iid, void **ppv);
|
|
virtual STDMETHODIMP_(ULONG) AddRef();
|
|
virtual STDMETHODIMP_(ULONG) Release();
|
|
|
|
public:
|
|
HRESULT STDMETHODCALLTYPE Init(
|
|
/*[in]*/ IDirectMusicSegment* pSegment
|
|
);
|
|
|
|
HRESULT STDMETHODCALLTYPE InitPlay(
|
|
/*[in]*/ IDirectMusicSegmentState* pSegmentState,
|
|
/*[in]*/ IDirectMusicPerformance* pPerformance,
|
|
/*[out]*/ void** ppStateData,
|
|
/*[in]*/ DWORD dwTrackID,
|
|
/*[in]*/ DWORD dwFlags
|
|
);
|
|
|
|
HRESULT STDMETHODCALLTYPE EndPlay(
|
|
/*[in]*/ void* pStateData
|
|
);
|
|
|
|
HRESULT STDMETHODCALLTYPE Play(
|
|
/*[in]*/ void* pStateData,
|
|
/*[in]*/ MUSIC_TIME mtStart,
|
|
/*[in]*/ MUSIC_TIME mtEnd,
|
|
/*[in]*/ MUSIC_TIME mtOffset,
|
|
DWORD dwFlags,
|
|
IDirectMusicPerformance* pPerf,
|
|
IDirectMusicSegmentState* pSegState,
|
|
DWORD dwVirtualID
|
|
);
|
|
|
|
HRESULT STDMETHODCALLTYPE GetParam(
|
|
REFGUID pCommandGuid,
|
|
MUSIC_TIME mtTime,
|
|
MUSIC_TIME* pmtNext,
|
|
void *pData);
|
|
|
|
HRESULT STDMETHODCALLTYPE SetParam(
|
|
/* [in] */ REFGUID pCommandGuid,
|
|
/* [in] */ MUSIC_TIME mtTime,
|
|
/* [out] */ void __RPC_FAR *pData);
|
|
|
|
HRESULT STDMETHODCALLTYPE AddNotificationType(
|
|
/* [in] */ REFGUID pGuidNotify
|
|
);
|
|
|
|
HRESULT STDMETHODCALLTYPE RemoveNotificationType(
|
|
/* [in] */ REFGUID pGuidNotify
|
|
);
|
|
|
|
HRESULT STDMETHODCALLTYPE Clone(
|
|
MUSIC_TIME mtStart,
|
|
MUSIC_TIME mtEnd,
|
|
IDirectMusicTrack** ppTrack);
|
|
|
|
HRESULT STDMETHODCALLTYPE IsParamSupported(
|
|
/*[in]*/ REFGUID pGuid
|
|
);
|
|
|
|
// IDirectMusicTrack8 Methods
|
|
STDMETHODIMP PlayEx(void* pStateData,REFERENCE_TIME rtStart,
|
|
REFERENCE_TIME rtEnd,REFERENCE_TIME rtOffset,
|
|
DWORD dwFlags,IDirectMusicPerformance* pPerf,
|
|
IDirectMusicSegmentState* pSegSt,DWORD dwVirtualID) ;
|
|
STDMETHODIMP GetParamEx(REFGUID rguidType,REFERENCE_TIME rtTime,
|
|
REFERENCE_TIME* prtNext,void* pParam,void * pStateData, DWORD dwFlags) ;
|
|
STDMETHODIMP SetParamEx(REFGUID rguidType,REFERENCE_TIME rtTime,void* pParam, void * pStateData, DWORD dwFlags) ;
|
|
STDMETHODIMP Compose(IUnknown* pContext,
|
|
DWORD dwTrackGroup,
|
|
IDirectMusicTrack** ppResultTrack) ;
|
|
STDMETHODIMP Join(IDirectMusicTrack* pNewTrack,
|
|
MUSIC_TIME mtJoin,
|
|
IUnknown* pContext,
|
|
DWORD dwTrackGroup,
|
|
IDirectMusicTrack** ppResultTrack) ;
|
|
|
|
// IPersist methods
|
|
HRESULT STDMETHODCALLTYPE GetClassID( LPCLSID pclsid );
|
|
|
|
// IPersistStream methods
|
|
HRESULT STDMETHODCALLTYPE IsDirty();
|
|
|
|
HRESULT STDMETHODCALLTYPE Save( LPSTREAM pStream, BOOL fClearDirty );
|
|
|
|
HRESULT STDMETHODCALLTYPE GetSizeMax( ULARGE_INTEGER* /*pcbSize*/ );
|
|
|
|
HRESULT STDMETHODCALLTYPE Load( LPSTREAM pStream );
|
|
|
|
// Methods for dealing with melody fragments
|
|
HRESULT SendNotification(MUSIC_TIME mtTime,
|
|
IDirectMusicPerformance* pPerf,
|
|
IDirectMusicSegment* pSegment,
|
|
IDirectMusicSegmentState* pSegState,
|
|
DWORD dwFlags);
|
|
HRESULT LoadFragments(LPSTREAM pStream, long lFileSize );
|
|
HRESULT SetID(DWORD& rdwID);
|
|
HRESULT GetID(DWORD& rdwID);
|
|
HRESULT AddToSegment(IDirectMusicSegment* pTempSeg,
|
|
IDirectMusicTrack* pNewPatternTrack,
|
|
DWORD dwGroupBits);
|
|
|
|
protected:
|
|
// attributes
|
|
long m_cRef;
|
|
CRITICAL_SECTION m_CriticalSection; // for load and playback
|
|
BYTE m_bRequiresSave;
|
|
|
|
BOOL m_fNotifyRecompose;
|
|
TList<DMUS_MELODY_FRAGMENT> m_FragmentList;
|
|
DWORD m_dwLastId;
|
|
BYTE m_bPlaymode; // playmode for events in the generated pattern track.
|
|
};
|
|
|
|
#endif // __MELGENTRK_H_
|