static HRESULT CreateAAFFile(
aafWChar * pFileName,
aafUID_constref fileKind,
testRawStorageType_t rawStorageType,
aafProductIdentification_constref productID)
{
IAAFFile* pFile = NULL;
IAAFHeader * pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFCodecDef* pCodecDef = NULL;
IAAFClassDef* pClass = NULL;
bool bFileOpen = false;
HRESULT hr = S_OK;
aafUID_t uid;
/* 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.cdCodecDef()->
CreateInstance(IID_IAAFCodecDef,
(IUnknown **)&pCodecDef));
checkResult(pCodecDef->AddEssenceKind (defs.ddkAAFMatte()));
uid = kAAFNoCodec;
checkResult(pCodecDef->Initialize (uid, sName1, sDescription1));
checkResult(pDictionary->LookupClassDef(kAAFClassID_EssenceDescriptor, &pClass));
checkResult(pCodecDef->SetFileDescriptorClass (pClass));
checkResult(pDictionary->RegisterCodecDef(pCodecDef));
pCodecDef->Release();
pCodecDef = NULL;
checkResult(defs.cdCodecDef()->
CreateInstance(IID_IAAFCodecDef,
(IUnknown **)&pCodecDef));
checkResult(pCodecDef->AddEssenceKind (defs.ddkAAFMatte()));
uid = TESTID_2;
checkResult(pCodecDef->Initialize (uid, sName2, sDescription2));
checkResult(pCodecDef->SetFileDescriptorClass (pClass));
checkResult(pDictionary->RegisterCodecDef(pCodecDef));
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (pCodecDef)
pCodecDef->Release();
if (pDictionary)
pDictionary->Release();
if (pHeader)
pHeader->Release();
if (pClass)
pClass->Release();
if (pFile)
{ // Close file
if (bFileOpen)
{
pFile->Save();
pFile->Close();
}
pFile->Release();
}
return hr;
}
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;
IAAFCodecDef* pPlugDef = NULL;
IAAFDataDef *pDataDef = NULL;
IAAFClassDef *classDef = NULL;
IAAFClassDef *pWaveClassDef=0,*pReturnedClassDef=0;
bool bFileOpen = false;
HRESULT hr = S_OK;
aafUID_t uid;
try
{
// Remove the previous test file if any.
RemoveTestFile(pFileName);
// Create the AAF file
checkResult(CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile ));
bFileOpen = true;
// Get the AAF file 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.cdCodecDef()->
CreateInstance(IID_IAAFCodecDef,
(IUnknown **)&pPlugDef));
uid = kAAFCodecWAVE;
checkResult(pPlugDef->Initialize (uid, L"TestCodec", L"TestCodecDescription"));
checkResult(pPlugDef->AddEssenceKind (defs.ddkAAFMatte()));
checkResult(pDictionary->RegisterCodecDef(pPlugDef));
uid = kAAFClassID_WAVEDescriptor;
checkResult(pDictionary->LookupClassDef(uid, &classDef));
checkResult(pPlugDef->SetFileDescriptorClass (classDef));
// Make sure GetFileDescriptorClass() returns correct value
aafUID_t uid = kAAFClassID_WAVEDescriptor;
checkResult(pDictionary->LookupClassDef(uid, &pWaveClassDef));
checkResult(pPlugDef->GetFileDescriptorClass(&pReturnedClassDef));
// COM interface pointers pReturnedClassDef and pWaveClassDef should be
// equal
checkExpression(AreUnksSame(pReturnedClassDef,pWaveClassDef)==kAAFTrue,
AAFRESULT_TEST_FAILED);
/* Not tested
virtual HRESULT STDMETHODCALLTYPE RemoveEssenceKind();
virtual HRESULT STDMETHODCALLTYPE CountEssenceKinds();
virtual HRESULT STDMETHODCALLTYPE GetEssenceKinds();
*/
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (pReturnedClassDef)
pReturnedClassDef->Release();
if (pWaveClassDef)
pWaveClassDef->Release();
if (classDef)
classDef->Release();
if (pDataDef)
pDataDef->Release();
if (pPlugDef)
pPlugDef->Release();
if (pDictionary)
pDictionary->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{ // Close file
if (bFileOpen)
{
pFile->Save();
pFile->Close();
}
pFile->Release();
}
return hr;
}
