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; }