IAAFInterpolationDef *AAFDomainUtils::CreateInterpolationDefinition(IAAFDictionary *dict, aafUID_t interpolationDefID) { IAAFInterpolationDef *interpDef; AAFRESULT rc; CAAFBuiltinDefs defs (dict); rc = dict->LookupInterpolationDef(interpolationDefID,&interpDef); if(rc == AAFRESULT_SUCCESS && interpDef != NULL) return interpDef; // dprintf("AEffect::CreateInterpolationDefinition()\n"); //JeffB: (void)(defs.cdInterpolationDefinition()-> CreateInstance(IID_IAAFInterpolationDef, (IUnknown **)&interpDef)); if(memcmp(&interpolationDefID, &LinearInterpolator, sizeof(aafUID_t)) == 0) { (void)(interpDef->Initialize(interpolationDefID, L"LinearInterp", L"Linear keyframe interpolation")); dict->RegisterInterpolationDef(interpDef); } else { interpDef->Release(); interpDef = NULL; } //cleanup: return(interpDef); }
IAAFVaryingValue *AAFDomainUtils::AAFAddEmptyVaryingVal(IAAFDictionary *dict, IAAFParameterDef *pParameterDef, IAAFOperationGroup *pOutputEffect) { IAAFVaryingValue *pVVal = NULL; IAAFParameter *pParm = NULL; // AAFRESULT rc; CAAFBuiltinDefs defs (dict); CHECKAAF(defs.cdVaryingValue()-> CreateInstance(IID_IAAFVaryingValue, (IUnknown **)&pVVal)); AutoRelease<IAAFVaryingValue> arVaryingValue(pVVal); CHECKAAF(pVVal->Initialize (pParameterDef, CreateInterpolationDefinition( dict, LinearInterpolator))); CHECKAAF(pVVal->QueryInterface(IID_IAAFParameter, (void **) &pParm)); CHECKAAF(pOutputEffect->AddParameter(pParm)); //cleanup: if(pParm != NULL) pParm->Release(); // Since we are using the "auto release" for the return value that // we just created we need to bump the reference count. pVVal->AddRef(); return(pVVal); }
static HRESULT CreateAAFSequence(IAAFDictionary *pDictionary, IAAFSequence** ppSequence) { IAAFSequence* pSequence = NULL; HRESULT hr = S_OK; aafUInt32 i; CAAFBuiltinDefs defs (pDictionary); hr = defs.cdSequence()-> CreateInstance(IID_IAAFSequence, (IUnknown **)&pSequence); if (SUCCEEDED(hr)) { pSequence->Initialize(defs.ddkAAFSound()); // // Add some segments. Need to test failure conditions // (i.e. starting/ending w/ transition, two trans back // to bacl). // for(i = 0; i < kNumComponents; i++) { IAAFComponent* pComponent = NULL; aafLength_t len = 10; hr = defs.cdFiller()-> CreateInstance(IID_IAAFComponent, (IUnknown **)&pComponent); if (FAILED(hr)) break; pComponent->SetDataDef(defs.ddkAAFSound()); pComponent->SetLength(len); hr = pSequence->AppendComponent(pComponent); pComponent->Release(); pComponent = NULL; if (FAILED(hr)) break; } } if (SUCCEEDED(hr)) { *ppSequence = pSequence; } else { pSequence->Release(); *ppSequence = NULL; } return hr; }
void EssenceDataTest::createFileMob(unsigned int mobid_Index) { assert(_pFile && _pHeader && _pDictionary); assert(NULL == _pSourceMob); assert(NULL == _pMob); assert(NULL == _pFileDescriptor); assert(NULL == _pEssenceDescriptor); assert(NULL == _pSourceMob); CAAFBuiltinDefs defs (_pDictionary); // Create a Mob check(defs.cdSourceMob()->CreateInstance(IID_IAAFSourceMob, (IUnknown **)&_pSourceMob)); check(_pSourceMob->QueryInterface (IID_IAAFMob, (void **)&_pMob)); check(_pMob->SetMobID(TEST_MobIDs[mobid_Index])); check(_pMob->SetName(L"EssenceDataTest File Mob")); // instantiate a concrete subclass of FileDescriptor check(defs.cdAIFCDescriptor()-> CreateInstance(IID_IAAFFileDescriptor, (IUnknown **)&_pFileDescriptor)); IAAFAIFCDescriptor* pAIFCDesc = NULL; check(_pFileDescriptor->QueryInterface (IID_IAAFAIFCDescriptor, (void **)&pAIFCDesc)); check(pAIFCDesc->SetSummary (5, (unsigned char*)"TEST")); pAIFCDesc->Release(); pAIFCDesc = NULL; check(_pFileDescriptor->QueryInterface (IID_IAAFEssenceDescriptor, (void **)&_pEssenceDescriptor)); check(_pSourceMob->SetEssenceDescriptor (_pEssenceDescriptor)); check(_pHeader->AddMob(_pMob)); createEssenceData(_pSourceMob); // Cleanup instance data for reuse... _pEssenceDescriptor->Release(); _pEssenceDescriptor = NULL; _pFileDescriptor->Release(); _pFileDescriptor = NULL; _pMob->Release(); _pMob = NULL; _pSourceMob->Release(); _pSourceMob = NULL; }
void AAFDomainUtils::AAFAddOnePoint(IAAFDictionary *dict, aafRational_t percentTime, long buflen, void *buf, IAAFTypeDef * /* typeDef */, IAAFVaryingValue *pVVal) { IAAFControlPoint *pPoint = NULL; // AAFRESULT rc; CAAFBuiltinDefs defs (dict); CHECKAAF(defs.cdControlPoint()-> CreateInstance(IID_IAAFControlPoint, (IUnknown **)&pPoint)); CHECKAAF(pPoint->Initialize (pVVal, percentTime, buflen, (aafDataBuffer_t)buf)); CHECKAAF(pVVal->AddControlPoint(pPoint)); //cleanup: if(pPoint != NULL) pPoint->Release(); }
IAAFParameterDef *AAFDomainUtils::CreateParameterDefinition(IAAFDictionary *pDict, aafUID_t parmDefID) { IAAFParameterDef *parmDef; IAAFTypeDef *typeDef; AAFRESULT rc; // dprintf("AEffect::CreateParameterDefinition()\n"); rc = pDict->LookupParameterDef(parmDefID,&parmDef); if(rc == AAFRESULT_SUCCESS && parmDef != NULL) return parmDef; CAAFBuiltinDefs defs (pDict); CHECKAAF(defs.cdParameterDef()-> CreateInstance(IID_IAAFParameterDef, (IUnknown **)&parmDef)); AutoRelease<IAAFParameterDef> arParmDef(parmDef); if(memcmp(&parmDefID, &kAAFParameterDefLevel, sizeof(aafUID_t)) == 0) { CHECKAAF(pDict->LookupTypeDef(kAAFTypeID_Rational, &typeDef)); AutoRelease<IAAFTypeDef> r1( typeDef ); CHECKAAF(parmDef->Initialize(parmDefID, L"Level", L"fractional 0-1 inclusive", typeDef)); } else if(memcmp(&parmDefID, &kAAFParameterDefSMPTEWipeNumber, sizeof(aafUID_t)) == 0) { CHECKAAF(pDict->LookupTypeDef(kAAFTypeID_Int32, &typeDef)); AutoRelease<IAAFTypeDef> r2( typeDef ); CHECKAAF(parmDef->Initialize(parmDefID, L"WipeCode", L"SMPTE Wipe Code", typeDef)); } else { // Unrecognized parameter definition. Should we emit a log entry? return NULL; } if(parmDef != NULL) { CHECKAAF(pDict->RegisterParameterDef(parmDef)); // Since we are using the "auto release" for the return value that // we just created we need to bump the reference count. parmDef->AddRef(); } //cleanup: return(parmDef); }
// Create a SourceMob with the specified ID and name, // then create an EssenceData object associating it // with the new SourceMob. static void Test_CreateEssenceData( CAAFBuiltinDefs& defs, IAAFHeader* pHeader, const aafMobID_t& mobID, aafCharacter_constptr mobName, IAAFEssenceData** pResult) { IAAFSourceMobSP pSourceMob; IAAFMobSP pMob; IAAFEssenceDescriptorSP pEssenceDesciptor; IAAFEssenceDataSP pEssenceData; // Create a Mob CheckResult(defs.cdSourceMob()->CreateInstance(IID_IAAFSourceMob, (IUnknown **)&pSourceMob)); CheckResult(pSourceMob->QueryInterface(IID_IAAFMob, (void **)&pMob)); CheckResult(pMob->SetMobID(mobID)); CheckResult(pMob->SetName(mobName)); // Create a concrete subclass of EssenceDescriptor CheckResult(defs.cdAIFCDescriptor()->CreateInstance(IID_IAAFEssenceDescriptor, (IUnknown **)&pEssenceDesciptor)); IAAFAIFCDescriptor* pAIFCDesc = NULL; CheckResult(pEssenceDesciptor->QueryInterface (IID_IAAFAIFCDescriptor, (void **)&pAIFCDesc)); CheckResult(pAIFCDesc->SetSummary (5, (unsigned char*)"TEST")); pAIFCDesc->Release(); pAIFCDesc = NULL; CheckResult(pSourceMob->SetEssenceDescriptor (pEssenceDesciptor)); CheckResult(pHeader->AddMob(pMob)); // Attempt to create an AAFEssenceData. CheckResult(defs.cdEssenceData()->CreateInstance(IID_IAAFEssenceData, (IUnknown **)&pEssenceData)); CheckResult(pEssenceData->SetFileMob(pSourceMob)); CheckResult(pHeader->AddEssenceData(pEssenceData)); *pResult = pEssenceData; (*pResult)->AddRef(); }
void EnumEssenceDataTest::createEssenceData(IAAFSourceMob *pSourceMob) { assert(_pFile && _pHeader && _pDictionary); assert(pSourceMob); assert(NULL == _pEssenceData); CAAFBuiltinDefs defs (_pDictionary); // Attempt to create an AAFEssenceData. check(defs.cdEssenceData()-> CreateInstance(IID_IAAFEssenceData, (IUnknown **)&_pEssenceData)); check(_pEssenceData->SetFileMob(pSourceMob)); check(_pHeader->AddEssenceData(_pEssenceData)); _pEssenceData->Release(); _pEssenceData = NULL; }
IAAFParameter *AAFDomainUtils::AAFAddConstantVal(IAAFDictionary *dict, IAAFParameterDef *pParameterDef, long buflen, void *buf, IAAFOperationGroup *pGroup) { IAAFConstantValue *pCVal = NULL; IAAFParameter *pParm = NULL; // AAFRESULT rc; CAAFBuiltinDefs defs (dict); CHECKAAF(defs.cdConstantValue()-> CreateInstance(IID_IAAFConstantValue, (IUnknown **)&pCVal)); CHECKAAF(pCVal->Initialize (pParameterDef, buflen, (unsigned char *)buf)); CHECKAAF(pCVal->QueryInterface(IID_IAAFParameter, (void **) &pParm)); CHECKAAF(pGroup->AddParameter(pParm)); //cleanup: if(pParm) pParm->Release(); if(pCVal) pCVal->Release(); return(pParm); }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { HRESULT hr = AAFRESULT_SUCCESS; IAAFFile* pFile = NULL; IAAFHeader * pHeader = NULL; IAAFDictionary * pDict = NULL; IAAFCompositionMob * pCMob = NULL; IAAFMob * pMob = NULL; IAAFObject * pObj = NULL; try { //Do the usual ... RemoveTestFile (pFileName); checkResult (CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile )); assert (pFile); checkResult (pFile->GetHeader (&pHeader)); assert (pHeader); checkResult (pHeader->GetDictionary (&pDict)); assert (pDict); CAAFBuiltinDefs defs (pDict); //Create a composition ... checkResult (defs.cdCompositionMob()-> CreateInstance (IID_IAAFCompositionMob, (IUnknown **) &pCMob)); assert (pCMob); checkResult (pCMob->Initialize (TEST_NAME)); //... Get its mob, and add it to the header info checkResult (pCMob->QueryInterface (IID_IAAFMob, (void **) &pMob)); assert (pMob); checkResult (pHeader->AddMob (pMob)); } catch (HRESULT & rResult) { hr = rResult; } if (pCMob) pCMob->Release(); if (pMob) pCMob->Release(); if (pObj) pObj->Release(); if (pDict) pDict->Release(); if (pHeader) pHeader->Release(); if (pFile) { AAFRESULT temphr = pFile->Save(); if (! SUCCEEDED (temphr)) return temphr; temphr = pFile->Close(); if (! SUCCEEDED (temphr)) return temphr; pFile->Release(); } return hr; }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { IAAFFile* pFile = NULL; IAAFHeader * pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFParameterDef* pParamDef = NULL; bool bFileOpen = false; HRESULT hr = S_OK; aafUID_t testParmID = kParmID; aafInt32 index; IAAFOperationDef *pOperationDef = NULL, *defResults[3] = { NULL, NULL, NULL }; /* 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.cdParameterDef()-> CreateInstance(IID_IAAFParameterDef, (IUnknown **)&pParamDef)); checkResult(pParamDef->Initialize (testParmID, TEST_PARAM_NAME, TEST_PARAM_DESC, defs.tdRational())); checkResult(pDictionary->RegisterParameterDef(pParamDef)); for(index = 0; index < 3; index++) { checkResult(defs.cdOperationDef()-> CreateInstance(IID_IAAFOperationDef, (IUnknown **)&pOperationDef)); checkResult(pOperationDef->Initialize (effectID[index], effectNames[index], effectDesc[index])); checkResult(pDictionary->RegisterOperationDef(pOperationDef)); 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)); defResults[index] = pOperationDef; pOperationDef = NULL; } checkResult(defResults[1]->AppendDegradeToOperation (defResults[1])); checkResult(defResults[2]->AppendDegradeToOperation (defResults[2])); checkResult(defResults[0]->AppendDegradeToOperation (defResults[1])); checkResult(defResults[0]->PrependDegradeToOperation (defResults[2])); // Add an extra one to delete for the test //!!! checkResult(defResults[0]->CountDegradeToOperations(&numDegrade)); // checkExpression(2 == numDegrade, AAFRESULT_TEST_FAILED); // checkResult(defResults[0]->AppendDegradeToOperation (defResults[1])); // checkResult(defResults[0]->CountDegradeToOperations(&numDegrade)); // checkExpression(3 == numDegrade, AAFRESULT_TEST_FAILED); // checkResult(defResults[0]->RemoveDegradeToOperationAt (2)); // checkResult(defResults[0]->CountDegradeToOperations(&numDegrade)); // checkExpression(2 == numDegrade, AAFRESULT_TEST_FAILED); for(index = 0; index < 3; index++) { defResults[index]->Release(); defResults[index] = NULL; } } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (pOperationDef) pOperationDef->Release(); if (pParamDef) pParamDef->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if (pFile) { // Close file if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } return hr; }
static HRESULT ReadAAFFile(aafWChar* pFileName) { IAAFFile* pFile = NULL; IAAFHeader* pHeader = NULL; IAAFDictionary* pDictionary = NULL; IEnumAAFOperationDefs *pEffectEnum = NULL; IEnumAAFOperationDefs *pDegradeEnum = NULL; IEnumAAFParameterDefs *pParmDefEnum = NULL; IAAFOperationDef *pOperationDef = NULL; IAAFParameterDef *pParmDef = NULL; IAAFDefObject* pDefObject = NULL; bool bFileOpen = false; IAAFDataDefSP pReadDataDef; aafBool readIsTimeWarp; aafInt32 checkNumInputs; aafUInt32 checkBypass; HRESULT hr = S_OK; wchar_t checkName[256]; aafUID_t checkCat; aafBool bResult = kAAFFalse; try { // Open the AAF file checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile)); bFileOpen = true; // Get the AAF file header. checkResult(pFile->GetHeader(&pHeader)); checkResult(pHeader->GetDictionary(&pDictionary)); CAAFBuiltinDefs defs (pDictionary); checkResult(pDictionary->GetOperationDefs(&pEffectEnum)); checkResult(pEffectEnum->NextOne (&pOperationDef)); checkResult(pOperationDef->GetDataDef(&pReadDataDef)); checkResult(pOperationDef->QueryInterface(IID_IAAFDefObject, (void **) &pDefObject)); checkResult(pDefObject->GetName (checkName, sizeof(checkName))); checkExpression(wcscmp(checkName, effectNames[0]) == 0, AAFRESULT_TEST_FAILED); checkResult(pDefObject->GetDescription (checkName, sizeof(checkName))); checkExpression(wcscmp(checkName, effectDesc[0]) == 0, AAFRESULT_TEST_FAILED); pDefObject->Release(); pDefObject = NULL; checkResult(pReadDataDef->IsDataDefOf(defs.ddkAAFPicture(), &bResult)); checkExpression(bResult == kAAFTrue, AAFRESULT_TEST_FAILED); checkResult(pOperationDef->IsTimeWarp (&readIsTimeWarp)); checkExpression(readIsTimeWarp == kAAFFalse, AAFRESULT_TEST_FAILED); checkResult(pOperationDef->GetCategory (&checkCat)); checkExpression(memcmp(&checkCat, &TEST_CATEGORY, sizeof(aafUID_t)) == 0, AAFRESULT_TEST_FAILED); checkResult(pOperationDef->GetBypass (&checkBypass)); checkExpression(checkBypass == TEST_BYPASS, AAFRESULT_TEST_FAILED); checkResult(pOperationDef->GetNumberInputs (&checkNumInputs)); checkExpression(checkNumInputs == TEST_NUM_INPUTS, AAFRESULT_TEST_FAILED); checkResult(pOperationDef->GetParameterDefs (&pParmDefEnum)); checkResult(pParmDefEnum->NextOne (&pParmDef)); checkResult(pParmDef->QueryInterface(IID_IAAFDefObject, (void **) &pDefObject)); checkResult(pDefObject->GetName (checkName, sizeof(checkName))); checkExpression(wcscmp(checkName, TEST_PARAM_NAME) == 0, AAFRESULT_TEST_FAILED); checkResult(pDefObject->GetDescription (checkName, sizeof(checkName))); checkExpression(wcscmp(checkName, TEST_PARAM_DESC) == 0, AAFRESULT_TEST_FAILED); pDefObject->Release(); pDefObject = NULL; checkResult(pOperationDef->GetDegradeToOperations (&pDegradeEnum)); pOperationDef->Release(); pOperationDef = NULL; // Check for prepended one first checkResult(pDegradeEnum->NextOne (&pOperationDef)); checkResult(pOperationDef->QueryInterface(IID_IAAFDefObject, (void **) &pDefObject)); checkResult(pDefObject->GetName (checkName, sizeof(checkName))); checkExpression(wcscmp(checkName, effectNames[2]) == 0, AAFRESULT_TEST_FAILED); checkResult(pDefObject->GetDescription (checkName, sizeof(checkName))); checkExpression(wcscmp(checkName, effectDesc[2]) == 0, AAFRESULT_TEST_FAILED); pDefObject->Release(); pDefObject = NULL; pOperationDef->Release(); pOperationDef = NULL; // Check for appended one second checkResult(pDegradeEnum->NextOne (&pOperationDef)); checkResult(pOperationDef->QueryInterface(IID_IAAFDefObject, (void **) &pDefObject)); checkResult(pDefObject->GetName (checkName, sizeof(checkName))); checkExpression(wcscmp(checkName, effectNames[1]) == 0, AAFRESULT_TEST_FAILED); checkResult(pDefObject->GetDescription (checkName, sizeof(checkName))); checkExpression(wcscmp(checkName, effectDesc[1]) == 0, AAFRESULT_TEST_FAILED); pDefObject->Release(); pDefObject = NULL; pOperationDef->Release(); pOperationDef = NULL; } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (pHeader) pHeader->Release(); if (pDictionary) pDictionary->Release(); if (pEffectEnum) pEffectEnum->Release(); if (pDegradeEnum) pDegradeEnum->Release(); if (pParmDefEnum) pParmDefEnum->Release(); if (pOperationDef) pOperationDef->Release(); if (pDefObject) pDefObject->Release(); if (pParmDef) pParmDef->Release(); if (pFile) { // Close file if (bFileOpen) pFile->Close(); pFile->Release(); } return hr; }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { IAAFFile* pFile = NULL; IAAFHeader * pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFDefObject* pDef = NULL; IAAFContainerDef* pContainerDef = NULL; bool bFileOpen = false; HRESULT hr = S_OK; /* long test; */ try { // Remove the previous test file if any. RemoveTestFile(pFileName); // Create the AAF file checkResult(CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile )); bFileOpen = true; // 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.cdContainerDef()-> CreateInstance(IID_IAAFContainerDef, (IUnknown **)&pContainerDef)); checkResult(pContainerDef->QueryInterface (IID_IAAFDefObject, (void **)&pDef)); checkResult(pContainerDef->Initialize (testUID, sName, sDescription)); checkResult(pDictionary->RegisterContainerDef(pContainerDef)); // // test Append, Prepend, and enum plugin descriptor using same type def // IAAFPluginDescriptorSP pd1; checkResult (defs.cdPluginDef()-> CreateInstance (IID_IAAFPluginDef, (IUnknown **)&pd1)); checkResult (pd1->Initialize (kTestPluginDescID1, L"PluginDesc1", L"Plugin Descriptor 1 description")); checkResult(pd1->SetDefinitionObjectID(kTestPluginDescID1)); checkResult (pDictionary->RegisterPluginDef (pd1)); IAAFPluginDescriptorSP pd2; checkResult (defs.cdPluginDef()-> CreateInstance (IID_IAAFPluginDef, (IUnknown **)&pd2)); checkResult (pd2->Initialize (kTestPluginDescID2, L"PluginDesc2", L"Plugin Descriptor 2 description")); checkResult(pd2->SetDefinitionObjectID(kTestPluginDescID2)); checkResult (pDictionary->RegisterPluginDef (pd2)); IAAFPluginDescriptorSP pd3; checkResult (defs.cdPluginDef()-> CreateInstance (IID_IAAFPluginDef, (IUnknown **)&pd3)); checkResult (pd3->Initialize (kTestPluginDescID3, L"PluginDesc3", L"Plugin Descriptor 3 description")); checkResult(pd3->SetDefinitionObjectID(kTestPluginDescID3)); checkResult (pDictionary->RegisterPluginDef (pd3)); } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (pDef) pDef->Release(); if (pContainerDef) pContainerDef->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if (pFile) { // Close file if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } 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; IAAFLocator * pLocator = NULL; IAAFNetworkLocator * pNetLocator = NULL; IAAFSourceMob *pSourceMob = NULL; IAAFMob *pMob = NULL; IAAFEssenceDescriptor *edesc = NULL; aafUInt32 numLocators; HRESULT hr = AAFRESULT_SUCCESS; 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 // Create a Mob checkResult(defs.cdSourceMob()-> CreateInstance(IID_IAAFSourceMob, (IUnknown **)&pSourceMob)); checkResult(pSourceMob->QueryInterface (IID_IAAFMob, (void **)&pMob)); checkResult(pMob->SetMobID(TEST_MobID)); checkResult(pMob->SetName(L"SourceMOBTest")); // Create a concrete subclass of EssenceDescriptor checkResult(defs.cdAIFCDescriptor()-> CreateInstance(IID_IAAFEssenceDescriptor, (IUnknown **)&edesc)); IAAFAIFCDescriptor* pAIFCDesc = NULL; checkResult(edesc->QueryInterface (IID_IAAFAIFCDescriptor, (void **)&pAIFCDesc)); checkResult(pAIFCDesc->SetSummary (5, (unsigned char*)"TEST")); pAIFCDesc->Release(); pAIFCDesc = NULL; // Verify that there are no locators checkResult(edesc->CountLocators(&numLocators)); checkExpression(0 == numLocators, AAFRESULT_TEST_FAILED); // Make a locator, and attach it to the EssenceDescriptor checkResult(defs.cdNetworkLocator()-> CreateInstance(IID_IAAFNetworkLocator, (IUnknown **)&pNetLocator)); checkResult(pNetLocator->QueryInterface (IID_IAAFLocator, (void **)&pLocator)); checkResult(pLocator->SetPath (TEST_PATH)); checkResult(edesc->AppendLocator(pLocator)); checkResult(pSourceMob->SetEssenceDescriptor (edesc)); // Verify that there is now one locator checkResult(edesc->CountLocators(&numLocators)); checkExpression(1 == numLocators, AAFRESULT_TEST_FAILED); // Add the source mob into the tree checkResult(pHeader->AddMob(pMob)); } catch (HRESULT& rResult) { hr = rResult; } // cleanup if (pLocator) pLocator->Release(); if (pNetLocator) pNetLocator->Release(); if (edesc) edesc->Release(); if (pMob) pMob->Release(); if (pSourceMob) pSourceMob->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if (pFile) { if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } // hr = pSession->EndSession(); // if (AAFRESULT_SUCCESS != hr) // return hr; // if (pSession) pSession->Release(); return hr; }
static HRESULT ReadAAFFile(aafWChar * pFileName) { IAAFFile * pFile = NULL; IAAFHeader * pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFSourceMob* pSourceMob = NULL; IAAFMob* pMob = NULL; IAAFEssenceDescriptor* pEssDesc = NULL; IAAFBWFImportDescriptor* pBWFImportDesc = NULL; IEnumAAFRIFFChunks* pEnum = NULL; IAAFRIFFChunk* pRIFFChunk = NULL; IAAFRIFFChunk* pRIFFChunkTest = NULL; IEnumAAFMobs* pMobIter = NULL; aafUInt32 numData, bytesRead, com, testNum; aafLength_t testRIFFLen; aafNumSlots_t numMobs; char Value[sizeof(RIFFChunksmiley)]; char Value2[sizeof(RIFFChunkfrowney)]; HRESULT hr = AAFRESULT_SUCCESS; wchar_t testString[256]; checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile)); checkResult( pFile->GetHeader(&pHeader)); // Get the AAF Dictionary so that we can create a fake RIFFChunk to test RemoveUnknownBWFChunks. checkResult(pHeader->GetDictionary(&pDictionary)); CAAFBuiltinDefs defs (pDictionary); checkResult(defs.cdRIFFChunk()->CreateInstance(IID_IAAFRIFFChunk, (IUnknown **)&pRIFFChunkTest)); checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs)); if (1 == numMobs ) { checkResult(pHeader->GetMobs(NULL, &pMobIter)); checkResult(pMobIter->NextOne(&pMob)); checkResult(pMob->QueryInterface(IID_IAAFSourceMob, (void **)&pSourceMob)); // Back into testing mode checkResult(pSourceMob->GetEssenceDescriptor(&pEssDesc)); checkResult( pEssDesc->QueryInterface( IID_IAAFBWFImportDescriptor, (void**)&pBWFImportDesc )); checkResult(pBWFImportDesc->GetFileSecurityReport(&testNum)); checkExpression(testNum==TEST_FileSecurityReport, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetFileSecurityWave(&testNum)); checkExpression(testNum==TEST_FileSecurityWave, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetCodingHistory(testString, sizeof(testString))); checkExpression(wcscmp(testString, TEST_CodingHistory) == 0, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetBasicData(testString, sizeof(testString))); checkExpression(wcscmp(testString, TEST_BasicData) == 0, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetStartOfModulation(testString, sizeof(testString))); checkExpression(wcscmp(testString, TEST_StartOfModulation) == 0, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetQualityEvent(testString, sizeof(testString))); checkExpression(wcscmp(testString, TEST_QualityEvent) == 0, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetEndOfModulation(testString, sizeof(testString))); checkExpression(wcscmp(testString, TEST_EndOfModulation) == 0, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetQualityParameter(testString, sizeof(testString))); checkExpression(wcscmp(testString, TEST_QualityParameter) == 0, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetOperatorComment(testString, sizeof(testString))); checkExpression(wcscmp(testString, TEST_OperatorComment) == 0, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetCueSheet(testString, sizeof(testString))); checkExpression(wcscmp(testString, TEST_CueSheet) == 0, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->CountUnknownBWFChunks(&numData)); checkExpression(2 == numData, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->GetUnknownBWFChunks(&pEnum)); for(com = 0; com < numData; com++) { checkResult(pEnum->NextOne(&pRIFFChunk)); pRIFFChunk->GetLength(&testRIFFLen); checkExpression(testRIFFLen!=chunkLength /*huh?*/, AAFRESULT_TEST_FAILED); checkResult(pRIFFChunk->GetLength(&testRIFFLen)); pRIFFChunk->GetChunkID(&testNum); if (testNum==1){ checkExpression(sizeof(RIFFChunksmiley) == testRIFFLen, AAFRESULT_TEST_FAILED); checkResult(pRIFFChunk->Read( sizeof(Value), (unsigned char *)Value, &bytesRead)); checkExpression(memcmp(Value, RIFFChunksmiley, sizeof(RIFFChunksmiley)) == 0, AAFRESULT_TEST_FAILED); } else if (testNum==2){ checkExpression(sizeof(RIFFChunkfrowney) == testRIFFLen, AAFRESULT_TEST_FAILED); checkResult(pRIFFChunk->Read( sizeof(Value2), (unsigned char *)Value2, &bytesRead)); checkExpression(memcmp(Value2, RIFFChunkfrowney, sizeof(RIFFChunkfrowney)) == 0, AAFRESULT_TEST_FAILED); } pRIFFChunk->Release(); pRIFFChunk = NULL; } checkResult(pEnum->Reset()); checkResult(pEnum->NextOne(&pRIFFChunk)); checkExpression((pBWFImportDesc->RemoveUnknownBWFChunkAt(2))==AAFRESULT_BADINDEX, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->RemoveUnknownBWFChunkAt(0)); checkResult(pBWFImportDesc->CountUnknownBWFChunks(&numData)); checkExpression(1 == numData, AAFRESULT_TEST_FAILED); pRIFFChunk->Release(); pRIFFChunk = NULL; pEnum->Release(); pEnum = NULL; pBWFImportDesc->Release(); pBWFImportDesc = NULL; pEssDesc->Release(); pEssDesc = NULL; pSourceMob->Release(); pSourceMob = NULL; pMobIter->Release(); pMobIter = NULL; } pRIFFChunkTest->Release(); pRIFFChunkTest = NULL; pMob->Release(); pMob = NULL; pHeader->Release(); pHeader = NULL; pDictionary->Release(); pDictionary = NULL; pFile->Close(); pFile->Release(); pFile = NULL; return hr; }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { // IAAFSession * pSession = NULL; IAAFFile * pFile = NULL; bool bFileOpen = false; IAAFHeader * pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFSourceMob *pSourceMob = NULL; IAAFMob *pMob = NULL; IAAFEssenceDescriptor *edesc = NULL; HRESULT hr = S_OK; 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 // Create a FileMob checkResult(defs.cdSourceMob()-> CreateInstance(IID_IAAFSourceMob, (IUnknown **)&pSourceMob)); checkResult(pSourceMob->QueryInterface (IID_IAAFMob, (void **)&pMob)); checkResult(pMob->SetMobID(TEST_File_MobID)); checkResult(pMob->SetName(L"File Mob")); // Check the Mob2 usage code implementations. // Need IAAFMob2 for to do that. { IAAFSmartPointer<IAAFMob2> pMobInterface2; checkResult( pMob->QueryInterface( IID_IAAFMob2, reinterpret_cast<void**>(&pMobInterface2) ) ); checkResult( pMobInterface2->SetUsageCode( kAAFUsage_Template ) ); } // Create a concrete subclass of FileDescriptor checkResult(defs.cdAIFCDescriptor()-> CreateInstance(IID_IAAFEssenceDescriptor, (IUnknown **)&edesc)); IAAFAIFCDescriptor* pAIFCDesc = NULL; checkResult(edesc->QueryInterface (IID_IAAFAIFCDescriptor, (void **)&pAIFCDesc)); checkResult(pAIFCDesc->SetSummary (5, (unsigned char*)"TEST")); pAIFCDesc->Release(); pAIFCDesc = NULL; checkResult(pSourceMob->SetEssenceDescriptor (edesc)); checkResult(pHeader->AddMob(pMob)); // Reusing local variable so we need to release the inteface. pMob->Release(); pMob = NULL; // Create a MasterMob checkResult(defs.cdMasterMob()-> CreateInstance(IID_IAAFMob, (IUnknown **)&pMob)); checkResult(pMob->SetMobID(TEST_Master_MobID)); checkResult(pMob->SetName(L"Master Mob")); // Check the Mob2 usage code implementations. // Need IAAFMob2 for to do that. { IAAFSmartPointer<IAAFMob2> pMobInterface2; checkResult( pMob->QueryInterface( IID_IAAFMob2, reinterpret_cast<void**>(&pMobInterface2) ) ); checkResult( pMobInterface2->SetUsageCode( kAAFUsage_Template ) ); } checkResult(pHeader->AddMob(pMob)); // Reusing local variable so we need to release the inteface. pMob->Release(); pMob = NULL; // Create a CompositionMob checkResult(defs.cdCompositionMob()-> CreateInstance(IID_IAAFMob, (IUnknown **)&pMob)); checkResult(pMob->SetMobID(TEST_Composition_MobID)); checkResult(pMob->SetName(L"Composition Mob")); // Check the Mob2 usage code implementations. // Need IAAFMob2 for to do that. IAAFSmartPointer<IAAFMob2> pMobInterface2; checkResult( pMob->QueryInterface( IID_IAAFMob2, reinterpret_cast<void**>(&pMobInterface2) ) ); checkResult( pMobInterface2->SetUsageCode( kAAFUsage_TopLevel ) ); checkResult(pHeader->AddMob(pMob)); } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (edesc) edesc->Release(); if (pMob) pMob->Release(); if (pSourceMob) pSourceMob->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if (pFile) { if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } return hr; }
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 HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType) { IAAFFile * pFile = NULL; bool bFileOpen = false; IAAFHeader * pHeader = NULL; IAAFDictionary *pDictionary = NULL; IAAFIdentification *pIdent = NULL; IAAFIdentification *pTestIdent = NULL; aafUInt32 readNumIdents; char testName[35]; aafCharacter *myBuffer; aafUInt32 bufSize = 0; aafUInt32 bufSize2 = 0; aafProductIdentification_t ProductInfo; memset(&ProductInfo, 0, sizeof(ProductInfo)); ProductInfo.companyName = const_cast<aafWChar*>(COMPANY_NAME); ProductInfo.productName = const_cast<aafWChar*>(PRODUCT_NAME); ProductInfo.productVersionString = const_cast<aafWChar*>(TEST_VERSION); ProductInfo.productID = UnitTestProductID; ProductInfo.productVersion = &testVersion; hr = S_OK; try { // Remove the previous test file if any. RemoveTestFile(pFileName); // Create the file. checkResult(CreateTestFile(pFileName, fileKind, rawStorageType, ProductInfo, &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->CountIdentifications(&readNumIdents)); checkExpression(1 == readNumIdents, AAFRESULT_TEST_FAILED); checkResult(pHeader->GetLastIdentification (&pIdent)); checkResult(defs.cdIdentification()-> CreateInstance(IID_IAAFIdentification, (IUnknown **)&pTestIdent)); /* Initialize */ localhr = AAFRESULT_SUCCESS; strcpy(testName, "Initialize()"); TestMethod(pTestIdent->Initialize(NULL, PRODUCT_NAME, TEST_VERSION, UnitTestProductID), AAFRESULT_NULL_PARAM); TestMethod(pTestIdent->Initialize(COMPANY_NAME, NULL, TEST_VERSION, UnitTestProductID), AAFRESULT_NULL_PARAM); TestMethod(pTestIdent->Initialize(COMPANY_NAME, PRODUCT_NAME, NULL, UnitTestProductID), AAFRESULT_NULL_PARAM); TestMethod(pTestIdent->Initialize(COMPANY_NAME, PRODUCT_NAME, TEST_VERSION, UnitTestProductID), AAFRESULT_SUCCESS); TestMethod(pTestIdent->Initialize(COMPANY_NAME, PRODUCT_NAME, TEST_VERSION, UnitTestProductID), AAFRESULT_ALREADY_INITIALIZED); pTestIdent->Release(); PrintTestResult(testName); /* GetCompanyNameBufLen *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetCompanyNameBufLen()"); bufSize = sizeof(COMPANY_NAME); bufSize2 = 0; TestMethod(pIdent->GetCompanyNameBufLen(NULL), AAFRESULT_NULL_PARAM); TestMethod(pIdent->GetCompanyNameBufLen(&bufSize2), AAFRESULT_SUCCESS); if (bufSize != bufSize2) localhr = AAFRESULT_TEST_FAILED; PrintTestResult(testName); /* GetCompanyName *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetCompanyName()"); myBuffer = new aafCharacter [bufSize]; TestMethod(pIdent->GetCompanyName(NULL, bufSize), AAFRESULT_NULL_PARAM); TestMethod(pIdent->GetCompanyName(myBuffer, bufSize-1), AAFRESULT_SMALLBUF); TestMethod(pIdent->GetCompanyName(myBuffer, bufSize), AAFRESULT_SUCCESS); if (wcscmp(myBuffer, COMPANY_NAME)) localhr = AAFRESULT_TEST_FAILED; delete [] myBuffer; PrintTestResult(testName); /* GetProductNameBufLen *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetProductNameBufLen()"); bufSize = sizeof(PRODUCT_NAME); bufSize2 = 0; TestMethod(pIdent->GetProductNameBufLen(NULL), AAFRESULT_NULL_PARAM); TestMethod(pIdent->GetProductNameBufLen(&bufSize2), AAFRESULT_SUCCESS); if (bufSize != bufSize2) localhr = AAFRESULT_TEST_FAILED; PrintTestResult(testName); /* GetProductName *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetProductName()"); myBuffer = new aafCharacter [bufSize]; TestMethod(pIdent->GetProductName(NULL, bufSize), AAFRESULT_NULL_PARAM); TestMethod(pIdent->GetProductName(myBuffer, bufSize-1), AAFRESULT_SMALLBUF); TestMethod(pIdent->GetProductName(myBuffer, bufSize), AAFRESULT_SUCCESS); if (wcscmp(myBuffer, PRODUCT_NAME)) localhr = AAFRESULT_TEST_FAILED; delete [] myBuffer; PrintTestResult(testName); /* GetProductVersionStringBufLen *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetProductVersionStringBufLen()"); bufSize = sizeof(TEST_VERSION); bufSize2 = 0; TestMethod(pIdent->GetProductVersionStringBufLen(NULL), AAFRESULT_NULL_PARAM); TestMethod(pIdent->GetProductVersionStringBufLen(&bufSize2), AAFRESULT_SUCCESS); if (bufSize != bufSize2) localhr = AAFRESULT_TEST_FAILED; PrintTestResult(testName); /* GetProductVersionString *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetProductVersionString()"); myBuffer = new aafCharacter [bufSize]; TestMethod(pIdent->GetProductVersionString(NULL, bufSize), AAFRESULT_NULL_PARAM); TestMethod(pIdent->GetProductVersionString(myBuffer, bufSize-1), AAFRESULT_SMALLBUF); TestMethod(pIdent->GetProductVersionString(myBuffer, bufSize), AAFRESULT_SUCCESS); if (wcscmp(myBuffer, TEST_VERSION)) localhr = AAFRESULT_TEST_FAILED; delete [] myBuffer; PrintTestResult(testName); /* SetProductVersion *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "SetProductVersion()"); checkResult(defs.cdIdentification()-> CreateInstance(IID_IAAFIdentification, (IUnknown **)&pTestIdent)); TestMethod(pTestIdent->SetProductVersion(testVersion), AAFRESULT_NOT_INITIALIZED); TestMethod(pTestIdent->Initialize(COMPANY_NAME, PRODUCT_NAME, TEST_VERSION, UnitTestProductID), AAFRESULT_SUCCESS); TestMethod(pTestIdent->SetProductVersion(testVersion), AAFRESULT_SUCCESS); TestMethod(pIdent->SetProductVersion(testVersion), AAFRESULT_SUCCESS); pTestIdent->Release(); PrintTestResult(testName); /* GetProductVersion *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetProductVersion()"); aafProductVersion_t productVersion; checkResult(defs.cdIdentification()-> CreateInstance(IID_IAAFIdentification, (IUnknown **)&pTestIdent)); TestMethod(pTestIdent->GetProductVersion(&productVersion), AAFRESULT_NOT_INITIALIZED); TestMethod(pTestIdent->Initialize(COMPANY_NAME, PRODUCT_NAME, TEST_VERSION, UnitTestProductID), AAFRESULT_SUCCESS); TestMethod(pTestIdent->GetProductVersion(&productVersion), AAFRESULT_PROP_NOT_PRESENT); TestMethod(pTestIdent->SetProductVersion(testVersion), AAFRESULT_SUCCESS); TestMethod(pTestIdent->GetProductVersion(NULL), AAFRESULT_NULL_PARAM); TestMethod(pTestIdent->GetProductVersion(&productVersion), AAFRESULT_SUCCESS); if (productVersion.major != testVersion.major || productVersion.minor != testVersion.minor || productVersion.tertiary != testVersion.tertiary || productVersion.patchLevel != testVersion.patchLevel || productVersion.type != testVersion.type) localhr = AAFRESULT_TEST_FAILED; pTestIdent->Release(); PrintTestResult(testName); /* GetPlatformBufLen *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetPlatformBufLen()"); TestMethod(pIdent->GetPlatformBufLen(NULL), AAFRESULT_NULL_PARAM); TestMethod(pIdent->GetPlatformBufLen(&bufSize), AAFRESULT_SUCCESS); if (bufSize != sizeof(PLATFORM_STRING)) localhr = AAFRESULT_TEST_FAILED; PrintTestResult(testName); /* GetPlatform *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetPlatform()"); myBuffer = new aafCharacter [bufSize]; TestMethod(pIdent->GetPlatform(NULL, bufSize), AAFRESULT_NULL_PARAM); TestMethod(pIdent->GetPlatform(myBuffer, bufSize-1), AAFRESULT_SMALLBUF); TestMethod(pIdent->GetPlatform(myBuffer, bufSize), AAFRESULT_SUCCESS); if (wcscmp(myBuffer, PLATFORM_STRING)) localhr = AAFRESULT_TEST_FAILED; delete [] myBuffer; PrintTestResult(testName); /* GetProductID *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetProductID()"); aafUID_t thisProductID; checkResult(defs.cdIdentification()-> CreateInstance(IID_IAAFIdentification, (IUnknown **)&pTestIdent)); TestMethod(pTestIdent->GetProductID(&thisProductID), AAFRESULT_NOT_INITIALIZED); TestMethod(pTestIdent->Initialize(COMPANY_NAME, PRODUCT_NAME, TEST_VERSION, UnitTestProductID), AAFRESULT_SUCCESS); TestMethod(pTestIdent->GetProductID(NULL), AAFRESULT_NULL_PARAM); TestMethod(pTestIdent->GetProductID(&thisProductID), AAFRESULT_SUCCESS); if (memcmp(&UnitTestProductID, &thisProductID, sizeof(UnitTestProductID)) != 0) localhr = AAFRESULT_TEST_FAILED; pTestIdent->Release(); PrintTestResult(testName); /* GetRefImplVersion *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetRefImplVersion()"); aafProductVersion_t refImplVersion; checkResult(defs.cdIdentification()-> CreateInstance(IID_IAAFIdentification, (IUnknown **)&pTestIdent)); TestMethod(pTestIdent->GetRefImplVersion(&refImplVersion), AAFRESULT_NOT_INITIALIZED); TestMethod(pTestIdent->Initialize(COMPANY_NAME, PRODUCT_NAME, TEST_VERSION, UnitTestProductID), AAFRESULT_SUCCESS); TestMethod(pTestIdent->GetRefImplVersion(NULL), AAFRESULT_NULL_PARAM); TestMethod(pTestIdent->GetRefImplVersion(&refImplVersion), AAFRESULT_SUCCESS); pTestIdent->Release(); PrintTestResult(testName); /* GetDate *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetDate()"); aafTimeStamp_t timeStamp; aafTimeStamp_t startTimeStamp; checkResult(defs.cdIdentification()-> CreateInstance(IID_IAAFIdentification, (IUnknown **)&pTestIdent)); TestMethod(pTestIdent->GetDate(&timeStamp), AAFRESULT_NOT_INITIALIZED); GetDateTime (&startTimeStamp); TestMethod(pTestIdent->Initialize(COMPANY_NAME, PRODUCT_NAME, TEST_VERSION, UnitTestProductID), AAFRESULT_SUCCESS); TestMethod(pTestIdent->GetDate(NULL), AAFRESULT_NULL_PARAM); TestMethod(pTestIdent->GetDate(&timeStamp), AAFRESULT_SUCCESS); if (timeStamp.date.year != startTimeStamp.date.year || timeStamp.date.month != startTimeStamp.date.month || timeStamp.date.day != startTimeStamp.date.day) localhr = AAFRESULT_TEST_FAILED; if (timeStamp.time.hour != startTimeStamp.time.hour || timeStamp.time.minute != startTimeStamp.time.minute || timeStamp.time.second != startTimeStamp.time.second) localhr = AAFRESULT_TEST_FAILED; pTestIdent->Release(); PrintTestResult(testName); /* GetGeneration *****/ localhr = AAFRESULT_SUCCESS; strcpy(testName, "GetGeneration()"); aafUID_t generation; checkResult(defs.cdIdentification()-> CreateInstance(IID_IAAFIdentification, (IUnknown **)&pTestIdent)); TestMethod(pTestIdent->GetGenerationID(&generation), AAFRESULT_NOT_INITIALIZED); TestMethod(pTestIdent->Initialize(COMPANY_NAME, PRODUCT_NAME, TEST_VERSION, UnitTestProductID), AAFRESULT_SUCCESS); TestMethod(pIdent->GetGenerationID(NULL), AAFRESULT_NULL_PARAM); TestMethod(pIdent->GetGenerationID(&generation), AAFRESULT_SUCCESS); pTestIdent->Release(); PrintTestResult(testName); // Attempt to save the file. checkResult(pFile->Save()); // Attempt to close the file. checkResult(pFile->Close()); bFileOpen = false; } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (pIdent) pIdent->Release(); if (pHeader) pHeader->Release(); if (pDictionary) pDictionary->Release(); if (pFile) { // Close file if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } return hr; }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { IAAFFile* pFile = NULL; IAAFHeader * pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFContainerDef* pContainerDef = NULL; bool bFileOpen = false; aafUID_t uid = testUID; HRESULT hr = S_OK; /* long test; */ try { // Remove the previous test file if any. RemoveTestFile(pFileName); // Create the AAF file checkResult(CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile )); bFileOpen = true; // 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.cdContainerDef()-> CreateInstance(IID_IAAFContainerDef, (IUnknown **)&pContainerDef)); checkResult(pContainerDef->Initialize(uid, L"Test Container", L"Test Container Definition")); checkResult(pContainerDef->SetEssenceIsIdentified (kAAFTrue)); checkResult(pDictionary->RegisterContainerDef(pContainerDef)); } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (pContainerDef) pContainerDef->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if (pFile) { // Close file if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } return hr; }
static void Test_EssenceStreamWrite( CAAFBuiltinDefs & defs, IAAFPropertyValue *pStreamPropertyValue) { IAAFPlainStreamDataSP pTypeDefStream; Test_GetTypeDefStream(pStreamPropertyValue, &pTypeDefStream); // Check the byte order of the stream. aafBoolean_t hasByteOrder; eAAFByteOrder_t byteOrder; CheckResult(pTypeDefStream->HasStoredByteOrder(pStreamPropertyValue, &hasByteOrder)); // The byte order has never... CheckExpression(kAAFFalse == hasByteOrder, AAFRESULT_TEST_FAILED); // Set the byte order of the stream to little endian... CheckResult(pTypeDefStream->SetStoredByteOrder(pStreamPropertyValue, kAAFByteOrderLittle)); CheckResult(pTypeDefStream->HasStoredByteOrder(pStreamPropertyValue, &hasByteOrder)); CheckExpression(kAAFTrue == hasByteOrder, AAFRESULT_TEST_FAILED); CheckResult(pTypeDefStream->GetStoredByteOrder(pStreamPropertyValue, &byteOrder)); CheckExpression(kAAFByteOrderLittle == byteOrder, AAFRESULT_TEST_FAILED); // Change the byte order. CheckResult(pTypeDefStream->ClearStoredByteOrder(pStreamPropertyValue)); CheckResult(pTypeDefStream->HasStoredByteOrder(pStreamPropertyValue, &hasByteOrder)); CheckExpression(kAAFFalse == hasByteOrder, AAFRESULT_TEST_FAILED); // Set the byte order of the stream to big endian... CheckResult(pTypeDefStream->SetStoredByteOrder(pStreamPropertyValue, kAAFByteOrderBig)); CheckResult(pTypeDefStream->HasStoredByteOrder(pStreamPropertyValue, &hasByteOrder)); CheckExpression(kAAFTrue == hasByteOrder, AAFRESULT_TEST_FAILED); CheckResult(pTypeDefStream->GetStoredByteOrder(pStreamPropertyValue, &byteOrder)); CheckExpression(kAAFByteOrderBig == byteOrder, AAFRESULT_TEST_FAILED); // Get the current position aafInt64 streamSize = 0, expectedSize = 0, streamPosition = 0, expectedPosition = 0; CheckResult(pTypeDefStream->GetSize(pStreamPropertyValue, &streamSize)); CheckExpression(0 == streamSize, AAFRESULT_TEST_FAILED); CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(0 == streamPosition, AAFRESULT_TEST_FAILED); // The postioning code has the following assumption: assert(sizeof(sSmiley) == sizeof(sFrowney)); // The current position is where the stream data starts. aafInt64 dataStartPosition = 0; CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &dataStartPosition)); expectedSize = dataStartPosition; expectedPosition = dataStartPosition; // Write an array of bytes. CheckResult(pTypeDefStream->Write(pStreamPropertyValue, sizeof(sSmiley), reinterpret_cast<aafMemPtr_t>(const_cast<char *>(sSmiley)))); // Checking for non-zero size and position must be checked // carefully since the persistent size for structures and // characters may be smaller then the in memory size. This // is why this test only uses types that have a known // persistent size: aafUInt8, aafUInt16, aafCharacter. expectedSize += sizeof(sSmiley); expectedPosition += sizeof(sSmiley); CheckResult(pTypeDefStream->GetSize(pStreamPropertyValue, &streamSize)); CheckExpression(expectedSize == streamSize, AAFRESULT_TEST_FAILED); CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(expectedPosition == streamPosition, AAFRESULT_TEST_FAILED); // Test append // Restore the position to the begining of the stream. CheckResult(pTypeDefStream->SetPosition(pStreamPropertyValue, 0)); CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(0 == streamPosition, AAFRESULT_TEST_FAILED); // Append an array of bytes. CheckResult(pTypeDefStream->Append(pStreamPropertyValue, sizeof(sFrowney), reinterpret_cast<aafMemPtr_t>(const_cast<char *>(sFrowney)))); expectedSize += sizeof(sFrowney); expectedPosition += sizeof(sFrowney); CheckResult(pTypeDefStream->GetSize(pStreamPropertyValue, &streamSize)); CheckExpression(expectedSize == streamSize, AAFRESULT_TEST_FAILED); CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(expectedPosition == streamPosition, AAFRESULT_TEST_FAILED); // Test non-zero repositioning and overriting... expectedPosition -= sizeof(sFrowney); CheckResult(pTypeDefStream->SetPosition(pStreamPropertyValue, expectedPosition)); CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(expectedPosition == streamPosition, AAFRESULT_TEST_FAILED); // Write an array of bytes. CheckResult(pTypeDefStream->Write(pStreamPropertyValue, sizeof(sSmiley), reinterpret_cast<aafMemPtr_t>(const_cast<char *>(sSmiley)))); expectedPosition += sizeof(sSmiley); CheckResult(pTypeDefStream->GetSize(pStreamPropertyValue, &streamSize)); CheckExpression(expectedSize == streamSize, AAFRESULT_TEST_FAILED); CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(expectedPosition == streamPosition, AAFRESULT_TEST_FAILED); // Write an array of shorts CheckResult(pTypeDefStream->WriteElements(pStreamPropertyValue, defs.tdUInt16(), sizeof(sTestUInt16), reinterpret_cast<aafMemPtr_t>(const_cast<aafUInt16 *>(sTestUInt16)))); expectedSize += sizeof(sTestUInt16); expectedPosition += sizeof(sTestUInt16); CheckResult(pTypeDefStream->GetSize(pStreamPropertyValue, &streamSize)); CheckExpression(expectedSize == streamSize, AAFRESULT_TEST_FAILED); CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(expectedPosition == streamPosition, AAFRESULT_TEST_FAILED); // Restore the position to the begining of the stream. CheckResult(pTypeDefStream->SetPosition(pStreamPropertyValue, 0)); // Append an array of characters CheckResult(pTypeDefStream->AppendElements(pStreamPropertyValue, defs.tdCharacter(), sizeof(sTestCharacter), reinterpret_cast<aafMemPtr_t>(const_cast<aafCharacter *>(sTestCharacter)))); // The expected size and position must be incremented according to the // *persisted* size of aafCharacter, which is always 2, whereas the // in-memory size may be 2 or 4, depending on the platform. expectedSize += (sizeof(sTestCharacter)/sizeof(wchar_t))*2; // sizeof(sTestCharacter); expectedPosition += (sizeof(sTestCharacter)/sizeof(wchar_t))*2; // sizeof(sTestCharacter); CheckResult(pTypeDefStream->GetSize(pStreamPropertyValue, &streamSize)); CheckExpression(expectedSize == streamSize, AAFRESULT_TEST_FAILED); CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(expectedPosition == streamPosition, AAFRESULT_TEST_FAILED); // Test truncating the stream. CheckResult(pTypeDefStream->AppendElements(pStreamPropertyValue, defs.tdCharacter(), sizeof(sTruncatedCharacters), reinterpret_cast<aafMemPtr_t>(const_cast<aafCharacter *>(sTruncatedCharacters)))); CheckResult(pTypeDefStream->SetSize(pStreamPropertyValue, expectedSize)); CheckResult(pTypeDefStream->GetSize(pStreamPropertyValue, &streamSize)); CheckExpression(expectedSize == streamSize, AAFRESULT_TEST_FAILED); CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(expectedPosition == streamPosition, AAFRESULT_TEST_FAILED); // Test growing the stream const aafUInt32 increment = 50; CheckResult(pTypeDefStream->SetSize(pStreamPropertyValue, expectedSize+increment)); CheckResult(pTypeDefStream->GetSize(pStreamPropertyValue, &streamSize)); CheckExpression(expectedSize+increment == streamSize, AAFRESULT_TEST_FAILED); // After growing, truncate the stream back to the original size CheckResult(pTypeDefStream->SetSize(pStreamPropertyValue, expectedSize)); CheckResult(pTypeDefStream->GetSize(pStreamPropertyValue, &streamSize)); CheckExpression(expectedSize == streamSize, AAFRESULT_TEST_FAILED); // Make sure the current position didn't change CheckResult(pTypeDefStream->GetPosition(pStreamPropertyValue, &streamPosition)); CheckExpression(expectedPosition == streamPosition, AAFRESULT_TEST_FAILED); // Restore the position to the begining of the stream. CheckResult(pTypeDefStream->SetPosition(pStreamPropertyValue, 0)); }
static void Test_EssenceStreamRead( CAAFBuiltinDefs & defs, IAAFPropertyValue *pStreamPropertyValue) { IAAFPlainStreamDataSP pTypeDefStream; aafUInt32 bytesRead; Test_GetTypeDefStream(pStreamPropertyValue, &pTypeDefStream); // Read an array of bytes. char smileyTest[sizeof(sSmiley)]; bytesRead = 0; CheckResult(pTypeDefStream->Read(pStreamPropertyValue, sizeof(sSmiley), reinterpret_cast<aafMemPtr_t>(smileyTest), &bytesRead)); CheckExpression(bytesRead == sizeof(sSmiley), AAFRESULT_TEST_FAILED); CheckExpression(0 == memcmp(smileyTest, sSmiley, bytesRead), AAFRESULT_TEST_FAILED); bytesRead = 0; CheckResult(pTypeDefStream->Read(pStreamPropertyValue, sizeof(sSmiley), reinterpret_cast<aafMemPtr_t>(smileyTest), &bytesRead)); CheckExpression(bytesRead == sizeof(sSmiley), AAFRESULT_TEST_FAILED); CheckExpression(0 == memcmp(smileyTest, sSmiley, bytesRead), AAFRESULT_TEST_FAILED); // Read the "appended" array of bytes. // char frowneyTest[sizeof(sFrowney)]; //bytesRead = 0; //CheckResult(pTypeDefStream->Read(pStreamPropertyValue, // sizeof(sFrowney), // reinterpret_cast<aafMemPtr_t>(frowneyTest), // &bytesRead)); //CheckExpression(bytesRead == sizeof(sFrowney), AAFRESULT_TEST_FAILED); //CheckExpression(0 == memcmp(frowneyTest, sFrowney, bytesRead), // AAFRESULT_TEST_FAILED); // Read an array of aafUInt16 aafUInt16 uint16Test[sizeof(sTestUInt16)/sizeof(aafUInt16)]; bytesRead = 0; CheckResult(pTypeDefStream->ReadElements(pStreamPropertyValue, defs.tdUInt16(), sizeof(sTestUInt16), reinterpret_cast<aafMemPtr_t>(uint16Test), &bytesRead)); CheckExpression(bytesRead == sizeof(sTestUInt16), AAFRESULT_TEST_FAILED); CheckExpression(0 == memcmp(uint16Test, sTestUInt16, bytesRead), AAFRESULT_TEST_FAILED); // Read the "appended" array of aafCharacter(s) aafCharacter characterTest[sizeof(sTestCharacter)/sizeof(aafCharacter)]; bytesRead = 0; CheckResult(pTypeDefStream->ReadElements(pStreamPropertyValue, defs.tdCharacter(), sizeof(sTestCharacter), reinterpret_cast<aafMemPtr_t>(characterTest), &bytesRead)); CheckExpression(bytesRead == sizeof(sTestCharacter), AAFRESULT_TEST_FAILED); CheckExpression(0 == memcmp(characterTest, sTestCharacter, bytesRead), AAFRESULT_TEST_FAILED); }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { IAAFFile* pFile = NULL; IAAFHeader* pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFSourceMob* pSourceMob = NULL; IAAFMob* pMob = NULL; IAAFTIFFDescriptor* pTIFFDesc = NULL; IAAFEssenceDescriptor* pEssDesc = NULL; HRESULT hr = AAFRESULT_SUCCESS; aafUInt8 summary[512]; aafUInt16 numEntries = 2; unsigned long nOffset; #if defined( OS_WINDOWS ) tiffHeader.tiff_byteOrder = TIFF_LITTLEENDIAN; #else tiffHeader.tiff_byteOrder = TIFF_BIGENDIAN; #endif tiffHeader.tiff_identNumber = TIFF_VERSION; tiffHeader.tiff_firstIFD = 0; memcpy(summary, (void *)&tiffHeader, sizeof(tiffHeader)); nOffset = sizeof(tiffHeader); tagImageWidth.tdir_tag = TIFFTAG_IMAGEWIDTH; tagImageWidth.tdir_type = TIFF_LONG; tagImageWidth.tdir_count = 1; tagImageWidth.tdir_offset = 320; tagImageLength.tdir_tag = TIFFTAG_IMAGELENGTH; tagImageLength.tdir_type = TIFF_LONG; tagImageLength.tdir_count = 1; tagImageLength.tdir_offset = 640; // Write IFD data memcpy(summary+nOffset, &numEntries, sizeof(numEntries)); nOffset += sizeof(numEntries); memcpy((void *)(summary+nOffset), (void *)&tagImageWidth, sizeof(tagImageWidth)); nOffset += sizeof(tagImageWidth); memcpy((void *)(summary+nOffset), (void *)&tagImageLength, sizeof(tagImageLength)); nOffset += sizeof(tagImageLength); try { // Remove the previous test file if any. RemoveTestFile(pFileName); // Create the AAF file checkResult(CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile )); // 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); // Create a source mob checkResult(defs.cdSourceMob()-> CreateInstance(IID_IAAFSourceMob, (IUnknown **)&pSourceMob)); checkResult(pSourceMob->QueryInterface(IID_IAAFMob, (void **)&pMob)); checkResult(pMob->SetMobID(TEST_MobID)); checkResult(pMob->SetName(L"TIFFDescriptorTest")); checkResult(defs.cdTIFFDescriptor()-> CreateInstance(IID_IAAFTIFFDescriptor, (IUnknown **)&pTIFFDesc)); checkResult(pTIFFDesc->QueryInterface(IID_IAAFEssenceDescriptor, (void **)&pEssDesc)); checkResult(pTIFFDesc->SetIsUniform(kAAFFalse)); checkResult(pTIFFDesc->SetIsContiguous(kAAFTrue)); checkResult(pTIFFDesc->SetLeadingLines((aafInt32)10)); checkResult(pTIFFDesc->SetTrailingLines((aafInt32)20)); checkResult(pTIFFDesc->SetJPEGTableID((aafJPEGTableID_t)0)); checkResult(pTIFFDesc->SetSummary((aafUInt32)nOffset, (aafDataValue_t) summary)); checkResult(pSourceMob->SetEssenceDescriptor(pEssDesc)); // Add the MOB to the file checkResult(pHeader->AddMob(pMob)); } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (pTIFFDesc) pTIFFDesc->Release(); if (pDictionary) pDictionary->Release(); if (pEssDesc) pEssDesc->Release(); if (pMob) pMob->Release(); if (pSourceMob) pSourceMob->Release(); if (pHeader) pHeader->Release(); if (pFile) { pFile->Save(); pFile->Close(); pFile->Release(); } 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; IAAFRIFFChunk* pRIFFChunk = NULL; IAAFRIFFChunk* pRIFFChunk2 = NULL; IAAFSourceMob* pSourceMob = NULL; IAAFEssenceDescriptor* pEssDesc = NULL; IAAFBWFImportDescriptor* pBWFImportDesc = NULL; aafUInt32 testNum; HRESULT hr = S_OK; // 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); checkResult(defs.cdSourceMob()-> CreateInstance(IID_IAAFSourceMob, (IUnknown **)&pSourceMob)); pSourceMob->QueryInterface(IID_IAAFMob, (void **)&pMob); pMob->SetMobID(TEST_MobID); pMob->SetName(L"BWFImportDescriptorTest"); //Create BWFImportDescriptor to hold the RIFFChunk checkResult( defs.cdBWFImportDescriptor()-> CreateInstance(IID_IAAFBWFImportDescriptor, (IUnknown **)&pBWFImportDesc)); // Create RIFFChunks and append them to BWFImportDescriptor checkResult(defs.cdRIFFChunk()->CreateInstance(IID_IAAFRIFFChunk, (IUnknown **)&pRIFFChunk)); checkResult(defs.cdRIFFChunk()->CreateInstance(IID_IAAFRIFFChunk, (IUnknown **)&pRIFFChunk2)); checkResult(pBWFImportDesc->AppendUnknownBWFChunk(pRIFFChunk)); checkResult(pBWFImportDesc->AppendUnknownBWFChunk(pRIFFChunk2)); checkExpression(pBWFImportDesc->AppendUnknownBWFChunk(pRIFFChunk)==AAFRESULT_OBJECT_ALREADY_ATTACHED, AAFRESULT_TEST_FAILED); checkResult(pBWFImportDesc->SetFileSecurityReport(TEST_FileSecurityReport)); checkResult(pBWFImportDesc->SetFileSecurityWave(TEST_FileSecurityWave)); checkResult(pBWFImportDesc->SetCodingHistory(TEST_CodingHistory)); checkResult(pBWFImportDesc->SetBasicData(TEST_BasicData)); checkResult(pBWFImportDesc->SetStartOfModulation(TEST_StartOfModulation)); checkResult(pBWFImportDesc->SetQualityEvent(TEST_QualityEvent)); checkResult(pBWFImportDesc->SetEndOfModulation(TEST_EndOfModulation)); checkResult(pBWFImportDesc->SetQualityParameter(TEST_QualityParameter)); checkResult(pBWFImportDesc->SetOperatorComment(TEST_OperatorComment)); checkResult(pBWFImportDesc->SetCueSheet(TEST_CueSheet)); checkResult( pBWFImportDesc->QueryInterface(IID_IAAFEssenceDescriptor, (void **)&pEssDesc)); checkResult(pSourceMob->SetEssenceDescriptor(pEssDesc)); //Add the MOB to the file checkResult(pHeader->AddMob(pMob)); testNum = 0; checkResult(pRIFFChunk->Initialize(chunkID)); checkResult(pRIFFChunk->Write(sizeof(RIFFChunksmiley), (unsigned char *)RIFFChunksmiley, &testNum)); checkExpression(testNum == sizeof(RIFFChunksmiley), AAFRESULT_TEST_FAILED); testNum = 0; checkResult(pRIFFChunk2->Initialize(chunkID2)); checkResult(pRIFFChunk2->Write(sizeof(RIFFChunkfrowney), (unsigned char *)RIFFChunkfrowney, &testNum)); checkExpression(testNum == sizeof(RIFFChunkfrowney), AAFRESULT_TEST_FAILED); pFile->Save(); pEssDesc->Release(); pEssDesc = NULL; pBWFImportDesc->Release(); pBWFImportDesc = NULL; pRIFFChunk->Release(); pRIFFChunk = NULL; pRIFFChunk2->Release(); pRIFFChunk2 = NULL; pMob->Release(); pMob = NULL; pSourceMob->Release(); pSourceMob = NULL; pDictionary->Release(); pDictionary = NULL; pHeader->Release(); pHeader = NULL; pFile->Close(); pFile->Release(); pFile = NULL; return hr; }
void EssenceDataTest::createEssenceData(IAAFSourceMob *pSourceMob) { assert(_pFile && _pHeader && _pDictionary); assert(pSourceMob); assert(NULL == _pEssenceData); CAAFBuiltinDefs defs (_pDictionary); // Attempt to create an AAFEssenceData. IAAFEssenceData* pRawEssenceData = NULL; check(defs.cdEssenceData()-> CreateInstance(IID_IAAFEssenceData, (IUnknown **)&pRawEssenceData)); check(pRawEssenceData->SetFileMob(pSourceMob)); check(_pHeader->AddEssenceData(pRawEssenceData)); IAAFEssenceData2* pEssenceData2 = NULL; check(pRawEssenceData->QueryInterface(IID_IAAFEssenceData2, (void**)&pEssenceData2)); check(pEssenceData2->GetPlainEssenceData(0, &_pEssenceData)); // Set essence element key IAAFKLVEssenceDataParameters* pParameters = NULL; check(_pEssenceData->QueryInterface(IID_IAAFKLVEssenceDataParameters, (void **)&pParameters)); AAFRESULT hr = pParameters->SetEssenceElementKey(_essenceElementKey); checkExpression(AAFRESULT_SUCCEEDED(hr) || hr == AAFRESULT_OPERATION_NOT_PERMITTED, AAFRESULT_TEST_FAILED); aafUID_t key; hr = pParameters->GetEssenceElementKey(&key); checkExpression(AAFRESULT_SUCCEEDED(hr) || hr == AAFRESULT_OPERATION_NOT_PERMITTED, AAFRESULT_TEST_FAILED); checkExpression(AAFRESULT_FAILED(hr) || key == _essenceElementKey, AAFRESULT_TEST_FAILED); writeEssenceData(_pEssenceData, (aafDataBuffer_t)_smiley, sizeof(_smiley)); writeEssenceData(_pEssenceData, (aafDataBuffer_t)_frowney, sizeof(_frowney)); // Read back the data before saving and/or closing the file check(_pEssenceData->SetPosition(0)); aafPosition_t dataPosition = 0; check(_pEssenceData->GetPosition(&dataPosition)); checkExpression(dataPosition == 0, AAFRESULT_TEST_FAILED); // Validate the current essence size. aafLength_t essenceSize = 0; aafLength_t expectedEssenceSize = sizeof(_smiley) + sizeof(_frowney); check(_pEssenceData->GetSize(&essenceSize)); checkExpression(essenceSize == expectedEssenceSize, AAFRESULT_TEST_FAILED); readEssenceData(_pEssenceData, (aafDataBuffer_t)_smiley, sizeof(_smiley)); readEssenceData(_pEssenceData, (aafDataBuffer_t)_frowney, sizeof(_frowney)); pParameters->Release(); pParameters = NULL; pRawEssenceData->Release(); pRawEssenceData = NULL; pEssenceData2->Release(); pEssenceData2 = NULL; _pEssenceData->Release(); _pEssenceData = NULL; }
void EnumEssenceDataTest::createFileMob(int itemNumber) { assert(_pFile && _pHeader && _pDictionary); assert(NULL == _pSourceMob); assert(NULL == _pMob); assert(NULL == _pFileDescriptor); assert(NULL == _pEssenceDescriptor); assert(NULL == _pSourceMob); // Format the mob name. wchar_t wcBuffer[512]; char cBuffer[256]; sprintf(cBuffer, "EnumEssenceDataTest File Mob %d", itemNumber); size_t count = mbstowcs(wcBuffer, cBuffer, strlen(cBuffer) + 1); if (static_cast<size_t>(-1) == count) check(AAFRESULT_INTERNAL_ERROR); CAAFBuiltinDefs defs (_pDictionary); // Create a Mob check(defs.cdSourceMob()-> CreateInstance(IID_IAAFSourceMob, (IUnknown **)&_pSourceMob)); check(_pSourceMob->QueryInterface (IID_IAAFMob, (void **)&_pMob)); check(_pMob->SetMobID(TEST_MobIDs[itemNumber])); check(_pMob->SetName(wcBuffer)); // Create a concrete subclass of FileDescriptor check(defs.cdAIFCDescriptor()-> CreateInstance(IID_IAAFFileDescriptor, (IUnknown **)&_pFileDescriptor)); IAAFAIFCDescriptor* pAIFCDesc = NULL; check(_pFileDescriptor->QueryInterface (IID_IAAFAIFCDescriptor, (void **)&pAIFCDesc)); check(pAIFCDesc->SetSummary (5, (unsigned char*)"TEST")); pAIFCDesc->Release(); pAIFCDesc = NULL; check(_pFileDescriptor->QueryInterface (IID_IAAFEssenceDescriptor, (void **)&_pEssenceDescriptor)); check(_pSourceMob->SetEssenceDescriptor (_pEssenceDescriptor)); check(_pHeader->AddMob(_pMob)); createEssenceData(_pSourceMob); // Cleanup instance data for reuse... _pEssenceDescriptor->Release(); _pEssenceDescriptor = NULL; _pFileDescriptor->Release(); _pFileDescriptor = NULL; _pMob->Release(); _pMob = NULL; _pSourceMob->Release(); _pSourceMob = NULL; }
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; }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { // IAAFSession* pSession = NULL; IAAFFile* pFile = NULL; IAAFHeader* pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFMob* pMob = NULL; IAAFMob* pReferencedMob = NULL; IAAFTimelineMobSlot* newSlot = NULL; IAAFSegment* seg = NULL; bool bFileOpen = false; HRESULT hr = AAFRESULT_SUCCESS; IAAFComponent* pComponent = NULL; 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 MOB to be referenced checkResult(defs.cdMasterMob()-> CreateInstance(IID_IAAFMob, (IUnknown **)&pReferencedMob)); checkResult(pReferencedMob->SetMobID(TEST_referencedMobID)); checkResult(pReferencedMob->SetName(L"AAFSourceClipTest::ReferencedMob")); // Create a Mob checkResult(defs.cdCompositionMob()-> CreateInstance(IID_IAAFMob, (IUnknown **)&pMob)); checkResult(pMob->SetMobID(TEST_MobID)); checkResult(pMob->SetName(L"AAFSourceClipTest")); // Create a SourceClip checkResult(defs.cdSourceClip()-> CreateInstance(IID_IAAFSegment, (IUnknown **)&seg)); checkResult(seg->QueryInterface(IID_IAAFComponent, (void **)&pComponent)); checkResult(pComponent->SetDataDef(defs.ddkAAFPicture())); pComponent->Release(); pComponent = NULL; aafRational_t editRate = { 0, 1}; checkResult(pMob->AppendNewTimelineSlot (editRate, seg, 1, slotName, 0, &newSlot)); checkResult(pHeader->AddMob(pMob)); checkResult(pHeader->AddMob(pReferencedMob)); } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (newSlot) newSlot->Release(); if (pComponent) pComponent->Release(); if (seg) seg->Release(); if (pMob) pMob->Release(); if (pReferencedMob) pReferencedMob->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if (pFile) { if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } return hr; }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { // IAAFSession *pSession = NULL; IAAFFile *pFile = NULL; IAAFHeader *pHeader = NULL; IAAFDictionary *pDictionary = NULL; IAAFLocator *pLocator = NULL; IAAFLocator *pLocator2 = NULL; IAAFSourceMob *pSourceMob = NULL; IAAFMob *pMob = NULL; IAAFEssenceDescriptor *edesc = NULL; IEnumAAFLocators *pEnumLocators = NULL; aafUInt32 numLocators, numLocators2; aafUInt32 i; HRESULT hr = AAFRESULT_SUCCESS, localhr = AAFRESULT_SUCCESS; bool bFileOpen = false; // aafUID_t ddef = kAAFDataDef_Sound; 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 // Create a Mob checkResult(defs.cdSourceMob()-> CreateInstance(IID_IAAFSourceMob, (IUnknown **)&pSourceMob)); // Initialize mob properties: checkResult(pSourceMob->QueryInterface (IID_IAAFMob, (void **)&pMob)); checkResult(pMob->SetMobID(TEST_MobID)); checkResult(pMob->SetName(L"EssenceDescriptorTest")); // Create the descriptor: // instantiate a concrete subclass of EssenceDescriptor checkResult(defs.cdAIFCDescriptor()-> CreateInstance(IID_IAAFEssenceDescriptor, (IUnknown **)&edesc)); IAAFAIFCDescriptor* pAIFCDesc = NULL; checkResult(edesc->QueryInterface (IID_IAAFAIFCDescriptor, (void **)&pAIFCDesc)); checkResult(pAIFCDesc->SetSummary (5, (unsigned char*)"TEST")); pAIFCDesc->Release(); pAIFCDesc = NULL; checkResult(pSourceMob->SetEssenceDescriptor (edesc)); /* CountLocators() ******************************************/ localhr = AAFRESULT_SUCCESS; // Verify AAFRESULT_NULL_PARAM is returned if (edesc->CountLocators(NULL) != AAFRESULT_NULL_PARAM) localhr = AAFRESULT_TEST_FAILED; // Verify that there are no locators if (edesc->CountLocators(&numLocators) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; if (0 != numLocators) localhr = AAFRESULT_TEST_FAILED; if (localhr == AAFRESULT_SUCCESS) cout<< " CountLocators() ... Passed"<< endl; else { cout<< " CountLocators() ... FAILED"<< endl; hr = AAFRESULT_TEST_FAILED; } /* AppendLocator() ******************************************/ localhr = AAFRESULT_SUCCESS; // Verify AAFRESULT_NULL_PARAM is returned if (edesc->AppendLocator(NULL) != AAFRESULT_NULL_PARAM) localhr = AAFRESULT_TEST_FAILED; // Append and Count a bunch of Locators for (i=1; i<=10; i++) { // Make a concrete subclass of locator, and attach it to // the EssenceDescriptor checkResult(defs.cdNetworkLocator()-> CreateInstance(IID_IAAFLocator, (IUnknown **)&pLocator)); if (edesc->AppendLocator(pLocator) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; // Verify the number of locators numLocators = 0; edesc->CountLocators(&numLocators); if (i != numLocators) localhr = AAFRESULT_TEST_FAILED; // Verify that locator was appended edesc->GetLocatorAt(i-1, &pLocator2); if (pLocator2 != pLocator) localhr = AAFRESULT_TEST_FAILED; pLocator->Release(); pLocator = 0; pLocator2->Release(); pLocator2 = 0; } // Make sure we can't add it again // if (edesc->AppendLocator(pLocator) != AAFRESULT_OBJECT_ALREADY_ATTACHED) // localhr = AAFRESULT_TEST_FAILED; if (localhr == AAFRESULT_SUCCESS) cout<< " AppendLocator() ... Passed"<< endl; else { cout<< " AppendLocator() ... FAILED"<< endl; hr = AAFRESULT_TEST_FAILED; } /* PrependLocator() ******************************************/ localhr = AAFRESULT_SUCCESS; // Verify AAFRESULT_NULL_PARAM is returned if (edesc->PrependLocator(NULL) != AAFRESULT_NULL_PARAM) localhr = AAFRESULT_TEST_FAILED; for (; i<=20; i++) { // Make a concrete subclass of locator, and attach it to // the EssenceDescriptor checkResult(defs.cdNetworkLocator()-> CreateInstance(IID_IAAFLocator, (IUnknown **)&pLocator)); if (edesc->PrependLocator(pLocator) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; // Verify the number of locators numLocators = 0; edesc->CountLocators(&numLocators); if (i != numLocators) localhr = AAFRESULT_TEST_FAILED; // Verify that locator was prepended edesc->GetLocatorAt(0, &pLocator2); if (pLocator2 != pLocator) localhr = AAFRESULT_TEST_FAILED; pLocator->Release(); pLocator = 0; pLocator2->Release(); pLocator2 = 0; } if (localhr == AAFRESULT_SUCCESS) cout<< " PrependLocator() ... Passed"<< endl; else { cout<< " PrependLocator() ... FAILED"<< endl; hr = AAFRESULT_TEST_FAILED; } /* InsertLocatorAt() **************************************/ localhr = AAFRESULT_SUCCESS; // Make a concrete subclass of locator to attach checkResult(defs.cdNetworkLocator()-> CreateInstance(IID_IAAFLocator, (IUnknown **)&pLocator)); // Verify that we can't remove an index value that is out of range if (edesc->InsertLocatorAt(numLocators+1, pLocator) != AAFRESULT_BADINDEX) localhr = AAFRESULT_TEST_FAILED; // Verify behavior when NULL is passed in if (edesc->InsertLocatorAt(1, NULL) != AAFRESULT_NULL_PARAM) localhr = AAFRESULT_TEST_FAILED; edesc->CountLocators(&numLocators); // Insert it if (edesc->InsertLocatorAt(0, pLocator) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; // Check it edesc->GetLocatorAt(0, &pLocator2); if (pLocator2 != pLocator) localhr = AAFRESULT_TEST_FAILED; // Count it edesc->CountLocators(&numLocators2); if (numLocators2 != numLocators+1) localhr = AAFRESULT_TEST_FAILED; pLocator->Release(); pLocator = 0; pLocator2->Release(); pLocator2 = 0; edesc->CountLocators(&numLocators); // Make a concrete subclass of locator to attach in the middle checkResult(defs.cdNetworkLocator()-> CreateInstance(IID_IAAFLocator, (IUnknown **)&pLocator)); // Insert it if (edesc->InsertLocatorAt(numLocators/2, pLocator) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; // Check it edesc->GetLocatorAt(numLocators/2, &pLocator2); if (pLocator2 != pLocator) localhr = AAFRESULT_TEST_FAILED; // Count it edesc->CountLocators(&numLocators2); if (numLocators2 != numLocators+1) localhr = AAFRESULT_TEST_FAILED; pLocator->Release(); pLocator = 0; pLocator2->Release(); pLocator2 = 0; edesc->CountLocators(&numLocators); // Make a concrete subclass of locator to attach to the end checkResult(defs.cdNetworkLocator()-> CreateInstance(IID_IAAFLocator, (IUnknown **)&pLocator)); // Insert it. note: its 0 based so the end is numLocators - 1 if (edesc->InsertLocatorAt(numLocators-1, pLocator) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; // Check it edesc->GetLocatorAt(numLocators-1, &pLocator2); if (pLocator2 != pLocator) localhr = AAFRESULT_TEST_FAILED; // Count it edesc->CountLocators(&numLocators2); if (numLocators2 != numLocators+1) localhr = AAFRESULT_TEST_FAILED; // Make sure we can't add it again if (edesc->InsertLocatorAt(numLocators+1, pLocator) != AAFRESULT_OBJECT_ALREADY_ATTACHED) localhr = AAFRESULT_TEST_FAILED; pLocator->Release(); pLocator = 0; pLocator2->Release(); pLocator2 = 0; if (localhr == AAFRESULT_SUCCESS) cout<< " InsertLocatorAt() ... Passed"<< endl; else { cout<< " InsertLocatorAt() ... FAILED"<< endl; hr = AAFRESULT_TEST_FAILED; } /* GetLocatorAt() ******************************************/ localhr = AAFRESULT_SUCCESS; edesc->CountLocators(&numLocators); // Verify that we can't remove an index value that is out of range // note: Locators index is 0 based so the index numLocators is out of range if (edesc->GetLocatorAt(numLocators, &pLocator) != AAFRESULT_BADINDEX) localhr = AAFRESULT_TEST_FAILED; // Verify behavior when NULL is passed in if (edesc->GetLocatorAt(1, NULL) != AAFRESULT_NULL_PARAM) localhr = AAFRESULT_TEST_FAILED; for (i=0; i<numLocators; i++) { pLocator = NULL; if (edesc->GetLocatorAt(i, &pLocator) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; if (pLocator != NULL) pLocator->Release(); } if (localhr == AAFRESULT_SUCCESS) cout<< " GetLocatorAt() ... Passed"<< endl; else { cout<< " GetLocatorAt() ... FAILED"<< endl; hr = AAFRESULT_TEST_FAILED; } /* GetLocators() ******************************************/ if (edesc->GetLocators(NULL) != AAFRESULT_NULL_PARAM) localhr = AAFRESULT_TEST_FAILED; pEnumLocators = NULL; if (edesc->GetLocators(&pEnumLocators) == AAFRESULT_SUCCESS) { if (pEnumLocators != NULL) { // Try a simple test to confirm if (pEnumLocators->NextOne(&pLocator) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; edesc->GetLocatorAt(0, &pLocator2); if (pLocator != pLocator2) localhr = AAFRESULT_TEST_FAILED; else pLocator2->Release(); pLocator->Release(); pLocator = 0; pEnumLocators->Release(); } else localhr = AAFRESULT_TEST_FAILED; } else localhr = AAFRESULT_TEST_FAILED; if (localhr == AAFRESULT_SUCCESS) cout<< " GetLocators() ... Passed"<< endl; else { cout<< " GetLocators() ... FAILED"<< endl; hr = AAFRESULT_TEST_FAILED; } /* RemoveLocatorAt() ******************************************/ localhr = AAFRESULT_SUCCESS; // Verify that we can't remove an index value that is out of range // note: Locators index is 0 based so the index numLocators is out of range if (edesc->RemoveLocatorAt (numLocators) != AAFRESULT_BADINDEX) localhr = AAFRESULT_TEST_FAILED; // Remove locator at beginning, but Release it first edesc->CountLocators(&numLocators); edesc->GetLocatorAt(0, &pLocator); pLocator->Release(); edesc->GetLocatorAt(1, &pLocator); if (edesc->RemoveLocatorAt (0) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; // Verify the count edesc->CountLocators(&numLocators2); if (numLocators2 != (numLocators - 1)) localhr = AAFRESULT_TEST_FAILED; edesc->GetLocatorAt(0, &pLocator2); // Verify that the locators shifted properly if (pLocator != pLocator2) localhr = AAFRESULT_TEST_FAILED; pLocator->Release(); pLocator = 0; pLocator2->Release(); pLocator2 = 0; // Remove locator in middle, but Release it first edesc->CountLocators(&numLocators); edesc->GetLocatorAt((numLocators/2), &pLocator); pLocator->Release(); edesc->GetLocatorAt((numLocators/2 +1), &pLocator); if (edesc->RemoveLocatorAt (numLocators/2) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; edesc->CountLocators(&numLocators2); if (numLocators2 != (numLocators - 1)) localhr = AAFRESULT_TEST_FAILED; edesc->GetLocatorAt(numLocators/2, &pLocator2); // Verify that the locators shifted properly if (pLocator != pLocator2) localhr = AAFRESULT_TEST_FAILED; pLocator->Release(); pLocator = 0; pLocator2->Release(); pLocator2 = 0; // Remove locator at end, but Release it first edesc->CountLocators(&numLocators); edesc->GetLocatorAt(numLocators-1, &pLocator); pLocator->Release(); edesc->GetLocatorAt(numLocators-2, &pLocator); if (edesc->RemoveLocatorAt (numLocators-1) != AAFRESULT_SUCCESS) localhr = AAFRESULT_TEST_FAILED; edesc->CountLocators(&numLocators2); if (numLocators2 != (numLocators - 1)) localhr = AAFRESULT_TEST_FAILED; edesc->GetLocatorAt(numLocators2-1, &pLocator2); // Verify that the locators shifted properly if (pLocator != pLocator2) localhr = AAFRESULT_TEST_FAILED; pLocator->Release(); pLocator = 0; pLocator2->Release(); pLocator2 = 0; if (localhr == AAFRESULT_SUCCESS) cout<< " RemoveLocatorAt() ... Passed"<< endl; else { cout<< " RemoveLocatorAt() ... FAILED"<< endl; hr = AAFRESULT_TEST_FAILED; } /*************************************************************/ // Add the source mob into the tree checkResult(pHeader->AddMob(pMob)); } catch (HRESULT& rResult) { hr = rResult; } // Cleanup object references if (edesc) edesc->Release(); if (pMob) pMob->Release(); if (pSourceMob) pSourceMob->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if (pFile) { // Close file, clean-up and return if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } 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; IAAFCompositionMob* pCompMob=NULL; IAAFMob* pMob = NULL; IAAFTimelineMobSlot* pNewSlot = NULL; IAAFSourceClip* pSourceClip = NULL; IAAFSourceReference* pSourceRef = NULL; IAAFTransition* pTransition = NULL; IAAFOperationGroup* pOperationGroup = NULL; IAAFSegment* pSegment = NULL; IAAFSegment* pEffectFiller = NULL; IAAFComponent* pComponent = NULL; IAAFFiller* pFiller = NULL; IAAFSequence* pSequence = NULL; IAAFOperationDef* pOperationDef = NULL; IAAFParameter *pParm = NULL; IAAFParameterDef* pParamDef = NULL; IAAFConstantValue* pConstantValue = NULL; HRESULT hr = S_OK; aafLength_t transitionLength; aafPosition_t cutPoint = 0; aafLength_t effectLen = TEST_EFFECT_LEN; aafUID_t effectID = kTestEffectID; aafUID_t parmID = kTestParmID; transitionLength = 100; 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); // Create the effect and parameter definitions checkResult(defs.cdOperationDef()-> CreateInstance(IID_IAAFOperationDef, (IUnknown **)&pOperationDef)); checkResult(defs.cdParameterDef()-> CreateInstance(IID_IAAFParameterDef, (IUnknown **)&pParamDef)); checkResult(pOperationDef->Initialize (effectID, TEST_EFFECT_NAME, TEST_EFFECT_DESC)); checkResult(pDictionary->RegisterOperationDef(pOperationDef)); checkResult(pParamDef->Initialize (parmID, TEST_PARAM_NAME, TEST_PARAM_DESC, defs.tdRational ())); checkResult(pParamDef->SetDisplayUnits(TEST_PARAM_UNITS)); checkResult(pDictionary->RegisterParameterDef(pParamDef)); 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)); // ------------------------------------------------------------ // To test a Transition we need to create a Sequence which will // a Filler, a transition and another Filler. I know this is not // very interesting, but it will let us test the Transition // interface with the least amount of other stuff. // ------------------------------------------------------------ // // Create a CompositionMob checkResult(defs.cdCompositionMob()-> CreateInstance(IID_IAAFCompositionMob, (IUnknown **)&pCompMob)); checkResult(pCompMob->Initialize(L"Transition Test")); // Get a MOB interface checkResult(pCompMob->QueryInterface (IID_IAAFMob, (void **)&pMob)); checkResult(pMob->SetMobID(TEST_MobID)); // Create a Sequence checkResult(defs.cdSequence()-> CreateInstance(IID_IAAFSequence, (IUnknown **) &pSequence)); // Get a Segment interface checkResult(pSequence->QueryInterface(IID_IAAFSegment, (void **)&pSegment)); // Get a component interface and checkResult(pSequence->QueryInterface(IID_IAAFComponent, (void **)&pComponent)); // set the Data definition for it ! checkResult(pComponent->SetDataDef(defs.ddkAAFPicture())); // Release the component - because we need to reuse the pointer later pComponent->Release(); pComponent = NULL; // Create a new Mob Slot that will contain the sequence aafRational_t editRate = { 0, 1}; checkResult(pMob->AppendNewTimelineSlot(editRate, pSegment, 1, L"Transition", 0, &pNewSlot)); // Create a Filler checkResult(defs.cdFiller()-> CreateInstance(IID_IAAFFiller, (IUnknown **) &pFiller)); // Get a component interface checkResult(pFiller->QueryInterface(IID_IAAFComponent, (void **) &pComponent)); // Set values for the filler checkResult(pFiller->Initialize(defs.ddkAAFPicture(), fillerLength)); // append the filler to the sequence checkResult(pSequence->AppendComponent(pComponent)); // Release the component - because we need to reuse the pointer later pFiller->Release(); pFiller = NULL; pComponent->Release(); pComponent = NULL; checkResult(defs.cdTransition()-> CreateInstance(IID_IAAFTransition, (IUnknown **)&pTransition)); // Create an empty EffectGroup object !! checkResult(defs.cdOperationGroup()-> CreateInstance(IID_IAAFOperationGroup, (IUnknown **)&pOperationGroup)); checkResult(pOperationGroup->Initialize(defs.ddkAAFPicture(), transitionLength, pOperationDef)); // Create a constant value parameter. checkResult(defs.cdConstantValue()-> CreateInstance(IID_IAAFConstantValue, (IUnknown **)&pConstantValue)); aafRational_t testLevel = {1, 2}; checkResult(pConstantValue->Initialize (pParamDef, sizeof(testLevel), (aafDataBuffer_t)&testLevel)); checkResult(pConstantValue->QueryInterface (IID_IAAFParameter, (void **)&pParm)); checkResult(pOperationGroup->AddParameter (pParm)); pParm->Release(); pParm = NULL; pConstantValue->Release(); pConstantValue = NULL; checkResult(defs.cdFiller()-> CreateInstance(IID_IAAFSegment, (IUnknown **) &pEffectFiller)); checkResult(pEffectFiller->QueryInterface(IID_IAAFComponent, (void **)&pComponent)); checkResult(pComponent->SetDataDef(defs.ddkAAFPicture())); pComponent->Release(); pComponent = NULL; checkResult(pOperationGroup->AppendInputSegment (pEffectFiller)); // release the filler pEffectFiller->Release(); pEffectFiller = 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(pTransition->Initialize (defs.ddkAAFPicture(), transitionLength, cutPoint, pOperationGroup)); checkResult(pTransition->QueryInterface (IID_IAAFComponent, (void **)&pComponent)); // now append the transition checkResult(pSequence->AppendComponent(pComponent)); // Release the component - because we need to reuse the pointer later pComponent->Release(); pComponent = NULL; // Create the second filler checkResult(defs.cdFiller()-> CreateInstance(IID_IAAFFiller, (IUnknown **) &pFiller)); checkResult(pFiller->QueryInterface(IID_IAAFComponent, (void **) &pComponent)); // Set values for the filler checkResult(pFiller->Initialize(defs.ddkAAFPicture(), fillerLength)); // append the filler to the sequence checkResult(pSequence->AppendComponent(pComponent)); pComponent->Release(); pComponent = NULL; pFiller->Release(); pFiller = NULL; // Now, we append the composition mob to the file checkResult(pHeader->AddMob(pMob)); // and we are done ! } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (pParm) pParm->Release(); if (pConstantValue) pConstantValue->Release(); if (pParamDef) pParamDef->Release(); if (pSourceClip) pSourceClip->Release(); if (pSourceRef) pSourceRef->Release(); if (pNewSlot) pNewSlot->Release(); if (pSegment) pSegment->Release(); if (pSequence) pSequence->Release(); if (pFiller) pFiller->Release(); if (pOperationDef) pOperationDef->Release(); if (pOperationGroup) pOperationGroup->Release(); if (pMob) pMob->Release(); if (pCompMob) pCompMob->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if (pTransition) pTransition->Release(); if (pFile) { if (bFileOpen) { pFile->Save(); pFile->Close(); } pFile->Release(); } return hr; }
static HRESULT CreateAAFFile( aafWChar * pFileName, aafUID_constref fileKind, testRawStorageType_t rawStorageType, aafProductIdentification_constref productID) { IAAFFile* pFile = NULL; IAAFHeader* pHeader = NULL; IAAFDictionary* pDictionary = NULL; IAAFSourceMob* pSourceMob = NULL; IAAFMob* pMob = NULL; IAAFDataEssenceDescriptor* pDataEssenceDesc = NULL; IAAFEssenceDescriptor* pEssDesc = NULL; HRESULT hr = AAFRESULT_SUCCESS; try { // Remove the previous test file if any. RemoveTestFile(pFileName); // Create the AAF file checkResult(CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile )); // 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)); // Create a source mob CAAFBuiltinDefs defs (pDictionary); checkResult(defs.cdSourceMob()-> CreateInstance(IID_IAAFSourceMob, (IUnknown **)&pSourceMob)); checkResult(pSourceMob->QueryInterface(IID_IAAFMob, (void **)&pMob)); checkResult(pMob->SetMobID(TEST_MobID)); RegisterDataEssenceDescriptorTest( pDictionary ); checkResult(pMob->SetName(L"DataEssenceDescriptorTest")); checkResult( pDictionary->CreateInstance( TestDataEssenceDescriptorClassID, IID_IAAFDataEssenceDescriptor, (IUnknown**)&pDataEssenceDesc ) ); aafUID_t dataEssenceCoding; memset(&dataEssenceCoding, 0, sizeof(aafUID_t)); checkResult(pDataEssenceDesc->SetDataEssenceCoding(dataEssenceCoding)); checkResult(pDataEssenceDesc->QueryInterface(IID_IAAFEssenceDescriptor, (void **)&pEssDesc)); checkResult(pSourceMob->SetEssenceDescriptor(pEssDesc)); // Add the MOB to the file checkResult(pHeader->AddMob(pMob)); } catch (HRESULT& rResult) { hr = rResult; } // Cleanup and return if (pEssDesc) pEssDesc->Release(); if (pDataEssenceDesc) pDataEssenceDesc->Release(); if (pMob) pMob->Release(); if (pSourceMob) pSourceMob->Release(); if (pDictionary) pDictionary->Release(); if (pHeader) pHeader->Release(); if (pFile) { pFile->Save(); pFile->Close(); pFile->Release(); } return hr; }