archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/multimedia/directx/dmusic/dmscript/dmscript.cpp

1161 lines
38 KiB
Raw Permalink Blame History

//
// Copyright (c) 1999-2001 Microsoft Corporation. All rights reserved.
//
// Implementation of CDirectMusicScript.
//
#include "stdinc.h"
#include "dll.h"
#include "dmscript.h"
#include "oleaut.h"
#include "globaldisp.h"
#include "activescript.h"
#include "sourcetext.h"
//////////////////////////////////////////////////////////////////////
// Creation
CDirectMusicScript::CDirectMusicScript()
: m_cRef(0),
m_fZombie(false),
m_fCriticalSectionInitialized(false),
m_pPerformance8(NULL),
m_pLoader8P(NULL),
m_pDispPerformance(NULL),
m_pComposer8(NULL),
m_fUseOleAut(true),
m_pScriptManager(NULL),
m_pContainerDispatch(NULL),
m_pGlobalDispatch(NULL),
m_fInitError(false)
{
LockModule(true);
InitializeCriticalSection(&m_CriticalSection);
// Note: on pre-Blackcomb OS's, this call can raise an exception; if it
// ever pops in stress, we can add an exception handler and retry loop.
m_fCriticalSectionInitialized = TRUE;
m_info.fLoaded = false;
m_vDirectMusicVersion.dwVersionMS = 0;
m_vDirectMusicVersion.dwVersionLS = 0;
Zero(&m_iohead);
ZeroAndSize(&m_InitErrorInfo);
}
void CDirectMusicScript::ReleaseObjects()
{
if (m_pScriptManager)
{
m_pScriptManager->Close();
SafeRelease(m_pScriptManager);
}
SafeRelease(m_pPerformance8);
SafeRelease(m_pDispPerformance);
if (m_pLoader8P)
{
m_pLoader8P->ReleaseP();
m_pLoader8P = NULL;
}
SafeRelease(m_pComposer8);
delete m_pContainerDispatch;
m_pContainerDispatch = NULL;
delete m_pGlobalDispatch;
m_pGlobalDispatch = NULL;
}
HRESULT CDirectMusicScript::CreateInstance(
IUnknown* pUnknownOuter,
const IID& iid,
void** ppv)
{
*ppv = NULL;
if (pUnknownOuter)
return CLASS_E_NOAGGREGATION;
CDirectMusicScript *pInst = new CDirectMusicScript;
if (pInst == NULL)
return E_OUTOFMEMORY;
return pInst->QueryInterface(iid, ppv);
}
//////////////////////////////////////////////////////////////////////
// IUnknown
STDMETHODIMP
CDirectMusicScript::QueryInterface(const IID &iid, void **ppv)
{
V_INAME(CDirectMusicScript::QueryInterface);
V_PTRPTR_WRITE(ppv);
V_REFGUID(iid);
if (iid == IID_IUnknown || iid == IID_IDirectMusicScript)
{
*ppv = static_cast<IDirectMusicScript*>(this);
}
else if (iid == IID_IDirectMusicScriptPrivate)
{
*ppv = static_cast<IDirectMusicScriptPrivate*>(this);
}
else if (iid == IID_IDirectMusicObject)
{
*ppv = static_cast<IDirectMusicObject*>(this);
}
else if (iid == IID_IDirectMusicObjectP)
{
*ppv = static_cast<IDirectMusicObjectP*>(this);
}
else if (iid == IID_IPersistStream)
{
*ppv = static_cast<IPersistStream*>(this);
}
else if (iid == IID_IPersist)
{
*ppv = static_cast<IPersist*>(this);
}
else if (iid == IID_IDispatch)
{
*ppv = static_cast<IDispatch*>(this);
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
reinterpret_cast<IUnknown*>(this)->AddRef();
return S_OK;
}
STDMETHODIMP_(ULONG)
CDirectMusicScript::AddRef()
{
return InterlockedIncrement(&m_cRef);
}
STDMETHODIMP_(ULONG)
CDirectMusicScript::Release()
{
if (!InterlockedDecrement(&m_cRef))
{
this->Zombie();
DeleteCriticalSection(&m_CriticalSection);
delete this;
LockModule(false);
return 0;
}
return m_cRef;
}
//////////////////////////////////////////////////////////////////////
// IPersistStream
STDMETHODIMP
CDirectMusicScript::Load(IStream* pStream)
{
V_INAME(CDirectMusicScript::Load);
V_INTERFACE(pStream);
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::Load after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
HRESULT hr = S_OK;
SmartRef::CritSec CS(&m_CriticalSection);
// Clear any old info
this->ReleaseObjects();
m_info.fLoaded = false;
m_info.oinfo.Clear();
m_vDirectMusicVersion.dwVersionMS = 0;
m_vDirectMusicVersion.dwVersionLS = 0;
m_wstrLanguage = NULL;
m_fInitError = false;
// Get the loader from stream
IDirectMusicGetLoader *pIDMGetLoader = NULL;
SmartRef::ComPtr<IDirectMusicLoader> scomLoader;
hr = pStream->QueryInterface(IID_IDirectMusicGetLoader, reinterpret_cast<void **>(&pIDMGetLoader));
if (FAILED(hr))
{
Trace(1, "Error: unable to load script from a stream because it doesn't support the IDirectMusicGetLoader interface.\n");
return DMUS_E_UNSUPPORTED_STREAM;
}
hr = pIDMGetLoader->GetLoader(&scomLoader);
pIDMGetLoader->Release();
if (FAILED(hr))
return hr;
hr = scomLoader->QueryInterface(IID_IDirectMusicLoader8P, reinterpret_cast<void **>(&m_pLoader8P)); // OK if this fails -- just means the scripts won't be garbage collected
if (SUCCEEDED(hr))
{
// Hold only a private ref on the loader. See IDirectMusicLoader8P::AddRefP for more info.
m_pLoader8P->AddRefP();
m_pLoader8P->Release(); // offset the QI
}
// Read the script's header information
SmartRef::RiffIter riForm(pStream);
if (!riForm)
{
#ifdef DBG
if (SUCCEEDED(riForm.hr()))
{
Trace(1, "Error: Unable to load script: Unexpected end of file.\n");
}
#endif
return SUCCEEDED(riForm.hr()) ? DMUS_E_SCRIPT_INVALID_FILE : riForm.hr();
}
hr = riForm.FindRequired(SmartRef::RiffIter::Riff, DMUS_FOURCC_SCRIPT_FORM, DMUS_E_SCRIPT_INVALID_FILE);
if (FAILED(hr))
{
#ifdef DBG
if (hr == DMUS_E_SCRIPT_INVALID_FILE)
{
Trace(1, "Error: Unable to load script: Form 'DMSC' not found.\n");
}
#endif
return hr;
}
SmartRef::RiffIter ri = riForm.Descend();
if (!ri)
return ri.hr();
hr = ri.FindRequired(SmartRef::RiffIter::Chunk, DMUS_FOURCC_SCRIPT_CHUNK, DMUS_E_SCRIPT_INVALID_FILE);
if (FAILED(hr))
{
#ifdef DBG
if (hr == DMUS_E_SCRIPT_INVALID_FILE)
{
Trace(1, "Error: Unable to load script: Chunk 'schd' not found.\n");
}
#endif
return hr;
}
hr = SmartRef::RiffIterReadChunk(ri, &m_iohead);
if (FAILED(hr))
return hr;
hr = ri.LoadObjectInfo(&m_info.oinfo, SmartRef::RiffIter::Chunk, DMUS_FOURCC_SCRIPTVERSION_CHUNK);
if (FAILED(hr))
return hr;
hr = SmartRef::RiffIterReadChunk(ri, &m_vDirectMusicVersion);
if (FAILED(hr))
return hr;
// Read the script's embedded container
IDirectMusicContainer *pContainer = NULL;
hr = ri.FindAndGetEmbeddedObject(
SmartRef::RiffIter::Riff,
DMUS_FOURCC_CONTAINER_FORM,
DMUS_E_SCRIPT_INVALID_FILE,
scomLoader,
CLSID_DirectMusicContainer,
IID_IDirectMusicContainer,
reinterpret_cast<void**>(&pContainer));
if (FAILED(hr))
{
#ifdef DBG
if (hr == DMUS_E_SCRIPT_INVALID_FILE)
{
Trace(1, "Error: Unable to load script: Form 'DMCN' no found.\n");
}
#endif
return hr;
}
// Build the container object that will represent the items in the container to the script
m_pContainerDispatch = new CContainerDispatch(pContainer, scomLoader, m_iohead.dwFlags, &hr);
pContainer->Release();
if (!m_pContainerDispatch)
return E_OUTOFMEMORY;
if (FAILED(hr))
return hr;
// Create the global dispatch object
m_pGlobalDispatch = new CGlobalDispatch(this);
if (!m_pGlobalDispatch)
return E_OUTOFMEMORY;
// Get the script's language
hr = ri.FindRequired(SmartRef::RiffIter::Chunk, DMUS_FOURCC_SCRIPTLANGUAGE_CHUNK, DMUS_E_SCRIPT_INVALID_FILE);
if (FAILED(hr))
{
#ifdef DBG
if (hr == DMUS_E_SCRIPT_INVALID_FILE)
{
Trace(1, "Error: Unable to load script: Chunk 'scla' no found.\n");
}
#endif
return hr;
}
hr = ri.ReadText(&m_wstrLanguage);
if (FAILED(hr))
{
#ifdef DBG
if (hr == E_FAIL)
{
Trace(1, "Error: Unable to load script: Problem reading 'scla' chunk.\n");
}
#endif
return hr == E_FAIL ? DMUS_E_SCRIPT_INVALID_FILE : hr;
}
// Get the script's source code
SmartRef::WString wstrSource;
for (++ri; ;++ri)
{
if (!ri)
{
Trace(1, "Error: Unable to load script: Expected chunk 'scsr' or list 'DMRF'.\n");
return DMUS_E_SCRIPT_INVALID_FILE;
}
SmartRef::RiffIter::RiffType type = ri.type();
FOURCC id = ri.id();
if (type == SmartRef::RiffIter::Chunk)
{
if (id == DMUS_FOURCC_SCRIPTSOURCE_CHUNK)
{
hr = ri.ReadText(&wstrSource);
if (FAILED(hr))
{
#ifdef DBG
if (hr == E_FAIL)
{
Trace(1, "Error: Unable to load script: Problem reading 'scsr' chunk.\n");
}
#endif
return hr == E_FAIL ? DMUS_E_SCRIPT_INVALID_FILE : hr;
}
}
break;
}
else if (type == SmartRef::RiffIter::List)
{
if (id == DMUS_FOURCC_REF_LIST)
{
DMUS_OBJECTDESC desc;
hr = ri.ReadReference(&desc);
if (FAILED(hr))
return hr;
// The resulting desc shouldn't have a name or GUID (the plain text file can't hold name/GUID info)
// and it should have a clsid should be GUID_NULL, which we'll replace with the clsid of our private
// source helper object.
if (desc.dwValidData & (DMUS_OBJ_NAME | DMUS_OBJ_OBJECT) ||
!(desc.dwValidData & DMUS_OBJ_CLASS) || desc.guidClass != GUID_NULL)
{
#ifdef DBG
if (desc.dwValidData & (DMUS_OBJ_NAME | DMUS_OBJ_OBJECT))
{
Trace(1, "Error: Unable to load script: 'DMRF' list must have dwValidData with DMUS_OBJ_CLASS and guidClassID of GUID_NULL.\n");
}
else
{
Trace(1, "Error: Unable to load script: 'DMRF' list cannot have dwValidData with DMUS_OBJ_NAME or DMUS_OBJ_OBJECT.\n");
}
#endif
return DMUS_E_SCRIPT_INVALID_FILE;
}
desc.guidClass = CLSID_DirectMusicSourceText;
IDirectMusicSourceText *pISource = NULL;
hr = scomLoader->EnableCache(CLSID_DirectMusicSourceText, false); // This is a private object we just use temporarily. Don't want these guys hanging around in the cache.
if (FAILED(hr))
return hr;
hr = scomLoader->GetObject(&desc, IID_IDirectMusicSourceText, reinterpret_cast<void**>(&pISource));
if (FAILED(hr))
return hr;
DWORD cwchSourceBufferSize = 0;
pISource->GetTextLength(&cwchSourceBufferSize);
WCHAR *pwszSource = new WCHAR[cwchSourceBufferSize];
if (!pwszSource)
return E_OUTOFMEMORY;
pISource->GetText(pwszSource);
*&wstrSource = pwszSource;
pISource->Release();
}
break;
}
}
m_info.fLoaded = true;
// Now that we are loaded and initialized, we can start active scripting
// See if we're dealing with a custom DirectMusic scripting engine. Such engines are marked with the key DMScript. They can be
// called on multiple threads and they don't use oleaut32. Ordinary active scripting engines are marked with the key OLEScript.
SmartRef::HKey shkeyLanguage;
SmartRef::HKey shkeyMark;
SmartRef::AString astrLanguage = m_wstrLanguage;
if (ERROR_SUCCESS != ::RegOpenKeyEx(HKEY_CLASSES_ROOT, astrLanguage, 0, KEY_QUERY_VALUE, &shkeyLanguage) || !shkeyLanguage)
{
Trace(1, "Error: Unable to load script: Scripting engine for language %s does not exist or is not registered.\n", astrLanguage);
return DMUS_E_SCRIPT_LANGUAGE_INCOMPATIBLE;
}
bool fCustomScriptEngine = ERROR_SUCCESS == ::RegOpenKeyEx(shkeyLanguage, "DMScript", 0, KEY_QUERY_VALUE, &shkeyMark) && shkeyMark;
if (!fCustomScriptEngine)
{
if (ERROR_SUCCESS != ::RegOpenKeyEx(shkeyLanguage, "OLEScript", 0, KEY_QUERY_VALUE, &shkeyMark) || !shkeyMark)
{
Trace(1, "Error: Unable to load script: Language %s refers to a COM object that is not registered as a scripting engine (OLEScript key).\n", astrLanguage);
return DMUS_E_SCRIPT_LANGUAGE_INCOMPATIBLE;
}
}
m_fUseOleAut = !fCustomScriptEngine;
if (fCustomScriptEngine)
{
m_pScriptManager = new CActiveScriptManager(
m_fUseOleAut,
m_wstrLanguage,
wstrSource,
this,
&hr,
&m_InitErrorInfo);
}
else
{
m_pScriptManager = new CSingleThreadedScriptManager(
m_fUseOleAut,
m_wstrLanguage,
wstrSource,
this,
&hr,
&m_InitErrorInfo);
}
if (!m_pScriptManager)
return E_OUTOFMEMORY;
if (FAILED(hr))
{
SafeRelease(m_pScriptManager);
}
if (hr == DMUS_E_SCRIPT_ERROR_IN_SCRIPT)
{
// If we fail here, load would fail and client would never be able to get the
// error information. Instead, return S_OK and save the error to return from Init.
m_fInitError = true;
hr = S_OK;
}
return hr;
}
//////////////////////////////////////////////////////////////////////
// IDirectMusicObject
STDMETHODIMP
CDirectMusicScript::GetDescriptor(LPDMUS_OBJECTDESC pDesc)
{
V_INAME(CDirectMusicScript::GetDescriptor);
V_PTR_WRITE(pDesc, DMUS_OBJECTDESC);
ZeroMemory(pDesc, sizeof(DMUS_OBJECTDESC));
pDesc->dwSize = sizeof(DMUS_OBJECTDESC);
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::GetDescriptor after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
if (wcslen(m_info.oinfo.wszName) > 0)
{
pDesc->dwValidData |= DMUS_OBJ_NAME;
wcsncpy(pDesc->wszName, m_info.oinfo.wszName, DMUS_MAX_NAME);
pDesc->wszName[DMUS_MAX_NAME-1] = L'\0';
}
if (GUID_NULL != m_info.oinfo.guid)
{
pDesc->guidObject = m_info.oinfo.guid;
pDesc->dwValidData |= DMUS_OBJ_OBJECT;
}
pDesc->vVersion = m_info.oinfo.vVersion;
pDesc->dwValidData |= DMUS_OBJ_VERSION;
pDesc->guidClass = CLSID_DirectMusicScript;
pDesc->dwValidData |= DMUS_OBJ_CLASS;
if (m_info.wstrFilename)
{
wcsncpy(pDesc->wszFileName, m_info.wstrFilename, DMUS_MAX_FILENAME);
pDesc->wszFileName[DMUS_MAX_FILENAME-1] = L'\0';
pDesc->dwValidData |= DMUS_OBJ_FILENAME;
}
if (m_info.fLoaded)
{
pDesc->dwValidData |= DMUS_OBJ_LOADED;
}
return S_OK;
}
STDMETHODIMP
CDirectMusicScript::SetDescriptor(LPDMUS_OBJECTDESC pDesc)
{
V_INAME(CDirectMusicScript::SetDescriptor);
V_STRUCTPTR_READ(pDesc, DMUS_OBJECTDESC);
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::SetDescriptor after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
DWORD dwTemp = pDesc->dwValidData;
if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
{
m_info.oinfo.guid = pDesc->guidObject;
}
if (pDesc->dwValidData & DMUS_OBJ_CLASS)
{
pDesc->dwValidData &= ~DMUS_OBJ_CLASS;
}
if (pDesc->dwValidData & DMUS_OBJ_NAME)
{
wcsncpy(m_info.oinfo.wszName, pDesc->wszName, DMUS_MAX_NAME);
m_info.oinfo.wszName[DMUS_MAX_NAME-1] = L'\0';
}
if (pDesc->dwValidData & DMUS_OBJ_CATEGORY)
{
pDesc->dwValidData &= ~DMUS_OBJ_CATEGORY;
}
if (pDesc->dwValidData & DMUS_OBJ_FILENAME)
{
m_info.wstrFilename = pDesc->wszFileName;
}
if (pDesc->dwValidData & DMUS_OBJ_FULLPATH)
{
pDesc->dwValidData &= ~DMUS_OBJ_FULLPATH;
}
if (pDesc->dwValidData & DMUS_OBJ_URL)
{
pDesc->dwValidData &= ~DMUS_OBJ_URL;
}
if (pDesc->dwValidData & DMUS_OBJ_VERSION)
{
m_info.oinfo.vVersion = pDesc->vVersion;
}
if (pDesc->dwValidData & DMUS_OBJ_DATE)
{
pDesc->dwValidData &= ~DMUS_OBJ_DATE;
}
if (pDesc->dwValidData & DMUS_OBJ_LOADED)
{
pDesc->dwValidData &= ~DMUS_OBJ_LOADED;
}
return dwTemp == pDesc->dwValidData ? S_OK : S_FALSE;
}
STDMETHODIMP
CDirectMusicScript::ParseDescriptor(LPSTREAM pStream, LPDMUS_OBJECTDESC pDesc)
{
V_INAME(CDirectMusicScript::ParseDescriptor);
V_INTERFACE(pStream);
V_PTR_WRITE(pDesc, DMUS_OBJECTDESC);
ZeroMemory(pDesc, sizeof(DMUS_OBJECTDESC));
pDesc->dwSize = sizeof(DMUS_OBJECTDESC);
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::ParseDescriptor after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
SmartRef::CritSec CS(&m_CriticalSection);
// Read the script's header information
SmartRef::RiffIter riForm(pStream);
if (!riForm)
{
#ifdef DBG
if (SUCCEEDED(riForm.hr()))
{
Trace(2, "Error: ParseDescriptor on a script failed: Unexpected end of file. "
"(Note that this may be OK, such as when ScanDirectory is used to parse a set of unknown files, some of which are not scripts.)\n");
}
#endif
return SUCCEEDED(riForm.hr()) ? DMUS_E_SCRIPT_INVALID_FILE : riForm.hr();
}
HRESULT hr = riForm.FindRequired(SmartRef::RiffIter::Riff, DMUS_FOURCC_SCRIPT_FORM, DMUS_E_SCRIPT_INVALID_FILE);
if (FAILED(hr))
{
#ifdef DBG
if (hr == DMUS_E_SCRIPT_INVALID_FILE)
{
Trace(1, "Error: ParseDescriptor on a script failed: Form 'DMSC' not found. "
"(Note that this may be OK, such as when ScanDirectory is used to parse a set of unknown files, some of which are not scripts.)\n");
}
#endif
return hr;
}
SmartRef::RiffIter ri = riForm.Descend();
if (!ri)
return ri.hr();
hr = ri.LoadObjectInfo(&m_info.oinfo, SmartRef::RiffIter::Chunk, DMUS_FOURCC_SCRIPTVERSION_CHUNK);
if (FAILED(hr))
return hr;
hr = this->GetDescriptor(pDesc);
return hr;
}
STDMETHODIMP_(void)
CDirectMusicScript::Zombie()
{
m_fZombie = true;
this->ReleaseObjects();
}
//////////////////////////////////////////////////////////////////////
// IDirectMusicScript
STDMETHODIMP
CDirectMusicScript::Init(IDirectMusicPerformance *pPerformance, DMUS_SCRIPT_ERRORINFO *pErrorInfo)
{
V_INAME(CDirectMusicScript::Init);
V_INTERFACE(pPerformance);
V_PTR_WRITE_OPT(pErrorInfo, DMUS_SCRIPT_ERRORINFO);
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::Init after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
SmartRef::ComPtr<IDirectMusicPerformance8> scomPerformance8;
HRESULT hr = pPerformance->QueryInterface(IID_IDirectMusicPerformance8, reinterpret_cast<void **>(&scomPerformance8));
if (FAILED(hr))
return hr;
// Don't take the critical section if the script is already initialized.
// For example, this is necessary in the following situation:
// - The critical section has already been taken by CallRoutine.
// - The routine played a segment with a script track referencing this script.
// - The script track calls Init (from a different thread) to make sure the script
// is initialized.
if (m_pPerformance8)
{
// Additional calls to Init are ignored.
// First call wins. Return S_FALSE if performance doesn't match.
if (m_pPerformance8 == scomPerformance8)
return S_OK;
else
return S_FALSE;
}
SmartRef::CritSec CS(&m_CriticalSection);
if (m_fInitError)
{
if (pErrorInfo)
{
// Syntax errors in a script occur as it is loaded, before SetDescriptor gives a script
// its filename. We'll have it after the load (before init is called) so can add it
// back in here.
if (m_InitErrorInfo.wszSourceFile[0] == L'\0' && m_info.wstrFilename)
wcsTruncatedCopy(m_InitErrorInfo.wszSourceFile, m_info.wstrFilename, DMUS_MAX_FILENAME);
CopySizedStruct(pErrorInfo, &m_InitErrorInfo);
}
return DMUS_E_SCRIPT_ERROR_IN_SCRIPT;
}
if (!m_info.fLoaded)
{
Trace(1, "Error: IDirectMusicScript::Init called before the script has been loaded.\n");
return DMUS_E_NOT_LOADED;
}
// Get the dispatch interface for the performance
SmartRef::ComPtr<IDispatch> scomDispPerformance = NULL;
hr = pPerformance->QueryInterface(IID_IDispatch, reinterpret_cast<void **>(&scomDispPerformance));
if (FAILED(hr))
return hr;
// Get a composer object
hr = CoCreateInstance(CLSID_DirectMusicComposer, NULL, CLSCTX_INPROC_SERVER, IID_IDirectMusicComposer8, reinterpret_cast<void **>(&m_pComposer8));
if (FAILED(hr))
return hr;
m_pDispPerformance = scomDispPerformance.disown();
m_pPerformance8 = scomPerformance8.disown();
hr = m_pScriptManager->Start(pErrorInfo);
if (FAILED(hr))
return hr;
hr = m_pContainerDispatch->OnScriptInit(m_pPerformance8);
return hr;
}
// Returns DMUS_E_SCRIPT_ROUTINE_NOT_FOUND if routine doesn't exist in the script.
STDMETHODIMP
CDirectMusicScript::CallRoutine(WCHAR *pwszRoutineName, DMUS_SCRIPT_ERRORINFO *pErrorInfo)
{
V_INAME(CDirectMusicScript::CallRoutine);
V_BUFPTR_READ(pwszRoutineName, 2);
V_PTR_WRITE_OPT(pErrorInfo, DMUS_SCRIPT_ERRORINFO);
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::CallRoutine after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
SmartRef::CritSec CS(&m_CriticalSection);
if (!m_pScriptManager || !m_pPerformance8)
{
Trace(1, "Error: IDirectMusicScript::Init must be called before IDirectMusicScript::CallRoutine.\n");
return DMUS_E_NOT_INIT;
}
return m_pScriptManager->CallRoutine(pwszRoutineName, pErrorInfo);
}
// Returns DMUS_E_SCRIPT_VARIABLE_NOT_FOUND if variable doesn't exist in the script.
STDMETHODIMP
CDirectMusicScript::SetVariableVariant(
WCHAR *pwszVariableName,
VARIANT varValue,
BOOL fSetRef,
DMUS_SCRIPT_ERRORINFO *pErrorInfo)
{
V_INAME(CDirectMusicScript::SetVariableVariant);
V_BUFPTR_READ(pwszVariableName, 2);
V_PTR_WRITE_OPT(pErrorInfo, DMUS_SCRIPT_ERRORINFO);
switch (varValue.vt)
{
case VT_BSTR:
V_BUFPTR_READ_OPT(varValue.bstrVal, sizeof(OLECHAR));
// We could be more thorough and verify each character until we hit the terminator but
// that would be inefficient. We could also use the length preceding a BSTR pointer,
// but that would be cheating COM's functions that encapsulate BSTRs and could lead to
// problems in future versions of windows such as 64 bit if the BSTR format changes.
break;
case VT_UNKNOWN:
V_INTERFACE_OPT(varValue.punkVal);
break;
case VT_DISPATCH:
V_INTERFACE_OPT(varValue.pdispVal);
break;
}
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::SetVariableObject/SetVariableNumber/SetVariableVariant after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
SmartRef::CritSec CS(&m_CriticalSection);
if (!m_pScriptManager || !m_pPerformance8)
{
Trace(1, "Error: IDirectMusicScript::Init must be called before IDirectMusicScript::SetVariableVariant.\n");
return DMUS_E_NOT_INIT;
}
HRESULT hr = m_pScriptManager->SetVariable(pwszVariableName, varValue, !!fSetRef, pErrorInfo);
if (hr == DMUS_E_SCRIPT_VARIABLE_NOT_FOUND)
{
// There are also items in the script's container that the m_pScriptManager object isn't available.
// If that's the case, we should return a more specific error message.
IUnknown *punk = NULL;
hr = m_pContainerDispatch->GetVariableObject(pwszVariableName, &punk);
if (SUCCEEDED(hr))
{
// We don't actually need the object--it can't be set. Just needed to find out if it's there
// in order to return a more specific error message.
punk->Release();
return DMUS_E_SCRIPT_CONTENT_READONLY;
}
}
return hr;
}
// Returns DMUS_E_SCRIPT_VARIABLE_NOT_FOUND and empty value if variable doesn't exist in the script.
// Certain varient types such as BSTRs and interface pointers must be freed/released according to the standards for VARIANTS.
// If unsure, use VariantClear (requires oleaut32).
STDMETHODIMP
CDirectMusicScript::GetVariableVariant(WCHAR *pwszVariableName, VARIANT *pvarValue, DMUS_SCRIPT_ERRORINFO *pErrorInfo)
{
V_INAME(CDirectMusicScript::GetVariableVariant);
V_BUFPTR_READ(pwszVariableName, 2);
V_PTR_WRITE(pvarValue, VARIANT);
V_PTR_WRITE_OPT(pErrorInfo, DMUS_SCRIPT_ERRORINFO);
DMS_VariantInit(m_fUseOleAut, pvarValue);
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::GetVariableObject/GetVariableNumber/GetVariableVariant after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
SmartRef::CritSec CS(&m_CriticalSection);
if (!m_pScriptManager || !m_pPerformance8)
{
Trace(1, "Error: IDirectMusicScript::Init must be called before IDirectMusicScript::GetVariableVariant.\n");
return DMUS_E_NOT_INIT;
}
HRESULT hr = m_pScriptManager->GetVariable(pwszVariableName, pvarValue, pErrorInfo);
if (hr == DMUS_E_SCRIPT_VARIABLE_NOT_FOUND)
{
// There are also items in the script's container that we need to return.
// This is implemented by the container, which returns the IUnknown pointer directly rather than through a variant.
IUnknown *punk = NULL;
hr = m_pContainerDispatch->GetVariableObject(pwszVariableName, &punk);
if (SUCCEEDED(hr))
{
pvarValue->vt = VT_UNKNOWN;
pvarValue->punkVal = punk;
}
}
#ifdef DBG
if (hr == DMUS_E_SCRIPT_VARIABLE_NOT_FOUND)
{
Trace(1, "Error: Attempt to get variable '%S' that is not defined in the script.\n", pwszVariableName);
}
#endif
if (!m_fUseOleAut && pvarValue->vt == VT_BSTR)
{
// m_fUseOleAut is false when we're using our own custom scripting engine that avoids
// depending on oleaut32.dll. But in this case we're returning a BSTR variant to the
// caller. We have to allocate this string with SysAllocString (from oleaut32)
// because the caller is going to free it with SysFreeString--the standard thing to
// do with a variant BSTR.
BSTR bstrOle = DMS_SysAllocString(true, pvarValue->bstrVal); // allocate a copy with oleaut
DMS_SysFreeString(false, pvarValue->bstrVal); // free the previous value (allocated without oleaut)
pvarValue->bstrVal = bstrOle; // return the oleaut string to the user
if (!bstrOle)
hr = E_OUTOFMEMORY;
}
return hr;
}
// Returns DMUS_E_SCRIPT_VARIABLE_NOT_FOUND if variable doesn't exist in the script.
STDMETHODIMP
CDirectMusicScript::SetVariableNumber(WCHAR *pwszVariableName, LONG lValue, DMUS_SCRIPT_ERRORINFO *pErrorInfo)
{
VARIANT var;
var.vt = VT_I4;
var.lVal = lValue;
return this->SetVariableVariant(pwszVariableName, var, false, pErrorInfo);
}
// Returns DMUS_E_SCRIPT_VARIABLE_NOT_FOUND and 0 if variable doesn't exist in the script.
// Returns DISP_E_TYPEMISMATCH if variable's datatype cannot be converted to LONG.
STDMETHODIMP
CDirectMusicScript::GetVariableNumber(WCHAR *pwszVariableName, LONG *plValue, DMUS_SCRIPT_ERRORINFO *pErrorInfo)
{
V_INAME(CDirectMusicScript::GetVariableNumber);
V_PTR_WRITE(plValue, LONG);
*plValue = 0;
VARIANT var;
HRESULT hr = this->GetVariableVariant(pwszVariableName, &var, pErrorInfo);
if (FAILED(hr) || hr == S_FALSE || hr == DMUS_S_GARBAGE_COLLECTED)
return hr;
hr = DMS_VariantChangeType(m_fUseOleAut, &var, &var, 0, VT_I4);
if (SUCCEEDED(hr))
*plValue = var.lVal;
// GetVariableVariant forces a BSTR to be allocated with SysAllocString;
// so if we allocated a BSTR there, we need to free it with SysAllocString here.
bool fUseOleAut = m_fUseOleAut;
if (!m_fUseOleAut && var.vt == VT_BSTR)
{
fUseOleAut = true;
}
DMS_VariantClear(fUseOleAut, &var);
return hr;
}
// Returns DMUS_E_SCRIPT_VARIABLE_NOT_FOUND if variable doesn't exist in the script.
STDMETHODIMP
CDirectMusicScript::SetVariableObject(WCHAR *pwszVariableName, IUnknown *punkValue, DMUS_SCRIPT_ERRORINFO *pErrorInfo)
{
VARIANT var;
var.vt = VT_UNKNOWN;
var.punkVal = punkValue;
return this->SetVariableVariant(pwszVariableName, var, true, pErrorInfo);
}
// Returns DMUS_E_SCRIPT_VARIABLE_NOT_FOUND and NULL if variable doesn't exist in the script.
// Returns DISP_E_TYPEMISMATCH if variable's datatype cannot be converted to IUnknown.
STDMETHODIMP
CDirectMusicScript::GetVariableObject(WCHAR *pwszVariableName, REFIID riid, LPVOID FAR *ppv, DMUS_SCRIPT_ERRORINFO *pErrorInfo)
{
V_INAME(CDirectMusicScript::GetVariableObject);
V_PTR_WRITE(ppv, IUnknown *);
*ppv = NULL;
VARIANT var;
HRESULT hr = this->GetVariableVariant(pwszVariableName, &var, pErrorInfo);
if (FAILED(hr) || hr == DMUS_S_GARBAGE_COLLECTED)
return hr;
hr = DMS_VariantChangeType(m_fUseOleAut, &var, &var, 0, VT_UNKNOWN);
if (SUCCEEDED(hr))
hr = var.punkVal->QueryInterface(riid, ppv);
DMS_VariantClear(m_fUseOleAut, &var);
return hr;
}
STDMETHODIMP
CDirectMusicScript::EnumRoutine(DWORD dwIndex, WCHAR *pwszName)
{
V_INAME(CDirectMusicScript::EnumRoutine);
V_BUFPTR_WRITE(pwszName, MAX_PATH);
*pwszName = L'\0';
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::EnumRoutine after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
if (!m_pScriptManager || !m_pPerformance8)
{
Trace(1, "Error: IDirectMusicScript::Init must be called before IDirectMusicScript::EnumRoutine.\n");
return DMUS_E_NOT_INIT;
}
return m_pScriptManager->EnumItem(true, dwIndex, pwszName, NULL);
}
STDMETHODIMP
CDirectMusicScript::EnumVariable(DWORD dwIndex, WCHAR *pwszName)
{
V_INAME(CDirectMusicScript::EnumRoutine);
V_BUFPTR_WRITE(pwszName, MAX_PATH);
*pwszName = L'\0';
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::EnumVariable after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
if (!m_pScriptManager || !m_pPerformance8)
{
Trace(1, "Error: IDirectMusicScript::Init must be called before IDirectMusicScript::EnumVariable.\n");
return DMUS_E_NOT_INIT;
}
int cScriptItems = 0;
HRESULT hr = m_pScriptManager->EnumItem(false, dwIndex, pwszName, &cScriptItems);
if (FAILED(hr))
return hr;
if (hr == S_FALSE)
{
// There are also items in the script's container that we need to report.
assert(dwIndex >= cScriptItems);
hr = m_pContainerDispatch->EnumItem(dwIndex - cScriptItems, pwszName);
}
return hr;
}
STDMETHODIMP
CDirectMusicScript::ScriptTrackCallRoutine(
WCHAR *pwszRoutineName,
IDirectMusicSegmentState *pSegSt,
DWORD dwVirtualTrackID,
bool fErrorPMsgsEnabled,
__int64 i64IntendedStartTime,
DWORD dwIntendedStartTimeFlags)
{
V_INAME(CDirectMusicScript::CallRoutine);
V_BUFPTR_READ(pwszRoutineName, 2);
V_INTERFACE(pSegSt);
if (m_fZombie)
{
Trace(1, "Error: Script track attempted to call a routine after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
SmartRef::CritSec CS(&m_CriticalSection);
if (!m_pScriptManager || !m_pPerformance8)
{
Trace(1, "Error: Unitialized Script elements in an attempt to call a Script Routine.\n");
return DMUS_E_NOT_INIT;
}
return m_pScriptManager->ScriptTrackCallRoutine(
pwszRoutineName,
pSegSt,
dwVirtualTrackID,
fErrorPMsgsEnabled,
i64IntendedStartTime,
dwIntendedStartTimeFlags);
}
STDMETHODIMP
CDirectMusicScript::GetTypeInfoCount(UINT *pctinfo)
{
V_INAME(CDirectMusicScript::GetTypeInfoCount);
V_PTR_WRITE(pctinfo, UINT);
*pctinfo = 0;
if (m_fZombie)
{
Trace(1, "Error: Call of IDirectMusicScript::GetTypeInfoCount after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
return S_OK;
}
STDMETHODIMP
CDirectMusicScript::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
{
*ppTInfo = NULL;
return E_NOTIMPL;
}
STDMETHODIMP
CDirectMusicScript::GetIDsOfNames(
REFIID riid,
LPOLESTR __RPC_FAR *rgszNames,
UINT cNames,
LCID lcid,
DISPID __RPC_FAR *rgDispId)
{
if (m_fZombie)
{
if (rgDispId)
{
for (int i = 0; i < cNames; ++i)
{
rgDispId[i] = DISPID_UNKNOWN;
}
}
Trace(1, "Error: Call of GetIDsOfNames after a script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
if (!m_pScriptManager || !m_pPerformance8)
{
Trace(1, "Error: IDirectMusicScript::Init must be called before GetIDsOfNames.\n");
return DMUS_E_NOT_INIT;
}
return m_pScriptManager->DispGetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
}
STDMETHODIMP
CDirectMusicScript::Invoke(
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS __RPC_FAR *pDispParams,
VARIANT __RPC_FAR *pVarResult,
EXCEPINFO __RPC_FAR *pExcepInfo,
UINT __RPC_FAR *puArgErr)
{
if (m_fZombie)
{
if (pVarResult)
DMS_VariantInit(m_fUseOleAut, pVarResult);
Trace(1, "Error: Call of Invoke after the script has been garbage collected. "
"It is invalid to continue using a script after releasing it from the loader (ReleaseObject/ReleaseObjectByUnknown) "
"and then calling CollectGarbage or Release on the loader.");
return DMUS_S_GARBAGE_COLLECTED;
}
if (!m_pScriptManager || !m_pPerformance8)
{
Trace(1, "Error: IDirectMusicScript::Init must be called before Invoke.\n");
return DMUS_E_NOT_INIT;
}
return m_pScriptManager->DispInvoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}
//////////////////////////////////////////////////////////////////////
// Methods that allow CActiveScriptManager access to private script interfaces
IDispatch *CDirectMusicScript::GetGlobalDispatch()
{
assert(m_pGlobalDispatch);
return m_pGlobalDispatch;
}