IAAFInterpolationDef *AAFDomainUtils::CreateInterpolationDefinition(IAAFDictionary *dict, aafUID_t interpolationDefID)
{
IAAFInterpolationDef *interpDef;
AAFRESULT rc;
CAAFBuiltinDefs defs (dict);
rc = dict->LookupInterpolationDef(interpolationDefID,&interpDef);
if(rc == AAFRESULT_SUCCESS && interpDef != NULL)
return interpDef;
// dprintf("AEffect::CreateInterpolationDefinition()\n"); //JeffB:
(void)(defs.cdInterpolationDefinition()->
CreateInstance(IID_IAAFInterpolationDef,
(IUnknown **)&interpDef));
if(memcmp(&interpolationDefID, &LinearInterpolator, sizeof(aafUID_t)) == 0)
{
(void)(interpDef->Initialize(interpolationDefID, L"LinearInterp", L"Linear keyframe interpolation"));
dict->RegisterInterpolationDef(interpDef);
}
else
{
interpDef->Release();
interpDef = NULL;
}
//cleanup:
return(interpDef);
}
static HRESULT RegisterDefs (IAAFDictionary * pDict)
{
assert (pDict);
CAAFBuiltinDefs defs (pDict);
// IAAFTypeDefSP pTypeUInt8;
// checkResult(pDict->LookupTypeDef(kAAFTypeID_UInt8, &pTypeUInt8));
{ // Create an opaque type and register it in the dictionary.
IAAFTypeDefSP pOpaqueType;
IAAFTypeDefRenameSP pOpaqueTestType;
checkResult(pDict->CreateMetaInstance(AUID_AAFTypeDefRename, IID_IAAFTypeDefRename, (IUnknown **)&pOpaqueTestType));
checkResult(pOpaqueTestType->Initialize(kTestTypeID, defs.tdUInt8(), L"TestUInt8"));
checkResult(pOpaqueTestType->QueryInterface(IID_IAAFTypeDef, (void **)&pOpaqueType));
checkResult(pDict->RegisterOpaqueTypeDef(pOpaqueType));
}
RegisterOneMetaDef (/* dictionary*/ pDict,
/* def object's class id */ AUID_AAFTypeDefRename,
/* IID of def to pass to Init */ IID_IAAFTypeDefRename,
/* SP of def to use with Init */ IAAFTypeDefRenameSP,
/* Init() invocation */
Initialize (kTestTypeID, defs.tdUInt8(), L"TestUInt8"),
/* IID of type to QI */ IID_IAAFMetaDefinition,
/* SP for type to QI */ IAAFMetaDefinitionSP,
/* IID of def to register */ IID_IAAFTypeDef,
/* SP for def to register */ IAAFTypeDefSP,
/* reg method on pDict */ RegisterTypeDef);
{ // Make sure that "TestUInt8" is no longer opaque.
IAAFTypeDefSP pOpaqueTestType;
checkExpression(FAILED(pDict->LookupOpaqueTypeDef(kTestTypeID, &pOpaqueTestType)),
AAFRESULT_TEST_FAILED);
}
RegisterOneDef (/* dictionary*/ pDict,
/* def object's class */ defs.cdDataDef(),
/* IID of def to pass to Init */ IID_IAAFDataDef,
/* SP of def to use with Init */ IAAFDataDefSP,
/* Init() invocation */
Initialize (kTestDataDefID, L"TestDataDef", L"Desc"),
/* IID of type to QI */ IID_IAAFDefObject,
/* SP for type to QI */ IAAFDefObjectSP,
/* IID of def to register */ IID_IAAFDataDef,
/* SP for def to register */ IAAFDataDefSP,
/* reg method on pDict */ RegisterDataDef);
RegisterOneDef (/* dictionary*/ pDict,
/* def object's class */ defs.cdOperationDef(),
/* IID of def to pass to Init */ IID_IAAFOperationDef,
/* SP of def to use with Init */ IAAFOperationDefSP,
/* Init() invocation */
Initialize (kTestOperationDefID, L"TestOperationDef", L"Desc"),
/* IID of type to QI */ IID_IAAFDefObject,
/* SP for type to QI */ IAAFDefObjectSP,
/* IID of def to register */ IID_IAAFOperationDef,
/* SP for def to register */ IAAFOperationDefSP,
/* reg method on pDict */ RegisterOperationDef);
// Hack!
{
IAAFOperationDefSP od;
checkResult (pDict->LookupOperationDef (kTestOperationDefID,
&od));
checkResult (od->SetDataDef (defs.ddkAAFMatte()));
}
RegisterOneDef (/* dictionary*/ pDict,
/* def object's class */ defs.cdParameterDef(),
/* IID of def to pass to Init */ IID_IAAFParameterDef,
/* SP of def to use with Init */ IAAFParameterDefSP,
/* Init() invocation */
Initialize (kTestParameterDefID, L"TestParameterDef", L"Desc", defs.tdRational()),
/* IID of type to QI */ IID_IAAFDefObject,
/* SP for type to QI */ IAAFDefObjectSP,
/* IID of def to register */ IID_IAAFParameterDef,
/* SP for def to register */ IAAFParameterDefSP,
/* reg method on pDict */ RegisterParameterDef);
RegisterOneDef (/* dictionary*/ pDict,
/* def object's class */ defs.cdCodecDef(),
/* IID of def to pass to Init */ IID_IAAFCodecDef,
/* SP of def to use with Init */ IAAFCodecDefSP,
/* Init() invocation */
Initialize (kTestCodecDefID, L"TestCodecDef", L"Desc"),
/* IID of type to QI */ IID_IAAFDefObject,
/* SP for type to QI */ IAAFDefObjectSP,
/* IID of def to register */ IID_IAAFCodecDef,
/* SP for def to register */ IAAFCodecDefSP,
/* reg method on pDict */ RegisterCodecDef);
// Hack! Codec defs must have at least one data def appended in
// order to be saved correctly...
{
IAAFCodecDefSP cd;
IAAFClassDefSP pClassDef;
checkResult (pDict->LookupCodecDef (kTestCodecDefID,
&cd));
checkResult (cd->AddEssenceKind (defs.ddkAAFMatte()));
checkResult(pDict->LookupClassDef(kAAFClassID_EssenceDescriptor, &pClassDef));
checkResult(cd->SetFileDescriptorClass (pClassDef));
}
RegisterOneDef (/* dictionary*/ pDict,
/* def object's class */ defs.cdContainerDef(),
/* IID of def to pass to Init */ IID_IAAFContainerDef,
/* SP of def to use with Init */ IAAFContainerDefSP,
/* Init() invocation */
Initialize (kTestContainerDefID, L"TestContainerDef", L"Desc"),
/* IID of type to QI */ IID_IAAFDefObject,
/* SP for type to QI */ IAAFDefObjectSP,
/* IID of def to register */ IID_IAAFContainerDef,
/* SP for def to register */ IAAFContainerDefSP,
/* reg method on pDict */ RegisterContainerDef);
RegisterOneDef (/* dictionary*/ pDict,
/* def object's class */ defs.cdInterpolationDefinition(),
/* IID of def to pass to Init */ IID_IAAFInterpolationDef,
/* SP of def to use with Init */ IAAFInterpolationDefSP,
/* Init() invocation */
Initialize (kTestInterpolationDefID, L"TestInterpolationDef", L"Desc"),
/* IID of type to QI */ IID_IAAFDefObject,
/* SP for type to QI */ IAAFDefObjectSP,
/* IID of def to register */ IID_IAAFInterpolationDef,
/* SP for def to register */ IAAFInterpolationDefSP,
/* reg method on pDict */ RegisterInterpolationDef);
RegisterOneDef (/* dictionary*/ pDict,
/* def object's class */ defs.cdPluginDef(),
/* IID of def to pass to Init */ IID_IAAFPluginDef,
/* SP of def to use with Init */ IAAFPluginDefSP,
/* Init() invocation */
Initialize (kTestPluginDefID, L"TestPluginDef", L"Desc"),
/* IID of type to QI */ IID_IAAFObject,
/* SP for type to QI */ IAAFObjectSP,
/* IID of def to register */ IID_IAAFPluginDef,
/* SP for def to register */ IAAFPluginDefSP,
/* reg method on pDict */ RegisterPluginDef);
return AAFRESULT_SUCCESS;
}
static HRESULT CreateAAFFile(
aafWChar * pFileName,
aafUID_constref fileKind,
testRawStorageType_t rawStorageType,
aafProductIdentification_constref productID)
{
IAAFFile* pFile = NULL;
IAAFHeader * pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFDefObject* pDef = NULL;
IAAFInterpolationDef* pInterpolationDef = NULL;
bool bFileOpen = false;
HRESULT hr = S_OK;
/* long test;
*/
try
{
// Remove the previous test file if any.
RemoveTestFile(pFileName);
// Create the AAF file
checkResult(CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile ));
bFileOpen = true;
// We can't really do anthing in AAF without the header.
checkResult(pFile->GetHeader(&pHeader));
// Get the AAF Dictionary so that we can create valid AAF objects.
checkResult(pHeader->GetDictionary(&pDictionary));
CAAFBuiltinDefs defs (pDictionary);
checkResult(defs.cdInterpolationDefinition()->
CreateInstance(IID_IAAFInterpolationDef,
(IUnknown **)&pInterpolationDef));
checkResult(pInterpolationDef->QueryInterface (IID_IAAFDefObject,
(void **)&pDef));
checkResult(pInterpolationDef->Initialize(InterpDef1, sName1, sDescription1));
checkResult(pDictionary->RegisterInterpolationDef(pInterpolationDef));
pDef->Release();
pDef = NULL;
pInterpolationDef->Release();
pInterpolationDef = NULL;
checkResult(defs.cdInterpolationDefinition()->
CreateInstance(IID_IAAFInterpolationDef,
(IUnknown **)&pInterpolationDef));
checkResult(pInterpolationDef->QueryInterface (IID_IAAFDefObject,
(void **)&pDef));
checkResult(pInterpolationDef->Initialize(InterpDef2, sName2, sDescription2));
checkResult(pDictionary->RegisterInterpolationDef(pInterpolationDef));
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (pDef)
pDef->Release();
if (pInterpolationDef)
pInterpolationDef->Release();
if (pDictionary)
pDictionary->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{ // Close file
if (bFileOpen)
{
pFile->Save();
pFile->Close();
}
pFile->Release();
}
return hr;
}
