static HRESULT ReadAAFFile(aafWChar* pFileName)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IEnumAAFContainerDefs *pPlug = NULL;
IAAFDefObject* pDef = NULL;
IAAFContainerDef* pContainerDef = NULL;
bool bFileOpen = false;
HRESULT hr = S_OK;
aafUID_t readUID;
wchar_t testString[256];
try
{
// Open the AAF file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// Get the AAF file header.
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->GetDictionary(&pDictionary));
checkResult(pDictionary->GetContainerDefs(&pPlug));
while(pPlug->NextOne (&pContainerDef) == AAFRESULT_SUCCESS)
{
checkResult(pContainerDef->QueryInterface (IID_IAAFDefObject, (void **)&pDef));
checkResult(pDef->GetAUID(&readUID));
if(memcmp(&readUID, &testUID, sizeof(aafUID_t)) == 0)
{
checkResult(pDef->GetName (testString, sizeof(testString)));
checkExpression (wcscmp(testString, sName) == 0, AAFRESULT_TEST_FAILED);
aafUInt32 nameLen;
checkResult (pDef->GetNameBufLen (&nameLen));
checkExpression (((wcslen (sName)+1) * sizeof (aafCharacter) == nameLen),
AAFRESULT_TEST_FAILED);
checkResult(pDef->GetDescription (testString, sizeof(testString)));
checkExpression (wcscmp(testString, sDescription) == 0, AAFRESULT_TEST_FAILED);
checkResult (pDef->GetDescriptionBufLen (&nameLen));
checkExpression (((wcslen (sDescription)+1) * sizeof (aafCharacter) == nameLen),
AAFRESULT_TEST_FAILED);
break;
}
pDef->Release();
pDef = NULL;
pContainerDef->Release();
pContainerDef = NULL;
}// checkResult(pPlug->NextOne(&pContainerDef));
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (pHeader)
pHeader->Release();
if (pPlug)
pPlug->Release();
if (pDef)
pDef->Release();
if (pContainerDef)
pContainerDef->Release();
if (pDictionary)
pDictionary->Release();
if (pFile)
{ // Close file
if (bFileOpen)
pFile->Close();
pFile->Release();
}
return hr;
}
static HRESULT ReadAAFFile(aafWChar* pFileName)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IEnumAAFContainerDefs *pPlug = NULL;
IAAFContainerDef *pPlugDef = NULL;
IAAFDefObject *pDef = NULL;
bool bFileOpen = false;
aafBool testBool;
aafUID_t readUID;
HRESULT hr = S_OK;
try
{
// Open the AAF file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// Get the AAF file header.
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->GetDictionary(&pDictionary));
checkResult(pDictionary->GetContainerDefs(&pPlug));
while(pPlug->NextOne (&pPlugDef) == AAFRESULT_SUCCESS)
{
checkResult(pPlugDef->QueryInterface (IID_IAAFDefObject, (void **)&pDef));
checkResult(pDef->GetAUID(&readUID));
if(memcmp(&readUID, &testUID, sizeof(aafUID_t)) == 0)
{
checkResult(pPlugDef->EssenceIsIdentified (&testBool));
checkExpression(testBool == kAAFTrue, AAFRESULT_TEST_FAILED);
break;
}
pDef->Release();
pDef = NULL;
pPlugDef->Release();
pPlugDef = NULL;
}
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (pDef)
pDef->Release();
if (pPlugDef)
pPlugDef->Release();
if (pPlug)
pPlug->Release();
if (pDictionary)
pDictionary->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{ // Close file
if (bFileOpen)
pFile->Close();
pFile->Release();
}
return hr;
}
static HRESULT ReadAAFFile(aafWChar* pFileName)
{
IAAFFileSP pFile;
IAAFHeaderSP pHeader;
IEnumAAFMobsSP pMobIter;
IAAFMobSP pMob;
IEnumAAFMobSlotsSP pSlotIter;
IAAFMobSlotSP pSlot;
IAAFComponentSP pComp;
IAAFSegmentSP pSegment;
IAAFDataDefSP pDataDef;
IAAFSequenceSP pSequence;
IAAFDictionarySP pDictionary;
IEnumAAFComponentsSP pCompIter;
aafNumSlots_t numMobs;
aafSearchCrit_t criteria;
HRESULT hr = S_OK;
try
{
// Open the AAF file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
// Get the AAF file header.
checkResult(pFile->GetHeader(&pHeader));
// Validate that there is only one composition mob.
checkResult(pHeader->CountMobs(kAAFCompMob, &numMobs));
checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED);
// Get the AAF Dictionary so that we can create valid AAF objects.
checkResult(pHeader->GetDictionary(&pDictionary));
CAAFBuiltinDefs defs (pDictionary);
// Check a data definition from a composition MOB in order to test weak references
criteria.searchTag = kAAFByMobKind;
criteria.tags.mobKind = kAAFCompMob;
checkResult(pHeader->GetMobs(&criteria, &pMobIter));
while (pMobIter && pMobIter->NextOne(&pMob) == AAFRESULT_SUCCESS)
{
// Enumerate the first MOB slot for this MOB
checkResult(pMob->GetSlots(&pSlotIter));
checkResult(pSlotIter->NextOne(&pSlot));
checkResult(pSlot->GetSegment(&pSegment));
checkResult(pSegment->QueryInterface(IID_IAAFSequence, (void **) &pSequence));
checkResult(pSequence->GetComponents(&pCompIter));
checkResult(pCompIter->NextOne(&pComp));
aafBool testBool;
checkResult(pComp->GetDataDef(&pDataDef));
checkResult(pDataDef->IsSoundKind(&testBool));
checkExpression(testBool == kAAFFalse, AAFRESULT_TEST_FAILED);
checkResult(pDataDef->IsDataDefOf(defs.ddkAAFPictureWithMatte(), &testBool));
checkExpression(testBool == kAAFTrue, AAFRESULT_TEST_FAILED);
// Make sure first component is a filler, and is our extended
// class. To do that, we'll compare the class def we looked
// up in the dict, with the one we got from the new object.
//
// First get the class from the object.
IAAFFillerSP pFill;
checkResult(pComp->QueryInterface(IID_IAAFFiller,
(void **) &pFill));
assert (pFill);
IAAFObjectSP pObj;
checkResult(pFill->QueryInterface(IID_IAAFObject,
(void **) &pObj));
assert (pObj);
IAAFClassDefSP pClassFromObj;
checkResult (pObj->GetDefinition (&pClassFromObj));
assert (pClassFromObj);
IUnknownSP pUnkFromObj;
checkResult(pClassFromObj->QueryInterface(IID_IUnknown,
(void **) &pUnkFromObj));
// Now get the class from the dict
IAAFClassDefSP pClassFromDict;
checkResult (pDictionary->LookupClassDef (kClassAUID_NewFill,
&pClassFromDict));
assert (pClassFromDict);
IUnknownSP pUnkFromDict;
checkResult(pClassFromDict->QueryInterface(IID_IUnknown,
(void **) &pUnkFromDict));
// Compare class from object with class from dict. Compare
// using IUnknown pointers.
assert (((IUnknown*)pUnkFromObj) ==
((IUnknown*)pUnkFromDict));
// To test GetClassDefinitions(), try explicit lookup.
IEnumAAFClassDefsSP pClassDefEnum;
checkResult (pDictionary->GetClassDefs (&pClassDefEnum));
bool found = false;
IAAFClassDefSP cd;
while (SUCCEEDED (pClassDefEnum->NextOne (&cd)))
{
IAAFMetaDefinitionSP def;
checkResult(cd->QueryInterface(IID_IAAFMetaDefinition,
(void **) &def));
aafUID_t classid;
checkResult (def->GetAUID (&classid));
if (EqualGUID (&classid, &kClassAUID_NewFill))
{
// Found it the hard way.
found = true;
break;
}
}
// make sure we found it the hard way.
checkExpression(found == kAAFTrue, AAFRESULT_TEST_FAILED);
// Get the 'odor' property from our new fill clip. Make
// sure it is set to the value we think it should be
// ('42').
//
// First get the property def from the class.
IAAFPropertyDefSP pPropDef;
checkResult (pClassFromObj->LookupPropertyDef
(kPropAUID_NewFill_Odor,
&pPropDef));
//
// Get the property value from the object
IAAFPropertyValueSP pPropVal;
checkResult (pObj->GetPropertyValue (pPropDef, &pPropVal));
//
// We know the property is int32; get the int32 type def
IAAFTypeDefSP ptd;
checkResult (pDictionary->LookupTypeDef
(kAAFTypeID_UInt32,
&ptd));
IAAFTypeDefIntSP pTDUint32;
checkResult(ptd->QueryInterface(IID_IAAFTypeDefInt,
(void **) &pTDUint32));
assert (pTDUint32);
//
// Ask the typedef to interpret this property value for us.
aafUInt32 odorValue = 0;
checkResult (pTDUint32->GetInteger
(pPropVal,
(aafMemPtr_t) &odorValue,
sizeof (odorValue)));
//
// make sure it's what we expect.
assert (42 == odorValue);
}
checkResult (LookupDefs (pDictionary));
//Test the Lookup KLV and Tagged methods
IAAFKLVDataDefinition *pKLVLook = NULL;
IAAFTaggedValueDefinition *pTAGDefLook = NULL;
IAAFDictionary2 *pDic2 = NULL;
IAAFDefObject *pKLVDataDefObj = NULL;
IAAFDefObject *pTaggedValueDefObj = NULL;
aafUID_t auid;
checkResult( pDictionary->QueryInterface( IID_IAAFDictionary2, reinterpret_cast<void**>(&pDic2) ) );
assert(pDic2);
//test LookUpKLV()
if(pDic2->LookupKLVDataDef(KLVDef_TestData, &pKLVLook) != AAFRESULT_SUCCESS)
checkResult(AAFRESULT_TEST_FAILED);
checkResult( pKLVLook->QueryInterface( IID_IAAFDefObject, reinterpret_cast<void**>(&pKLVDataDefObj) ) );
assert(pKLVDataDefObj);
//ensure the KLVLook auid is equal to KLVDef_TestData auid
checkResult(pKLVDataDefObj->GetAUID(&auid));
if(auid != KLVDef_TestData)
checkResult(AAFRESULT_TEST_FAILED);
//test LookUpTagged()
if(pDic2->LookupTaggedValueDef(TAGDef_TestData, &pTAGDefLook) != AAFRESULT_SUCCESS)
checkResult(AAFRESULT_TEST_FAILED);
checkResult( pTAGDefLook->QueryInterface( IID_IAAFDefObject, reinterpret_cast<void**>(&pTaggedValueDefObj) ) );
assert(pTaggedValueDefObj);
//ensure the TAGDefLook auid is equal to TAGDef_TestData auid
checkResult(pTaggedValueDefObj->GetAUID(&auid));
if(auid != TAGDef_TestData)
checkResult(AAFRESULT_TEST_FAILED);
//cleanup
pDic2->Release();
pDic2 = NULL;
pKLVLook->Release();
pKLVLook = NULL;
pTAGDefLook->Release();
pTAGDefLook = NULL;
pKLVDataDefObj->Release();
pKLVDataDefObj = NULL;
pTaggedValueDefObj->Release();
pTaggedValueDefObj = NULL;
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return.
if (pFile)
{
pFile->Close();
}
return hr;
}
static HRESULT ReadAAFFile(aafWChar * pFileName)
{
// IAAFSession * pSession = NULL;
IAAFFile * pFile = NULL;
bool bFileOpen = false;
IAAFHeader * pHeader = NULL;
IEnumAAFMobs *mobIter = NULL;
IAAFContainerDef* pContainer = NULL;
IAAFDefObject * pDef = NULL;
IAAFEssenceDescriptor *pEdesc = NULL;
IAAFSourceMob *pSourceMob = NULL;
IAAFMob *aMob = NULL;
IEnumAAFMobSlots *slotIter = NULL;
IAAFMobSlot *slot = NULL;
IAAFFileDescriptor *pFileDesc = NULL;
IAAFFileDescriptor2 *pFileDesc2 = NULL;
aafNumSlots_t numMobs, n, s;
HRESULT hr = S_OK;
aafRational_t testSampleRate;
aafUID_t testContainer;
aafLength_t testLength;
aafUInt32 testLinkedSlotID;
// aafBool testBool;
try
{
// Open the file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// We can't really do anthing in AAF without the header.
checkResult(pFile->GetHeader(&pHeader));
// Get the number of mobs in the file (should be one)
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED);
checkResult(pHeader->GetMobs (NULL, &mobIter));
for(n = 0; n < numMobs; n++)
{
aafWChar name[500];
aafNumSlots_t numSlots;
aafMobID_t mobID;
aafSlotID_t trackID;
checkResult(mobIter->NextOne (&aMob));
checkResult(aMob->GetName (name, sizeof(name)));
checkResult(aMob->GetMobID (&mobID));
checkResult(aMob->CountSlots (&numSlots));
if (2 != numSlots)
return AAFRESULT_TEST_FAILED;
if(numSlots != 0)
{
checkResult(aMob->GetSlots(&slotIter));
for(s = 0; s < numSlots; s++)
{
checkResult(slotIter->NextOne (&slot));
checkResult(slot->GetSlotID(&trackID));
slot->Release();
slot = NULL;
}
}
checkResult(aMob->QueryInterface (IID_IAAFSourceMob, (void **)&pSourceMob));
checkResult(pSourceMob->GetEssenceDescriptor (&pEdesc));
checkResult(pEdesc->QueryInterface(IID_IAAFFileDescriptor, (void **) &pFileDesc));
checkResult(pFileDesc->GetSampleRate (&testSampleRate));
checkExpression(testSampleRate.numerator == checkSampleRate.numerator, AAFRESULT_TEST_FAILED);
checkExpression(testSampleRate.denominator == checkSampleRate.denominator, AAFRESULT_TEST_FAILED);
checkResult(pFileDesc->GetContainerFormat (&pContainer));
checkResult(pContainer->QueryInterface(IID_IAAFDefObject, (void **) &pDef));
checkResult(pDef->GetAUID(&testContainer));
pContainer->Release();
pContainer = NULL;
pDef->Release();
pDef = NULL;
checkExpression(memcmp(&testContainer, &checkContainer, sizeof(testContainer)) == 0, AAFRESULT_TEST_FAILED);
checkResult(pFileDesc->GetLength (&testLength));
checkExpression(checkLength == testLength, AAFRESULT_TEST_FAILED);
checkResult(pFileDesc->QueryInterface(IID_IAAFFileDescriptor2, (void **)&pFileDesc2));
checkResult(pFileDesc2->GetLinkedSlotID (&testLinkedSlotID));
checkExpression(checkLinkedSlotID == testLinkedSlotID, AAFRESULT_TEST_FAILED);
// checkResult(pFileDesc->GetIsInContainer (&testBool));
// checkExpression(testBool == kAAFTrue, AAFRESULT_TEST_FAILED);
pEdesc->Release();
pEdesc = NULL;
pFileDesc->Release();
pFileDesc = NULL;
pFileDesc2->Release();
pFileDesc2 = NULL;
pSourceMob->Release();
pSourceMob = NULL;
aMob->Release();
aMob = NULL;
}
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (slot)
slot->Release();
if (pFileDesc)
pFileDesc->Release();
if (pFileDesc2)
pFileDesc2->Release();
if (slotIter)
slotIter->Release();
if (pEdesc)
pEdesc->Release();
if (pSourceMob)
pSourceMob->Release();
if (aMob)
aMob->Release();
if(mobIter)
mobIter->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{
if (bFileOpen)
pFile->Close();
pFile->Release();
}
return hr;
}
static HRESULT ReadAAFFile(aafWChar * pFileName)
{
IAAFFile *pFile = NULL;
bool bFileOpen = false;
IAAFHeader *pHeader = NULL;
IEnumAAFMobs *mobIter = NULL;
IAAFMob *aMob = NULL;
IEnumAAFMobSlots *slotIter = NULL;
IAAFMobSlot *slot = NULL;
IAAFSegment *pSeg = NULL;
IAAFSourceClip *pSourceClip = NULL;
IAAFDataDef * pDataDef = 0;
IAAFDefObject * pDefObj = 0;
aafNumSlots_t numMobs, n;
aafSlotID_t s;
aafUInt32 length;
HRESULT hr = S_OK;
aafUID_t readUID, typeUID = kAAFDataDef_Picture;
try
{
// Open the file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// We can't really do anthing in AAF without the header.
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED);
aafSearchCrit_t criteria;
criteria.searchTag = kAAFNoSearch;
checkResult(pHeader->GetMobs (&criteria, &mobIter));
for(n = 0; n < numMobs; n++)
{
aafWChar name[500], slotName[500];
aafNumSlots_t numSlots;
aafMobID_t mobID;
aafSlotID_t trackID;
checkResult(mobIter->NextOne (&aMob));
checkResult(aMob->GetName (name, sizeof(name)));
checkResult(aMob->GetMobID (&mobID));
checkResult(aMob->CountSlots (&numSlots));
checkExpression(5 == numSlots, AAFRESULT_TEST_FAILED);
checkResult(aMob->GetSlots(&slotIter));
for(s = 0; s < (aafSlotID_t)numSlots; s++)
{
checkResult(slotIter->NextOne (&slot));
checkResult(slot->GetNameBufLen(&length));
checkResult(slot->GetName (slotName, length));
checkExpression (wcscmp(slotName, slotNames[s]) == 0, AAFRESULT_TEST_FAILED);
checkResult(slot->GetSlotID(&trackID));
checkExpression (trackID == s+1, AAFRESULT_TEST_FAILED);
checkResult(slot->GetPhysicalNum(&trackID));
checkExpression (trackID == s+2, AAFRESULT_TEST_FAILED);
checkResult(slot->GetPhysicalNum(&trackID));
checkResult(slot->GetDataDef(&pDataDef));
checkResult(pDataDef->QueryInterface (IID_IAAFDefObject, (void **)&pDefObj));
checkResult(pDefObj->GetAUID(&readUID));
checkExpression (memcmp(&typeUID, &readUID, sizeof(typeUID)) == 0, AAFRESULT_TEST_FAILED);
checkResult(slot->GetSegment(&pSeg));
checkResult(pSeg->QueryInterface (IID_IAAFSourceClip, (void **)&pSourceClip));
pDataDef->Release();
pDataDef = 0;
pDefObj->Release ();
pDefObj = 0;
pSourceClip->Release();
pSourceClip = NULL;
pSeg->Release();
pSeg = NULL;
slot->Release();
slot = NULL;
}
aMob->Release();
aMob = NULL;
}
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup object references
if (slot)
{
slot->Release();
slot = 0;
}
if (pSeg)
{
pSeg->Release();
pSeg = 0;
}
if (pSourceClip)
{
pSourceClip->Release();
pSourceClip = 0;
}
if (slotIter)
{
slotIter->Release();
slotIter = 0;
}
if (aMob)
{
aMob->Release();
aMob = 0;
}
if (mobIter)
{
mobIter->Release();
mobIter = 0;
}
if (pHeader)
{
pHeader->Release();
pHeader = 0;
}
if (pDataDef)
{
pDataDef->Release();
pDataDef = 0;
}
if (pDefObj)
{
pDefObj->Release ();
pDefObj = 0;
}
if (pFile)
{ // Close file
if (bFileOpen)
pFile->Close();
pFile->Release();
pFile = 0;
}
return hr;
}
