1072 lines
32 KiB
C++
1072 lines
32 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (c) 1998-1999 Microsoft Corporation
|
|
//
|
|
// File: cmmdtrk.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
// READ THIS!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
//
|
|
// 4530: C++ exception handler used, but unwind semantics are not enabled. Specify -GX
|
|
//
|
|
// We disable this because we use exceptions and do *not* specify -GX (USE_NATIVE_EH in
|
|
// sources).
|
|
//
|
|
// The one place we use exceptions is around construction of objects that call
|
|
// InitializeCriticalSection. We guarantee that it is safe to use in this case with
|
|
// the restriction given by not using -GX (automatic objects in the call chain between
|
|
// throw and handler are not destructed). Turning on -GX buys us nothing but +10% to code
|
|
// size because of the unwind code.
|
|
//
|
|
// Any other use of exceptions must follow these restrictions or -GX must be turned on.
|
|
//
|
|
// READ THIS!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
//
|
|
#pragma warning(disable:4530)
|
|
|
|
// CommandTrack.cpp : Implementation of CCommandTrack
|
|
#include <objbase.h>
|
|
#include "CmmdTrk.h"
|
|
#include "debug.h"
|
|
#include "debug.h"
|
|
#include "..\shared\Validate.h"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CCommandTrack
|
|
|
|
CCommandTrack::CCommandTrack() : m_bRequiresSave(0),
|
|
m_cRef(1), m_fNotifyCommand(FALSE), m_fCSInitialized(FALSE), m_pNextCommand(NULL)
|
|
|
|
{
|
|
InterlockedIncrement(&g_cComponent);
|
|
|
|
::InitializeCriticalSection( &m_CriticalSection );
|
|
m_fCSInitialized = TRUE;
|
|
}
|
|
|
|
// it is assumed that cloning of commands will only happen on measure boundaries
|
|
CCommandTrack::CCommandTrack(const CCommandTrack& rTrack, MUSIC_TIME mtStart, MUSIC_TIME mtEnd) :
|
|
m_bRequiresSave(0),
|
|
m_cRef(1), m_fNotifyCommand(rTrack.m_fNotifyCommand),
|
|
m_fCSInitialized(FALSE), m_pNextCommand(NULL)
|
|
|
|
{
|
|
InterlockedIncrement(&g_cComponent);
|
|
|
|
::InitializeCriticalSection( &m_CriticalSection );
|
|
m_fCSInitialized = TRUE;
|
|
WORD wMeasure = 0;
|
|
BOOL fStarted = FALSE;
|
|
TListItem<DMCommand>* pScan = rTrack.m_CommandList.GetHead();
|
|
TListItem<DMCommand>* pPrevious = NULL;
|
|
for(; pScan; pScan = pScan->GetNext())
|
|
{
|
|
DMCommand& rScan = pScan->GetItemValue();
|
|
if (rScan.m_mtTime < mtStart)
|
|
{
|
|
pPrevious = pScan;
|
|
}
|
|
else if (rScan.m_mtTime < mtEnd)
|
|
{
|
|
if (!fStarted)
|
|
{
|
|
fStarted = TRUE;
|
|
wMeasure = rScan.m_wMeasure;
|
|
}
|
|
if (rScan.m_mtTime == mtStart)
|
|
{
|
|
pPrevious = NULL;
|
|
}
|
|
TListItem<DMCommand>* pNew = new TListItem<DMCommand>;
|
|
if (pNew)
|
|
{
|
|
DMCommand& rNew = pNew->GetItemValue();
|
|
rNew.m_mtTime = rScan.m_mtTime - mtStart;
|
|
rNew.m_wMeasure = rScan.m_wMeasure - wMeasure;
|
|
rNew.m_bBeat = rScan.m_bBeat;
|
|
rNew.m_bCommand = rScan.m_bCommand;
|
|
rNew.m_bGrooveLevel = rScan.m_bGrooveLevel;
|
|
rNew.m_bGrooveRange = rScan.m_bGrooveRange;
|
|
rNew.m_bRepeatMode = rScan.m_bRepeatMode;
|
|
m_CommandList.AddTail(pNew);
|
|
}
|
|
}
|
|
else break;
|
|
}
|
|
if (pPrevious)
|
|
{
|
|
TListItem<DMCommand>* pNew = new TListItem<DMCommand>;
|
|
if (pNew)
|
|
{
|
|
DMCommand& rNew = pNew->GetItemValue();
|
|
rNew.m_mtTime = 0;
|
|
rNew.m_wMeasure = 0;
|
|
rNew.m_bBeat = 0;
|
|
// Since embellishments are only supposed to last for a bar,
|
|
// start the new segment with a regular groove.
|
|
rNew.m_bCommand = DMUS_COMMANDT_GROOVE;
|
|
// Keep the groove level and range of the previous bar.
|
|
rNew.m_bGrooveLevel = pPrevious->GetItemValue().m_bGrooveLevel;
|
|
rNew.m_bGrooveRange = pPrevious->GetItemValue().m_bGrooveRange;
|
|
// Default to random selection of the pattern.
|
|
rNew.m_bRepeatMode = DMUS_PATTERNT_RANDOM;
|
|
m_CommandList.AddHead(pNew);
|
|
}
|
|
}
|
|
}
|
|
|
|
CCommandTrack::~CCommandTrack()
|
|
{
|
|
if (m_fCSInitialized)
|
|
{
|
|
::DeleteCriticalSection( &m_CriticalSection );
|
|
}
|
|
if (m_pNextCommand)
|
|
{
|
|
delete m_pNextCommand;
|
|
}
|
|
InterlockedDecrement(&g_cComponent);
|
|
}
|
|
|
|
void CCommandTrack::Clear()
|
|
{
|
|
m_CommandList.CleanUp();
|
|
}
|
|
|
|
|
|
STDMETHODIMP CCommandTrack::QueryInterface(
|
|
const IID &iid,
|
|
void **ppv)
|
|
{
|
|
V_INAME(CCommandTrack::QueryInterface);
|
|
V_REFGUID(iid);
|
|
V_PTRPTR_WRITE(ppv);
|
|
|
|
if (iid == IID_IUnknown || iid == IID_IDirectMusicTrack || iid == IID_IDirectMusicTrack8)
|
|
{
|
|
*ppv = static_cast<IDirectMusicTrack*>(this);
|
|
}
|
|
else if (iid == IID_IPersistStream)
|
|
{
|
|
*ppv = static_cast<IPersistStream*>(this);
|
|
}
|
|
else
|
|
{
|
|
*ppv = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
reinterpret_cast<IUnknown*>(this)->AddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CCommandTrack::AddRef()
|
|
{
|
|
return InterlockedIncrement(&m_cRef);
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(ULONG) CCommandTrack::Release()
|
|
{
|
|
if (!InterlockedDecrement(&m_cRef))
|
|
{
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_cRef;
|
|
}
|
|
|
|
|
|
// CCommandTrack Methods
|
|
HRESULT CCommandTrack::Init(
|
|
/*[in]*/ IDirectMusicSegment* pSegment
|
|
)
|
|
{
|
|
V_INAME(CCommandTrack::Init);
|
|
V_INTERFACE(pSegment);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CCommandTrack::InitPlay(
|
|
/*[in]*/ IDirectMusicSegmentState* pSegmentState,
|
|
/*[in]*/ IDirectMusicPerformance* pPerformance,
|
|
/*[out]*/ void** ppStateData,
|
|
/*[in]*/ DWORD dwTrackID,
|
|
/*[in]*/ DWORD dwFlags
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CommandStateData* pStateData;
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
pStateData = new CommandStateData;
|
|
if( NULL == pStateData )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
*pStateData = 0;
|
|
*ppStateData = pStateData;
|
|
}
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CCommandTrack::EndPlay(
|
|
/*[in]*/ void* pStateData
|
|
)
|
|
{
|
|
if( pStateData )
|
|
{
|
|
V_INAME(IDirectMusicTrack::EndPlay);
|
|
V_BUFPTR_WRITE(pStateData, sizeof(CommandStateData));
|
|
CommandStateData* pSD = (CommandStateData*)pStateData;
|
|
delete pSD;
|
|
}
|
|
if (m_pNextCommand) delete m_pNextCommand;
|
|
m_pNextCommand = NULL;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CCommandTrack::SendNotification(DWORD dwCommand,
|
|
MUSIC_TIME mtTime,
|
|
IDirectMusicPerformance* pPerf,
|
|
IDirectMusicSegmentState* pSegState,
|
|
DWORD dwFlags)
|
|
{
|
|
if (dwFlags & DMUS_TRACKF_NOTIFY_OFF)
|
|
{
|
|
return S_OK;
|
|
}
|
|
IDirectMusicSegment* pSegment = NULL;
|
|
DWORD dwOption = DMUS_NOTIFICATION_GROOVE;
|
|
if (dwCommand != DMUS_COMMANDT_GROOVE)
|
|
{
|
|
dwOption = DMUS_NOTIFICATION_EMBELLISHMENT;
|
|
}
|
|
DMUS_NOTIFICATION_PMSG* pEvent = NULL;
|
|
HRESULT hr = pPerf->AllocPMsg( sizeof(DMUS_NOTIFICATION_PMSG), (DMUS_PMSG**)&pEvent );
|
|
if( SUCCEEDED( hr ))
|
|
{
|
|
pEvent->dwField1 = 0;
|
|
pEvent->dwField2 = 0;
|
|
pEvent->dwType = DMUS_PMSGT_NOTIFICATION;
|
|
pEvent->mtTime = mtTime;
|
|
pEvent->dwFlags = DMUS_PMSGF_MUSICTIME | DMUS_PMSGF_TOOL_ATTIME;
|
|
pSegState->QueryInterface(IID_IUnknown, (void**)&pEvent->punkUser);
|
|
|
|
pEvent->dwNotificationOption = dwOption;
|
|
pEvent->guidNotificationType = GUID_NOTIFICATION_COMMAND;
|
|
|
|
if( SUCCEEDED( pSegState->GetSegment(&pSegment)))
|
|
{
|
|
if (FAILED(pSegment->GetTrackGroup(this, &pEvent->dwGroupID)))
|
|
{
|
|
pEvent->dwGroupID = 0xffffffff;
|
|
}
|
|
pSegment->Release();
|
|
}
|
|
|
|
IDirectMusicGraph* pGraph;
|
|
hr = pSegState->QueryInterface( IID_IDirectMusicGraph, (void**)&pGraph );
|
|
if( SUCCEEDED( hr ))
|
|
{
|
|
pGraph->StampPMsg((DMUS_PMSG*) pEvent );
|
|
pGraph->Release();
|
|
}
|
|
hr = pPerf->SendPMsg((DMUS_PMSG*) pEvent );
|
|
if( FAILED(hr) )
|
|
{
|
|
pPerf->FreePMsg((DMUS_PMSG*) pEvent );
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CCommandTrack::Play(
|
|
/*[in]*/ void* pStateData,
|
|
/*[in]*/ MUSIC_TIME mtStart,
|
|
/*[in]*/ MUSIC_TIME mtEnd,
|
|
/*[in]*/ MUSIC_TIME mtOffset,
|
|
DWORD dwFlags,
|
|
IDirectMusicPerformance* pPerf,
|
|
IDirectMusicSegmentState* pSegState,
|
|
DWORD dwVirtualID
|
|
)
|
|
{
|
|
bool fNotifyPastCommand = false;
|
|
TListItem<DMCommand>* pLastCommand = NULL;
|
|
// If we're seeking and not flushing, we need to notify for the command that happens
|
|
// before the current start time (if there is one)
|
|
if ( (dwFlags & DMUS_TRACKF_SEEK) && !(dwFlags & DMUS_TRACKF_FLUSH) )
|
|
{
|
|
fNotifyPastCommand = true;
|
|
}
|
|
HRESULT hr = S_OK;
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
if (m_fNotifyCommand)
|
|
{
|
|
TListItem<DMCommand>* pCommand = m_CommandList.GetHead();
|
|
for(; pCommand && SUCCEEDED(hr); pCommand = pCommand->GetNext())
|
|
{
|
|
MUSIC_TIME mtCommandTime = pCommand->GetItemValue().m_mtTime;
|
|
if (mtCommandTime < mtStart && fNotifyPastCommand)
|
|
{
|
|
pLastCommand = pCommand;
|
|
}
|
|
else if (mtStart <= mtCommandTime && mtCommandTime < mtEnd)
|
|
{
|
|
if (pLastCommand)
|
|
{
|
|
hr = SendNotification(pLastCommand->GetItemValue().m_bCommand,
|
|
mtStart + mtOffset, pPerf, pSegState, dwFlags);
|
|
pLastCommand = NULL;
|
|
}
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SendNotification(pCommand->GetItemValue().m_bCommand,
|
|
mtCommandTime + mtOffset, pPerf, pSegState, dwFlags);
|
|
}
|
|
}
|
|
else if (mtCommandTime >= mtEnd)
|
|
{
|
|
if (pLastCommand)
|
|
{
|
|
hr = SendNotification(pLastCommand->GetItemValue().m_bCommand,
|
|
mtStart + mtOffset, pPerf, pSegState, dwFlags);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CCommandTrack::GetPriority(
|
|
/*[out]*/ DWORD* pPriority
|
|
)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
// Returns the Command in effect at the measure containing mtTime.
|
|
HRESULT CCommandTrack::GetParam(
|
|
REFGUID rCommandGuid,
|
|
MUSIC_TIME mtTime,
|
|
MUSIC_TIME* pmtNext,
|
|
void *pData)
|
|
{
|
|
V_INAME(CCommandTrack::GetParam);
|
|
V_PTR_WRITE_OPT(pmtNext,MUSIC_TIME);
|
|
V_REFGUID(rCommandGuid);
|
|
|
|
if (rCommandGuid == GUID_CommandParam2)
|
|
{
|
|
return GetParam2(mtTime, pmtNext, (DMUS_COMMAND_PARAM_2*) pData);
|
|
}
|
|
else if (rCommandGuid == GUID_CommandParamNext)
|
|
{
|
|
return GetParamNext(mtTime, pmtNext, (DMUS_COMMAND_PARAM_2*) pData);
|
|
}
|
|
else if (rCommandGuid != GUID_CommandParam)
|
|
{
|
|
return DMUS_E_GET_UNSUPPORTED;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
if (pData) // Something got passed in
|
|
{
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
DMUS_COMMAND_PARAM* pCommandParam = (DMUS_COMMAND_PARAM*) pData;
|
|
// Default to the old groove C
|
|
BYTE bCommand = DMUS_COMMANDT_GROOVE;
|
|
BYTE bGrooveLevel = 62;
|
|
BYTE bGrooveRange = 0;
|
|
BYTE bRepeatMode = DMUS_PATTERNT_RANDOM;
|
|
TListItem<DMCommand>* pNext = m_CommandList.GetHead();
|
|
const int epsilon = DMUS_PPQ / 16; // leave a 64th note on either side...
|
|
for( ; pNext; pNext = pNext->GetNext())
|
|
{
|
|
if ( abs(pNext->GetItemValue().m_mtTime - mtTime) < epsilon ) // this is it
|
|
{
|
|
bCommand = pNext->GetItemValue().m_bCommand;
|
|
bGrooveLevel = pNext->GetItemValue().m_bGrooveLevel;
|
|
bGrooveRange = pNext->GetItemValue().m_bGrooveRange;
|
|
bRepeatMode = pNext->GetItemValue().m_bRepeatMode;
|
|
pNext = pNext->GetNext();
|
|
break;
|
|
}
|
|
else if (pNext->GetItemValue().m_mtTime < mtTime) // may be it, but we need a next time
|
|
{
|
|
bGrooveLevel = pNext->GetItemValue().m_bGrooveLevel;
|
|
bGrooveRange = pNext->GetItemValue().m_bGrooveRange;
|
|
bRepeatMode = pNext->GetItemValue().m_bRepeatMode;
|
|
}
|
|
else // passed it
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
hr = S_OK;
|
|
pCommandParam->bCommand = bCommand;
|
|
pCommandParam->bGrooveLevel = bGrooveLevel;
|
|
pCommandParam->bGrooveRange = bGrooveRange;
|
|
pCommandParam->bRepeatMode = bRepeatMode;
|
|
if (pmtNext)
|
|
{
|
|
if (pNext)
|
|
{
|
|
*pmtNext = pNext->GetItemValue().m_mtTime - mtTime; // RSW: bug 167740
|
|
}
|
|
else
|
|
{
|
|
MUSIC_TIME mtLength = 0;
|
|
*pmtNext = mtLength;
|
|
}
|
|
}
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return hr;
|
|
}
|
|
else
|
|
return E_POINTER;
|
|
}
|
|
|
|
HRESULT CCommandTrack::GetParam2(
|
|
MUSIC_TIME mtTime,
|
|
MUSIC_TIME* pmtNext,
|
|
DMUS_COMMAND_PARAM_2* pCommandParam)
|
|
{
|
|
//TraceI(0, "GetParam time: %d\n", mtTime);
|
|
HRESULT hr = S_OK;
|
|
if (pCommandParam) // Something got passed in
|
|
{
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
// Default to the old groove C
|
|
MUSIC_TIME mtCommandTime = 0;
|
|
BYTE bCommand = DMUS_COMMANDT_GROOVE;
|
|
BYTE bGrooveLevel = 62;
|
|
BYTE bGrooveRange = 0;
|
|
BYTE bRepeatMode = DMUS_PATTERNT_RANDOM;
|
|
TListItem<DMCommand>* pNext = m_CommandList.GetHead();
|
|
for( ; pNext; pNext = pNext->GetNext())
|
|
{
|
|
if (pNext->GetItemValue().m_mtTime <= mtTime) // may be it, but we need a next time
|
|
{
|
|
mtCommandTime = pNext->GetItemValue().m_mtTime - mtTime;
|
|
bCommand = pNext->GetItemValue().m_bCommand;
|
|
bGrooveLevel = pNext->GetItemValue().m_bGrooveLevel;
|
|
bGrooveRange = pNext->GetItemValue().m_bGrooveRange;
|
|
bRepeatMode = pNext->GetItemValue().m_bRepeatMode;
|
|
}
|
|
else // passed it
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
hr = S_OK;
|
|
pCommandParam->mtTime = mtCommandTime;
|
|
pCommandParam->bCommand = bCommand;
|
|
pCommandParam->bGrooveLevel = bGrooveLevel;
|
|
pCommandParam->bGrooveRange = bGrooveRange;
|
|
pCommandParam->bRepeatMode = bRepeatMode;
|
|
if (pmtNext)
|
|
{
|
|
if (pNext)
|
|
{
|
|
*pmtNext = pNext->GetItemValue().m_mtTime - mtTime; // RSW: bug 167740
|
|
}
|
|
else
|
|
{
|
|
*pmtNext = 0;
|
|
}
|
|
}
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return hr;
|
|
}
|
|
else
|
|
return E_POINTER;
|
|
}
|
|
|
|
HRESULT CCommandTrack::GetParamNext(
|
|
MUSIC_TIME mtTime,
|
|
MUSIC_TIME* pmtNext,
|
|
DMUS_COMMAND_PARAM_2* pCommandParam)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
if (pCommandParam) // Something got passed in
|
|
{
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
if (m_pNextCommand)
|
|
{
|
|
*pCommandParam = *m_pNextCommand;
|
|
}
|
|
else
|
|
{
|
|
hr = DMUS_E_NOT_FOUND;
|
|
/*// Default to the old groove C
|
|
pCommandParam->bCommand = DMUS_COMMANDT_GROOVE;
|
|
pCommandParam->bGrooveLevel = 62;
|
|
pCommandParam->bGrooveRange = 0;*/
|
|
}
|
|
if (pmtNext)
|
|
{
|
|
*pmtNext = 0;
|
|
}
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return hr;
|
|
}
|
|
else
|
|
return E_POINTER;
|
|
}
|
|
|
|
HRESULT CCommandTrack::SetParam(
|
|
REFGUID rCommandGuid,
|
|
MUSIC_TIME mtTime,
|
|
void __RPC_FAR *pData)
|
|
{
|
|
V_INAME(CCommandTrack::SetParam);
|
|
V_REFGUID(rCommandGuid);
|
|
|
|
if (rCommandGuid == GUID_CommandParamNext)
|
|
{
|
|
return SetParamNext(mtTime, (DMUS_COMMAND_PARAM_2*) pData);
|
|
}
|
|
else if (rCommandGuid != GUID_CommandParam)
|
|
{
|
|
return DMUS_E_SET_UNSUPPORTED;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
if (pData) // Something got passed in
|
|
{
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
DMUS_COMMAND_PARAM* pCommandParam = (DMUS_COMMAND_PARAM*) pData;
|
|
//DirectMusicTimeSig TimeSig = ((CommandData *)(pData))->m_TimeSig;
|
|
//WORD wMeasure = ClocksToMeasure(mtTime, TimeSig);
|
|
TListItem<DMCommand>* pCommand = m_CommandList.GetHead();
|
|
TListItem<DMCommand>* pPrevious = NULL;
|
|
TListItem<DMCommand>* pNew = new TListItem<DMCommand>;
|
|
if (!pNew)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
DMCommand& rNew = pNew->GetItemValue();
|
|
rNew.m_mtTime = mtTime;
|
|
rNew.m_bBeat = 0;
|
|
rNew.m_bCommand = pCommandParam->bCommand;
|
|
rNew.m_bGrooveLevel = pCommandParam->bGrooveLevel;
|
|
rNew.m_bGrooveRange = pCommandParam->bGrooveRange;
|
|
rNew.m_bRepeatMode = pCommandParam->bRepeatMode;
|
|
for (; pCommand != NULL; pCommand = pCommand->GetNext())
|
|
{
|
|
DMCommand& rCommand = pCommand->GetItemValue();
|
|
if (rCommand.m_mtTime >= mtTime) break;
|
|
pPrevious = pCommand;
|
|
}
|
|
if (pPrevious)
|
|
{
|
|
pPrevious->SetNext(pNew);
|
|
pNew->SetNext(pCommand);
|
|
}
|
|
else // pCommand is current head of list
|
|
{
|
|
m_CommandList.AddHead(pNew);
|
|
}
|
|
if (pCommand && pCommand->GetItemValue().m_mtTime == mtTime)
|
|
{
|
|
// remove it
|
|
pNew->SetNext(pCommand->GetNext());
|
|
pCommand->SetNext(NULL);
|
|
delete pCommand;
|
|
}
|
|
hr = S_OK;
|
|
}
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return hr;
|
|
}
|
|
else
|
|
return E_POINTER;
|
|
}
|
|
|
|
HRESULT CCommandTrack::SetParamNext(
|
|
MUSIC_TIME mtTime,
|
|
DMUS_COMMAND_PARAM_2* pCommandParam)
|
|
{
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
if (m_pNextCommand)
|
|
{
|
|
delete m_pNextCommand;
|
|
m_pNextCommand = NULL;
|
|
}
|
|
if (pCommandParam)
|
|
{
|
|
m_pNextCommand = new DMUS_COMMAND_PARAM_2;
|
|
if (!m_pNextCommand)
|
|
{
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
*m_pNextCommand = *pCommandParam;
|
|
}
|
|
// Otherwise, allow a null pCommandParam to act as a reset.
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return S_OK;
|
|
}
|
|
|
|
// IPersist methods
|
|
HRESULT CCommandTrack::GetClassID( LPCLSID pClassID )
|
|
{
|
|
V_INAME(CCommandTrack::GetClassID);
|
|
V_PTR_WRITE(pClassID, CLSID);
|
|
*pClassID = CLSID_DirectMusicCommandTrack;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CCommandTrack::IsParamSupported(
|
|
/*[in]*/ REFGUID rGuid
|
|
)
|
|
{
|
|
V_INAME(CCommandTrack::IsParamSupported);
|
|
V_REFGUID(rGuid);
|
|
|
|
if (rGuid == GUID_CommandParam ||
|
|
rGuid == GUID_CommandParam2 ||
|
|
rGuid == GUID_CommandParamNext)
|
|
{
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return DMUS_E_TYPE_UNSUPPORTED;
|
|
}
|
|
}
|
|
|
|
// IPersistStream methods
|
|
HRESULT CCommandTrack::IsDirty()
|
|
{
|
|
return m_bRequiresSave ? S_OK : S_FALSE;
|
|
}
|
|
|
|
HRESULT CCommandTrack::Save( LPSTREAM pStream, BOOL fClearDirty )
|
|
{
|
|
V_INAME(CCommandTrack::Save);
|
|
V_INTERFACE(pStream);
|
|
|
|
IAARIFFStream* pRIFF ;
|
|
MMCKINFO ck;
|
|
HRESULT hr;
|
|
DWORD cb;
|
|
DWORD dwSize;
|
|
DMUS_IO_COMMAND iCommand;
|
|
TListItem<DMCommand>* pCommand;
|
|
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
hr = AllocRIFFStream( pStream, &pRIFF );
|
|
if (!SUCCEEDED(hr))
|
|
{
|
|
goto ON_END;
|
|
}
|
|
hr = E_FAIL;
|
|
ck.ckid = FOURCC_COMMAND;
|
|
if( pRIFF->CreateChunk( &ck, 0 ) == 0 )
|
|
{
|
|
dwSize = sizeof( DMUS_IO_COMMAND );
|
|
hr = pStream->Write( &dwSize, sizeof( dwSize ), &cb );
|
|
if( FAILED( hr ) || cb != sizeof( dwSize ) )
|
|
{
|
|
if (SUCCEEDED(hr)) hr = E_FAIL;
|
|
goto ON_END;
|
|
}
|
|
for( pCommand = m_CommandList.GetHead(); pCommand != NULL ; pCommand = pCommand->GetNext() )
|
|
{
|
|
DMCommand& rCommand = pCommand->GetItemValue();
|
|
memset( &iCommand, 0, sizeof( iCommand ) );
|
|
iCommand.mtTime = rCommand.m_mtTime;
|
|
iCommand.wMeasure = rCommand.m_wMeasure;
|
|
iCommand.bBeat = rCommand.m_bBeat;
|
|
iCommand.bCommand = rCommand.m_bCommand;
|
|
iCommand.bGrooveLevel = rCommand.m_bGrooveLevel;
|
|
iCommand.bGrooveRange = rCommand.m_bGrooveRange;
|
|
iCommand.bRepeatMode = rCommand.m_bRepeatMode;
|
|
if( FAILED( pStream->Write( &iCommand, sizeof( iCommand ), &cb ) ) ||
|
|
cb != sizeof( iCommand ) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if( pCommand == NULL &&
|
|
pRIFF->Ascend( &ck, 0 ) == 0 )
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
ON_END:
|
|
if (pRIFF) pRIFF->Release();
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CCommandTrack::GetSizeMax( ULARGE_INTEGER* /*pcbSize*/ )
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
BOOL Greater(DMCommand& Command1, DMCommand& Command2)
|
|
{ return Command1.m_wMeasure > Command2.m_wMeasure; }
|
|
|
|
BOOL Less(DMCommand& Command1, DMCommand& Command2)
|
|
{ return Command1.m_wMeasure < Command2.m_wMeasure; }
|
|
|
|
HRESULT CCommandTrack::Load(LPSTREAM pStream )
|
|
{
|
|
V_INAME(CCommandTrack::Load);
|
|
V_INTERFACE(pStream);
|
|
|
|
long lFileSize = 0;
|
|
DWORD dwNodeSize;
|
|
DWORD cb;
|
|
MMCKINFO ck;
|
|
IAARIFFStream* pRIFF;
|
|
// FOURCC id = 0;
|
|
HRESULT hr = E_FAIL;
|
|
DMUS_IO_COMMAND iCommand;
|
|
DWORD dwPos;
|
|
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
Clear();
|
|
dwPos = StreamTell( pStream );
|
|
StreamSeek( pStream, dwPos, STREAM_SEEK_SET );
|
|
|
|
ck.ckid = FOURCC_COMMAND;
|
|
if( SUCCEEDED( AllocRIFFStream( pStream, &pRIFF ) ) &&
|
|
pRIFF->Descend( &ck, NULL, MMIO_FINDCHUNK ) == 0 )
|
|
{
|
|
lFileSize = ck.cksize;
|
|
hr = pStream->Read( &dwNodeSize, sizeof( dwNodeSize ), &cb );
|
|
if( SUCCEEDED( hr ) && cb == sizeof( dwNodeSize ) )
|
|
{
|
|
lFileSize -= 4; // for the size dword
|
|
TListItem<DMCommand>* pCommand;
|
|
if (lFileSize % dwNodeSize)
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
while( lFileSize > 0 )
|
|
{
|
|
pCommand = new TListItem<DMCommand>;
|
|
if( pCommand )
|
|
{
|
|
DMCommand& rCommand = pCommand->GetItemValue();
|
|
if( dwNodeSize <= sizeof( DMUS_IO_COMMAND ) )
|
|
{
|
|
pStream->Read( &iCommand, dwNodeSize, NULL );
|
|
}
|
|
else
|
|
{
|
|
pStream->Read( &iCommand, sizeof( DMUS_IO_COMMAND ), NULL );
|
|
StreamSeek( pStream, lFileSize - sizeof( DMUS_IO_COMMAND ), STREAM_SEEK_CUR );
|
|
}
|
|
memset( &rCommand, 0, sizeof( rCommand ) );
|
|
rCommand.m_mtTime = iCommand.mtTime;
|
|
rCommand.m_wMeasure = iCommand.wMeasure;
|
|
rCommand.m_bBeat = iCommand.bBeat;
|
|
rCommand.m_bCommand = iCommand.bCommand;
|
|
rCommand.m_bGrooveLevel = iCommand.bGrooveLevel;
|
|
if( iCommand.bGrooveRange > 100 )
|
|
{
|
|
Trace(0, "Warning: Illegal value %d read for Command's groove range.\n", iCommand.bGrooveRange);
|
|
rCommand.m_bGrooveRange = 0;
|
|
}
|
|
else
|
|
{
|
|
rCommand.m_bGrooveRange = iCommand.bGrooveRange;
|
|
}
|
|
if( iCommand.bRepeatMode > DMUS_PATTERNT_RANDOM_ROW )
|
|
{
|
|
Trace(0, "Warning: Illegal value %d read for Command's repeat mode.\n", iCommand.bRepeatMode);
|
|
rCommand.m_bRepeatMode = 0;
|
|
}
|
|
else
|
|
{
|
|
rCommand.m_bRepeatMode = iCommand.bRepeatMode;
|
|
}
|
|
m_CommandList.AddTail(pCommand);
|
|
lFileSize -= dwNodeSize;
|
|
}
|
|
else break;
|
|
}
|
|
}
|
|
}
|
|
if( lFileSize == 0 &&
|
|
pRIFF->Ascend( &ck, 0 ) == 0 )
|
|
{
|
|
hr = S_OK;
|
|
m_CommandList.MergeSort(Less);
|
|
BYTE bLastGrooveLevel = 62;
|
|
TListItem<DMCommand>* pCommand = m_CommandList.GetHead();
|
|
for(; pCommand != NULL; pCommand = pCommand->GetNext())
|
|
{
|
|
if (!pCommand->GetItemValue().m_bGrooveLevel)
|
|
{
|
|
pCommand->GetItemValue().m_bGrooveLevel = bLastGrooveLevel;
|
|
}
|
|
else
|
|
{
|
|
bLastGrooveLevel = pCommand->GetItemValue().m_bGrooveLevel;
|
|
}
|
|
}
|
|
}
|
|
pRIFF->Release();
|
|
}
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return hr;
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE CCommandTrack::AddNotificationType(
|
|
/* [in] */ REFGUID rGuidNotify)
|
|
{
|
|
V_INAME(CCommandTrack::AddNotificationType);
|
|
V_REFGUID(rGuidNotify);
|
|
|
|
if( rGuidNotify == GUID_NOTIFICATION_COMMAND )
|
|
{
|
|
m_fNotifyCommand = TRUE;
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE CCommandTrack::RemoveNotificationType(
|
|
/* [in] */ REFGUID rGuidNotify)
|
|
{
|
|
V_INAME(CCommandTrack::RemoveNotificationType);
|
|
V_REFGUID(rGuidNotify);
|
|
|
|
if( rGuidNotify == GUID_NOTIFICATION_COMMAND )
|
|
{
|
|
m_fNotifyCommand = FALSE;
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
}
|
|
|
|
HRESULT STDMETHODCALLTYPE CCommandTrack::Clone(
|
|
MUSIC_TIME mtStart,
|
|
MUSIC_TIME mtEnd,
|
|
IDirectMusicTrack** ppTrack)
|
|
{
|
|
V_INAME(CCommandTrack::Clone);
|
|
V_PTRPTR_WRITE(ppTrack);
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(mtStart < 0 )
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
if(mtStart > mtEnd)
|
|
{
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
EnterCriticalSection( &m_CriticalSection );
|
|
CCommandTrack *pDM;
|
|
try
|
|
{
|
|
pDM = new CCommandTrack(*this, mtStart, mtEnd);
|
|
}
|
|
catch( ... )
|
|
{
|
|
pDM = NULL;
|
|
}
|
|
|
|
if (pDM == NULL) {
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
hr = pDM->QueryInterface(IID_IDirectMusicTrack, (void**)ppTrack);
|
|
pDM->Release();
|
|
|
|
LeaveCriticalSection( &m_CriticalSection );
|
|
return hr;
|
|
}
|
|
|
|
// For consistency with other track types
|
|
STDMETHODIMP CCommandTrack::GetParamEx(REFGUID rguidType,REFERENCE_TIME rtTime,
|
|
REFERENCE_TIME* prtNext,void* pParam,void * pStateData, DWORD dwFlags)
|
|
{
|
|
HRESULT hr;
|
|
MUSIC_TIME mtNext;
|
|
hr = GetParam(rguidType,(MUSIC_TIME) rtTime, &mtNext, pParam);
|
|
if (prtNext)
|
|
{
|
|
*prtNext = mtNext;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// For consistency with other track types
|
|
STDMETHODIMP CCommandTrack::SetParamEx(REFGUID rguidType,REFERENCE_TIME rtTime,
|
|
void* pParam, void * pStateData, DWORD dwFlags)
|
|
{
|
|
return SetParam(rguidType, (MUSIC_TIME) rtTime , pParam);
|
|
}
|
|
|
|
// For consistency with other track types
|
|
STDMETHODIMP CCommandTrack::PlayEx(void* pStateData,REFERENCE_TIME rtStart,
|
|
REFERENCE_TIME rtEnd,REFERENCE_TIME rtOffset,
|
|
DWORD dwFlags,IDirectMusicPerformance* pPerf,
|
|
IDirectMusicSegmentState* pSegSt,DWORD dwVirtualID)
|
|
{
|
|
V_INAME(IDirectMusicTrack::PlayEx);
|
|
V_INTERFACE(pPerf);
|
|
V_INTERFACE(pSegSt);
|
|
|
|
HRESULT hr;
|
|
EnterCriticalSection(&m_CriticalSection);
|
|
hr = Play(pStateData, (MUSIC_TIME)rtStart, (MUSIC_TIME)rtEnd,
|
|
(MUSIC_TIME)rtOffset, dwFlags, pPerf, pSegSt, dwVirtualID);
|
|
LeaveCriticalSection(&m_CriticalSection);
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CCommandTrack::Compose(
|
|
IUnknown* pContext,
|
|
DWORD dwTrackGroup,
|
|
IDirectMusicTrack** ppResultTrack)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP CCommandTrack::Join(
|
|
IDirectMusicTrack* pNewTrack,
|
|
MUSIC_TIME mtJoin,
|
|
IUnknown* pContext,
|
|
DWORD dwTrackGroup,
|
|
IDirectMusicTrack** ppResultTrack)
|
|
{
|
|
V_INAME(IDirectMusicTrack::Join);
|
|
V_INTERFACE(pNewTrack);
|
|
V_INTERFACE(pContext);
|
|
V_PTRPTR_WRITE_OPT(ppResultTrack);
|
|
|
|
HRESULT hr = S_OK;
|
|
EnterCriticalSection(&m_CriticalSection);
|
|
TList<DMCommand> ResultList;
|
|
CCommandTrack* pResultTrack = NULL;
|
|
if (ppResultTrack)
|
|
{
|
|
hr = Clone(0, mtJoin, ppResultTrack);
|
|
pResultTrack = (CCommandTrack*)*ppResultTrack;
|
|
while(!pResultTrack->m_CommandList.IsEmpty())
|
|
{
|
|
ResultList.AddHead(pResultTrack->m_CommandList.RemoveHead());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pResultTrack = this;
|
|
while(!m_CommandList.IsEmpty() &&
|
|
m_CommandList.GetHead()->GetItemValue().m_mtTime < mtJoin)
|
|
{
|
|
ResultList.AddHead(m_CommandList.RemoveHead());
|
|
}
|
|
m_CommandList.CleanUp();
|
|
}
|
|
WORD wMeasure = 0;
|
|
HRESULT hrTimeSig = S_OK;
|
|
MUSIC_TIME mtTimeSig = 0;
|
|
MUSIC_TIME mtOver = 0;
|
|
IDirectMusicSong* pSong = NULL;
|
|
IDirectMusicSegment* pSegment = NULL;
|
|
if (FAILED(pContext->QueryInterface(IID_IDirectMusicSegment, (void**)&pSegment)))
|
|
{
|
|
if (FAILED(pContext->QueryInterface(IID_IDirectMusicSong, (void**)&pSong)))
|
|
{
|
|
hrTimeSig = E_FAIL;
|
|
}
|
|
}
|
|
while (SUCCEEDED(hrTimeSig) && mtTimeSig < mtJoin)
|
|
{
|
|
DMUS_TIMESIGNATURE TimeSig;
|
|
MUSIC_TIME mtNext = 0;
|
|
if (pSegment)
|
|
{
|
|
hrTimeSig = pSegment->GetParam(GUID_TimeSignature, dwTrackGroup, 0, mtTimeSig, &mtNext, (void*)&TimeSig);
|
|
}
|
|
else
|
|
{
|
|
hrTimeSig = pSong->GetParam(GUID_TimeSignature, dwTrackGroup, 0, mtTimeSig, &mtNext, (void*)&TimeSig);
|
|
}
|
|
if (SUCCEEDED(hrTimeSig))
|
|
{
|
|
if (!mtNext) mtNext = mtJoin - mtTimeSig; // means no more time sigs
|
|
DirectMusicTimeSig DMTimeSig = TimeSig;
|
|
WORD wMeasureOffset = (WORD)DMTimeSig.ClocksToMeasure(mtNext + mtOver);
|
|
MUSIC_TIME mtMeasureOffset = (MUSIC_TIME) wMeasureOffset;
|
|
// The following line crashes on certain builds on certain machines.
|
|
// mtOver = mtMeasureOffset ? (mtNext % mtMeasureOffset) : 0;
|
|
if (mtMeasureOffset)
|
|
{
|
|
mtOver = mtNext % mtMeasureOffset;
|
|
}
|
|
else
|
|
{
|
|
mtOver = 0;
|
|
}
|
|
wMeasure += wMeasureOffset;
|
|
mtTimeSig += mtNext;
|
|
}
|
|
}
|
|
CCommandTrack* pOtherTrack = (CCommandTrack*)pNewTrack;
|
|
TListItem<DMCommand>* pScan = pOtherTrack->m_CommandList.GetHead();
|
|
for (; pScan; pScan = pScan->GetNext())
|
|
{
|
|
TListItem<DMCommand>* pNew = new TListItem<DMCommand>(pScan->GetItemValue());
|
|
if (pNew)
|
|
{
|
|
pNew->GetItemValue().m_mtTime += mtJoin;
|
|
pNew->GetItemValue().m_wMeasure += wMeasure;
|
|
ResultList.AddHead(pNew);
|
|
}
|
|
else
|
|
{
|
|
ResultList.CleanUp();
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
}
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pResultTrack->m_CommandList.CleanUp();
|
|
while(!ResultList.IsEmpty() )
|
|
{
|
|
pResultTrack->m_CommandList.AddHead(ResultList.RemoveHead());
|
|
}
|
|
}
|
|
if (pSong) pSong->Release();
|
|
if (pSegment) pSegment->Release();
|
|
LeaveCriticalSection(&m_CriticalSection);
|
|
return hr;
|
|
}
|
|
|