//*********************************************************** // // SetIntegerPropOnObject() // // Set an integer property to the AAF object specified by pObj. // The value of the property is specified in value. // // Returns: // // On Success: AAFRESULT_SUCCESS // On Failure: An exception. // HRESULT AAFDomainUtils::SetIntegerPropOnObject(IAAFObject* pObj, aafUID_t* pClassID, aafUID_t* pPropID, const aafUID_t* pIntTypeID, aafMemPtr_t pValue, aafUInt32 ValueSize, IAAFDictionary *dict) { AAFCheck hr; // Create a property value from the supplied value (pValue) IAAFTypeDef* pTD; hr = dict->LookupTypeDef(*pIntTypeID, &pTD); AutoRelease<IAAFTypeDef> r1( pTD ); IAAFTypeDefInt* pTDInt; hr = pTD->QueryInterface(IID_IAAFTypeDefInt, (void**)&pTDInt); AutoRelease<IAAFTypeDefInt> r2( pTDInt ); // Now create a property value object with that value. IAAFPropertyValue* pPV; hr = pTDInt->CreateValue(pValue, ValueSize, &pPV); AutoRelease<IAAFPropertyValue> r3( pPV ); // Add the property to the target object. // Get the class def for the object IAAFClassDef* pCD; hr = dict->LookupClassDef(*pClassID, &pCD); AutoRelease<IAAFClassDef> r4( pCD ); IAAFPropertyDef* pPD; hr = pCD->LookupPropertyDef(*pPropID, &pPD); AutoRelease<IAAFPropertyDef> r5( pPD ); // Set the propeter value on the target object hr = pObj->SetPropertyValue(pPD, pPV); return AAFRESULT_SUCCESS; }
//*********************************************************** // // GetObjRefPropFromObject() // // Get a object reference property on the AAF object specified // by pObj. The value of the property is returned in ppObject. // // Returns: // // On Success: S_OK // On Failure: A failed HRESULT // HRESULT AAFDomainUtils::GetObjRefPropFromObject(IAAFObject* pObj, aafUID_t* pClassID, const aafUID_t* pPropTypeID, aafUID_t* pPropID, IAAFObject** ppObject) { IAAFPropertyValue* pPV = NULL; IAAFClassDef* pCD; HRESULT hr; // Get the property value for the target property hr = _dict->LookupClassDef(*pClassID, &pCD); if (SUCCEEDED(hr)) { IAAFPropertyDef* pPD; hr = pCD->LookupPropertyDef(*pPropID, &pPD); if (SUCCEEDED(hr)) { aafBool present = kAAFFalse; pObj->IsPropertyPresent(pPD, &present); if (present == kAAFTrue) hr = pObj->GetPropertyValue(pPD, &pPV); else hr = AAFRESULT_PROP_NOT_PRESENT; pPD->Release(); } pCD->Release(); } // Get the property type def from the dictionary to interpret this property value // and return the resulting object. if (SUCCEEDED(hr)) { IAAFTypeDef* pTD; hr = _dict->LookupTypeDef(*pPropTypeID, &pTD); if (SUCCEEDED(hr)) { IAAFTypeDefObjectRef* pTDObjectRef; hr = pTD->QueryInterface(IID_IAAFTypeDefObjectRef, (void**)&pTDObjectRef); if (SUCCEEDED(hr)) { IAAFObject* pTempObj; hr = pTDObjectRef->GetObject(pPV, IID_IAAFObject, (IUnknown **)&pTempObj); if (SUCCEEDED(hr)) { *ppObject = pTempObj; } pTDObjectRef->Release(); } pTD->Release(); } } if (pPV) pPV->Release(); return hr; }
// // Creates a type definition to describe ePosition enumerations, and // registers it in the dictionary. // void CreateAndRegisterPositionEnum (IAAFDictionary * pDict) { assert (pDict); IAAFTypeDef *ptd = NULL; IAAFTypeDefExtEnum *ptde = NULL; // Check to see if we are have already been registered. if (SUCCEEDED(pDict->LookupTypeDef (kTypeID_ePosition, &ptd))) { ptd->Release(); ptd = NULL; return; } try { // Instantiate a type definition object which will describe ePosition // extensible enumerations. check (pDict->CreateMetaInstance (AUID_AAFTypeDefExtEnum, IID_IAAFTypeDefExtEnum, (IUnknown**) &ptde)); // Initialize the type definition object with the given name, and to // be represented by the given AUID. We've already generated an // auid (kTypeID_ePosition) to represent this type defintion. check (ptde->Initialize (kTypeID_ePosition, L"PersonnelPosition")); // Pre-register a few element values, along with their names. We've // already generated AUIDs to represent the values (kPosition_XXX). check (ptde->AppendElement (kPosition_Producer, L"Producer")); check (ptde->AppendElement (kPosition_Editor, L"Editor")); check (ptde->AppendElement (kPosition_FloorManager, L"FloorManager")); check (ptde->AppendElement (kPosition_Actor, L"Actor")); // Register this type definition in the dictionary. The // dictionary::RegisterTypeDef() method expects an IAAFTypeDef // pointer, so we'll QI for that first. check (ptde->QueryInterface (IID_IAAFTypeDef, (void **)&ptd)); check (pDict->RegisterTypeDef (ptd)); ptd->Release(); ptd=NULL; ptde->Release(); ptde=NULL; } catch (...) { // cleanup after error... if (ptd) ptd->Release(); if (ptde) ptde->Release(); throw; } }
/* throws on error */ static void CheckMemberTypeEqual (IAAFTypeDefRecordSP rec, int member, IAAFTypeDef *td) { IAAFTypeDef * pMemberTd = 0; checkResult (rec->GetMemberType (member, &pMemberTd)); checkExpression (pMemberTd == td, AAFRESULT_TEST_FAILED); pMemberTd->Release (); }
void testKLVDataDefinitions(IAAFDictionary *pDictionary, IAAFMob *pMob) { IAAFDictionary2 *pDic2 = NULL; IAAFClassDef *pKLVDataCD = NULL; IAAFKLVDataDefinition *pKLVDef = NULL; IAAFKLVData *pKLVData = NULL; IAAFTypeDef *typeDef = NULL; IAAFClassDef *pKLVDataDefCD = NULL; const aafCharacter defName[32] = L"Data Definition Omega"; const aafCharacter defDescription[64] = L"This is a test of the data definition!!!"; static const aafUInt8 blobData[]={ 0x01, 0x02, 0x00, 0x00, 0x03 }; //lookup class definition for KLVData checkResult(pDictionary->LookupClassDef(AUID_AAFKLVData, &pKLVDataCD)); //Register the KLVKeys checkResult(pDictionary->LookupTypeDef(kAAFTypeID_UInt8Array, &typeDef)); checkResult(pDictionary->RegisterKLVDataKey(KLVKey_TestData, typeDef)); //Create KLVData and append it to Mob checkResult(pKLVDataCD->CreateInstance(IID_IAAFKLVData, (IUnknown **)&pKLVData)); checkResult(pKLVData->Initialize(KLVKey_TestData, sizeof(blobData), (aafUInt8 *)blobData)); checkResult(pMob->AppendKLVData(pKLVData)); checkResult( pDictionary->QueryInterface( IID_IAAFDictionary2, reinterpret_cast<void**>(&pDic2) ) ); assert(pDic2); //lookup class definition for KLVDataDefinition checkResult(pDictionary->LookupClassDef(AUID_AAFKLVDataDefinition, &pKLVDataDefCD)); //Create KLVDataDef and append it to Dic checkResult(pKLVDataDefCD->CreateInstance(IID_IAAFKLVDataDefinition, (IUnknown **)&pKLVDef)); checkResult(pKLVDef->Initialize(KLVDef_TestData, defName, defDescription)); checkResult(pDic2->RegisterKLVDataDef(pKLVDef)); //cleanup pDic2->Release(); pDic2 = NULL; pKLVDataCD->Release(); pKLVDataCD = NULL; pKLVDef->Release(); pKLVDef = NULL; pKLVData->Release(); pKLVData = NULL; typeDef->Release(); typeDef = NULL; pKLVDataDefCD->Release(); pKLVDataDefCD = NULL; }
//*********************************************************** // // SetObjRefPropOnObject() // // Set an object reference property on the AAF object specified // by pObj. The value of the property is specified in pObject. // // Returns: // // On Success: S_OK // On Failure: A failed HRESULT // HRESULT AAFDomainUtils::SetObjRefPropOnObject(IAAFObject* pObj, aafUID_t* pClassID, const aafUID_t* pPropTypeID, aafUID_t* pPropID, IAAFObject* pValue) { IAAFPropertyValue* pPV = NULL; IAAFTypeDef* pTD; HRESULT hr; // Create a property value from the supplied value (pValue) hr = _dict->LookupTypeDef(*pPropTypeID, &pTD); if (SUCCEEDED(hr)) { IAAFTypeDefObjectRef* pTDObjRef; hr = pTD->QueryInterface(IID_IAAFTypeDefObjectRef, (void**)&pTDObjRef); if (SUCCEEDED(hr)) { hr = pTDObjRef->CreateValue(pValue, &pPV); pTDObjRef->Release(); } pTD->Release(); } // Add the property to the target object. if (SUCCEEDED(hr)) { if (SUCCEEDED(hr)) { IAAFClassDef* pCD; // Get the class def for the object hr = _dict->LookupClassDef(*pClassID, &pCD); if (SUCCEEDED(hr)) { IAAFPropertyDef* pPD; hr = pCD->LookupPropertyDef(*pPropID, &pPD); if (SUCCEEDED(hr)) { // Set the propeter value on the target object hr = pObj->SetPropertyValue(pPD, pPV); pPD->Release(); } pCD->Release(); } } } if (pPV) pPV->Release(); return hr; }
static HRESULT GetOneTypeDef (IAAFDictionary * pDict, const aafUID_t & id, IAAFTypeDefInt ** ppTD) { assert (pDict); assert (ppTD); HRESULT hr = S_OK; IAAFTypeDef * pTypeDef = NULL; hr = pDict->LookupTypeDef(id, &pTypeDef); if (SUCCEEDED(hr)) { hr = pTypeDef->QueryInterface (IID_IAAFTypeDefInt, (void **) ppTD); pTypeDef->Release(); } return hr; }
//*********************************************************** // // GetIntegerPropFromObject() // // Get an integer property from the AAF object specified by pObj. // The value of the property is returned in pValue. // // Returns: // // On Success: AAFRESULT_SUCCESS // On Failure: An exception. // HRESULT AAFDomainUtils::GetIntegerPropFromObject(IAAFObject* pObj, const aafUID_t* pClassID, aafUID_t* pPropID, const aafUID_t* pIntTypeID, aafMemPtr_t pValue, aafUInt32 ValueSize, IAAFDictionary *dict) { AAFCheck hr; // Get the property value for the target property IAAFClassDef* pCD; hr = dict->LookupClassDef(*pClassID, &pCD); AutoRelease<IAAFClassDef> r1(pCD); IAAFPropertyDef* pPD; hr = pCD->LookupPropertyDef(*pPropID, &pPD); AutoRelease<IAAFPropertyDef> r2( pPD ); aafBool present = kAAFFalse; pObj->IsPropertyPresent(pPD, &present); IAAFPropertyValue* pPV = NULL; AutoRelease<IAAFPropertyValue> r3; if (present == kAAFTrue) { hr = pObj->GetPropertyValue(pPD, &pPV); r3 = pPV; } else { hr = AAFRESULT_PROP_NOT_PRESENT; } // Get the type def from the dict with which to interpret this // property value. IAAFTypeDef* pTD; hr = dict->LookupTypeDef(*pIntTypeID, &pTD); AutoRelease< IAAFTypeDef > r4 (pTD); IAAFTypeDefInt* pTDInt; hr = pTD->QueryInterface(IID_IAAFTypeDefInt, (void**)&pTDInt); AutoRelease< IAAFTypeDefInt > r5( pTDInt ); pTDInt->GetInteger(pPV, pValue, ValueSize); return AAFRESULT_SUCCESS; }
static HRESULT ReadAAFFile(aafWChar* pFileName) { IAAFFile* pFile = NULL; IAAFHeader* pHeader = NULL; IAAFDictionary* pDictionary = NULL; IEnumAAFOperationDefs *pOperationGroupEnum = NULL; IEnumAAFParameterDefs *pParmDefEnum = NULL; IAAFOperationDef *pOperationDef = NULL; IAAFParameterDef *pParmDef = NULL; IAAFParameter *pParameter = NULL; IAAFMetaDefinition* pMetaDefinition = NULL; IAAFSegment* pSeg = NULL; IAAFOperationGroup* pOperationGroup = NULL; IEnumAAFMobs *mobIter = NULL; IAAFMob* pMob = NULL; IEnumAAFMobSlots *slotIter = NULL; IAAFMobSlot* pSlot = NULL; IAAFFiller* pFill = NULL; IAAFSourceReference *pSourceRef = NULL; IEnumAAFControlPoints *pEnumCP = NULL; IAAFControlPoint *pControlPoint = NULL; IAAFVaryingValue *pVaryingValue = NULL; IAAFInterpolationDef *pInterpDef = NULL; IAAFTypeDef *pTypeDef = NULL; bool bFileOpen = false; aafBool readIsTimeWarp; aafUInt32 testNumSources, testNumParam; HRESULT hr = S_OK; aafNumSlots_t s; aafNumSlots_t numSlots; aafUInt32 readOverride; aafBool readValidTransition; aafRational_t testTime; aafRational_t sampleValue1 = kTestLevel1, sampleValue2 = kTestLevel2, testValue; aafRational_t checkTime1 = kTestTime1; aafRational_t checkTime2 = kTestTime2; aafEditHint_t checkEditHint; aafUID_t testInterpDef, checkInterpDef = kAAFTypeID_Rational; try { // Open the AAF file checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile)); bFileOpen = true; // Get the AAF file header. checkResult(pFile->GetHeader(&pHeader)); aafSearchCrit_t criteria; criteria.searchTag = kAAFNoSearch; checkResult(pHeader->GetMobs (&criteria, &mobIter)); checkResult(mobIter->NextOne (&pMob)); checkResult(pMob->GetSlots(&slotIter)); checkResult(pMob->CountSlots (&numSlots)); for(s = 0; s < numSlots; s++) { checkResult(slotIter->NextOne (&pSlot)); checkResult(pSlot->GetSegment (&pSeg)); checkResult(pSeg->QueryInterface (IID_IAAFOperationGroup, (void **)&pOperationGroup)); pSeg->Release(); pSeg = NULL; checkResult(pOperationGroup->CountSourceSegments(&testNumSources)); checkExpression(testNumSources == TEST_NUM_INPUTS, AAFRESULT_TEST_FAILED); checkResult(pOperationGroup->CountParameters(&testNumParam)); checkExpression(testNumSources == 1, AAFRESULT_TEST_FAILED); checkResult(pOperationGroup->IsATimeWarp (&readIsTimeWarp)); checkExpression(readIsTimeWarp == kAAFFalse, AAFRESULT_TEST_FAILED); checkResult(pOperationGroup->GetBypassOverride (&readOverride)); checkExpression(readOverride == 1, AAFRESULT_TEST_FAILED); checkResult(pOperationGroup->IsValidTranOperation (&readValidTransition)); checkExpression(readValidTransition == kAAFFalse, AAFRESULT_TEST_FAILED); /**/ checkResult(pOperationGroup->GetInputSegmentAt (0, &pSeg)); checkResult(pSeg->QueryInterface(IID_IAAFFiller, (void **) &pFill)); pFill->Release(); pFill = NULL; /**/ checkResult(pOperationGroup->LookupParameter (kTestParmID, &pParameter)); checkResult(pParameter->QueryInterface(IID_IAAFVaryingValue, (void **) &pVaryingValue)); /*** Check the VaryingValue methods **/ aafUInt32 testLen, bytesRead; checkResult(pVaryingValue->GetControlPoints(&pEnumCP)); checkResult(pEnumCP->NextOne(&pControlPoint)); checkResult(pControlPoint->GetValueBufLen (&testLen)); checkExpression(testLen == sizeof(sampleValue1), AAFRESULT_TEST_FAILED); checkResult(pControlPoint->GetValue (sizeof(sampleValue1), (aafDataBuffer_t)&testValue, &bytesRead)); checkExpression(testValue.numerator == sampleValue1.numerator, AAFRESULT_TEST_FAILED); checkExpression(testValue.denominator == sampleValue1.denominator, AAFRESULT_TEST_FAILED); checkExpression(bytesRead == sizeof(sampleValue1), AAFRESULT_TEST_FAILED); checkResult(pControlPoint->GetTime(&testTime)); checkExpression(testTime.numerator == checkTime1.numerator, AAFRESULT_TEST_FAILED); checkExpression(testTime.denominator == checkTime1.denominator, AAFRESULT_TEST_FAILED); checkResult(pControlPoint->GetEditHint(&checkEditHint)); checkExpression(checkEditHint == kAAFRelativeLeft, AAFRESULT_TEST_FAILED); checkResult(pControlPoint->GetTypeDefinition (&pTypeDef)); checkResult(pTypeDef->QueryInterface(IID_IAAFMetaDefinition, (void **) &pMetaDefinition)); checkResult(pMetaDefinition->GetAUID(&testInterpDef)); checkExpression(memcmp(&testInterpDef, &checkInterpDef, sizeof(aafUID_t)) == 0, AAFRESULT_TEST_FAILED); pControlPoint->Release(); pControlPoint = NULL; pTypeDef->Release(); pTypeDef = NULL; pMetaDefinition->Release(); pMetaDefinition = NULL; /**/ checkResult(pEnumCP->NextOne(&pControlPoint)); checkResult(pControlPoint->GetValueBufLen (&testLen)); checkExpression(testLen == sizeof(sampleValue2), AAFRESULT_TEST_FAILED); checkResult(pControlPoint->GetValue (sizeof(sampleValue2), (aafDataBuffer_t)&testValue, &bytesRead)); checkExpression(testValue.numerator == sampleValue2.numerator, AAFRESULT_TEST_FAILED); checkExpression(testValue.denominator == sampleValue2.denominator, AAFRESULT_TEST_FAILED); checkExpression(bytesRead == sizeof(sampleValue2), AAFRESULT_TEST_FAILED); checkResult(pControlPoint->GetTime(&testTime)); checkExpression(testTime.numerator == checkTime2.numerator, AAFRESULT_TEST_FAILED); checkExpression(testTime.denominator == checkTime2.denominator, AAFRESULT_TEST_FAILED); checkResult(pControlPoint->GetEditHint(&checkEditHint)); checkExpression(checkEditHint == kAAFProportional, AAFRESULT_TEST_FAILED); checkResult(pControlPoint->GetTypeDefinition (&pTypeDef)); checkResult(pTypeDef->QueryInterface(IID_IAAFMetaDefinition, (void **) &pMetaDefinition)); checkResult(pMetaDefinition->GetAUID(&testInterpDef)); checkExpression(memcmp(&testInterpDef, &checkInterpDef, sizeof(aafUID_t)) == 0, AAFRESULT_TEST_FAILED); pControlPoint->Release(); pControlPoint = NULL; pEnumCP->Release(); pEnumCP = NULL; pTypeDef->Release(); pTypeDef = NULL; pMetaDefinition->Release(); pMetaDefinition = NULL; /*****/ pVaryingValue->Release(); pVaryingValue = NULL; pParameter->Release(); pParameter = NULL; pSeg->Release(); pSeg = NULL; pOperationGroup->Release(); pOperationGroup = NULL; pSlot->Release(); pSlot = NULL; } slotIter->Release(); slotIter = NULL; pMob->Release(); pMob = NULL; } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (pFill) pFill->Release(); if(pInterpDef) pInterpDef->Release(); if(pVaryingValue) pVaryingValue->Release(); if (pSourceRef) pSourceRef->Release(); if (mobIter) mobIter->Release(); if (pSlot) pSlot->Release(); if (slotIter) slotIter->Release(); if (pMob) pMob->Release(); if (pHeader) pHeader->Release(); if (pSeg) pSeg->Release(); if (pControlPoint) pControlPoint->Release(); if(pEnumCP) pEnumCP->Release(); if (pOperationGroup) pOperationGroup->Release(); if (pDictionary) pDictionary->Release(); if (pOperationGroupEnum) pOperationGroupEnum->Release(); if (pParameter) pParameter->Release(); if (pParmDefEnum) pParmDefEnum->Release(); if (pOperationDef) pOperationDef->Release(); if (pMetaDefinition) pMetaDefinition->Release(); if (pParmDef) pParmDef->Release(); if (pTypeDef) pTypeDef->Release(); if (pFile) { // Close file if (bFileOpen) pFile->Close(); pFile->Release(); } return hr; }
static bool testRestore(const wchar_t* fileName) { bool passed = true; IAAFFile* pFile = 0; IAAFHeader* pHeader = 0; IAAFDictionary* pDictionary = 0; IAAFContentStorage* pStorage = 0; IEnumAAFMobs* pMobs = 0; IAAFMob* pMob = 0; try { pFile = openFileForReading(fileName); } catch (...) { return false; } try { // get the Mob containing the test data checkResult(pFile->GetHeader(&pHeader)); checkResult(pHeader->GetDictionary(&pDictionary)); checkResult(pHeader->GetContentStorage(&pStorage)); aafSearchCrit_t searchCrit; searchCrit.searchTag = kAAFByMobKind; searchCrit.tags.mobKind = kAAFAllMob; checkResult(pStorage->GetMobs(&searchCrit, &pMobs)); checkResult(pMobs->NextOne(&pMob)); IAAFObject* pObject = 0; IAAFClassDef* pClassDef = 0; IAAFPropertyDef* pPropertyDef = 0; IAAFPropertyValue* pPropertyValue = 0; IAAFTypeDef* pType = 0; IAAFTypeDefEnum* pEnumType = 0; try { printf(" * Baseline: "); const aafUID_t propId = {0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUInt8 testValue = 5; const wchar_t* testName = L"VersionPrivateBuild"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType)); aafInt64 value; aafCharacter name[256]; checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value)); checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256)); if (value == testValue && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pEnumType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); try { printf(" * Enum element size 1 : "); const aafUID_t propId = {0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUInt8 testValue = 1; const wchar_t* testName = L"AAA"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType)); aafInt64 value; aafCharacter name[256]; checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value)); checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256)); if (value == testValue && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pEnumType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); try { printf(" * Enum element size 2 : "); const aafUID_t propId = {0x20000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUInt8 testValue = 2; const wchar_t* testName = L"BBB"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType)); aafInt64 value; aafCharacter name[256]; checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value)); checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256)); if (value == testValue && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pEnumType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); try { printf(" * Enum element size 4 : "); const aafUID_t propId = {0x30000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUInt8 testValue = 1; const wchar_t* testName = L"AAA"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType)); aafInt64 value; aafCharacter name[256]; checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value)); checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256)); if (value == testValue && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pEnumType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); try { printf(" * Enum element size 8 : "); const aafUID_t propId = {0x40000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUInt8 testValue = 2; const wchar_t* testName = L"BBB"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType)); aafInt64 value; aafCharacter name[256]; checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value)); checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256)); if (value == testValue && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pEnumType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); } catch (...) { passed = false; } // cleanup release(pMob); release(pMobs); release(pStorage); release(pDictionary); release(pHeader); checkResult(pFile->Close()); release(pFile); report(passed); return passed; }
static HRESULT TestPropertyValue ( testMode_t mode, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { // HRESULT hr = E_FAIL; long hr = E_FAIL; const size_t fileNameBufLen = 128; aafWChar testFileName[ fileNameBufLen ] = L""; GenerateTestFileName( productID.productName, fileKind, fileNameBufLen, testFileName ); IAAFFile* pFile = NULL; if(mode == kAAFUnitTestReadWrite) { RemoveTestFile (testFileName); checkResult (CreateTestFile( testFileName, fileKind, rawStorageType, productID, &pFile )); assert (pFile); } else { checkResult (AAFFileOpenExistingRead(testFileName, 0, &pFile)); assert (pFile); } IAAFHeader * pHeader = NULL; hr = pFile->GetHeader (&pHeader); if (! SUCCEEDED (hr)) return hr; assert (pHeader); IAAFDictionary * pDict = NULL; hr = pHeader->GetDictionary (&pDict); if (! SUCCEEDED (hr)) return hr; assert (pDict); CAAFBuiltinDefs defs (pDict); // Let's try to do something interesting with a type definition IAAFTypeDefInt * pTypeDef = NULL; hr = defs.tdInt32()->QueryInterface (IID_IAAFTypeDefInt, (void **) &pTypeDef); if (! SUCCEEDED (hr)) return hr; assert (pTypeDef); if(mode == kAAFUnitTestReadWrite) { // Now attempt to create invalid property values; check for errors. const aafInt32 forty_two = 42; IAAFPropertyValue * pv = NULL; // This is what a correct one would look like; we're not ready for that yet: // hr = pTypeDef->CreateValue (&forty_two, 4, &pv); // set this to -1 to see if it gets modified pv = (IAAFPropertyValue *) (-1); // Try null pVal hr = pTypeDef->CreateValue (NULL, 4, &pv); if (AAFRESULT_NULL_PARAM != hr) return AAFRESULT_TEST_FAILED; if ((IAAFPropertyValue *)(-1) != pv) return AAFRESULT_TEST_FAILED; // Try valSize too large hr = pTypeDef->CreateValue ((aafMemPtr_t) &forty_two, 8, &pv); if (AAFRESULT_BAD_SIZE != hr) return AAFRESULT_TEST_FAILED; if ((IAAFPropertyValue *)(-1) != pv) return AAFRESULT_TEST_FAILED; // Now try correct one pv = NULL; hr = pTypeDef->CreateValue ((aafMemPtr_t) &forty_two, 4, &pv); if (! SUCCEEDED (hr)) return hr; if (! pv) return AAFRESULT_TEST_FAILED; // That one worked; let's try one with a smaller init size (should // also work) pv->Release(); pv = NULL; const aafInt16 fifty_seven = 57; hr = pTypeDef->CreateValue ((aafMemPtr_t) &fifty_seven, 2, &pv); if (! SUCCEEDED (hr)) return hr; if (! pv) return AAFRESULT_TEST_FAILED; // cool. Now we should have a good property value whose value is 57. // check GetType() for error condition hr = pv->GetType (NULL); if (AAFRESULT_NULL_PARAM != hr) return AAFRESULT_TEST_FAILED; // this GetType() call should work, and return the original type def. IAAFTypeDef * propType = NULL; hr = pv->GetType (&propType); if (! SUCCEEDED (hr)) return hr; if (! propType) return AAFRESULT_TEST_FAILED; // Convert both to IUnknown for comparison IUnknown * pPropUnknown = NULL; IUnknown * pTypeDefUnknown = NULL; hr = propType->QueryInterface(IID_IUnknown, (void **)&pPropUnknown); if (! SUCCEEDED (hr)) return hr; assert (pPropUnknown); hr = pTypeDef->QueryInterface(IID_IUnknown, (void **)&pTypeDefUnknown); if (! SUCCEEDED (hr)) return hr; assert (pTypeDefUnknown); if (pPropUnknown != pTypeDefUnknown) return AAFRESULT_TEST_FAILED; // Test IsDefinedType () // (Currently only returns true.) aafBool b = kAAFFalse; hr = pv->IsDefinedType (&b); if (! SUCCEEDED (hr)) return hr; if (kAAFTrue != b) return AAFRESULT_TEST_FAILED; pTypeDefUnknown->Release(); pPropUnknown->Release(); pTypeDef->Release(); propType->Release(); pv->Release(); pDict->Release(); pHeader->Release(); hr = pFile->Save(); } if (! SUCCEEDED (hr)) return hr; hr = pFile->Close(); if (! SUCCEEDED (hr)) return hr; pFile->Release(); return AAFRESULT_SUCCESS; }
static bool testRestore(const wchar_t* fileName) { bool passed = true; IAAFFile* pFile = 0; IAAFHeader* pHeader = 0; IAAFDictionary* pDictionary = 0; IAAFContentStorage* pStorage = 0; IEnumAAFMobs* pMobs = 0; IAAFMob* pMob = 0; try { pFile = openFileForReading(fileName); } catch (...) { return false; } try { // get the Mob containing the test data checkResult(pFile->GetHeader(&pHeader)); checkResult(pHeader->GetDictionary(&pDictionary)); checkResult(pHeader->GetContentStorage(&pStorage)); aafSearchCrit_t searchCrit; searchCrit.searchTag = kAAFByMobKind; searchCrit.tags.mobKind = kAAFAllMob; checkResult(pStorage->GetMobs(&searchCrit, &pMobs)); checkResult(pMobs->NextOne(&pMob)); IAAFObject* pObject = 0; IAAFClassDef* pClassDef = 0; IAAFPropertyDef* pPropertyDef = 0; IAAFPropertyValue* pPropertyValue = 0; IAAFTypeDef* pType = 0; IAAFTypeDefFixedArray* pFixedArrayType = 0; IAAFTypeDefInt* pIntType = 0; IAAFPropertyValue* pIntValue = 0; try { printf(" * Baseline element type: "); const aafUID_t propId = {0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUInt8 testValue[2] = {0,255}; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefFixedArray, (void **)&pFixedArrayType)); release(pType); checkResult(pFixedArrayType->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefInt, (void **)&pIntType)); aafUInt8 value[2]; checkResult(pFixedArrayType->GetElementValue(pPropertyValue, 0, &pIntValue)); checkResult(pIntType->GetInteger(pIntValue, &value[0], 1)); release(pIntValue); checkResult(pFixedArrayType->GetElementValue(pPropertyValue, 1, &pIntValue)); checkResult(pIntType->GetInteger(pIntValue, &value[1], 1)); if (value[0] == testValue[0] && value[1] == testValue[1]) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pIntValue); release(pIntType); release(pFixedArrayType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); try { printf(" * Non-Baseline element type: "); const aafUID_t propId = {0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUInt8 testValue[2] = {1,2}; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefFixedArray, (void **)&pFixedArrayType)); release(pType); checkResult(pFixedArrayType->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefInt, (void **)&pIntType)); aafUInt8 value[2]; checkResult(pFixedArrayType->GetElementValue(pPropertyValue, 0, &pIntValue)); checkResult(pIntType->GetInteger(pIntValue, &value[0], 1)); release(pIntValue); checkResult(pFixedArrayType->GetElementValue(pPropertyValue, 1, &pIntValue)); checkResult(pIntType->GetInteger(pIntValue, &value[1], 1)); if (value[0] == testValue[0] && value[1] == testValue[1]) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pIntValue); release(pIntType); release(pFixedArrayType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); } catch (...) { passed = false; } // cleanup release(pMob); release(pMobs); release(pStorage); release(pDictionary); release(pHeader); checkResult(pFile->Close()); release(pFile); report(passed); return passed; }
static HRESULT ReadRecordNoStructs (const aafWChar * pFileName, int loadingMode) { HRESULT hr = E_FAIL; HRESULT temphr; IAAFFileSP pFile; try { // Open the file, and get the dictionary. checkResult(AAFFileOpenExistingRead(pFileName, loadingMode, &pFile)); IAAFHeaderSP pHeader; checkResult(pFile->GetHeader(&pHeader)); IAAFDictionarySP pDict; checkResult (pHeader->GetDictionary(&pDict)); CAAFBuiltinDefs defs(pDict); // get the SDK version against which we are testing aafProductVersion_t testVer; checkResult(pHeader->GetRefImplVersion(&testVer)); // Get the type definitions for our new types. IAAFTypeDefSP ptd; checkResult (pDict->LookupTypeDef (sTypeId_Rational16, &ptd)); IAAFTypeDefRecordSP ptdr16; checkResult (ptd->QueryInterface (IID_IAAFTypeDefRecord, (void**) &ptdr16)); checkResult (pDict->LookupTypeDef (sTypeId_Rational16_pair, &ptd)); IAAFTypeDefRecordSP ptdr16p; checkResult (ptd->QueryInterface (IID_IAAFTypeDefRecord, (void**) &ptdr16p)); // Setup to read the Velocity property which is of typed Mixed_t checkResult (pDict->LookupTypeDef (sTypeId_Mixed, &ptd)); IAAFTypeDefRecordSP ptdrmixed; checkResult (ptd->QueryInterface (IID_IAAFTypeDefRecord, (void**) &ptdrmixed)); IAAFTypeDef * pTempTd = 0; checkResult (ptdr16->QueryInterface (IID_IAAFTypeDef, (void**) &pTempTd)); CheckMemberTypeEqual (ptdr16p, 0, pTempTd); CheckMemberTypeEqual (ptdr16p, 1, pTempTd); pTempTd->Release (); pTempTd = 0; temphr = ptdr16p->GetMemberType (2, &pTempTd); checkExpression (temphr == AAFRESULT_ILLEGAL_VALUE, AAFRESULT_TEST_FAILED); // register variable array of Rational16Pair records IAAFTypeDefVariableArraySP ptdvaarpr; IAAFTypeDefSP ptdarpr; // perform this part only for specified versions if( versionUInt(testVer) >= versionUInt(1,1,1,0) ) { checkResult (pDict->LookupTypeDef (sTypeId_Rational16_array,&ptdarpr)); checkResult (ptdarpr->QueryInterface (IID_IAAFTypeDefVariableArray,(void**) &ptdvaarpr)); } // Now read the CompositionMob to which we added some optional // properties. IEnumAAFMobsSP pEnumMobs; checkResult (pHeader->GetMobs (0, &pEnumMobs)); IAAFMobSP pMob; checkResult (pEnumMobs->NextOne (&pMob)); IAAFObjectSP pObj; checkResult (pMob->QueryInterface (IID_IAAFObject, (void**) &pObj)); // get the property definitions for the added properties IAAFPropertyDefSP pPdPosA; checkResult (defs.cdCompositionMob()-> LookupPropertyDef (sPropertyId_positionA, &pPdPosA)); IAAFPropertyDefSP pPdPosB; checkResult (defs.cdCompositionMob()-> LookupPropertyDef (sPropertyId_positionB, &pPdPosB)); IAAFPropertyDefSP pPdPosC; checkResult (defs.cdCompositionMob()-> LookupPropertyDef (sPropertyId_positionC, &pPdPosC)); IAAFPropertyValueSP pPVa; checkResult (pObj->GetPropertyValue (pPdPosA, &pPVa)); IAAFPropertyValueSP pPVb; checkResult (pObj->GetPropertyValue (pPdPosB, &pPVb)); IAAFPropertyValueSP pPVc; checkResult (pObj->GetPropertyValue (pPdPosC, &pPVc)); // Read back the value of the Velocity property IAAFPropertyDefSP pPdvelocity; checkResult (defs.cdCompositionMob()->LookupPropertyDef(sPropertyId_velocity, &pPdvelocity)); IAAFPropertyValueSP pPVvelocity; checkResult (pObj->GetPropertyValue (pPdvelocity, &pPVvelocity)); IAAFPropertyValueSP pPVvelocityAngle, pPVvelocitySpeed; checkResult (ptdrmixed->GetValue (pPVvelocity, 0, &pPVvelocityAngle)); checkResult (ptdrmixed->GetValue (pPVvelocity, 1, &pPVvelocitySpeed)); Mixed_t velocity = {0, 0}; IAAFTypeDefSP pTDmem; IAAFTypeDefIntSP pTDIntMem; checkResult (ptdrmixed->GetMemberType (0, &pTDmem)); checkResult (pTDmem->QueryInterface (IID_IAAFTypeDefInt, (void **) &pTDIntMem)); checkResult (pTDIntMem->GetInteger (pPVvelocityAngle, (aafMemPtr_t)(&velocity.angle), sizeof(velocity.angle))); checkResult (ptdrmixed->GetMemberType (1, &pTDmem)); checkResult (pTDmem->QueryInterface (IID_IAAFTypeDefInt, (void **) &pTDIntMem)); checkResult (pTDIntMem->GetInteger (pPVvelocitySpeed, (aafMemPtr_t)(&velocity.speed), sizeof(velocity.speed))); checkExpression (15 == velocity.angle, AAFRESULT_TEST_FAILED); checkExpression (2001 == velocity.speed, AAFRESULT_TEST_FAILED); // Try to read the first one Rational16pair_t valA = { {1, 2}, {3, 4} }; CheckRational16PairByValues (ptdr16p, ptdr16, pPVa, valA); // Try to read the second one Rational16pair_t valB = { {5, 6}, {7, 8} }; CheckRational16PairByValues (ptdr16p, ptdr16, pPVb, valB); // Check misc. error return conditions for TypeDefRecord GetValue IAAFPropertyValueSP junkPv; temphr = ptdr16->GetValue (0, 1, &junkPv); checkExpression (AAFRESULT_NULL_PARAM == temphr, AAFRESULT_TEST_FAILED); temphr = ptdr16p->GetValue (pPVb, 1, 0); checkExpression (AAFRESULT_NULL_PARAM == temphr, AAFRESULT_TEST_FAILED); // Read the last two with GetStruct just to get it over with. ;) Rational16pair_t valC = { {9, 10}, {11, 12} }; CheckRational16PairByValues (ptdr16p, ptdr16, pPVc, valC); // test variable array of records // perform this part only for specified versions if( versionUInt(testVer) >= versionUInt(1,1,1,0) ) { IAAFPropertyDefSP pPdPosN; checkResult (defs.cdCompositionMob()->LookupPropertyDef (sPropertyId_positionN, &pPdPosN)); IAAFPropertyValueSP pPVN; checkResult (pObj->GetPropertyValue (pPdPosN, &pPVN)); // get the middle element of the array, 9abc IAAFPropertyValueSP pPVN1; checkResult (ptdvaarpr->GetElementValue (pPVN, 1, &pPVN1)); // Read the value with GetStruct Rational16pair_t valN1 = { {9,10},{11,12} }; CheckRational16PairByValues (ptdr16p, ptdr16, pPVN1, valN1); } // Attempt to close the file. checkResult(pFile->Close()); IAAFFileSP nullFile; pFile = nullFile; // zeros the pFile, and releases it. hr = AAFRESULT_SUCCESS; } catch (HRESULT& rResult) { hr = rResult; } // cleanup if (pFile) { pFile->Close(); } return hr; }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { IAAFFile * pFile = NULL; bool bFileOpen = false; IAAFHeader * pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFMob *pMob = NULL; IAAFMob *pMob2 = NULL; IAAFMob2 *pMobInterface2 = NULL; IAAFTimelineMobSlot *newSlot = NULL; IAAFStaticMobSlot *newStaticSlot=NULL; IAAFEventMobSlot *newEventSlot=NULL; IAAFSegment *seg = NULL; IAAFSourceClip *sclp = NULL; IAAFEvent *event=NULL; IAAFComponent* pComponent = NULL; IAAFClassDef *pcdEventMeta=NULL; IAAFClassDef *pcdEvent=NULL; IAAFClassDef *pcdEventConcrete=NULL; HRESULT hr = S_OK; aafNumSlots_t numMobs; aafUInt32 bufLen = 0; aafUInt32 bytesRead = 0; aafUInt32 numComments = 0; aafUInt32 numFound = 0; aafWChar name[500]; aafWChar value[500]; IEnumAAFTaggedValues *enumTaggedVal = NULL; IAAFTaggedValue *taggedVal = NULL; IAAFMobSlot *mSlot = NULL; IAAFFiller *filler = NULL; IAAFKLVData *pKLVData = NULL; IAAFTypeDef* pBaseType = NULL; IAAFSourceReference *pSourceRef = NULL; IAAFTimecode *pTimecode = NULL; aafTimecode_t timecode; int i; try { // Remove the previous test file if any. RemoveTestFile(pFileName); // Create the 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); //Make the first mob long test; // Create a concrete subclass of Mob checkResult(defs.cdMasterMob()-> CreateInstance(IID_IAAFMob, (IUnknown **)&pMob)); checkResult( pMob->QueryInterface(IID_IAAFMob2,(void**)&pMobInterface2)); checkResult(pMob->SetMobID(MOBTestID)); checkExpression(pMob->GetNameBufLen(&bufLen) == AAFRESULT_PROP_NOT_PRESENT, AAFRESULT_TEST_FAILED); checkExpression(pMob->GetName(name, 0) == AAFRESULT_PROP_NOT_PRESENT, AAFRESULT_TEST_FAILED); checkExpression(pMob->SetName(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(pMob->SetName(mobName)); checkResult(pMob->SetCreateTime(creationTimeStamp)); checkResult(pMob->SetModTime(modificationTimeStamp)); // Add some slots for(test = 1; test < 6; test++) { checkResult(defs.cdSourceClip()-> CreateInstance(IID_IAAFSourceClip, (IUnknown **)&sclp)); checkResult(sclp->QueryInterface(IID_IAAFSourceReference, (void **)&pSourceRef)); checkResult(pSourceRef->SetSourceID(MOBTestID3)); checkResult(sclp->QueryInterface(IID_IAAFComponent, (void **)&pComponent)); checkResult(pComponent->SetDataDef(defs.ddkAAFPicture())); checkResult(sclp->QueryInterface (IID_IAAFSegment, (void **)&seg)); aafRational_t editRate = { 0, 1}; checkResult(pMob->AppendNewTimelineSlot (editRate, seg, test+1, slotNames[test], 0, &newSlot)); if(test == 5) { checkExpression(pMob->AppendNewTimelineSlot (editRate, NULL, test+1, slotNames[test], 0, &newSlot) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkExpression(pMob->AppendNewTimelineSlot (editRate, seg, test+1, NULL, 0, &newSlot) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkExpression(pMob->AppendNewTimelineSlot (editRate, seg, test+1, slotNames[test], 0, NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); pMob->RemoveSlotAt(4); checkExpression(pMob->RemoveSlotAt(test+1) == AAFRESULT_BADINDEX, AAFRESULT_TEST_FAILED); } newSlot->Release(); newSlot = NULL; if(newStaticSlot) newStaticSlot->Release(); newStaticSlot = NULL; seg->Release(); seg = NULL; sclp->Release(); sclp = NULL; pComponent->Release(); pComponent = NULL; pSourceRef->Release(); pSourceRef = NULL; } // PrependSlot checkResult(defs.cdStaticMobSlot()-> CreateInstance(IID_IAAFMobSlot, (IUnknown **)&mSlot)); checkResult(defs.cdFiller()-> CreateInstance(IID_IAAFFiller, (IUnknown **)&filler)); checkResult(filler->Initialize(defs.ddkAAFSound(), 10)); checkResult(filler->QueryInterface (IID_IAAFSegment, (void **)&seg)); checkResult(mSlot->SetName(slotNames[0])); checkResult(mSlot->SetPhysicalNum(1)); checkResult(mSlot->SetSlotID(1)); checkResult(mSlot->SetSegment(seg)); checkResult(pMob->PrependSlot(mSlot)); checkExpression(pMob->PrependSlot(mSlot) == AAFRESULT_OBJECT_ALREADY_ATTACHED, AAFRESULT_TEST_FAILED); checkExpression(pMob->PrependSlot(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); mSlot->Release(); mSlot = NULL; seg->Release(); seg = NULL; filler->Release(); filler = NULL; // AppendSlot checkResult(defs.cdStaticMobSlot()-> CreateInstance(IID_IAAFMobSlot, (IUnknown **)&mSlot)); checkResult(defs.cdFiller()-> CreateInstance(IID_IAAFFiller, (IUnknown **)&filler)); checkResult(filler->Initialize(defs.ddkAAFSound(), 10)); checkResult(filler->QueryInterface (IID_IAAFSegment, (void **)&seg)); checkResult(mSlot->SetName(slotNames[6])); checkResult(mSlot->SetPhysicalNum(1)); checkResult(mSlot->SetSlotID(7)); checkResult(mSlot->SetSegment(seg)); checkResult(pMob->AppendSlot(mSlot)); checkExpression(pMob->AppendSlot(mSlot) == AAFRESULT_OBJECT_ALREADY_ATTACHED, AAFRESULT_TEST_FAILED); checkExpression(pMob->AppendSlot(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); mSlot->Release(); mSlot = NULL; seg->Release(); seg = NULL; filler->Release(); filler = NULL; // InsertSlotAt -- insert a timecode object for OffsetToMobTimecode() testing timecode.startFrame = TCstartFrame; // One hour timecode.drop = TCdrop; timecode.fps = TCfps; checkResult(defs.cdTimecode()-> CreateInstance(IID_IAAFTimecode, (IUnknown **)&pTimecode)); checkResult(pTimecode->Initialize(100, &timecode)); checkResult(pTimecode->QueryInterface (IID_IAAFSegment, (void **)&seg)); assert(pComponent == NULL); checkResult(pTimecode->QueryInterface(IID_IAAFComponent,(void **)&pComponent)); checkResult(pComponent->SetDataDef(defs.ddkAAFTimecode())); pComponent->Release(); pComponent = NULL; checkResult(defs.cdStaticMobSlot()-> CreateInstance(IID_IAAFMobSlot, (IUnknown **)&mSlot)); checkResult(mSlot->SetName(slotNames[5])); checkResult(mSlot->SetPhysicalNum(1)); checkResult(mSlot->SetSlotID(6)); checkResult(mSlot->SetSegment(seg)); checkExpression(pMob->InsertSlotAt(8, mSlot) == AAFRESULT_BADINDEX, AAFRESULT_TEST_FAILED); checkResult(pMob->InsertSlotAt(5, mSlot)); checkExpression(pMob->InsertSlotAt(4, mSlot) == AAFRESULT_OBJECT_ALREADY_ATTACHED, AAFRESULT_TEST_FAILED); checkExpression(pMob->InsertSlotAt(1, NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); mSlot->Release(); mSlot = NULL; seg->Release(); seg = NULL; pTimecode->Release(); pTimecode = NULL; //now test AppendNewStaticSlot checkResult(defs.cdSourceClip()-> CreateInstance(IID_IAAFSourceClip, (IUnknown **)&sclp)); checkResult(sclp->QueryInterface(IID_IAAFSourceReference, (void **)&pSourceRef)); checkResult(pSourceRef->SetSourceID(MOBTestID_Static)); checkResult(sclp->QueryInterface(IID_IAAFComponent, (void **)&pComponent)); checkResult(pComponent->SetDataDef(defs.ddkAAFPicture())); checkResult(sclp->QueryInterface (IID_IAAFSegment, (void **)&seg)); checkResult(pMobInterface2->AppendNewStaticSlot ( seg, 8, slotNames[7], &newStaticSlot)); if(newStaticSlot) newStaticSlot->Release(); newStaticSlot = NULL; seg->Release(); seg = NULL; pSourceRef->Release(); pSourceRef = NULL; sclp->Release(); sclp = NULL; pComponent->Release(); pComponent = NULL; //now test AppendNewEventSlot //Create a concrete version of IAAFEvent checkResult (pDictionary->CreateMetaInstance (AUID_AAFClassDef, IID_IAAFClassDef, (IUnknown**) &pcdEventMeta)); checkResult (pDictionary->LookupClassDef (AUID_AAFEvent, &pcdEvent)); checkResult (pcdEventMeta->Initialize (kClassID_ConcreteEvent, pcdEvent, L"COncreteEvent", kAAFTrue)); checkResult (pDictionary->RegisterClassDef (pcdEventMeta)); //Now instantiate it checkResult(pDictionary->LookupClassDef(kClassID_ConcreteEvent, &pcdEventConcrete)); checkResult(pcdEventConcrete->CreateInstance(IID_IAAFEvent, (IUnknown **)&event)); //and initialize reqruied properties checkResult(event->QueryInterface(IID_IAAFComponent, (void **)&pComponent)); checkResult(pComponent->SetDataDef(defs.ddkAAFPicture())); event->SetPosition(1); aafRational_t EventeditRate = { 0, 1}; //get the segment checkResult(event->QueryInterface (IID_IAAFSegment, (void **)&seg)); checkResult(pMobInterface2->AppendNewEventSlot ( EventeditRate, seg, 9, slotNames[8], 0, &newEventSlot)); if(newEventSlot) newEventSlot->Release(); newEventSlot = NULL; seg->Release(); seg = NULL; pComponent->Release(); pComponent = NULL; event->Release(); event = NULL; pcdEventConcrete->Release(); pcdEventConcrete = NULL; pcdEvent->Release(); pcdEvent = NULL; pcdEventMeta->Release(); pcdEventMeta = NULL; // Try CountKLVData before any have been attached numFound = 1; checkResult(pMob->CountKLVData(&numFound)); checkExpression(numFound == 0, AAFRESULT_TEST_FAILED); checkExpression(pMob->CountKLVData(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); // AppendKLVData - attach some objects checkResult(pDictionary->LookupTypeDef (kAAFTypeID_UInt8Array, &pBaseType)); checkResult(pDictionary->RegisterKLVDataKey(TEST_KLV, pBaseType)); pBaseType->Release(); pBaseType = NULL; checkExpression(pMob->AppendKLVData(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(defs.cdKLVData()-> CreateInstance(IID_IAAFKLVData, (IUnknown **)&pKLVData)); checkResult(pKLVData->Initialize(TEST_KLV, sizeof(KLVfrowney), (unsigned char *)KLVfrowney)); checkResult(pMob->AppendKLVData(pKLVData)); pKLVData->Release(); pKLVData = NULL; checkResult(defs.cdKLVData()-> CreateInstance(IID_IAAFKLVData, (IUnknown **)&pKLVData)); checkResult(pKLVData->Initialize(TEST_KLV, sizeof(KLVfrowney), (unsigned char *)KLVfrowney)); checkResult(pMob->AppendKLVData(pKLVData)); checkExpression(pMob->AppendKLVData(pKLVData) == AAFRESULT_OBJECT_ALREADY_ATTACHED, AAFRESULT_TEST_FAILED); // RemoveKLVData - remove object #2 checkExpression(pMob->RemoveKLVData(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(pMob->CountKLVData(&numFound)); checkExpression(numFound == 2, AAFRESULT_TEST_FAILED); checkResult(pMob->RemoveKLVData(pKLVData)); checkResult(pMob->CountKLVData(&numFound)); checkExpression(numFound == 1, AAFRESULT_TEST_FAILED); pKLVData->Release(); pKLVData = NULL; // Try removing an object that is not attached checkResult(defs.cdKLVData()-> CreateInstance(IID_IAAFKLVData, (IUnknown **)&pKLVData)); checkResult(pKLVData->Initialize(TEST_KLV, sizeof(KLVsmiley), (unsigned char *)KLVsmiley)); checkExpression(pMob->RemoveKLVData(pKLVData) == AAFRESULT_OBJECT_NOT_ATTACHED, AAFRESULT_TEST_FAILED); // Attach it to replace the one removed checkResult(pMob->AppendKLVData(pKLVData)); pKLVData->Release(); pKLVData = NULL; // Comments checkExpression(pMob->GetComments(&enumTaggedVal) == AAFRESULT_PROP_NOT_PRESENT, AAFRESULT_TEST_FAILED); // Check CountComments() checkExpression(pMob->CountComments(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); numComments = 1; checkResult(pMob->CountComments(&numComments)); checkExpression(numComments == 0, AAFRESULT_TEST_FAILED); // Check AppendComments() checkExpression(pMob->AppendComment(NULL, pComment[0]) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkExpression(pMob->AppendComment(const_cast<aafWChar*>(pCategory[0]), NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); for (i = 0; i < 5; ++i) { checkResult(pMob->AppendComment(const_cast<aafWChar*>(pCategory[i]), pComment[i])); } checkResult(pMob->CountComments(&numComments)); checkExpression(numComments == 5, AAFRESULT_TEST_FAILED); // Check GetComments() checkExpression(pMob->GetComments(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(pMob->GetComments(&enumTaggedVal)); for (i = 0; i < 5; ++i) { checkResult(enumTaggedVal->NextOne(&taggedVal)); checkResult(taggedVal->GetNameBufLen(&bufLen)); checkResult(taggedVal->GetName(name, bufLen)); checkExpression(wcscmp(name, pCategory[i]) == 0, AAFRESULT_TEST_FAILED); checkResult(taggedVal->GetValueBufLen(&bufLen)); checkResult(taggedVal->GetValue(bufLen, (aafDataBuffer_t)value, &bytesRead)); checkExpression(wcscmp(value, pComment[i]) == 0, AAFRESULT_TEST_FAILED); taggedVal->Release(); taggedVal = NULL; } checkResult(defs.cdTaggedValue()-> CreateInstance(IID_IAAFTaggedValue, (IUnknown **)&taggedVal)); checkExpression(pMob->RemoveComment(taggedVal) == AAFRESULT_OBJECT_NOT_ATTACHED, AAFRESULT_TEST_FAILED); taggedVal->Release(); taggedVal = NULL; enumTaggedVal->Reset(); enumTaggedVal->Skip(2); checkResult(enumTaggedVal->NextOne(&taggedVal)); checkExpression(pMob->RemoveComment(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(pMob->RemoveComment(taggedVal)); taggedVal->Release(); taggedVal = NULL; enumTaggedVal->Reset(); for (i = 0; i < 5; ++i) { if (i==2) continue; checkResult(enumTaggedVal->NextOne(&taggedVal)); checkResult(taggedVal->GetNameBufLen(&bufLen)); checkResult(taggedVal->GetName(name, bufLen)); checkExpression(wcscmp(name, pCategory[i]) == 0, AAFRESULT_TEST_FAILED); checkResult(taggedVal->GetValueBufLen(&bufLen)); checkResult(taggedVal->GetValue(bufLen, (aafDataBuffer_t)value, &bytesRead)); checkExpression(wcscmp(value, pComment[i]) == 0, AAFRESULT_TEST_FAILED); taggedVal->Release(); taggedVal = NULL; } enumTaggedVal->Release(); enumTaggedVal = NULL; // Check the Mob2 attribute and usage code implementations. // Need IAAFMob2 for that; checkResult( pMobInterface2->AppendAttribute( AttributeNames[0], AttributeValues[0] ) ); checkResult( pMobInterface2->AppendAttribute( AttributeNames[1], AttributeValues[1] ) ); checkResult( pMobInterface2->SetUsageCode( kAAFUsage_SubClip ) ); // Add the mob to the file. checkResult(pHeader->AddMob(pMob)); // Test changing the mob id after the mob is attached to the // content store. Change it, then reset to the original id. checkResult(pMob->SetMobID(MOBTestID2)); checkResult(pMob->SetMobID(MOBTestID)); // Create another Mob, check mob count, then delete and recheck count checkResult(defs.cdMasterMob()-> CreateInstance(IID_IAAFMob, (IUnknown **)&pMob2)); checkResult(pMob2->SetMobID(MOBTestID2)); checkResult(pMob2->SetName(mobName)); checkResult(pMob2->SetCreateTime(creationTimeStamp)); checkResult(pMob2->SetModTime(modificationTimeStamp)); // Add the mob to the file. checkResult(pHeader->AddMob(pMob2)); checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs)); checkExpression(numMobs == 2, AAFRESULT_TEST_FAILED); checkResult(pHeader->RemoveMob(pMob2)); checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs)); checkExpression(numMobs == 1, AAFRESULT_TEST_FAILED); //try Copy() const aafCharacter *copy_name = L"Name of Copied Mob"; IAAFMobSP spCopiedMob; checkResult(pMob->Copy(copy_name, &spCopiedMob)); checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs)); checkExpression(numMobs == 2, AAFRESULT_TEST_FAILED); checkResult(pHeader->RemoveMob(spCopiedMob)); checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs)); checkExpression(numMobs == 1, AAFRESULT_TEST_FAILED); //try CloneExternal IAAFMobSP spClonedMob; IAAFFileSP spDestFile; aafCharacter dest_filename[128]; wcscpy(dest_filename, pFileName); wcscat(dest_filename, L"_clone"); // Remove the previous test file if any. RemoveTestFile(dest_filename); checkResult(CreateTestFile( dest_filename, fileKind, rawStorageType, productID, &spDestFile )); checkResult(pMob->CloneExternal(kAAFNoFollowDepend, kAAFNoIncludeMedia, spDestFile, &spClonedMob)); checkResult(spDestFile->Save()); checkResult(spDestFile->Close()); } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (enumTaggedVal) enumTaggedVal->Release(); if (newSlot) newSlot->Release(); if (newStaticSlot) newStaticSlot->Release(); if (seg) seg->Release(); if (pComponent) pComponent->Release(); if (sclp) sclp->Release(); if (pMob) pMob->Release(); if (pMob2) pMob2->Release(); if (pMobInterface2) pMobInterface2->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if(pcdEventMeta) pcdEventMeta->Release(); if(pcdEvent) pcdEvent->Release(); if(pcdEventConcrete) pcdEventConcrete->Release(); if (pFile) { // Close file if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } return hr; }
static HRESULT ReadAAFFile(aafWChar * pFileName) { IAAFDictionary *pDictionary = NULL; IAAFFile *pFile = NULL; bool bFileOpen = false; IAAFHeader *pHeader = NULL; IEnumAAFMobs *mobIter = NULL; IAAFMob *aMob = NULL; IEnumAAFMobSlots *slotIter = NULL; IAAFMobSlot *slot = NULL; aafNumSlots_t numMobs, n, s; HRESULT hr = S_OK; aafUInt32 bufLen = 0; aafUInt32 bytesRead = 0; aafUInt32 numFound = 0; aafWChar value[500]; IEnumAAFTaggedValues *enumTaggedVal = NULL; IAAFTaggedValue *taggedVal = NULL; aafUID_t testKey; IEnumAAFKLVData *klvEnum = NULL; IAAFKLVData *pKLVData = NULL; IAAFTypeDef* pBaseType = NULL; IAAFSourceClip *pSourceClip = NULL; IAAFSourceReference *pSourceRef = NULL; IAAFSegment *pSegment = NULL; aafMobID_t sourceID; int i; 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->GetDictionary(&pDictionary)); CAAFBuiltinDefs defs (pDictionary); 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; aafUInt32 nameBufLen = 0; checkResult(mobIter->NextOne (&aMob)); // Check GetNameBufLen and GetName checkExpression(aMob->GetNameBufLen(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(aMob->GetNameBufLen(&nameBufLen)); checkExpression(((wcslen(mobName) + 1) * sizeof(aafCharacter)) == nameBufLen, AAFRESULT_TEST_FAILED); checkExpression(aMob->GetName (NULL, nameBufLen) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkExpression(aMob->GetName (name, 4) == AAFRESULT_SMALLBUF, AAFRESULT_TEST_FAILED); checkResult(aMob->GetName (name, nameBufLen)); checkExpression (wcscmp(mobName, name) == 0, AAFRESULT_TEST_FAILED); // Check GetMobID checkExpression(aMob->GetMobID (NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(aMob->GetMobID (&mobID)); checkExpression(memcmp(&MOBTestID, &mobID, sizeof(mobID)) == 0, AAFRESULT_TEST_FAILED); // Check the time stamps aafTimeStamp_t created = { {0,0,0}, {0,0,0,0} }; checkExpression(aMob->GetCreateTime(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(aMob->GetCreateTime(&created)); checkTimeStampsAreEqual(creationTimeStamp, created); aafTimeStamp_t modified = { {0,0,0}, {0,0,0,0} }; checkExpression(aMob->GetModTime(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(aMob->GetModTime(&modified)); checkTimeStampsAreEqual(modificationTimeStamp, modified); // Check the GetMobInfo data. memset(&created, 0, sizeof(created)); memset(&modified, 0, sizeof(modified)); checkExpression(aMob->GetMobInfo(NULL, &created, name, sizeof(name)) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkExpression(aMob->GetMobInfo(&modified, NULL, name, sizeof(name)) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkExpression(aMob->GetMobInfo(&modified, &created, NULL, sizeof(name)) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkExpression(aMob->GetMobInfo(&modified, &created, name, 1) == AAFRESULT_SMALLBUF, AAFRESULT_TEST_FAILED); checkResult(aMob->GetMobInfo(&modified, &created, name, sizeof(name))); checkTimeStampsAreEqual(creationTimeStamp, created); checkTimeStampsAreEqual(modificationTimeStamp, modified); checkExpression (wcscmp(mobName, name) == 0, AAFRESULT_TEST_FAILED); checkExpression(aMob->CountSlots (NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(aMob->CountSlots (&numSlots)); //seven slots made by IAAFMob and one static slot and event slot made throught IAAFMOb2 checkExpression((7+1+1) == numSlots, AAFRESULT_TEST_FAILED); checkExpression(aMob->GetSlots(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkResult(aMob->GetSlots(&slotIter)); for(s = 0; s < numSlots; s++) { checkResult(slotIter->NextOne (&slot)); checkResult(slot->GetNameBufLen(&bufLen)); checkResult(slot->GetName (slotName, bufLen)); checkResult(slot->GetSlotID(&trackID)); checkExpression (wcscmp(slotName, slotNames[s]) == 0, AAFRESULT_TEST_FAILED); checkExpression(trackID == (s+1), AAFRESULT_TEST_FAILED); slot->Release(); slot = NULL; bufLen = 0; trackID = 0; } slotIter->Release(); slotIter = NULL; // GetSlotAt checkExpression(aMob->GetSlotAt(1, NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkExpression(aMob->GetSlotAt(9, &slot) == AAFRESULT_BADINDEX, AAFRESULT_TEST_FAILED); for (s = 0; s < numSlots; ++s) { checkResult(aMob->GetSlotAt(s, &slot)); checkResult(slot->GetNameBufLen(&bufLen)); checkResult(slot->GetName(slotName, bufLen)); checkResult(slot->GetSlotID(&trackID)); checkExpression(wcscmp(slotName, slotNames[s]) == 0, AAFRESULT_TEST_FAILED); checkExpression(trackID == (s+1), AAFRESULT_TEST_FAILED); if ( 0 < s && s < 5 ) // These are the SourceClips { checkResult(slot->GetSegment(&pSegment)); checkResult(pSegment->QueryInterface (IID_IAAFSourceClip, (void **)&pSourceClip)); checkResult(pSourceClip->QueryInterface (IID_IAAFSourceReference, (void **)&pSourceRef)); checkResult(pSourceRef->GetSourceID(&sourceID)); checkExpression(memcmp(&sourceID, &MOBTestID3, sizeof(aafMobID_t)) == 0, AAFRESULT_TEST_FAILED); pSourceRef->Release(); pSourceRef = NULL; pSourceClip->Release(); pSourceClip = NULL; pSegment->Release(); pSegment = NULL; } slot->Release(); slot = NULL; bufLen = 0; trackID = 0; } // ChangeRef checkResult(aMob->ChangeRef(MOBTestID3, MOBTestID4)); for (s = 1; s < 5; ++s) // These are the SourceClips { checkResult(aMob->GetSlotAt(s, &slot)); checkResult(slot->GetSegment(&pSegment)); checkResult(pSegment->QueryInterface (IID_IAAFSourceClip, (void **)&pSourceClip)); checkResult(pSourceClip->QueryInterface (IID_IAAFSourceReference, (void **)&pSourceRef)); checkResult(pSourceRef->GetSourceID(&sourceID)); checkExpression(memcmp(&sourceID, &MOBTestID4, sizeof(aafMobID_t)) == 0, AAFRESULT_TEST_FAILED); pSourceRef->Release(); pSourceRef = NULL; pSourceClip->Release(); pSourceClip = NULL; pSegment->Release(); pSegment = NULL; slot->Release(); slot = NULL; } // try it again with a MobID it won't find. Make sure nothing changes checkResult(aMob->ChangeRef(MOBTestID3, MOBTestID2)); for (s = 1; s < 5; ++s) // These are the SourceClips { checkResult(aMob->GetSlotAt(s, &slot)); checkResult(slot->GetSegment(&pSegment)); checkResult(pSegment->QueryInterface (IID_IAAFSourceClip, (void **)&pSourceClip)); checkResult(pSourceClip->QueryInterface (IID_IAAFSourceReference, (void **)&pSourceRef)); checkResult(pSourceRef->GetSourceID(&sourceID)); checkExpression(memcmp(&sourceID, &MOBTestID4, sizeof(aafMobID_t)) == 0, AAFRESULT_TEST_FAILED); pSourceRef->Release(); pSourceRef = NULL; pSourceClip->Release(); pSourceClip = NULL; pSegment->Release(); pSegment = NULL; slot->Release(); slot = NULL; } // LookUpSlot checkResult(aMob->LookupSlot(4, &slot)); checkResult(slot->GetSegment(&pSegment)); checkResult(pSegment->QueryInterface (IID_IAAFSourceClip, (void **)&pSourceClip)); checkResult(pSourceClip->QueryInterface (IID_IAAFSourceReference, (void **)&pSourceRef)); checkResult(pSourceRef->GetSourceID(&sourceID)); checkResult(slot->GetNameBufLen(&bufLen)); checkResult(slot->GetName(slotName, bufLen)); checkResult(slot->GetSlotID(&trackID)); checkExpression(wcscmp(slotName, slotNames[3]) == 0, AAFRESULT_TEST_FAILED); checkExpression(trackID == (4), AAFRESULT_TEST_FAILED); pSourceRef->Release(); pSourceRef = NULL; pSourceClip->Release(); pSourceClip = NULL; pSegment->Release(); pSegment = NULL; slot->Release(); slot = NULL; checkExpression(aMob->LookupSlot(10, &slot) == AAFRESULT_SLOT_NOT_FOUND, AAFRESULT_TEST_FAILED); checkExpression(aMob->LookupSlot(0, NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); // OffsetToMobTimecode // 7/5/00 - this method is broken so the tests that will // make it fail have been commented out. This module test // will still report Partial Success until implementation has been fixed aafPosition_t offset = 1; aafTimecode_t timecode; // initialize timecode values timecode.startFrame = 0; timecode.drop = kAAFTcDrop; timecode.fps = 24; checkResult(aMob->LookupSlot(6, &slot)); checkResult(slot->GetSegment(&pSegment)); checkResult(aMob->OffsetToMobTimecode(pSegment, &offset, &timecode)); checkExpression(timecode.startFrame == (TCstartFrame + offset), AAFRESULT_TEST_FAILED); checkExpression(timecode.drop == TCdrop, AAFRESULT_TEST_FAILED); checkExpression(timecode.fps == TCfps, AAFRESULT_TEST_FAILED); checkExpression(aMob->OffsetToMobTimecode(pSegment, NULL, &timecode) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); checkExpression(aMob->OffsetToMobTimecode(pSegment, &offset, NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); // reinitialize values timecode.startFrame = 0; timecode.drop = kAAFTcDrop; timecode.fps = 24; // According to IDL this should search for the slot containing the timecode segment checkResult(aMob->OffsetToMobTimecode(NULL, &offset, &timecode)); checkExpression(timecode.startFrame == (TCstartFrame + offset), AAFRESULT_TEST_FAILED); checkExpression(timecode.drop == TCdrop, AAFRESULT_TEST_FAILED); checkExpression(timecode.fps == TCfps, AAFRESULT_TEST_FAILED); pSegment->Release(); pSegment = NULL; slot->Release(); slot = NULL; // Pass in a segment that is not a timecode and make sure it returns correct hr checkResult(aMob->LookupSlot(1, &slot)); checkResult(slot->GetSegment(&pSegment)); checkExpression(aMob->OffsetToMobTimecode(pSegment, &offset, &timecode) == AAFRESULT_TIMECODE_NOT_FOUND, AAFRESULT_TEST_FAILED); pSegment->Release(); pSegment = NULL; slot->Release(); slot = NULL; // GetKLVData checkResult(pDictionary->LookupTypeDef (kAAFTypeID_UInt8Array, &pBaseType)); checkResult(pDictionary->RegisterKLVDataKey(TEST_KLV, pBaseType)); pBaseType->Release(); pBaseType = NULL; checkResult(aMob->CountKLVData(&numFound)); checkExpression(numFound == 2, AAFRESULT_TEST_FAILED); checkResult(aMob->GetKLVData(&klvEnum)); checkResult(klvEnum->NextOne(&pKLVData)); checkResult(pKLVData->GetValueBufLen(&bufLen)); checkExpression(sizeof(KLVfrowney) == bufLen, AAFRESULT_TEST_FAILED); checkResult(pKLVData->GetValue( sizeof(value), (unsigned char *)value, &bytesRead)); checkExpression(memcmp(value, KLVfrowney, sizeof(KLVfrowney)) == 0, AAFRESULT_TEST_FAILED); checkResult(pKLVData->GetKey(&testKey)); checkExpression(memcmp(&testKey, &TEST_KLV, sizeof(aafUID_t)) == 0, AAFRESULT_TEST_FAILED); pKLVData->Release(); pKLVData = NULL; checkResult(klvEnum->NextOne(&pKLVData)); checkResult(pKLVData->GetValueBufLen(&bufLen)); checkExpression(sizeof(KLVsmiley) == bufLen, AAFRESULT_TEST_FAILED); checkResult(pKLVData->GetValue( sizeof(value), (unsigned char *)value, &bytesRead)); checkExpression(memcmp(value, KLVsmiley, sizeof(KLVsmiley)) == 0, AAFRESULT_TEST_FAILED); checkResult(pKLVData->GetKey(&testKey)); checkExpression(memcmp(&testKey, &TEST_KLV, sizeof(aafUID_t)) == 0, AAFRESULT_TEST_FAILED); pKLVData->Release(); pKLVData = NULL; klvEnum->Release(); klvEnum = NULL; checkExpression(aMob->GetKLVData(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED); // Check the comments checkResult(aMob->GetComments(&enumTaggedVal)); for (i = 0; i < 5; ++i) { if (i==2) continue; checkResult(enumTaggedVal->NextOne(&taggedVal)); checkResult(taggedVal->GetNameBufLen(&bufLen)); checkResult(taggedVal->GetName(name, bufLen)); checkExpression(wcscmp(name, pCategory[i]) == 0, AAFRESULT_TEST_FAILED); checkResult(taggedVal->GetValueBufLen(&bufLen)); checkResult(taggedVal->GetValue(bufLen, (aafDataBuffer_t)value, &bytesRead)); checkExpression(wcscmp(value, pComment[i]) == 0, AAFRESULT_TEST_FAILED); taggedVal->Release(); taggedVal = NULL; } // Check attributes and usage code. // Need IAAFMob2 for that; IAAFMob2* aMobInterface2 = 0; checkResult( aMob->QueryInterface( IID_IAAFMob2, reinterpret_cast<void**>(&aMobInterface2) ) ); IEnumAAFTaggedValues* pAttributesEnum = 0; checkResult( aMobInterface2->GetAttributes( &pAttributesEnum ) ); int attributeCount = 0; HRESULT atthr = AAFRESULT_SUCCESS; IAAFTaggedValue* pAttribute = 0; for( atthr = pAttributesEnum->NextOne( &pAttribute ); atthr == AAFRESULT_SUCCESS; atthr = pAttributesEnum->NextOne( &pAttribute ) ) { aafUInt32 bufLen = 0; checkResult( pAttribute->GetNameBufLen(&bufLen) ); // "name" is 500 chars long... sized more than // large enough for a simple test. checkExpression( attributeCount < 2, AAFRESULT_TEST_FAILED ); checkResult( pAttribute->GetName( name, bufLen ) ); checkExpression( wcscmp(name, AttributeNames[attributeCount] ) == 0, AAFRESULT_TEST_FAILED ); // check the value IAAFTypeDef* pAttributeTypeDef = NULL; checkResult( pAttribute->GetTypeDefinition( &pAttributeTypeDef ) ); // It should be a string. IAAFTypeDefString* pTDString = NULL; checkResult( pAttributeTypeDef->QueryInterface( IID_IAAFTypeDefString, reinterpret_cast<void**>(&pTDString) ) ); checkResult( pAttribute->GetValue( sizeof(name), reinterpret_cast<aafDataBuffer_t>(name), &bufLen ) ); checkExpression( wcscmp( AttributeValues[attributeCount], name ) == 0, AAFRESULT_TEST_FAILED ); pAttributeTypeDef->Release(); pAttributeTypeDef = NULL; pTDString->Release(); pTDString = NULL; pAttribute->Release(); pAttribute = NULL; attributeCount++; } checkExpression( 2 == attributeCount && atthr == AAFRESULT_NO_MORE_OBJECTS, AAFRESULT_TEST_FAILED ); aafUID_t code; checkResult( aMobInterface2->GetUsageCode( &code ) ); checkExpression( memcmp( &code, &kAAFUsage_SubClip, sizeof(code) ) == 0, AAFRESULT_TEST_FAILED ); pAttributesEnum->Release(); pAttributesEnum = NULL; enumTaggedVal->Release(); enumTaggedVal = NULL; aMobInterface2->Release(); aMobInterface2 = NULL; aMob->Release(); aMob = NULL; } } catch (HRESULT& rResult) { hr = rResult; } // Cleanup object references if (slot) slot->Release(); if (slotIter) slotIter->Release(); if (aMob) aMob->Release(); if (mobIter) mobIter->Release(); if (pHeader) pHeader->Release(); if (pDictionary) pDictionary->Release(); if (pFile) { // Close file if (bFileOpen) pFile->Close(); pFile->Release(); } return hr; }
static bool testRestore(const wchar_t* fileName) { bool passed = true; IAAFFile* pFile = 0; IAAFHeader* pHeader = 0; IAAFDictionary* pDictionary = 0; IAAFContentStorage* pStorage = 0; IEnumAAFMobs* pMobs = 0; IAAFMob* pMob = 0; try { pFile = openFileForReading(fileName); } catch (...) { return false; } try { // get the Mob containing the test data checkResult(pFile->GetHeader(&pHeader)); checkResult(pHeader->GetDictionary(&pDictionary)); checkResult(pHeader->GetContentStorage(&pStorage)); aafSearchCrit_t searchCrit; searchCrit.searchTag = kAAFByMobKind; searchCrit.tags.mobKind = kAAFAllMob; checkResult(pStorage->GetMobs(&searchCrit, &pMobs)); checkResult(pMobs->NextOne(&pMob)); IAAFObject* pObject = 0; IAAFClassDef* pClassDef = 0; IAAFPropertyDef* pPropertyDef = 0; IAAFPropertyValue* pPropertyValue = 0; IAAFTypeDef* pType = 0; IAAFTypeDefExtEnum* pExtEnumType = 0; // test baseline ext. enum try { printf(" * Baseline: "); const aafUID_t propId = {0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUID_t testValue = {0x0D010102,0x0101,0x0500,{0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01}}; const wchar_t* testName = L"Usage_SubClip"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefExtEnum, (void **)&pExtEnumType)); aafUID_t value; aafCharacter name[256]; checkResult(pExtEnumType->GetAUIDValue(pPropertyValue, &value)); checkResult(pExtEnumType->GetNameFromValue(pPropertyValue, name, 256)); if (memcmp(&value, &testValue, sizeof(aafUID_t)) ==0 && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pExtEnumType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); // test Int8 enum try { printf(" * Non-baseline Ext Enum: "); const aafUID_t propId = {0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUID_t testValue = {0x6f9685a4,0x0a0d,0x447b,{0x89,0xf3,0x1b,0x75,0x0b,0xc5,0xc7,0xde}}; const wchar_t* testName = L"AAA"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefExtEnum, (void **)&pExtEnumType)); aafUID_t value; aafCharacter name[256]; checkResult(pExtEnumType->GetAUIDValue(pPropertyValue, &value)); checkResult(pExtEnumType->GetNameFromValue(pPropertyValue, name, 256)); if (memcmp(&value, &testValue, sizeof(aafUID_t)) ==0 && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pExtEnumType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); // test baseline extension try { printf(" * Baseline extension: "); const aafUID_t propId = {0x20000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUID_t testValue = {0x197e78ac,0xb464,0x4bd1,{0x86,0x11,0xb6,0xf2,0xdf,0x0d,0x03,0xfe}}; const wchar_t* testName = L"MyUsage"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefExtEnum, (void **)&pExtEnumType)); aafUID_t value; aafCharacter name[256]; checkResult(pExtEnumType->GetAUIDValue(pPropertyValue, &value)); checkResult(pExtEnumType->GetNameFromValue(pPropertyValue, name, 256)); if (memcmp(&value, &testValue, sizeof(aafUID_t)) ==0 && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pExtEnumType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); // test non-baseline extension try { printf(" * Non-baseline extension: "); const aafUID_t propId = {0x30000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUID_t testValue = {0xe54f0efa,0x15c1,0x468f,{0xb7,0x43,0x9b,0xfd,0x12,0x94,0x04,0x49}}; const wchar_t* testName = L"CCC"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefExtEnum, (void **)&pExtEnumType)); aafUID_t value; aafCharacter name[256]; checkResult(pExtEnumType->GetAUIDValue(pPropertyValue, &value)); checkResult(pExtEnumType->GetNameFromValue(pPropertyValue, name, 256)); if (memcmp(&value, &testValue, sizeof(aafUID_t)) ==0 && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pExtEnumType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); } catch (...) { passed = false; } // cleanup release(pMob); release(pMobs); release(pStorage); release(pDictionary); release(pHeader); checkResult(pFile->Close()); release(pFile); report(passed); return passed; }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { IAAFFile* pFile = NULL; IAAFHeader * pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFOperationDef* pOperationDef = NULL; IAAFParameterDef* pParamDef = NULL; IAAFDefObject* pDefObject = NULL; IAAFOperationGroup *pOperationGroup = NULL; IAAFMob *pMob = NULL; IAAFSegment *pSeg = NULL; IAAFTimelineMobSlot *pSlot = NULL; IAAFParameter *pParm = NULL; IAAFVaryingValue *pVaryingValue = NULL; IAAFSegment *pFiller = NULL; IAAFComponent *pComponent = NULL; IAAFSourceClip *pSourceClip = NULL; IAAFControlPoint *pControlPoint = NULL; IAAFSourceReference *pSourceRef = NULL; IAAFInterpolationDef *pInterpDef = NULL; IAAFPluginManager *pMgr = NULL; IAAFTypeDef *pTypeDef = NULL; bool bFileOpen = false; HRESULT hr = S_OK; // aafUID_t testInterpDef = kAAFTypeID_Rational; aafLength_t effectLen = TEST_EFFECT_LEN; aafUID_t effectID = kTestEffectID; aafUID_t parmID = kTestParmID; aafRational_t testLevel1 = kTestLevel1; aafRational_t testLevel2 = kTestLevel2; aafRational_t testTime1 = kTestTime1; aafRational_t testTime2 = kTestTime2; /* 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; // 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.cdOperationDef()-> CreateInstance(IID_IAAFOperationDef, (IUnknown **)&pOperationDef)); checkResult(defs.cdParameterDef()-> CreateInstance(IID_IAAFParameterDef, (IUnknown **)&pParamDef)); checkResult(pDictionary->LookupTypeDef (kAAFTypeID_Rational, &pTypeDef)); checkResult(pParamDef->Initialize (parmID, TEST_PARAM_NAME, TEST_PARAM_DESC, pTypeDef)); checkResult(AAFGetPluginManager(&pMgr)); checkResult(pMgr->CreatePluginDefinition(LinearInterpolator, pDictionary, &pDefObject)); checkResult(pDefObject->QueryInterface(IID_IAAFInterpolationDef, (void **) &pInterpDef)); pDefObject->Release(); pDefObject = NULL; checkResult(pOperationDef->Initialize (effectID, TEST_EFFECT_NAME, TEST_EFFECT_DESC)); checkResult(pDictionary->RegisterOperationDef (pOperationDef)); checkResult(pDictionary->RegisterParameterDef (pParamDef)); checkResult(pDictionary->RegisterInterpolationDef (pInterpDef)); checkResult(pOperationDef->SetDataDef (defs.ddkAAFPicture())); checkResult(pOperationDef->SetIsTimeWarp (kAAFFalse)); checkResult(pOperationDef->SetNumberInputs (TEST_NUM_INPUTS)); checkResult(pOperationDef->SetCategory (TEST_CATEGORY)); checkResult(pOperationDef->AddParameterDef (pParamDef)); checkResult(pOperationDef->SetBypass (TEST_BYPASS)); checkResult(pParamDef->SetDisplayUnits(TEST_PARAM_UNITS)); //Make the first mob long test; aafRational_t videoRate = { 2997, 100 }; // Create a Mob checkResult(defs.cdCompositionMob()-> CreateInstance(IID_IAAFMob, (IUnknown **)&pMob)); checkResult(pMob->SetName(L"AAFOperationGroupTest")); // Add some slots for(test = 0; test < 2; test++) { checkResult(defs.cdOperationGroup()-> CreateInstance(IID_IAAFOperationGroup, (IUnknown **)&pOperationGroup)); checkResult(defs.cdFiller()-> CreateInstance(IID_IAAFSegment, (IUnknown **)&pFiller)); checkResult(pFiller->QueryInterface (IID_IAAFComponent, (void **)&pComponent)); checkResult(pComponent->SetLength(effectLen)); CAAFBuiltinDefs defs(pDictionary); checkResult(pComponent->SetDataDef(defs.ddkAAFPicture())); checkResult(pOperationGroup->Initialize(defs.ddkAAFPicture(), TEST_EFFECT_LEN, pOperationDef)); checkResult(defs.cdVaryingValue()-> CreateInstance(IID_IAAFVaryingValue, (IUnknown **)&pVaryingValue)); checkResult(pVaryingValue->Initialize (pParamDef, pInterpDef)); checkResult(defs.cdControlPoint()-> CreateInstance(IID_IAAFControlPoint, (IUnknown **)&pControlPoint)); checkResult(pControlPoint->Initialize (pVaryingValue, testTime1, sizeof(testLevel1), (aafDataBuffer_t)&testLevel1)); checkResult(pControlPoint->SetEditHint(kAAFRelativeLeft)); checkResult(pVaryingValue->AddControlPoint(pControlPoint)); pControlPoint->Release(); pControlPoint = NULL; checkResult(defs.cdControlPoint()-> CreateInstance(IID_IAAFControlPoint, (IUnknown **)&pControlPoint)); checkResult(pControlPoint->Initialize (pVaryingValue, testTime2, sizeof(testLevel2), (aafDataBuffer_t)&testLevel2)); checkResult(pControlPoint->SetEditHint(kAAFProportional)); checkResult(pVaryingValue->AddControlPoint(pControlPoint)); pControlPoint->Release(); pControlPoint = NULL; checkResult(pVaryingValue->QueryInterface (IID_IAAFParameter, (void **)&pParm)); checkResult(pOperationGroup->AddParameter (pParm)); checkResult(pOperationGroup->AppendInputSegment (pFiller)); pFiller->Release(); pFiller = NULL; checkResult(pOperationGroup->SetBypassOverride (1)); checkResult(defs.cdSourceClip()-> CreateInstance(IID_IAAFSourceClip, (IUnknown **)&pSourceClip)); aafSourceRef_t sourceRef; sourceRef.sourceID = zeroMobID; sourceRef.sourceSlotID = 0; sourceRef.startTime = 0; checkResult(pSourceClip->Initialize (defs.ddkAAFPicture(), effectLen, sourceRef)); checkResult(pSourceClip->QueryInterface (IID_IAAFSourceReference, (void **)&pSourceRef)); checkResult(pOperationGroup->SetRender (pSourceRef)); checkResult(pOperationGroup->QueryInterface (IID_IAAFSegment, (void **)&pSeg)); checkResult(pMob->AppendNewTimelineSlot (videoRate, pSeg, test+1, slotNames[test], 0, &pSlot)); pSlot->Release(); pSlot = NULL; pSeg->Release(); pSeg = NULL; pOperationGroup->Release(); pOperationGroup = NULL; pParm->Release(); pParm = NULL; pVaryingValue->Release(); pVaryingValue = NULL; pComponent->Release(); pComponent = NULL; pSourceRef->Release(); pSourceRef = NULL; pSourceClip->Release(); pSourceClip = NULL; } // Add the mob to the file. checkResult(pHeader->AddMob(pMob)); } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if(pSourceRef) pSourceRef->Release(); if(pControlPoint) pControlPoint->Release(); if(pSourceClip) pSourceClip->Release(); if (pDefObject) pDefObject->Release(); if (pOperationGroup) pOperationGroup->Release(); if (pMob) pMob->Release(); if (pSeg) pSeg->Release(); if (pSlot) pSlot->Release(); if (pComponent) pComponent->Release(); if (pParm) pParm->Release(); // if (pIntDef) // pIntDef->Release(); if (pInterpDef) pInterpDef->Release(); if (pVaryingValue) pVaryingValue->Release(); if (pFiller) pFiller->Release(); if (pOperationDef) pOperationDef->Release(); if (pParamDef) pParamDef->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if(pMgr) pMgr->Release(); if(pTypeDef) pTypeDef->Release(); if (pFile) { // Close file if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } return hr; }
//*********************************************************** // // GetObjRefArrayPropFromObject() // // Get an object reference array property on the AAF object // specified by pObj. The value of the property is returned // in pArray. // // Returns: // // On Success: S_OK // On Failure: A failed HRESULT // HRESULT AAFDomainUtils::GetObjRefArrayPropFromObject(IAAFObject* pObj, aafUID_t* pClassID, const aafUID_t* pPropTypeID, aafUID_t* pPropID, IAAFObject*** pArray, aafUInt32* pNumObjects) { IAAFTypeDefVariableArray* pTDVarArray = NULL; IAAFPropertyValue* pPVVarArray = NULL; IAAFTypeDefObjectRef* pTDArrayElement = NULL; IAAFClassDef* pCD; HRESULT hr; // Get the property value for the target property hr = _dict->LookupClassDef(*pClassID, &pCD); if (SUCCEEDED(hr)) { IAAFPropertyDef* pPD; hr = pCD->LookupPropertyDef(*pPropID, &pPD); if (SUCCEEDED(hr)) { aafBool present = kAAFFalse; pObj->IsPropertyPresent(pPD, &present); if (present == kAAFTrue) hr = pObj->GetPropertyValue(pPD, &pPVVarArray); else hr = AAFRESULT_PROP_NOT_PRESENT; pPD->Release(); } pCD->Release(); } // Get the property type def from the dictionary to interpret this property value. if (SUCCEEDED(hr)) { IAAFTypeDef* pTD; hr = _dict->LookupTypeDef(*pPropTypeID, &pTD); if (SUCCEEDED(hr)) { hr = pTD->QueryInterface(IID_IAAFTypeDefVariableArray, (void**)&pTDVarArray); pTD->Release(); } } // Get the array element type def to interpret the element property value. if (SUCCEEDED(hr)) { IAAFTypeDef* pTDElement; hr = pTDVarArray->GetType(&pTDElement); if (SUCCEEDED(hr)) { pTDElement->QueryInterface(IID_IAAFTypeDefObjectRef, (void **)&pTDArrayElement); pTDElement->Release(); } } // Get each element out of the property, convert them to an IAAFObject pointer and // add them to the array of object which is returned to the user. if (SUCCEEDED(hr)) { IAAFObject** pTempArray; aafUInt32 count = 0, numElements = 0; pTDVarArray->GetCount(pPVVarArray, &count); pTempArray = new IAAFObject* [count]; if (pTempArray) { for (aafUInt32 i = 0; i < count; i++) { IAAFPropertyValue* pPVElement; hr = pTDVarArray->GetElementValue(pPVVarArray, i, &pPVElement); if (SUCCEEDED(hr)) { IAAFObject* pTempObj; hr = pTDArrayElement->GetObject(pPVElement, IID_IAAFObject, (IUnknown **)&pTempObj); if (SUCCEEDED(hr)) { pTempArray[numElements] = pTempObj; numElements++; } pPVElement->Release(); } } if (numElements == 0) { delete [] pTempArray; pTempArray = NULL; } *pArray = pTempArray; *pNumObjects = numElements; } } if (pTDArrayElement) pTDArrayElement->Release(); if (pTDVarArray) pTDVarArray->Release(); if (pPVVarArray) pPVVarArray->Release(); return hr; }
//*********************************************************** // // SetObjRefArrayPropOnObject() // // Set an object reference array property on the AAF object // specified by pObj. The value of the property is specified // in pArray. // // Returns: // // On Success: S_OK // On Failure: A failed HRESULT // HRESULT AAFDomainUtils::SetObjRefArrayPropOnObject(IAAFObject* pObj, aafUID_t* pClassID, const aafUID_t* pPropTypeID, const aafUID_t* pElementTypeID, aafUID_t* pPropID, IAAFObject** pArray, aafUInt32 numObjects) { IAAFPropertyValue* pPVArray = NULL; IAAFTypeDef* pTD; HRESULT hr; // For each object in the source array, create a property value // and append it to the property value for the variable array. hr = _dict->LookupTypeDef(*pPropTypeID, &pTD); if (SUCCEEDED(hr)) { IAAFTypeDefVariableArray* pTDVarArray; hr = pTD->QueryInterface(IID_IAAFTypeDefVariableArray, (void**)&pTDVarArray); if (SUCCEEDED(hr)) { IAAFTypeDef* pTDElement; hr = _dict->LookupTypeDef(*pElementTypeID, &pTDElement); if (SUCCEEDED(hr)) { IAAFTypeDefObjectRef* pTDObjRef; hr = pTDElement->QueryInterface (IID_IAAFTypeDefObjectRef, (void **)&pTDObjRef); if (SUCCEEDED(hr)) { for (aafUInt32 i = 0; i < numObjects; i++) { IAAFPropertyValue* pPVObject; hr = pTDObjRef->CreateValue(pArray[i], &pPVObject); if (SUCCEEDED(hr)) { if (pPVArray == NULL) pTDVarArray->CreateEmptyValue(&pPVArray); hr = pTDVarArray->AppendElement(pPVArray, pPVObject); pPVObject->Release(); } } pTDObjRef->Release(); } pTDElement->Release(); } pTDVarArray->Release(); } pTD->Release(); } // If the object reference array was successfully created, // set the property value on the target object. if (pPVArray) { IAAFClassDef* pCD; // Get the class def for the object hr = _dict->LookupClassDef(*pClassID, &pCD); if (SUCCEEDED(hr)) { IAAFPropertyDef* pPD; hr = pCD->LookupPropertyDef(*pPropID, &pPD); if (SUCCEEDED(hr)) { hr = pObj->SetPropertyValue(pPD, pPVArray); pPD->Release(); } pCD->Release(); } pPVArray->Release(); } return hr; }
static void ReadAAFFile(aafWChar * pFileName) { HRESULT hr = S_OK; IAAFFile * pFile = NULL; hr = AAFFileOpenExistingRead (pFileName, AAF_FILE_MODE_LAZY_LOADING, &pFile); if (SUCCEEDED(hr)) { IAAFHeader * pHeader = NULL; hr = pFile->GetHeader(&pHeader); check(hr); // display error message if (SUCCEEDED(hr)) { IAAFIdentification * pIdent = NULL; hr = pHeader->GetLastIdentification(&pIdent); check(hr); // display error message if (SUCCEEDED(hr)) { printIdentification(pIdent); pIdent->Release(); pIdent = NULL; // count Mobs aafNumSlots_t n; hr = pHeader->CountMobs(kAAFAllMob, &n); check(hr); printf("\nNumber of Mobs = %d\n", n); // Header::Version, Header::ObjectModelVersion aafVersionType_t version = {0}; check(pHeader->GetFileRevision (&version) ); printf("\nHeader::Version = %d.%d\n", version.major, version.minor); aafFileRev_t fileVersion = kAAFRev1; check(pFile->GetRevision (&fileVersion) ); printf("\nHeader::ObjectModelVersion = %d", fileVersion); if (fileVersion == kAAFRev1) printf(" (recognized as kAAFRev1)\n"); else if (fileVersion == kAAFRev2) printf(" (recognized as kAAFRev2)\n"); else printf("\n"); // Show datadefs, with version IEnumAAFDataDefsSP pEnumDataDef; IAAFDictionarySP pDictionary; check(pHeader->GetDictionary(&pDictionary)); check(pDictionary->GetDataDefs(&pEnumDataDef)); IAAFDataDef* pDataDef; printf("\nDatadefs = "); while (SUCCEEDED(pEnumDataDef->NextOne(&pDataDef))) { IAAFDefObjectSP pDefObject; check(pDataDef->QueryInterface(IID_IAAFDefObject, (void**)&pDefObject)); pDataDef->Release(); pDataDef = NULL; aafUID_t id = {0}; check(pDefObject->GetAUID(&id)); aafWChar wchName[500]; char chName[1000]; check( pDefObject->GetName(wchName, sizeof (wchName)) ); convert(chName, sizeof(chName), wchName); if (memcmp( &id, &kAAFDataDef_LegacyPicture, sizeof(id)) == 0) printf("\"%s\" (recognized as legacy Picture)\n", chName); else if (memcmp( &id, &kAAFDataDef_Picture, sizeof(id)) == 0) printf("\"%s\" (recognized as Picture)\n", chName); else if (memcmp( &id, &kAAFDataDef_LegacySound, sizeof(id)) == 0) printf("\"%s\" (recognized as legacy Sound)\n", chName); else if (memcmp( &id, &kAAFDataDef_Sound, sizeof(id)) == 0) printf("\"%s\" (recognized as Sound)\n", chName); else if (memcmp( &id, &kAAFDataDef_LegacyTimecode, sizeof(id)) == 0) printf("\"%s\" (recognized as legacy Timecode)\n", chName); else if (memcmp( &id, &kAAFDataDef_Timecode, sizeof(id)) == 0) printf("\"%s\" (recognized as Timecode)\n", chName); else if (memcmp( &id, &kAAFDataDef_PictureWithMatte, sizeof(id)) == 0) printf("\"%s\" (recognized as PictureWithMatte)\n", chName); else if (memcmp( &id, &kAAFDataDef_Edgecode, sizeof(id)) == 0) printf("\"%s\" (recognized as Edgecode)\n", chName); else if (memcmp( &id, &kAAFDataDef_Auxiliary, sizeof(id)) == 0) printf("\"%s\" (recognized as Auxiliary)\n", chName); else if (memcmp( &id, &kAAFDataDef_DescriptiveMetadata, sizeof(id)) == 0) printf("\"%s\" (recognized as DescriptiveMetadata)\n", chName); else if (memcmp( &id, &kAAFDataDef_Matte, sizeof(id)) == 0) printf("\"%s\" (recognized as Matte)\n", chName); else printf("\"%s\"\n", chName); printf(" "); } // Check if file contains TypeDefs known to cause a v1.0 reader to assert. // Known instances of this are UInt32Set and AUIDSet added to the v1.1 SDK. // Cannot use Dictionary::LookupTypeDef to check for them, because this // has the side effect of registering the typedef we are checking for // from the built-in model. Instead, iterate through typedefs (in file) // and check for the known instances. printf("\nTypes incompatible with SDK v1.0.x ="); IEnumAAFTypeDefsSP pEnumTypeDef; check(pDictionary->GetTypeDefs(&pEnumTypeDef)); IAAFTypeDef* pTypeDef; bool foundToxic = false; while (SUCCEEDED(pEnumTypeDef->NextOne(&pTypeDef))) { IAAFMetaDefinitionSP pMetaDef; check(pTypeDef->QueryInterface(IID_IAAFMetaDefinition, (void**)&pMetaDef)); pTypeDef->Release(); pTypeDef = NULL; aafUID_t typeUID; check(pMetaDef->GetAUID(&typeUID)); aafWChar wchName[500]; char chName[1000]; check( pMetaDef->GetName(wchName, sizeof (wchName)) ); convert(chName, sizeof(chName), wchName); if ((memcmp( &typeUID, &kAAFTypeID_AUIDSet, sizeof(typeUID)) == 0) || (memcmp( &typeUID, &kAAFTypeID_UInt32Set, sizeof(typeUID)) == 0)) { printf(" %s", chName); foundToxic = true; } } if (!foundToxic) printf(" (none)"); printf("\n\n"); } pHeader->Release(); pHeader = NULL; } hr = pFile->Close(); check(hr); pFile->Release(); pFile = NULL; // Get file kind. // Since AAF SDK v1.0.2, the file kind actually identifies the implementation // of the file kind, from which the file kind is inferred. aafUID_t fileKind = {0}; aafBool isAAFFile = kAAFFalse; check(AAFFileIsAAFFile(pFileName, &fileKind, &isAAFFile)); if (isAAFFile) { if (memcmp( &fileKind, &kAAFFileKind_AafM512Binary, sizeof(fileKind)) == 0) printf("Filekind = 512-byte SS (reading with Microsoft)\n"); else if (memcmp( &fileKind, &kAAFFileKind_AafS512Binary, sizeof(fileKind)) == 0) printf("Filekind = 512-byte SS (reading with Schemasoft)\n"); else if (memcmp( &fileKind, &kAAFFileKind_AafG512Binary, sizeof(fileKind)) == 0) printf("Filekind = 512-byte SS (reading with GSF)\n"); else if (memcmp( &fileKind, &kAAFFileKind_Aaf512Binary, sizeof(fileKind)) == 0) printf("Filekind = 512-byte SS (reading with default implementation)\n"); else if (memcmp( &fileKind, &kAAFFileKind_AafM4KBinary, sizeof(fileKind)) == 0) printf("Filekind = 4096-byte SS (reading with Microsoft)\n"); else if (memcmp( &fileKind, &kAAFFileKind_AafS4KBinary, sizeof(fileKind)) == 0) printf("Filekind = 4096-byte SS (reading with Schemasoft)\n"); else if (memcmp( &fileKind, &kAAFFileKind_AafG4KBinary, sizeof(fileKind)) == 0) printf("Filekind = 4096-byte SS (reading with GSF)\n"); else if (memcmp( &fileKind, &kAAFFileKind_Aaf4KBinary, sizeof(fileKind)) == 0) printf("Filekind = 4096-byte SS (reading with default implementation)\n"); else printf("Filekind = Recognized by SDK but unknown to AAFInfo\n"); } } else { fprintf(stderr, "Error : Failed to open file (result = %0x).\n", hr); exit(1); } }
static HRESULT WriteRecord ( const aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { HRESULT hr = E_FAIL; IAAFFileSP pFile; try { HRESULT temphr; // Remove the previous test file if any. RemoveTestFile(pFileName); // Create the file and get the new file's header. checkResult(CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile )); IAAFHeaderSP pHeader; checkResult(pFile->GetHeader(&pHeader)); IAAFDictionarySP pDict; checkResult (pHeader->GetDictionary(&pDict)); CAAFBuiltinDefs defs(pDict); // get the SDK version against which we are testing aafProductVersion_t testVer; checkResult(pHeader->GetRefImplVersion(&testVer)); // Create, initialize, and register the Rational16 type, to // consist of an Int16 numerator and a UInt16 denominator. IAAFTypeDef* tdr16MemberTypes[] = {defs.tdInt16(), defs.tdUInt16()}; aafWChar numerator[] = L"Numerator"; aafWChar denominator[] = L"Denominator"; aafString_t tdr16MemberNames[] = {numerator, denominator}; IAAFTypeDefRecordSP ptdr16; checkResult (pDict-> CreateMetaInstance (kAAFClassID_TypeDefRecord, IID_IAAFTypeDefRecord, (IUnknown**) &ptdr16)); checkResult (ptdr16->Initialize (sTypeId_Rational16, tdr16MemberTypes, tdr16MemberNames, 2, L"Rational16")); // check for duplicate initialization temphr = ptdr16->Initialize (sTypeId_Rational16, tdr16MemberTypes, tdr16MemberNames, 2, L"Rational16"); checkExpression (AAFRESULT_ALREADY_INITIALIZED == temphr, AAFRESULT_TEST_FAILED); IAAFTypeDefSP ptd; checkResult (ptdr16->QueryInterface (IID_IAAFTypeDef, (void**) &ptd)); checkResult (pDict->RegisterTypeDef (ptd)); // Create, initialize, and register the Rational16Position type, // to consist of a Rational16 X and Rational16 Y coordinates. IAAFTypeDefRecordSP ptdr16p; //checkResult (defs.cdTypeDefRecord()-> // CreateInstance (IID_IAAFTypeDefRecord, // (IUnknown**)&ptdr16p)); checkResult (pDict-> CreateMetaInstance (kAAFClassID_TypeDefRecord, IID_IAAFTypeDefRecord, (IUnknown**) &ptdr16p)); IAAFTypeDef * pTempTd = 0; checkResult (ptdr16->QueryInterface (IID_IAAFTypeDef, (void**) &pTempTd)); IAAFTypeDef* tdr16pMemberTypes[] = {pTempTd, pTempTd}; aafWChar xpos[] = L"X Position"; aafWChar ypos[] = L"Y Position"; aafString_t tdr16pMemberNames[] = {xpos, ypos}; checkResult (ptdr16p->Initialize (sTypeId_Rational16_pair, tdr16pMemberTypes, tdr16pMemberNames, 2, L"Rational16Pair")); // check for duplicate initialization temphr = ptdr16p->Initialize (sTypeId_Rational16, tdr16pMemberTypes, tdr16pMemberNames, 2, L"Rational16Pair"); checkExpression (AAFRESULT_ALREADY_INITIALIZED == temphr, AAFRESULT_TEST_FAILED); pTempTd->Release (); pTempTd = 0; checkResult (ptdr16p->QueryInterface (IID_IAAFTypeDef, (void**) &ptd)); checkResult (pDict->RegisterTypeDef (ptd)); // Now attempt to register offsets of Rational16_pair. This // should fail, because offsets of its members (of type // Rational16) have not yet been registered. temphr = RegisterRational16PairOffsets (ptdr16p); checkExpression (temphr == AAFRESULT_NOT_REGISTERED, AAFRESULT_TEST_FAILED); // Now let's attempt registration the right way. checkResult (RegisterRational16Offsets (ptdr16)); checkResult (RegisterRational16PairOffsets (ptdr16p)); // register variable array of Rational16Pair records IAAFTypeDefVariableArraySP ptdvaarpr; IAAFTypeDefSP ptdarpr; // perform this part only for specified versions if( versionUInt(testVer) >= versionUInt(1,1,1,0) ) { //Create a Variable Array checkResult(pDict->CreateMetaInstance (AUID_AAFTypeDefVariableArray, IID_IAAFTypeDefVariableArray, (IUnknown **) &ptdvaarpr)); //IAAFTypeDefVariableArray::Initialize checkResult(ptdvaarpr->Initialize(sTypeId_Rational16_array, ptd, L"Rational16PairArray")); // Register our new VA type def : checkResult(ptdvaarpr->QueryInterface(IID_IAAFTypeDef, (void**)&ptdarpr)); checkResult(pDict->RegisterTypeDef(ptdarpr)); } // Create a new property on Composition mob (called Position) // whose type is Rational16_pair. checkResult (ptdr16p->QueryInterface (IID_IAAFTypeDef, (void**) &ptd)); IAAFPropertyDefSP pPropDefPosA; IAAFPropertyDefSP pPropDefPosB; IAAFPropertyDefSP pPropDefPosC; checkResult (defs.cdCompositionMob()->RegisterOptionalPropertyDef (sPropertyId_positionA, L"PositionA", ptd, &pPropDefPosA)); checkResult (defs.cdCompositionMob()->RegisterOptionalPropertyDef (sPropertyId_positionB, L"PositionB", ptd, &pPropDefPosB)); checkResult (defs.cdCompositionMob()->RegisterOptionalPropertyDef (sPropertyId_positionC, L"PositionC", ptd, &pPropDefPosC)); // register property of type variable array of Rational16Pair records IAAFPropertyDefSP pPropDefPosN; // perform this part only for specified versions if( versionUInt(testVer) >= versionUInt(1,1,1,0) ) { checkResult (defs.cdCompositionMob()->RegisterOptionalPropertyDef (sPropertyId_positionN, L"PositionN", ptdarpr, &pPropDefPosN)); } // Register the Mixed_t type IAAFTypeDef* tdMixedMemberTypes[] = {defs.tdInt8(), defs.tdUInt32()}; aafWChar str_angle[] = L"Angle"; aafWChar str_speed[] = L"Speed"; aafString_t tdMixedMemberNames[] = {str_angle, str_speed}; IAAFTypeDefRecordSP ptdrmixed; checkResult(pDict->CreateMetaInstance(kAAFClassID_TypeDefRecord, IID_IAAFTypeDefRecord, (IUnknown**) &ptdrmixed)); checkResult(ptdrmixed->Initialize(sTypeId_Mixed, tdMixedMemberTypes, tdMixedMemberNames, 2, L"Mixed")); // Register Mixed type def IAAFTypeDefSP ptdmixed; checkResult(ptdrmixed->QueryInterface(IID_IAAFTypeDef, (void**)&ptdmixed)); checkResult(pDict->RegisterTypeDef(ptdmixed)); checkResult(RegisterMixedOffsets(ptdrmixed)); // Added Velocity property to Composition Mob IAAFPropertyDefSP pPropDefVelocity; checkResult (defs.cdCompositionMob()->RegisterOptionalPropertyDef (sPropertyId_velocity, L"Velocity", ptdmixed, &pPropDefVelocity)); // Create one of our new CompositionMobs, and add a values for // the Position property. IAAFCompositionMobSP pcm; checkResult (defs.cdCompositionMob()-> CreateInstance (IID_IAAFCompositionMob, (IUnknown**)&pcm)); // Add property value for PositionA using CreateValueFromValues // methods. The constituent property values will be created // from CreateValueFromStruct, and from SetValueFromStruct. const Rational16_t v_12 = {1, 2}; const Rational16_t v_34 = {3, 4}; IAAFPropertyValue * pValRat[2] = { 0 }; checkResult (ptdr16-> CreateValueFromStruct ((aafMemPtr_t) &v_12, sizeof (v_12), &pValRat[0])); // create it with wrong data, and use SetStruct to give it right // data checkResult (ptdr16-> CreateValueFromStruct ((aafMemPtr_t) &v_12, sizeof (v_12), &pValRat[1])); checkResult (ptdr16-> SetStruct (pValRat[1], (aafMemPtr_t) &v_34, sizeof (v_34))); // Create the Rational16_pair property value from the // Rational16 property values. IAAFPropertyValueSP pRat16PairVal_1234; temphr = ptdr16p->CreateValueFromValues (0, 2, &pRat16PairVal_1234); checkExpression (AAFRESULT_NULL_PARAM == temphr, AAFRESULT_TEST_FAILED); temphr = ptdr16p->CreateValueFromValues (pValRat, 1, &pRat16PairVal_1234); checkExpression (AAFRESULT_ILLEGAL_VALUE == temphr, AAFRESULT_TEST_FAILED); checkResult (ptdr16p->CreateValueFromValues (pValRat, 2, &pRat16PairVal_1234)); pValRat[0]->Release (); pValRat[0] = 0; pValRat[1]->Release (); pValRat[1] = 0; IAAFObjectSP pObj; checkResult (pcm->QueryInterface (IID_IAAFObject, (void**) &pObj)); checkResult (pObj->SetPropertyValue (pPropDefPosA, pRat16PairVal_1234)); // Add property value for PositionB using CreateValueFromStruct // methods. const Rational16_t r16_56 = {5, 6}; const Rational16_t r16_78 = {7, 8}; Rational16pair_t r16p_5678; r16p_5678.X_Position = r16_56; r16p_5678.Y_Position = r16_78; IAAFPropertyValueSP pRat16PairVal_5678; temphr = ptdr16p-> CreateValueFromStruct (0, sizeof (r16p_5678), &pRat16PairVal_5678); checkExpression (AAFRESULT_NULL_PARAM == temphr, AAFRESULT_TEST_FAILED); temphr = ptdr16p-> CreateValueFromStruct ((aafMemPtr_t) &r16p_5678, sizeof (r16p_5678), 0); checkExpression (AAFRESULT_NULL_PARAM == temphr, AAFRESULT_TEST_FAILED); temphr = ptdr16p-> CreateValueFromStruct ((aafMemPtr_t) &r16p_5678, sizeof (r16p_5678)+1, &pRat16PairVal_5678); checkExpression (AAFRESULT_ILLEGAL_VALUE == temphr, AAFRESULT_TEST_FAILED); checkResult (ptdr16p-> CreateValueFromStruct ((aafMemPtr_t) &r16p_5678, sizeof (r16p_5678), &pRat16PairVal_5678)); checkResult (pObj->SetPropertyValue (pPropDefPosB, pRat16PairVal_5678)); // Add property value for PositionC using CreateValueFromStruct // methods, and then use SetStruct to set the value. const Rational16_t r16_9a = {9, 10}; const Rational16_t r16_bc = {11, 12}; Rational16pair_t r16p_9abc; r16p_9abc.X_Position = r16_9a; r16p_9abc.Y_Position = r16_bc; IAAFPropertyValueSP pRat16PairVal_9abc; checkResult (ptdr16p-> CreateValueFromStruct ((aafMemPtr_t) &r16p_5678, sizeof (r16p_5678), &pRat16PairVal_9abc)); temphr = ptdr16p->SetStruct (0, (aafMemPtr_t) &r16p_9abc, sizeof (r16p_9abc)); checkExpression (AAFRESULT_NULL_PARAM == temphr, AAFRESULT_TEST_FAILED); temphr = ptdr16p->SetStruct (pRat16PairVal_9abc, 0, sizeof (r16p_9abc)); checkExpression (AAFRESULT_NULL_PARAM == temphr, AAFRESULT_TEST_FAILED); temphr = ptdr16p->SetStruct (pRat16PairVal_9abc, (aafMemPtr_t) &r16p_9abc, sizeof (r16p_9abc)-1); checkExpression (AAFRESULT_ILLEGAL_VALUE == temphr, AAFRESULT_TEST_FAILED); checkResult (ptdr16p->SetStruct (pRat16PairVal_9abc, (aafMemPtr_t) &r16p_9abc, sizeof (r16p_9abc))); checkResult (pObj->SetPropertyValue (pPropDefPosC, pRat16PairVal_9abc)); // add a value of PropertyN IAAFPropertyValueSP spArrayPropertyValue; // perform this part only for specified versions if( versionUInt(testVer) >= versionUInt(1,1,1,0) ) { // Create an empty array and then fill it by appending elements... checkResult( ptdvaarpr->CreateEmptyValue (&spArrayPropertyValue) ); // intentionally in permuted order checkResult( ptdvaarpr->AppendElement(spArrayPropertyValue, pRat16PairVal_5678) ); checkResult( ptdvaarpr->AppendElement(spArrayPropertyValue, pRat16PairVal_9abc) ); checkResult( ptdvaarpr->AppendElement(spArrayPropertyValue, pRat16PairVal_1234) ); // set PropertyN checkResult ( pObj->SetPropertyValue( pPropDefPosN, spArrayPropertyValue ) ); } // Set the value on the new Velocity property (of Mixed_t type) const Mixed_t velocty = {15, 2001}; IAAFPropertyValueSP pVelocity; checkResult (ptdrmixed->CreateValueFromStruct((aafMemPtr_t) &velocty, sizeof(velocty), &pVelocity)); checkResult (pObj->SetPropertyValue(pPropDefVelocity, pVelocity)); //Put the modified comp mob into the file. IAAFMobSP pMob; checkResult (pcm->QueryInterface (IID_IAAFMob, (void**) &pMob)); checkResult (pHeader->AddMob(pMob)); // Attempt to save the file. checkResult(pFile->Save()); // Attempt to close the file. checkResult(pFile->Close()); IAAFFileSP nullFile; pFile = nullFile; // zeros the pFile, and releases it. hr = AAFRESULT_SUCCESS; } catch (HRESULT& rResult) { hr = rResult; } // cleanup if (pFile) { pFile->Save(); pFile->Close(); } return hr; }
static HRESULT ReadAAFFile(aafWChar * pFileName ) { HRESULT hr = AAFRESULT_SUCCESS; IAAFFile * pFile = NULL; IAAFHeader * pHeader = NULL; IEnumAAFMobs* pMobIter = NULL; IAAFCompositionMob * pCMob = NULL; IAAFMob* pMob = NULL; bool bFileOpen = false; aafNumSlots_t numMobs; IAAFObject* pObj = NULL; IEnumAAFProperties * pEnum = NULL; IAAFProperty *pProp = NULL; IAAFPropertyDef* pPropDef = NULL; IAAFPropertyValue* pPropVal = NULL; IAAFTypeDef* pTypeDef = NULL; 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)); // Validate that there is only one composition mob. checkResult(pHeader->CountMobs(kAAFCompMob, &numMobs)); checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED); // Enumerate over all Composition Mobs aafSearchCrit_t criteria; criteria.searchTag = kAAFByMobKind; criteria.tags.mobKind = kAAFCompMob; checkResult(pHeader->GetMobs(&criteria, &pMobIter)); while (AAFRESULT_SUCCESS == pMobIter->NextOne(&pMob)) { //Get the Composition mob checkResult (pMob->QueryInterface (IID_IAAFCompositionMob, (void **) &pCMob)); //Get the Object checkResult (pCMob->QueryInterface (IID_IAAFObject, (void **) &pObj)); //From the Object, we can get the properties .... aafUInt32 propCount = 0; checkResult (pObj->CountProperties (&propCount)); //A composition should have at least 5 properties ... checkExpression(propCount>=5, AAFRESULT_TEST_FAILED); //Get Enumeration over properties checkResult (pObj->GetProperties (&pEnum)); checkExpression (pEnum != 0, AAFRESULT_TEST_FAILED); while (propCount--) { //Check for property validity checkResult (pEnum->NextOne (&pProp)); checkExpression (pProp != NULL, AAFRESULT_TEST_FAILED); //Now call prop methods //1. Get Definition checkResult( pProp->GetDefinition(&pPropDef) ); //2. Get Value checkResult( pProp->GetValue(&pPropVal) ); //deal with prop value checkResult( pPropVal->GetType(&pTypeDef) ); //From propval, get the typedef!!!!!!!!!!!!!!!!!!!!! IAAFTypeDefSP spTypeDef; checkResult( pPropVal->GetType(&spTypeDef) ); //get category eAAFTypeCategory_t typeCat = kAAFTypeCatUnknown; checkResult (spTypeDef->GetTypeCategory(&typeCat)); //make sure it is not unknown checkExpression(kAAFTypeCatUnknown != typeCat, AAFRESULT_TEST_FAILED); //Deal with our Name String .... if (typeCat == kAAFTypeCatString) { IAAFTypeDefStringSP spTypeDefString; checkResult( spTypeDef->QueryInterface(IID_IAAFTypeDefString, (void**)&spTypeDefString) ); aafUInt32 bufSize = //don't forget the NULL char, and factoring in the size of a wchar (wcslen(TEST_NAME)+1) * sizeof(aafCharacter); aafCharacter *nameBuf = new aafCharacter[bufSize]; checkResult( spTypeDefString->GetElements(pPropVal, (aafMemPtr_t)nameBuf, bufSize) ); checkExpression( wcscmp(TEST_NAME, nameBuf) == 0, AAFRESULT_TEST_FAILED ); delete [] nameBuf; } //Done ........... //release typedef pTypeDef->Release(); //release defintion + value pPropDef->Release(); pPropVal->Release(); //release this prop pProp->Release(); pProp = NULL; }//while prop count }//while mob iter }//try catch (HRESULT & rResult) { hr = rResult; } //Release the rest ... if (pEnum) pEnum->Release(); if (pObj) pObj->Release(); if (pCMob) pCMob->Release(); if (pMob) pMob->Release(); if (pMobIter) pMobIter->Release(); if (pHeader) pHeader->Release(); if (pFile) { if (bFileOpen) pFile->Close(); pFile->Release(); } return hr; }
static HRESULT ReadRecord (const aafWChar * pFileName, int loadingMode) { HRESULT hr = E_FAIL; IAAFFileSP pFile; try { // Open the file, and get the dictionary. checkResult(AAFFileOpenExistingRead(pFileName, loadingMode, &pFile)); IAAFHeaderSP pHeader; checkResult(pFile->GetHeader(&pHeader)); IAAFDictionarySP pDict; checkResult (pHeader->GetDictionary(&pDict)); CAAFBuiltinDefs defs(pDict); // get the SDK version against which we are testing aafProductVersion_t testVer; checkResult(pHeader->GetRefImplVersion(&testVer)); // Get the type definitions for our new types. IAAFTypeDefSP ptd; checkResult (pDict->LookupTypeDef (sTypeId_Rational16, &ptd)); IAAFTypeDefRecordSP ptdr16; checkResult (ptd->QueryInterface (IID_IAAFTypeDefRecord, (void**) &ptdr16)); // check for duplicate initialization aafUID_t nullUid = { 0 }; HRESULT temphr; temphr = ptdr16->Initialize (nullUid, 0, 0, 1, L"foo"); checkExpression (AAFRESULT_ALREADY_INITIALIZED == temphr, AAFRESULT_TEST_FAILED); aafUInt32 count = 0; checkResult (ptdr16->GetCount (&count)); checkExpression (2 == count, AAFRESULT_TEST_FAILED); aafUInt32 nameLen = 0; aafCharacter nameBuf [100]; checkResult (ptdr16->GetMemberNameBufLen (0, &nameLen)); checkExpression (((wcslen(L"Numerator")+1)*sizeof(aafCharacter)) == nameLen, AAFRESULT_TEST_FAILED); checkExpression (nameLen < 100, AAFRESULT_TEST_FAILED); checkResult (ptdr16->GetMemberName (0, nameBuf, sizeof (nameBuf))); checkExpression (0 == wcscmp (L"Numerator", nameBuf), AAFRESULT_TEST_FAILED); checkResult (ptdr16->GetMemberNameBufLen (1, &nameLen)); checkExpression (((wcslen(L"Denominator")+1)*sizeof (aafCharacter)) == nameLen, AAFRESULT_TEST_FAILED); checkExpression (nameLen < 100, AAFRESULT_TEST_FAILED); checkResult (ptdr16->GetMemberName (1, nameBuf, sizeof (nameBuf))); checkExpression (0 == wcscmp (L"Denominator", nameBuf), AAFRESULT_TEST_FAILED); temphr = ptdr16->GetMemberNameBufLen (2, &nameLen); checkExpression (AAFRESULT_ILLEGAL_VALUE == temphr, AAFRESULT_TEST_FAILED); temphr = ptdr16->GetMemberName (2, nameBuf, sizeof (nameBuf)); checkExpression (AAFRESULT_ILLEGAL_VALUE == temphr, AAFRESULT_TEST_FAILED); checkResult (pDict->LookupTypeDef (sTypeId_Rational16_pair, &ptd)); IAAFTypeDefRecordSP ptdr16p; checkResult (ptd->QueryInterface (IID_IAAFTypeDefRecord, (void**) &ptdr16p)); // check for duplicate initialization temphr = ptdr16p->Initialize (nullUid, 0, 0, 1, L"foo"); checkExpression (AAFRESULT_ALREADY_INITIALIZED == temphr, AAFRESULT_TEST_FAILED); count = 0; checkResult (ptdr16p->GetCount (&count)); checkExpression (2 == count, AAFRESULT_TEST_FAILED); // Now attempt to register offsets of Rational16_pair. This // should fail, because offsets of its members (of type // Rational16) have not yet been registered. temphr = RegisterRational16PairOffsets (ptdr16p); checkExpression (temphr == AAFRESULT_NOT_REGISTERED, AAFRESULT_TEST_FAILED); // Now let's attempt registration the right way. checkResult (RegisterRational16Offsets (ptdr16)); checkResult (RegisterRational16PairOffsets (ptdr16p)); // Setup to read the Velocity property which is of typed Mixed_t checkResult (pDict->LookupTypeDef (sTypeId_Mixed, &ptd)); IAAFTypeDefRecordSP ptdrmixed; checkResult (ptd->QueryInterface (IID_IAAFTypeDefRecord, (void**) &ptdrmixed)); temphr = RegisterMixedOffsets(ptdrmixed); /* It is ok to return default already used due to current limitation * in implementation that default registration may occur and tie us * to a specific structural layout before we get the ability to * register own offsets/layout. This is slated for fixing in * future rev of the SDK. */ if (temphr == AAFRESULT_DEFAULT_ALREADY_USED) { temphr = AAFRESULT_SUCCESS; throw temphr; } checkResult (temphr); IAAFTypeDef * pTempTd = 0; checkResult (ptdr16->QueryInterface (IID_IAAFTypeDef, (void**) &pTempTd)); CheckMemberTypeEqual (ptdr16p, 0, pTempTd); CheckMemberTypeEqual (ptdr16p, 1, pTempTd); pTempTd->Release (); pTempTd = 0; temphr = ptdr16p->GetMemberType (2, &pTempTd); checkExpression (temphr == AAFRESULT_ILLEGAL_VALUE, AAFRESULT_TEST_FAILED); // register variable array of Rational16Pair records IAAFTypeDefVariableArraySP ptdvaarpr; IAAFTypeDefSP ptdarpr; // perform this part only for specified versions if( versionUInt(testVer) >= versionUInt(1,1,1,0) ) { checkResult (pDict->LookupTypeDef (sTypeId_Rational16_array,&ptdarpr)); checkResult (ptdarpr->QueryInterface (IID_IAAFTypeDefVariableArray,(void**) &ptdvaarpr)); } // Now read the CompositionMob to which we added some optional // properties. IEnumAAFMobsSP pEnumMobs; checkResult (pHeader->GetMobs (0, &pEnumMobs)); IAAFMobSP pMob; checkResult (pEnumMobs->NextOne (&pMob)); IAAFObjectSP pObj; checkResult (pMob->QueryInterface (IID_IAAFObject, (void**) &pObj)); // get the property definitions for the added properties IAAFPropertyDefSP pPdPosA; checkResult (defs.cdCompositionMob()-> LookupPropertyDef (sPropertyId_positionA, &pPdPosA)); IAAFPropertyDefSP pPdPosB; checkResult (defs.cdCompositionMob()-> LookupPropertyDef (sPropertyId_positionB, &pPdPosB)); IAAFPropertyDefSP pPdPosC; checkResult (defs.cdCompositionMob()-> LookupPropertyDef (sPropertyId_positionC, &pPdPosC)); IAAFPropertyValueSP pPVa; checkResult (pObj->GetPropertyValue (pPdPosA, &pPVa)); IAAFPropertyValueSP pPVb; checkResult (pObj->GetPropertyValue (pPdPosB, &pPVb)); IAAFPropertyValueSP pPVc; checkResult (pObj->GetPropertyValue (pPdPosC, &pPVc)); // Read back the value of the Velocity property IAAFPropertyDefSP pPdvelocity; checkResult (defs.cdCompositionMob()->LookupPropertyDef(sPropertyId_velocity, &pPdvelocity)); IAAFPropertyValueSP pPVvelocity; checkResult (pObj->GetPropertyValue (pPdvelocity, &pPVvelocity)); Mixed_t velocity = {0, 0}; checkResult (ptdrmixed->GetStruct (pPVvelocity, (aafMemPtr_t) &velocity, sizeof (velocity))); checkExpression (15 == velocity.angle, AAFRESULT_TEST_FAILED); checkExpression (2001 == velocity.speed, AAFRESULT_TEST_FAILED); // Try to read the first one with GetStruct. Rational16pair_t valA = { {0,0},{0,0} }; checkResult (ptdr16p->GetStruct (pPVa, (aafMemPtr_t) &valA, sizeof (valA))); checkExpression (1 == valA.X_Position.Numerator, AAFRESULT_TEST_FAILED); checkExpression (2 == valA.X_Position.Denominator, AAFRESULT_TEST_FAILED); checkExpression (3 == valA.Y_Position.Numerator, AAFRESULT_TEST_FAILED); checkExpression (4 == valA.Y_Position.Denominator, AAFRESULT_TEST_FAILED); // Try to read the second one by decomposing with GetValue. Rational16pair_t valB = { {5, 6}, {7, 8} }; CheckRational16PairByValues (ptdr16p, ptdr16, pPVb, valB); // Read the last two with GetStruct just to get it over with. ;) Rational16pair_t valC = { {0,0},{0,0} }; temphr = ptdr16p->GetStruct (pPVc, (aafMemPtr_t) &valC, sizeof (valC)-1); checkExpression (AAFRESULT_ILLEGAL_VALUE == temphr, AAFRESULT_TEST_FAILED); temphr = ptdr16p->GetStruct (0, (aafMemPtr_t) &valC, sizeof (valC)); checkExpression (AAFRESULT_NULL_PARAM == temphr, AAFRESULT_TEST_FAILED); temphr = ptdr16p->GetStruct (pPVc, 0, sizeof (valC)); checkExpression (AAFRESULT_NULL_PARAM == temphr, AAFRESULT_TEST_FAILED); checkResult (ptdr16p->GetStruct (pPVc, (aafMemPtr_t) &valC, sizeof (valC))); checkExpression (9 == valC.X_Position.Numerator, AAFRESULT_TEST_FAILED); checkExpression (10 == valC.X_Position.Denominator, AAFRESULT_TEST_FAILED); checkExpression (11 == valC.Y_Position.Numerator, AAFRESULT_TEST_FAILED); checkExpression (12 == valC.Y_Position.Denominator, AAFRESULT_TEST_FAILED); // test variable array of records // perform this part only for specified versions if( versionUInt(testVer) >= versionUInt(1,1,1,0) ) { IAAFPropertyDefSP pPdPosN; checkResult (defs.cdCompositionMob()->LookupPropertyDef (sPropertyId_positionN, &pPdPosN)); IAAFPropertyValueSP pPVN; checkResult (pObj->GetPropertyValue (pPdPosN, &pPVN)); // get the middle element of the array, 9abc IAAFPropertyValueSP pPVN1; checkResult (ptdvaarpr->GetElementValue (pPVN, 1, &pPVN1)); // Read the value with GetStruct Rational16pair_t valN1 = { {0,0},{0,0} }; checkResult (ptdr16p->GetStruct (pPVN1, (aafMemPtr_t) &valN1, sizeof (valN1))); checkExpression (9 == valN1.X_Position.Numerator, AAFRESULT_TEST_FAILED); checkExpression (10 == valN1.X_Position.Denominator, AAFRESULT_TEST_FAILED); checkExpression (11 == valN1.Y_Position.Numerator, AAFRESULT_TEST_FAILED); checkExpression (12 == valN1.Y_Position.Denominator, AAFRESULT_TEST_FAILED); } // Attempt to close the file. checkResult(pFile->Close()); IAAFFileSP nullFile; pFile = nullFile; // zeros the pFile, and releases it. hr = AAFRESULT_SUCCESS; } catch (HRESULT& rResult) { hr = rResult; } // cleanup if (pFile) { pFile->Close(); } return hr; }
static bool testRestore(const wchar_t* fileName) { bool passed = true; IAAFFile* pFile = 0; IAAFHeader* pHeader = 0; IAAFDictionary* pDictionary = 0; IAAFContentStorage* pStorage = 0; IEnumAAFMobs* pMobs = 0; IAAFMob* pMob = 0; try { pFile = openFileForReading(fileName); } catch (...) { return false; } try { // get the Mob containing the test data checkResult(pFile->GetHeader(&pHeader)); checkResult(pHeader->GetDictionary(&pDictionary)); checkResult(pHeader->GetContentStorage(&pStorage)); aafSearchCrit_t searchCrit; searchCrit.searchTag = kAAFByMobKind; searchCrit.tags.mobKind = kAAFAllMob; checkResult(pStorage->GetMobs(&searchCrit, &pMobs)); checkResult(pMobs->NextOne(&pMob)); IAAFObject* pObject = 0; IAAFClassDef* pClassDef = 0; IAAFPropertyDef* pPropertyDef = 0; IAAFPropertyValue* pPropertyValue = 0; IAAFTypeDef* pType = 0; IAAFTypeDefCharacter* pCharacterType = 0; // test simple try { printf(" * Simple: "); const aafUID_t propId = {0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; wchar_t testCharacter = L'A'; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefCharacter, (void **)&pCharacterType)); aafCharacter value; checkResult(pCharacterType->GetCharacter(pPropertyValue, &value)); if (value == testCharacter) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pCharacterType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); // test XML escaped try { printf(" * XML escaped: "); const aafUID_t propId = {0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; wchar_t testCharacter = L'\r'; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefCharacter, (void **)&pCharacterType)); aafCharacter value; checkResult(pCharacterType->GetCharacter(pPropertyValue, &value)); if (value == testCharacter) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pCharacterType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); // test AAF escaped try { printf(" * AAF escaped: "); const aafUID_t propId = {0x20000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; wchar_t testCharacter = 0x0; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefCharacter, (void **)&pCharacterType)); aafCharacter value; checkResult(pCharacterType->GetCharacter(pPropertyValue, &value)); if (value == testCharacter) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pCharacterType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); // test AAF escaped of invalid UNICODE character try { printf(" * AAF escaped invalid Unicode character: "); const aafUID_t propId = {0x30000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; wchar_t testCharacter = 0xFFFF; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefCharacter, (void **)&pCharacterType)); aafCharacter value; checkResult(pCharacterType->GetCharacter(pPropertyValue, &value)); if (value == testCharacter) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pCharacterType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); } catch (...) { passed = false; } // cleanup release(pMob); release(pMobs); release(pStorage); release(pDictionary); release(pHeader); checkResult(pFile->Close()); release(pFile); report(passed); return passed; }
static bool testRestore(const wchar_t* fileName) { bool passed = true; IAAFFile* pFile = 0; IAAFHeader* pHeader = 0; IAAFDictionary* pDictionary = 0; IAAFContentStorage* pStorage = 0; IEnumAAFMobs* pMobs = 0; IAAFMob* pMob = 0; try { pFile = openFileForReading(fileName); } catch (...) { return false; } try { // get the Mob containing the test data checkResult(pFile->GetHeader(&pHeader)); checkResult(pHeader->GetDictionary(&pDictionary)); checkResult(pHeader->GetContentStorage(&pStorage)); aafSearchCrit_t searchCrit; searchCrit.searchTag = kAAFByMobKind; searchCrit.tags.mobKind = kAAFAllMob; checkResult(pStorage->GetMobs(&searchCrit, &pMobs)); checkResult(pMobs->NextOne(&pMob)); IAAFObject* pObject = 0; IAAFClassDef* pClassDef = 0; IAAFPropertyDef* pPropertyDef = 0; IAAFPropertyValue* pPropertyValue = 0; IAAFTypeDef* pType = 0; IAAFTypeDefIndirect* pIndirectType = 0; IAAFPropertyValue* pActualPropertyValue = 0; IAAFTypeDef* pActualType = 0; IAAFTypeDefInt* pIntType = 0; IAAFTypeDefEnum* pEnumType = 0; IAAFTypeDefRecord* pRecordType = 0; try { printf(" * Baseline: "); const aafUID_t propId = {0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafInt8 testValue = -128; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefIndirect, (void **)&pIndirectType)); checkResult(pIndirectType->GetActualValue(pPropertyValue, &pActualPropertyValue)); checkResult(pActualPropertyValue->GetType(&pActualType)); checkResult(pActualType->QueryInterface(IID_IAAFTypeDefInt, (void **)&pIntType)); aafInt8 value; checkResult(pIntType->GetInteger(pActualPropertyValue, (aafUInt8*)&value, 1)); if (value == testValue) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pRecordType); release(pEnumType); release(pIntType); release(pActualType); release(pActualPropertyValue); release(pIndirectType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); try { printf(" * Non-baseline: "); const aafUID_t propId = {0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafUInt8 testValue = 1; const wchar_t* testName = L"AAA"; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefIndirect, (void **)&pIndirectType)); checkResult(pIndirectType->GetActualValue(pPropertyValue, &pActualPropertyValue)); checkResult(pActualPropertyValue->GetType(&pActualType)); checkResult(pActualType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType)); aafInt64 value; aafCharacter name[256]; checkResult(pEnumType->GetIntegerValue(pActualPropertyValue, &value)); checkResult(pEnumType->GetNameFromValue(pActualPropertyValue, name, 256)); if (value == testValue && wcscmp(name, testName) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pRecordType); release(pEnumType); release(pIntType); release(pActualType); release(pActualPropertyValue); release(pIndirectType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); try { printf(" * Baseline record: "); const aafUID_t propId = {0x20000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}}; aafProductVersion_t testValue = {0,1,0,0,kAAFVersionUnknown}; checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject)); checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef)); checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef)); checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue)); checkResult(pPropertyValue->GetType(&pType)); checkResult(pType->QueryInterface(IID_IAAFTypeDefIndirect, (void **)&pIndirectType)); checkResult(pIndirectType->GetActualValue(pPropertyValue, &pActualPropertyValue)); checkResult(pActualPropertyValue->GetType(&pActualType)); checkResult(pActualType->QueryInterface(IID_IAAFTypeDefRecord, (void **)&pRecordType)); aafProductVersion_t value; checkResult(pRecordType->GetStruct(pActualPropertyValue, (aafUInt8*)&value, sizeof(aafProductVersion_t))); if (memcmp(&testValue, &value, sizeof(aafProductVersion_t)) == 0) { printf("passed\n"); } else { printf("FAILED\n"); passed = false; } } catch (...) { printf("FAILED\n"); passed = false; } release(pRecordType); release(pEnumType); release(pIntType); release(pActualType); release(pActualPropertyValue); release(pIndirectType); release(pType); release(pPropertyValue); release(pPropertyDef); release(pClassDef); release(pObject); } catch (...) { passed = false; } // cleanup release(pMob); release(pMobs); release(pStorage); release(pDictionary); release(pHeader); checkResult(pFile->Close()); release(pFile); report(passed); return passed; }