static bool testRestore(const wchar_t* fileName)
{
bool passed = true;
IAAFFile* pFile = 0;
IAAFHeader* pHeader = 0;
IAAFDictionary* pDictionary = 0;
IAAFContentStorage* pStorage = 0;
IEnumAAFMobs* pMobs = 0;
IAAFMob* pMob = 0;
try
{
pFile = openFileForReading(fileName);
}
catch (...)
{
return false;
}
try
{
// get the Mob containing the test data
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->GetDictionary(&pDictionary));
checkResult(pHeader->GetContentStorage(&pStorage));
aafSearchCrit_t searchCrit;
searchCrit.searchTag = kAAFByMobKind;
searchCrit.tags.mobKind = kAAFAllMob;
checkResult(pStorage->GetMobs(&searchCrit, &pMobs));
checkResult(pMobs->NextOne(&pMob));
IAAFObject* pObject = 0;
IAAFClassDef* pClassDef = 0;
IAAFPropertyDef* pPropertyDef = 0;
IAAFPropertyValue* pPropertyValue = 0;
IAAFTypeDef* pType = 0;
IAAFTypeDefFixedArray* pFixedArrayType = 0;
IAAFTypeDefInt* pIntType = 0;
IAAFPropertyValue* pIntValue = 0;
try
{
printf(" * Baseline element type: ");
const aafUID_t propId =
{0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUInt8 testValue[2] = {0,255};
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefFixedArray, (void **)&pFixedArrayType));
release(pType);
checkResult(pFixedArrayType->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefInt, (void **)&pIntType));
aafUInt8 value[2];
checkResult(pFixedArrayType->GetElementValue(pPropertyValue, 0, &pIntValue));
checkResult(pIntType->GetInteger(pIntValue, &value[0], 1));
release(pIntValue);
checkResult(pFixedArrayType->GetElementValue(pPropertyValue, 1, &pIntValue));
checkResult(pIntType->GetInteger(pIntValue, &value[1], 1));
if (value[0] == testValue[0] && value[1] == testValue[1])
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pIntValue);
release(pIntType);
release(pFixedArrayType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
try
{
printf(" * Non-Baseline element type: ");
const aafUID_t propId =
{0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUInt8 testValue[2] = {1,2};
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefFixedArray, (void **)&pFixedArrayType));
release(pType);
checkResult(pFixedArrayType->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefInt, (void **)&pIntType));
aafUInt8 value[2];
checkResult(pFixedArrayType->GetElementValue(pPropertyValue, 0, &pIntValue));
checkResult(pIntType->GetInteger(pIntValue, &value[0], 1));
release(pIntValue);
checkResult(pFixedArrayType->GetElementValue(pPropertyValue, 1, &pIntValue));
checkResult(pIntType->GetInteger(pIntValue, &value[1], 1));
if (value[0] == testValue[0] && value[1] == testValue[1])
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pIntValue);
release(pIntType);
release(pFixedArrayType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
}
catch (...)
{
passed = false;
}
// cleanup
release(pMob);
release(pMobs);
release(pStorage);
release(pDictionary);
release(pHeader);
checkResult(pFile->Close());
release(pFile);
report(passed);
return passed;
}
static HRESULT CreateAAFFile(aafWChar * pFileName, long int N)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFMob* pMob = NULL;
IAAFMob* pCompMob = NULL;
IAAFEssenceDescriptor* aDesc = NULL;
IAAFMasterMob* pMasterMob = NULL;
IAAFSourceMob* pFileMob = NULL;
IAAFSourceMob* pTapeMob = NULL;
IAAFSequence* pSequence = NULL;
IAAFComponent* aComponent = NULL;
IAAFFileDescriptor* pFileDesc = NULL;
IAAFAIFCDescriptor* pAIFCDesc = NULL;
IAAFTapeDescriptor* pTapeDesc = NULL;
IAAFTimelineMobSlot* newSlot = NULL;
IAAFSegment* seg = NULL;
IAAFSourceClip* fileSclp = NULL;
IAAFSourceClip* masterSclp = NULL;
IAAFSourceClip* compSclp = NULL;
IAAFComponent* compFill = NULL;
IAAFLocator* pLocator = NULL;
IAAFNetworkLocator* pNetLocator = NULL;
IAAFClassDef * pCDCompositionMob = 0;
IAAFClassDef * pCDSequence = 0;
IAAFClassDef * pCDSourceMob = 0;
IAAFClassDef * pCDTapeDescriptor = 0;
IAAFClassDef * pCDAIFCDescriptor = 0;
IAAFClassDef * pCDNetworkLocator = 0;
IAAFClassDef * pCDMasterMob = 0;
IAAFClassDef * pCDSourceClip = 0;
IAAFClassDef * pCDFiller = 0;
IAAFDataDef * pDdefPicture = 0;
aafRational_t videoRate = { 30000, 1001 };
aafMobID_t tapeMobID, fileMobID, masterMobID;
aafTimecode_t tapeTC = { 108000, kAAFTcNonDrop, 30};
aafLength_t fileLen = FILE1_LENGTH;
aafLength_t fillLen = FILL_LENGTH;
aafLength_t segLen = SEG_LENGTH;
aafProductIdentification_t ProductInfo;
long int i = 0;
moduleErrorTmp = S_OK;
// delete any previous test file before continuing...
char chFileName[1000];
convert(chFileName, sizeof(chFileName), pFileName);
remove(chFileName);
aafProductVersion_t v;
v.major = 1;
v.minor = 0;
v.tertiary = 0;
v.patchLevel = 0;
v.type = kAAFVersionUnknown;
ProductInfo.companyName = companyName;
ProductInfo.productName = productName;
ProductInfo.productVersion = &v;
ProductInfo.productVersionString = NULL;
ProductInfo.productID = NIL_UID;
ProductInfo.platform = NULL;
#if defined(USE_MEMORY_FILE)
check(MemoryFileOpenNewModify (0, &ProductInfo, &pFile));
#else
check(AAFFileOpenNewModifyEx (pFileName, &kAAFFileKind_Aaf4KBinary, 0, &ProductInfo, &pFile));
#endif
check(pFile->GetHeader(&pHeader));
// Get the AAF Dictionary so that we can create valid AAF objects.
check(pHeader->GetDictionary(&pDictionary));
check(pDictionary->LookupClassDef(AUID_AAFCompositionMob,
&pCDCompositionMob));
check(pDictionary->LookupClassDef(AUID_AAFSequence,
&pCDSequence));
check(pDictionary->LookupClassDef(AUID_AAFSourceMob,
&pCDSourceMob));
check(pDictionary->LookupClassDef(AUID_AAFTapeDescriptor,
&pCDTapeDescriptor));
check(pDictionary->LookupClassDef(AUID_AAFAIFCDescriptor,
&pCDAIFCDescriptor));
check(pDictionary->LookupClassDef(AUID_AAFNetworkLocator,
&pCDNetworkLocator));
check(pDictionary->LookupClassDef(AUID_AAFMasterMob,
&pCDMasterMob));
check(pDictionary->LookupClassDef(AUID_AAFSourceClip,
&pCDSourceClip));
check(pDictionary->LookupClassDef(AUID_AAFFiller,
&pCDFiller));
check(pDictionary->LookupDataDef(kAAFDataDef_Picture,
&pDdefPicture));
// IMPORTANT: major remodification is from this point onwards...
// sequence creation code pulled out of the subsequent loop.
// Create a Composition Mob
check(pCDCompositionMob->CreateInstance(IID_IAAFMob,
(IUnknown **)&pCompMob));
check(pCDSequence->CreateInstance(IID_IAAFSequence,
(IUnknown **)&pSequence));
check(pSequence->QueryInterface (IID_IAAFSegment, (void **)&seg));
check(pSequence->QueryInterface(IID_IAAFComponent, (void **)&aComponent));
check(aComponent->SetDataDef(pDdefPicture));
aComponent->Release();
aComponent = NULL;
check(pCompMob->QueryInterface (IID_IAAFMob, (void **)&pMob));
check(pMob->AppendNewTimelineSlot(videoRate, seg, i, slotName, 0, &newSlot));
pMob->Release();
pMob = NULL;
newSlot->Release();
newSlot = NULL;
seg->Release();
seg = NULL;
check(pHeader->AddMob(pCompMob));
// now looping around the remainder N times to make N components
for (i=0; i < N; i++) {
//Make the Tape MOB
check(pCDSourceMob->CreateInstance(IID_IAAFSourceMob,
(IUnknown **)&pTapeMob));
check(pCDTapeDescriptor->CreateInstance(IID_IAAFTapeDescriptor,
(IUnknown **)&pTapeDesc));
check(pTapeDesc->QueryInterface (IID_IAAFEssenceDescriptor,
(void **)&aDesc));
check(pTapeMob->SetEssenceDescriptor(aDesc));
aDesc->Release();
aDesc = NULL;
pTapeDesc->Release();
pTapeDesc = NULL;
check(pTapeMob->AppendTimecodeSlot (videoRate, 0, tapeTC, TAPE_LENGTH));
check(pTapeMob->AddNilReference (1,TAPE_LENGTH, pDdefPicture, videoRate));
check(pTapeMob->QueryInterface (IID_IAAFMob, (void **)&pMob));
pTapeMob->Release();
pTapeMob = NULL;
// NOTE: TapeMob name is updated to change with number of objects
// requested at cli.
// In order to fit with the specification, it is made wide
char TapeMobNameBuffer[MAX];
sprintf(TapeMobNameBuffer,"Tape Mob %ld",i);
aafWChar TapeMobName[MAX];
mbstowcs(TapeMobName,TapeMobNameBuffer,MAX);
check(pMob->SetName (TapeMobName));
check(pHeader->AddMob(pMob));
check(pMob->GetMobID (&tapeMobID));
pMob->Release();
pMob = NULL;
// Make a FileMob
check(pCDSourceMob->CreateInstance(IID_IAAFSourceMob,
(IUnknown **)&pFileMob));
check(pCDAIFCDescriptor->CreateInstance(IID_IAAFFileDescriptor,
(IUnknown **)&pFileDesc));
check(pFileDesc->QueryInterface (IID_IAAFEssenceDescriptor,
(void **)&aDesc));
check(pFileDesc->QueryInterface (IID_IAAFAIFCDescriptor,
(void **)&pAIFCDesc));
check(pAIFCDesc->SetSummary (5, (unsigned char*)"TEST"));
pAIFCDesc->Release();
pAIFCDesc = NULL;
// Make a locator, and attach it to the EssenceDescriptor
check(pCDNetworkLocator->CreateInstance(IID_IAAFNetworkLocator,
(IUnknown **)&pNetLocator));
check(pNetLocator->QueryInterface (IID_IAAFLocator, (void **)&pLocator));
check(pLocator->SetPath (TEST_PATH));
check(aDesc->AppendLocator(pLocator));
pLocator->Release();
pLocator = NULL;
pNetLocator->Release();
pNetLocator = NULL;
check(pFileMob->SetEssenceDescriptor(aDesc));
aDesc->Release();
aDesc = NULL;
pFileDesc->Release();
pFileDesc = NULL;
sourceRef.sourceID = tapeMobID;
sourceRef.sourceSlotID = 1;
sourceRef.startTime = 0;
check(pFileMob->NewPhysSourceRef (videoRate, 1, pDdefPicture,
sourceRef, fileLen));
check(pFileMob->QueryInterface (IID_IAAFMob, (void **)&pMob));
check(pMob->GetMobID (&fileMobID));
check(pHeader->AddMob(pMob));
pMob->Release();
pMob = NULL;
//Make the Master MOB
check(pCDMasterMob->CreateInstance(IID_IAAFMasterMob,
(IUnknown **)&pMasterMob));
sourceRef.sourceID = fileMobID;
sourceRef.sourceSlotID = 1;
sourceRef.startTime = 0;
check(pMasterMob->NewPhysSourceRef(videoRate, 1, pDdefPicture,
sourceRef, fileLen));
check(pMasterMob->QueryInterface (IID_IAAFMob, (void **)&pMob));
check(pMob->GetMobID (&masterMobID));
// NOTE: MasterMob name is updated to change with number of objects
// requested at cli.
// In order to fit with the specification, it is made wide
char MasterMobNameBuffer[MAX];
sprintf(MasterMobNameBuffer,"Master Mob %ld",i);
aafWChar MasterMobName[MAX];
mbstowcs(MasterMobName,MasterMobNameBuffer,MAX);
check(pMob->SetName (MasterMobName));
check(pHeader->AddMob(pMob));
pMob->Release();
pMob = NULL;
// the remaining part of the sequence code, adapted for updating slot names
// Create a SourceClip
check(pCDSourceClip->CreateInstance(IID_IAAFSourceClip,
(IUnknown **)&compSclp));
sourceRef.sourceID = masterMobID;
sourceRef.sourceSlotID = 1;
sourceRef.startTime = 0;
check(compSclp->SetSourceReference (sourceRef));
check(compSclp->QueryInterface (IID_IAAFComponent, (void **)&aComponent));
check(aComponent->SetDataDef(pDdefPicture));
check(aComponent->SetLength (segLen));
check(pSequence->AppendComponent (aComponent));
// Create a filler - Get the component interface only (IID_IAAFComponent)
check(pCDFiller->CreateInstance(IID_IAAFComponent,
(IUnknown **)&compFill));
check(compFill->SetLength (fillLen));
check(compFill->SetDataDef(pDdefPicture));
check(pSequence->AppendComponent (compFill));
compFill->Release();
compFill = NULL;
aComponent->Release();
aComponent = NULL;
compSclp->Release();
compSclp = NULL;
pMasterMob->Release();
pMasterMob = NULL;
pFileMob->Release();
pFileMob = NULL;
// end of loop since only one dictionary and header are needed
// the file is then saved, closed and released after all modifications
// are complete
}
cleanup:
// Cleanup and return
if (pNetLocator)
pNetLocator->Release();
if (pLocator)
pLocator->Release();
if (compFill)
compFill->Release();
if (compSclp)
compSclp->Release();
if (masterSclp)
masterSclp->Release();
if (fileSclp)
fileSclp->Release();
if (pTapeDesc)
pTapeDesc->Release();
if (pFileDesc)
pFileDesc->Release();
if (pTapeMob)
pTapeMob->Release();
if (pFileMob)
pFileMob->Release();
if (pMasterMob)
pMasterMob->Release();
if (aDesc)
aDesc->Release();
if (newSlot)
newSlot->Release();
if (pMob)
pMob->Release();
if (pCompMob)
pCompMob->Release();
if (seg)
seg->Release();
if (aComponent)
aComponent->Release();
if (pSequence)
pSequence->Release();
if (pDictionary)
pDictionary->Release();
if (pHeader)
pHeader->Release();
if (pCDCompositionMob) {
pCDCompositionMob->Release();
pCDCompositionMob = 0;
}
if (pCDSequence) {
pCDSequence->Release();
pCDSequence = 0;
}
if (pCDSourceMob) {
pCDSourceMob->Release();
pCDSourceMob = 0;
}
if (pCDTapeDescriptor) {
pCDTapeDescriptor->Release();
pCDTapeDescriptor = 0;
}
if (pCDAIFCDescriptor) {
pCDAIFCDescriptor->Release();
pCDAIFCDescriptor = 0;
}
if (pCDNetworkLocator) {
pCDNetworkLocator->Release();
pCDNetworkLocator = 0;
}
if (pCDMasterMob) {
pCDMasterMob->Release();
pCDMasterMob = 0;
}
if (pCDSourceClip) {
pCDSourceClip->Release();
pCDSourceClip = 0;
}
if (pCDFiller) {
pCDFiller->Release();
pCDFiller = 0;
}
if (pDdefPicture) {
pDdefPicture->Release();
pDdefPicture = 0;
}
if (pFile) {
clock_t start = clock();
clock_t finish;
double duration;
pFile->Save();
pFile->Close();
#if defined(USE_MEMORY_FILE)
check(MemoryFileSaveToDisk(pFileName, pFile));
#endif
finish = clock();
duration = ((double) (finish - start) / CLOCKS_PER_SEC);
pFile->Release();
printf("Save time = %f seconds\n", duration);
}
return moduleErrorTmp;
}
static bool testRestore(const wchar_t* fileName)
{
bool passed = true;
IAAFFile* pFile = 0;
IAAFHeader* pHeader = 0;
IAAFDictionary* pDictionary = 0;
IAAFContentStorage* pStorage = 0;
IEnumAAFMobs* pMobs = 0;
IAAFMob* pMob = 0;
try
{
pFile = openFileForReading(fileName);
}
catch (...)
{
return false;
}
try
{
// get the Mob containing the test data
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->GetDictionary(&pDictionary));
checkResult(pHeader->GetContentStorage(&pStorage));
aafSearchCrit_t searchCrit;
searchCrit.searchTag = kAAFByMobKind;
searchCrit.tags.mobKind = kAAFAllMob;
checkResult(pStorage->GetMobs(&searchCrit, &pMobs));
checkResult(pMobs->NextOne(&pMob));
IAAFObject* pObject = 0;
IAAFClassDef* pClassDef = 0;
IAAFPropertyDef* pPropertyDef = 0;
IAAFPropertyValue* pPropertyValue = 0;
IAAFTypeDef* pType = 0;
IAAFTypeDefCharacter* pCharacterType = 0;
// test simple
try
{
printf(" * Simple: ");
const aafUID_t propId =
{0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
wchar_t testCharacter = L'A';
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefCharacter, (void **)&pCharacterType));
aafCharacter value;
checkResult(pCharacterType->GetCharacter(pPropertyValue, &value));
if (value == testCharacter)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pCharacterType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
// test XML escaped
try
{
printf(" * XML escaped: ");
const aafUID_t propId =
{0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
wchar_t testCharacter = L'\r';
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefCharacter, (void **)&pCharacterType));
aafCharacter value;
checkResult(pCharacterType->GetCharacter(pPropertyValue, &value));
if (value == testCharacter)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pCharacterType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
// test AAF escaped
try
{
printf(" * AAF escaped: ");
const aafUID_t propId =
{0x20000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
wchar_t testCharacter = 0x0;
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefCharacter, (void **)&pCharacterType));
aafCharacter value;
checkResult(pCharacterType->GetCharacter(pPropertyValue, &value));
if (value == testCharacter)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pCharacterType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
// test AAF escaped of invalid UNICODE character
try
{
printf(" * AAF escaped invalid Unicode character: ");
const aafUID_t propId =
{0x30000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
wchar_t testCharacter = 0xFFFF;
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefCharacter, (void **)&pCharacterType));
aafCharacter value;
checkResult(pCharacterType->GetCharacter(pPropertyValue, &value));
if (value == testCharacter)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pCharacterType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
}
catch (...)
{
passed = false;
}
// cleanup
release(pMob);
release(pMobs);
release(pStorage);
release(pDictionary);
release(pHeader);
checkResult(pFile->Close());
release(pFile);
report(passed);
return passed;
}
static bool testRestore(const wchar_t* fileName)
{
bool passed = true;
IAAFFile* pFile = 0;
IAAFHeader* pHeader = 0;
IAAFDictionary* pDictionary = 0;
IAAFContentStorage* pStorage = 0;
IEnumAAFMobs* pMobs = 0;
IAAFMob* pMob = 0;
try
{
pFile = openFileForReading(fileName);
}
catch (...)
{
return false;
}
try
{
// get the Mob containing the test data
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->GetDictionary(&pDictionary));
checkResult(pHeader->GetContentStorage(&pStorage));
aafSearchCrit_t searchCrit;
searchCrit.searchTag = kAAFByMobKind;
searchCrit.tags.mobKind = kAAFAllMob;
checkResult(pStorage->GetMobs(&searchCrit, &pMobs));
checkResult(pMobs->NextOne(&pMob));
IAAFObject* pObject = 0;
IAAFClassDef* pClassDef = 0;
IAAFPropertyDef* pPropertyDef = 0;
IAAFPropertyValue* pPropertyValue = 0;
IAAFTypeDef* pType = 0;
IAAFTypeDefIndirect* pIndirectType = 0;
IAAFPropertyValue* pActualPropertyValue = 0;
IAAFTypeDef* pActualType = 0;
IAAFTypeDefInt* pIntType = 0;
IAAFTypeDefEnum* pEnumType = 0;
IAAFTypeDefRecord* pRecordType = 0;
try
{
printf(" * Baseline: ");
const aafUID_t propId =
{0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafInt8 testValue = -128;
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefIndirect, (void **)&pIndirectType));
checkResult(pIndirectType->GetActualValue(pPropertyValue, &pActualPropertyValue));
checkResult(pActualPropertyValue->GetType(&pActualType));
checkResult(pActualType->QueryInterface(IID_IAAFTypeDefInt, (void **)&pIntType));
aafInt8 value;
checkResult(pIntType->GetInteger(pActualPropertyValue, (aafUInt8*)&value, 1));
if (value == testValue)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pRecordType);
release(pEnumType);
release(pIntType);
release(pActualType);
release(pActualPropertyValue);
release(pIndirectType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
try
{
printf(" * Non-baseline: ");
const aafUID_t propId =
{0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUInt8 testValue = 1;
const wchar_t* testName = L"AAA";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefIndirect, (void **)&pIndirectType));
checkResult(pIndirectType->GetActualValue(pPropertyValue, &pActualPropertyValue));
checkResult(pActualPropertyValue->GetType(&pActualType));
checkResult(pActualType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType));
aafInt64 value;
aafCharacter name[256];
checkResult(pEnumType->GetIntegerValue(pActualPropertyValue, &value));
checkResult(pEnumType->GetNameFromValue(pActualPropertyValue, name, 256));
if (value == testValue && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pRecordType);
release(pEnumType);
release(pIntType);
release(pActualType);
release(pActualPropertyValue);
release(pIndirectType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
try
{
printf(" * Baseline record: ");
const aafUID_t propId =
{0x20000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafProductVersion_t testValue = {0,1,0,0,kAAFVersionUnknown};
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefIndirect, (void **)&pIndirectType));
checkResult(pIndirectType->GetActualValue(pPropertyValue, &pActualPropertyValue));
checkResult(pActualPropertyValue->GetType(&pActualType));
checkResult(pActualType->QueryInterface(IID_IAAFTypeDefRecord, (void **)&pRecordType));
aafProductVersion_t value;
checkResult(pRecordType->GetStruct(pActualPropertyValue, (aafUInt8*)&value, sizeof(aafProductVersion_t)));
if (memcmp(&testValue, &value, sizeof(aafProductVersion_t)) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pRecordType);
release(pEnumType);
release(pIntType);
release(pActualType);
release(pActualPropertyValue);
release(pIndirectType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
}
catch (...)
{
passed = false;
}
// cleanup
release(pMob);
release(pMobs);
release(pStorage);
release(pDictionary);
release(pHeader);
checkResult(pFile->Close());
release(pFile);
report(passed);
return passed;
}
static HRESULT ReadAAFFile(aafWChar * pFileName )
{
HRESULT hr = AAFRESULT_SUCCESS;
IAAFFile * pFile = NULL;
IAAFHeader * pHeader = NULL;
IEnumAAFMobs* pMobIter = NULL;
IAAFCompositionMob * pCMob = NULL;
IAAFMob* pMob = NULL;
bool bFileOpen = false;
aafNumSlots_t numMobs;
IAAFObject* pObj = NULL;
IEnumAAFProperties * pEnum = NULL;
IAAFProperty *pProp = NULL;
IAAFPropertyDef* pPropDef = NULL;
IAAFPropertyValue* pPropVal = NULL;
IAAFTypeDef* pTypeDef = NULL;
try
{
// Open the file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// We can't really do anthing in AAF without the header.
checkResult(pFile->GetHeader(&pHeader));
// Validate that there is only one composition mob.
checkResult(pHeader->CountMobs(kAAFCompMob, &numMobs));
checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED);
// Enumerate over all Composition Mobs
aafSearchCrit_t criteria;
criteria.searchTag = kAAFByMobKind;
criteria.tags.mobKind = kAAFCompMob;
checkResult(pHeader->GetMobs(&criteria, &pMobIter));
while (AAFRESULT_SUCCESS == pMobIter->NextOne(&pMob))
{
//Get the Composition mob
checkResult (pMob->QueryInterface (IID_IAAFCompositionMob,
(void **) &pCMob));
//Get the Object
checkResult (pCMob->QueryInterface (IID_IAAFObject,
(void **) &pObj));
//From the Object, we can get the properties ....
aafUInt32 propCount = 0;
checkResult (pObj->CountProperties (&propCount));
//A composition should have at least 5 properties ...
checkExpression(propCount>=5, AAFRESULT_TEST_FAILED);
//Get Enumeration over properties
checkResult (pObj->GetProperties (&pEnum));
checkExpression (pEnum != 0, AAFRESULT_TEST_FAILED);
while (propCount--)
{
//Check for property validity
checkResult (pEnum->NextOne (&pProp));
checkExpression (pProp != NULL, AAFRESULT_TEST_FAILED);
//Now call prop methods
//1. Get Definition
checkResult( pProp->GetDefinition(&pPropDef) );
//2. Get Value
checkResult( pProp->GetValue(&pPropVal) );
//deal with prop value
checkResult( pPropVal->GetType(&pTypeDef) );
//From propval, get the typedef!!!!!!!!!!!!!!!!!!!!!
IAAFTypeDefSP spTypeDef;
checkResult( pPropVal->GetType(&spTypeDef) );
//get category
eAAFTypeCategory_t typeCat = kAAFTypeCatUnknown;
checkResult (spTypeDef->GetTypeCategory(&typeCat));
//make sure it is not unknown
checkExpression(kAAFTypeCatUnknown != typeCat, AAFRESULT_TEST_FAILED);
//Deal with our Name String ....
if (typeCat == kAAFTypeCatString)
{
IAAFTypeDefStringSP spTypeDefString;
checkResult( spTypeDef->QueryInterface(IID_IAAFTypeDefString,
(void**)&spTypeDefString) );
aafUInt32 bufSize =
//don't forget the NULL char, and factoring in the size of a wchar
(wcslen(TEST_NAME)+1) * sizeof(aafCharacter);
aafCharacter *nameBuf = new aafCharacter[bufSize];
checkResult( spTypeDefString->GetElements(pPropVal, (aafMemPtr_t)nameBuf, bufSize) );
checkExpression( wcscmp(TEST_NAME, nameBuf) == 0, AAFRESULT_TEST_FAILED );
delete [] nameBuf;
}
//Done ...........
//release typedef
pTypeDef->Release();
//release defintion + value
pPropDef->Release();
pPropVal->Release();
//release this prop
pProp->Release();
pProp = NULL;
}//while prop count
}//while mob iter
}//try
catch (HRESULT & rResult)
{
hr = rResult;
}
//Release the rest ...
if (pEnum)
pEnum->Release();
if (pObj)
pObj->Release();
if (pCMob)
pCMob->Release();
if (pMob)
pMob->Release();
if (pMobIter)
pMobIter->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{
if (bFileOpen)
pFile->Close();
pFile->Release();
}
return hr;
}
static HRESULT ModifyAAFFile(aafWChar *filename, int level)
{
HRESULT hr = S_OK;
try
{
// Open existing file for modification
IAAFFile *pFile = NULL;
TestProductID.productVersionString = const_cast<aafWChar*>(L"ModifyAAFFile");
checkResult( AAFFileOpenExistingModify(
filename,
0, // modeFlags
&TestProductID,
&pFile) );
cout << "ModifyAAFFile() - appended Identification" << endl;
// Get the header & dictionary
IAAFHeader *pHeader = NULL;
IAAFDictionary *pDictionary = NULL;
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->GetDictionary(&pDictionary));
// Search for Mobs
IAAFMob *pFileMob = NULL;
IEnumAAFMobs *pFileMobIter = NULL;
aafSearchCrit_t criteria;
criteria.searchTag = kAAFByMobKind;
criteria.tags.mobKind = kAAFFileMob; // Search by File Mob
checkResult(pHeader->GetMobs(&criteria, &pFileMobIter));
while (AAFRESULT_SUCCESS == pFileMobIter->NextOne(&pFileMob))
{
if (level == 0)
break;
IAAFEssenceDescriptor *edesc = NULL;
IAAFSourceMob *pSourceMob = NULL;
CR(pFileMob->QueryInterface(IID_IAAFSourceMob, (void **)&pSourceMob));
CR(pSourceMob->GetEssenceDescriptor(&edesc));
// Change the Name property
CR(pFileMob->SetName(L"ModifyAAFFile - modified Name"));
cout << "ModifyAAFFile() - changed FileMob's Name property" << endl;
if (level == 1)
break;
// Change descriptor's properties
IAAFAIFCDescriptor *pAIFCDesc = NULL;
CR(edesc->QueryInterface(IID_IAAFAIFCDescriptor, (void **)&pAIFCDesc));
aafUInt8 AIFCsum[] = {0xa1,0xfc};
CR(pAIFCDesc->SetSummary(sizeof(AIFCsum), AIFCsum));
pAIFCDesc->Release();
edesc->Release();
cout << "ModifyAAFFile() - changed AIFCDescriptor's Summary" << endl;
if (level == 2)
break;
// Change descriptor to new one (overwriting old one)
IAAFClassDef *classDef = NULL;
IAAFFileDescriptor *pFileDesc = NULL;
IAAFWAVEDescriptor *pWAVEDesc = NULL;
IAAFEssenceDescriptor *pNewEdesc = NULL;
CR(pDictionary->LookupClassDef(AUID_AAFWAVEDescriptor, &classDef));
CR(classDef->CreateInstance(IID_IAAFFileDescriptor, (IUnknown **)&pFileDesc));
CR(pFileDesc->QueryInterface(IID_IAAFWAVEDescriptor, (void **)&pWAVEDesc));
CR(pFileDesc->QueryInterface(IID_IAAFEssenceDescriptor, (void **)&pNewEdesc));
aafUInt8 WAVEsum[] = {0x1a,0x1e,0xee,0xee};
CR(pWAVEDesc->SetSummary(sizeof(WAVEsum), WAVEsum));
CR(pSourceMob->SetEssenceDescriptor(pNewEdesc));
pNewEdesc->Release();
pWAVEDesc->Release();
pFileDesc->Release();
classDef->Release();
cout << "ModifyAAFFile() - replaced AIFCDescriptor with WAVEDescriptor" << endl;
if (level == 3)
break;
// Add EssenceData
IAAFEssenceData *pEssenceData = NULL;
IAAFEssenceData2 *pEssenceData2 = NULL;
IAAFPlainEssenceData *pPlainEssenceData = NULL;
aafUInt32 bytesWritten = 0;
aafUInt8 essdata[] = "Zaphod Beeblebrox";
CR(pDictionary->LookupClassDef(AUID_AAFEssenceData, &classDef));
CR(classDef->CreateInstance(IID_IAAFEssenceData, (IUnknown **)&pEssenceData));
CR(pEssenceData->SetFileMob(pSourceMob));
CR(pHeader->AddEssenceData(pEssenceData));
CR(pEssenceData->QueryInterface(IID_IAAFEssenceData2, (void**)&pEssenceData2));
CR(pEssenceData2->GetPlainEssenceData(0, &pPlainEssenceData));
CR(pPlainEssenceData->Write(sizeof(essdata), essdata, &bytesWritten));
pEssenceData->Release();
pEssenceData2->Release();
pPlainEssenceData->Release();
classDef->Release();
cout << "ModifyAAFFile() - added EssenceData" << endl;
pSourceMob->Release();
}
pFileMob->Release();
pFileMobIter->Release();
pDictionary->Release();
pHeader->Release();
// Save & close the file
checkResult(pFile->Save());
checkResult(pFile->Close());
checkResult(pFile->Release());
}
catch (HRESULT& rResult)
{
hr = rResult;
cout << "*** ModifyAAFFile: caught error hr=0x" << hex << hr << dec << endl;
}
return hr;
}
static HRESULT OpenAAFFile(aafWChar * pFileName, bool comp_enable)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFMob* pMob = NULL;
IAAFEssenceAccess* pEssenceAccess = NULL;
IEnumAAFMobs* pMobIter = NULL;
aafNumSlots_t numMobs, numSlots;
aafSearchCrit_t criteria;
aafMobID_t mobID;
IAAFDataDef *pPictureDef = NULL;
IAAFMobSlot* pMobSlot = NULL;
// Open an AAF file
check(AAFFileOpenExistingRead (pFileName, 0, &pFile));
check(pFile->GetHeader(&pHeader));
// Open raw video output file
FILE *output;
const char *output_file = comp_enable ? "raw.uyvy" : "raw.mjpeg";
if ((output = fopen(output_file, "wb")) == NULL)
{
perror(output_file);
exit(1);
}
// Get the AAF Dictionary from the file
check(pHeader->GetDictionary(&pDictionary));
/* Lookup any necessary data definitions. */
check(pDictionary->LookupDataDef(kAAFDataDef_Picture, &pPictureDef));
/* Check number of Mobs in file */
check(pHeader->CountMobs(kAAFMasterMob, &numMobs));
if (numMobs == 0)
return 0;
printf("Found %d Master Mobs\n", numMobs);
criteria.searchTag = kAAFByMobKind;
criteria.tags.mobKind = kAAFMasterMob;
check(pHeader->GetMobs(&criteria, &pMobIter));
while (AAFRESULT_SUCCESS == pMobIter->NextOne(&pMob))
{
char mobIDstr[256];
char mobName[256];
aafWChar namebuf[1204];
IAAFTimelineMobSlot* pTimelineMobSlot = NULL;
IAAFDataDef *pDataDef = NULL;
IEnumAAFMobSlots* pMobSlotIter = NULL;
check(pMob->GetMobID (&mobID));
check(pMob->GetName (namebuf, sizeof(namebuf)));
convert(mobName, sizeof(mobName), namebuf);
MobIDtoString(mobID, mobIDstr);
printf(" MasterMob Name = '%s'\n", mobName);
printf(" (mobID %s)\n", mobIDstr);
// Get the number of slots
check(pMob->CountSlots(&numSlots));
// Iterating through all Mob Slots
check(pMob->GetSlots(&pMobSlotIter));
while(AAFRESULT_SUCCESS == pMobSlotIter->NextOne(&pMobSlot))
{
// Check to see if it is a Video Timeline Mob Slot
HRESULT hr;
hr = pMobSlot->QueryInterface(IID_IAAFTimelineMobSlot,(void **) &pTimelineMobSlot);
if (FAILED(hr))
{
pMobSlot->Release();
pMobSlot = NULL;
continue;
}
check(pMobSlot->GetDataDef(&pDataDef));
// Check that we have a picture data def
aafBool bIsPictureKind = kAAFFalse;
check(pDataDef->IsPictureKind(&bIsPictureKind));
if (kAAFTrue != bIsPictureKind)
{
pTimelineMobSlot->Release();
pTimelineMobSlot = NULL;
pDataDef->Release();
pDataDef = NULL;
continue; // skip non-picture data defs
}
aafUInt32 MobSlotID;
IAAFMasterMob* pMasterMob = NULL;
// Prepare to get video data: first get MobSlotID
check(pMobSlot->GetSlotID(&MobSlotID));
// Then get a Master Mob interface
check(pMob->QueryInterface(IID_IAAFMasterMob, (void **)&pMasterMob));
printf(" Opening slot %d with %s\n", MobSlotID, comp_enable ? "CompressionEnable" : "CompressionDisable");
// Open the Essence Data
check(pMasterMob->OpenEssence(MobSlotID,
NULL,
kAAFMediaOpenReadOnly,
comp_enable ? kAAFCompressionEnable : kAAFCompressionDisable,
&pEssenceAccess));
// First put the codec into YUV pixel format
IAAFEssenceFormat* pSetFormat = NULL;
aafInt32 YUV_pixel = kAAFColorSpaceYUV;
check(pEssenceAccess->GetEmptyFileFormat(&pSetFormat));
check(pSetFormat->AddFormatSpecifier(kAAFPixelFormat, 4, (unsigned char *) &YUV_pixel));
check(pEssenceAccess->PutFileFormat(pSetFormat));
pSetFormat->Release();
// Get the information about the format of the video data.
// The pFormat object must be setup with each specifier you
// wish to access, otherwise you get AAFRESULT_FORMAT_NOT_FOUND.
aafRational_t sampleRate;
aafUInt32 maxSampleSize;
aafRect_t storedRect;
aafFrameLayout_t frameLayout;
IAAFEssenceFormat *fmtTemplate = NULL;
IAAFEssenceFormat* pFormat = NULL;
check(pEssenceAccess->GetEmptyFileFormat (&fmtTemplate));
check(fmtTemplate->AddFormatSpecifier(kAAFSampleRate, 0, NULL));
check(fmtTemplate->AddFormatSpecifier(kAAFMaxSampleBytes, 0, NULL));
check(fmtTemplate->AddFormatSpecifier(kAAFStoredRect, 0, NULL));
check(fmtTemplate->AddFormatSpecifier(kAAFFrameLayout, 0, NULL));
check(pEssenceAccess->GetFileFormat(fmtTemplate, &pFormat));
fmtTemplate->Release();
fmtTemplate = NULL;
aafInt32 fmtBytesRead;
check(pFormat->GetFormatSpecifier(kAAFSampleRate, sizeof(sampleRate),
(aafDataBuffer_t)&sampleRate, &fmtBytesRead));
check(pFormat->GetFormatSpecifier(kAAFMaxSampleBytes, sizeof(maxSampleSize),
(aafDataBuffer_t)&maxSampleSize, &fmtBytesRead));
check(pFormat->GetFormatSpecifier(kAAFStoredRect, sizeof(storedRect),
(aafDataBuffer_t)&storedRect, &fmtBytesRead));
check(pFormat->GetFormatSpecifier(kAAFFrameLayout, sizeof(frameLayout),
(aafDataBuffer_t)&frameLayout, &fmtBytesRead));
pFormat->Release();
pFormat = NULL;
// Get the sample count which is in terms of EditRate
aafLength_t sampleCount;
check(pEssenceAccess->CountSamples(pPictureDef, &sampleCount));
const char *frameLayoutStr = "";
switch (frameLayout)
{
case kAAFFullFrame: frameLayoutStr = "FullFrame"; break;
case kAAFOneField: frameLayoutStr = "OneField"; break;
case kAAFSeparateFields: frameLayoutStr = "SeparateFields"; break;
case kAAFMixedFields: frameLayoutStr = "MixedFields"; break;
default: break;
}
printf("\tSlotID %u: SampleRate=%d/%d MaxSampleBytes=%u StoredRect=%dx%d\n",
MobSlotID, sampleRate.numerator, sampleRate.denominator,
maxSampleSize, storedRect.xSize, storedRect.ySize);
printf("\t\tFrameLayout=%s CountSamples=%"AAFFMT64"d\n", frameLayoutStr, sampleCount);
// Buffer to receive samples from ReadSamples
aafUInt8 *dataBuf = new aafUInt8[maxSampleSize];
// Buffer to recombine separated fields into interleaved fields
aafUInt8 *recombined_buf = new aafUInt8[maxSampleSize];
// Read samples until no more are available
aafUInt32 samplesRead, actualBytesRead, total_samples = 0;
while (true)
{
hr = (pEssenceAccess->ReadSamples(
1, // number of samples to read
maxSampleSize, // maximum buffer size
dataBuf, // output buffer for audio data
&samplesRead, // number of samples read
&actualBytesRead)); // number of bytes read
if (hr == AAFRESULT_EOF)
break;
else
check(hr);
aaf_assert(actualBytesRead != 0, "actualBytesRead != 0");
total_samples += samplesRead;
aafUInt8* saveBuf = dataBuf;
if (comp_enable && frameLayout == kAAFSeparateFields) {
// recombine fields into uncompressed frame when decompressing
recombine_fields(dataBuf, recombined_buf, storedRect.xSize, storedRect.ySize);
saveBuf = recombined_buf;
}
// Write out video
if ( fwrite(saveBuf, maxSampleSize, 1, output) != 1 )
{
perror(output_file);
return 1;
}
}
printf("\tTotal samples=%u - written to %s\n", total_samples, output_file);
delete [] dataBuf;
delete [] recombined_buf;
pEssenceAccess->Release();
pEssenceAccess = NULL;
pMasterMob->Release();
pMasterMob = NULL;
}
pMobSlotIter->Release();
pMobSlotIter = NULL;
pMob->Release();
pMob = NULL;
}
pMobIter->Release();
pMobIter = NULL;
return moduleErrorTmp;
}
static HRESULT ReadAAFFile(aafWChar * pFileName)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IEnumAAFMobs* pMobIter = NULL;
IAAFMob* pMob = NULL;
IAAFSourceMob* pSourceMob = NULL;
IAAFEssenceDescriptor* pEssDesc = NULL;
IAAFDataEssenceDescriptor* pDataEssenceDesc = NULL;
aafNumSlots_t numMobs = 0;
aafUID_t dataEssenceCoding, dataEssTestVal;
HRESULT hr = AAFRESULT_SUCCESS;
try
{
memset(&dataEssTestVal, 0, sizeof(aafUID_t));
// Open the AAF file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
// Get the AAF file header.
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED);
checkResult(pHeader->GetMobs(NULL, &pMobIter));
checkResult(pMobIter->NextOne(&pMob));
checkResult(pMob->QueryInterface(IID_IAAFSourceMob, (void **)&pSourceMob));
// Back into testing mode
checkResult(pSourceMob->GetEssenceDescriptor(&pEssDesc));
// if there is an Essence Descriptor then it MUST be an (essence) DataEssence Descriptor
checkResult(pEssDesc->QueryInterface(IID_IAAFDataEssenceDescriptor, (void **) &pDataEssenceDesc));
checkResult(pDataEssenceDesc->GetDataEssenceCoding(&dataEssenceCoding));
checkExpression(memcmp(&dataEssenceCoding, &dataEssTestVal, sizeof(aafUID_t)) == 0,
AAFRESULT_TEST_FAILED);
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (pDataEssenceDesc)
pDataEssenceDesc->Release();
if (pEssDesc)
pEssDesc->Release();
if (pSourceMob)
pSourceMob->Release();
if (pMob)
pMob->Release();
if (pMobIter)
pMobIter->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{
pFile->Close();
pFile->Release();
}
return hr;
}
void HTMLClipTest::OpenHTMLClip()
{
assert(_pHeader);
HRESULT hr = S_OK;
aafNumSlots_t compositionMobs = 0;
IEnumAAFMobs *pEnumMobs = NULL;
IAAFMob *pReferencingMob = NULL;
IAAFCompositionMob *pCompositionMob = NULL;
aafNumSlots_t mobSlots = 0;
IEnumAAFMobSlots *pEnumSlots = NULL;
IAAFMobSlot *pMobSlot = NULL;
IAAFSegment *pSegment = NULL;
IAAFHTMLClip *pHTMLClip = NULL;
aafUInt32 bufSize = 0;
aafUInt32 actualBufSize = 0;
aafUInt32 actualLength = 0;
wchar_t *pBeginAnchor = NULL;
wchar_t *pEndAnchor = NULL;
IAAFSourceReference *pSourceReference = NULL;
aafMobID_t masterMobID = {0};
IAAFMasterMob *pMasterMob = NULL;
IAAFMob *pReferencedMob = NULL;
try
{
// Get the number of composition mobs in the file (should be one)
checkResult(_pHeader->CountMobs(kAAFCompMob, &compositionMobs));
checkExpression(1 == compositionMobs, AAFRESULT_TEST_FAILED);
// Get the composition mob. There should only be one.
aafSearchCrit_t criteria;
criteria.searchTag = kAAFByMobKind;
criteria.tags.mobKind = kAAFCompMob;
checkResult(_pHeader->GetMobs(&criteria, &pEnumMobs));
checkResult(pEnumMobs->NextOne(&pReferencingMob));
checkResult(pReferencingMob->QueryInterface(IID_IAAFCompositionMob, (void **)&pCompositionMob));
// Get the html clip in the slot. There should be only one.
checkResult(pReferencingMob->CountSlots(&mobSlots));
checkExpression(1 == mobSlots, AAFRESULT_TEST_FAILED);
checkResult(pReferencingMob->GetSlots(&pEnumSlots));
checkResult(pEnumSlots->NextOne(&pMobSlot));
checkResult(pMobSlot->GetSegment(&pSegment));
checkResult(pSegment->QueryInterface(IID_IAAFHTMLClip, (void **)&pHTMLClip));
// Validate the properties...
checkResult(pHTMLClip->GetBeginAnchorBufLen(&bufSize));
actualLength = wcslen(_beginAnchor) + 1;
actualBufSize = actualLength * 2;
checkExpression(bufSize == actualBufSize, AAFRESULT_TEST_FAILED);
pBeginAnchor = new wchar_t[actualLength];
checkExpression(NULL != pBeginAnchor, AAFRESULT_NOMEMORY);
checkResult(pHTMLClip->GetBeginAnchor(pBeginAnchor, actualBufSize));
checkExpression(0 == wcscmp(pBeginAnchor, _beginAnchor), AAFRESULT_TEST_FAILED);
checkResult(pHTMLClip->GetEndAnchorBufLen(&bufSize));
actualLength = wcslen(_endAnchor) + 1;
actualBufSize = actualLength * 2;
checkExpression(bufSize == actualBufSize, AAFRESULT_TEST_FAILED);
pEndAnchor = new wchar_t[actualLength];
checkExpression(NULL != pEndAnchor, AAFRESULT_NOMEMORY);
checkResult(pHTMLClip->GetEndAnchor(pEndAnchor, actualBufSize));
checkExpression(0 == wcscmp(pEndAnchor, _endAnchor), AAFRESULT_TEST_FAILED);
// Attempt to "resolve" the reference and find the master mob.
checkResult(pHTMLClip->QueryInterface(IID_IAAFSourceReference, (void **)&pSourceReference));
checkResult(pSourceReference->GetSourceID(&masterMobID));
checkExpression(0 == memcmp(&masterMobID, &_referencedMobID, sizeof(masterMobID)), AAFRESULT_TEST_FAILED);
checkResult(_pHeader->LookupMob(masterMobID, &pReferencedMob));
checkResult(pReferencedMob->QueryInterface(IID_IAAFMasterMob, (void **)&pMasterMob));
// Use EssenceAccess to read some html essence
// Find the file mob for the html essence.
// Find the corresponding html essence.
// Read some html essence.
}
catch (HRESULT& rHR)
{
hr = rHR;
// fall through and handle cleanup
}
// Cleanup local references
if (pMasterMob)
{
pMasterMob->Release();
pMasterMob = NULL;
}
if (pReferencedMob)
{
pReferencedMob->Release();
pReferencedMob = NULL;
}
if (pSourceReference)
{
pSourceReference->Release();
pSourceReference = NULL;
}
if (pEndAnchor)
{
delete [] pEndAnchor;
pEndAnchor = NULL;
}
if (pBeginAnchor)
{
delete [] pBeginAnchor;
pBeginAnchor = NULL;
}
if (pHTMLClip)
{
pHTMLClip->Release();
pHTMLClip = NULL;
}
if (pSegment)
{
pSegment->Release();
pSegment = NULL;
}
if (pMobSlot)
{
pMobSlot->Release();
pMobSlot = NULL;
}
if (pEnumSlots)
{
pEnumSlots->Release();
pEnumSlots = NULL;
}
if (pCompositionMob)
{
pCompositionMob->Release();
pCompositionMob = NULL;
}
if (pReferencingMob)
{
pReferencingMob->Release();
pReferencingMob = NULL;
}
if (pEnumMobs)
{
pEnumMobs->Release();
pEnumMobs = NULL;
}
// Propogate the error if necessary.
checkResult(hr);
}
static HRESULT OpenAAFFile(aafWChar * pFileName)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFMob* pMob = NULL;
IAAFEssenceAccess* pEssenceAccess = NULL;
IAAFEssenceFormat* pFormat = NULL;
IEnumAAFMobs* pMobIter = NULL;
aafNumSlots_t numMobs, numSlots;
aafSearchCrit_t criteria;
aafMobID_t mobID;
IAAFDataDef *pSoundDef = NULL;
IAAFMobSlot* pMobSlot = NULL;
// Open an AAF file
check(AAFFileOpenExistingRead (pFileName, 0, &pFile));
check(pFile->GetHeader(&pHeader));
// Open raw audio output file
FILE *output;
const char *output_file = "raw.pcm";
if ((output = fopen(output_file, "wb")) == NULL)
{
perror(output_file);
exit(1);
}
// Get the AAF Dictionary from the file
check(pHeader->GetDictionary(&pDictionary));
/* Lookup any necessary data definitions. */
check(pDictionary->LookupDataDef(kAAFDataDef_Sound, &pSoundDef));
/* Check number of Mobs in file */
check(pHeader->CountMobs(kAAFMasterMob, &numMobs));
if (numMobs == 0)
{
printf("No Master Mobs found in AAF file\n");
return 0;
}
printf("Found %d Master Mobs\n", numMobs);
criteria.searchTag = kAAFByMobKind;
criteria.tags.mobKind = kAAFMasterMob;
check(pHeader->GetMobs(&criteria, &pMobIter));
while (AAFRESULT_SUCCESS == pMobIter->NextOne(&pMob))
{
char mobIDstr[256];
aafWChar namebuf[1204];
IAAFTimelineMobSlot* pTimelineMobSlot = NULL;
IAAFDataDef *pDataDef = NULL;
IAAFEssenceFormat *fmtTemplate = NULL;
unsigned char *dataBuff = NULL;
IEnumAAFMobSlots* pMobSlotIter = NULL;
check(pMob->GetMobID (&mobID));
check(pMob->GetName (namebuf, sizeof(namebuf)));
MobIDtoString(mobID, mobIDstr);
printf(" MasterMob Name = '%ls'\n", namebuf);
printf(" (mobID %s)\n", mobIDstr);
// Get the number of slots
check(pMob->CountSlots(&numSlots));
// Iterating through all Mob Slots
check(pMob->GetSlots(&pMobSlotIter));
while(AAFRESULT_SUCCESS == pMobSlotIter->NextOne(&pMobSlot))
{
// Check to see if it is an Audio Timeline Mob Slot
HRESULT hr;
aafUInt32 MobSlotID;
hr=pMobSlot->QueryInterface(IID_IAAFTimelineMobSlot,(void **) &pTimelineMobSlot);
if (SUCCEEDED(hr))
{
check(pMobSlot->GetDataDef(&pDataDef));
// Check that we have a sound file by examining its data definition
aafBool bIsSoundKind = kAAFFalse;
check(pDataDef->IsSoundKind(&bIsSoundKind));
if (kAAFTrue == bIsSoundKind)
{
IAAFMasterMob* pMasterMob = NULL;
// Prepare to get audio data: first get MobSlotID
check(pMobSlot->GetSlotID(&MobSlotID));
// Then get a Master Mob interface
check(pMob->QueryInterface(IID_IAAFMasterMob, (void **)&pMasterMob));
// Open the Essence Data
check(pMasterMob->OpenEssence(MobSlotID,
NULL,
kAAFMediaOpenReadOnly,
kAAFCompressionDisable,
&pEssenceAccess));
// Get the information about the format of the audio data.
// The pFormat object must be setup with each specifier you
// wish to access, otherwise you get AAFRESULT_FORMAT_NOT_FOUND.
aafUInt32 audioSampleBits;
aafRational_t sampleRate;
aafUInt32 numChannels;
aafUInt32 maxSampleBytes;
check(pEssenceAccess->GetEmptyFileFormat(&fmtTemplate));
check(fmtTemplate->AddFormatSpecifier(kAAFAudioSampleBits, 0, NULL));
check(fmtTemplate->AddFormatSpecifier(kAAFSampleRate, 0, NULL));
check(fmtTemplate->AddFormatSpecifier(kAAFNumChannels, 0, NULL));
check(fmtTemplate->AddFormatSpecifier(kAAFMaxSampleBytes, 0, NULL));
check(pEssenceAccess->GetFileFormat(fmtTemplate, &pFormat));
fmtTemplate->Release();
fmtTemplate = NULL;
aafInt32 fmtBytesRead;
check(pFormat->GetFormatSpecifier(kAAFAudioSampleBits, sizeof(audioSampleBits),
(aafDataBuffer_t)&audioSampleBits, &fmtBytesRead));
check(pFormat->GetFormatSpecifier(kAAFSampleRate, sizeof(sampleRate),
(aafDataBuffer_t)&sampleRate, &fmtBytesRead));
check(pFormat->GetFormatSpecifier(kAAFNumChannels, sizeof(numChannels),
(aafDataBuffer_t)&numChannels, &fmtBytesRead));
check(pFormat->GetFormatSpecifier(kAAFMaxSampleBytes, sizeof(maxSampleBytes),
(aafDataBuffer_t)&maxSampleBytes, &fmtBytesRead));
pFormat->Release();
pFormat = NULL;
// Get the sample count which is in terms of EditRate
aafLength_t sampleCount;
check(pEssenceAccess->CountSamples(pSoundDef, &sampleCount));
printf("\tSlotID %u: SampleBits=%d SampleRate=%d/%d NumChannels=%d MaxSampleBytes=%u\n",
MobSlotID,
audioSampleBits, sampleRate.numerator, sampleRate.denominator,
numChannels, maxSampleBytes);
printf("\t\tCountSamples=%"AAFFMT64"d\n", sampleCount);
// Set a suitable buffer size
dataBuff = new unsigned char[maxSampleBytes];
// Read samples until no more are available
aafUInt32 samplesRead, actualBytesRead, total_samples = 0;
while (true)
{
hr = (pEssenceAccess->ReadSamples(
1, // number of samples to read
maxSampleBytes, // maximum buffer size
dataBuff, // output buffer for audio data
&samplesRead, // number of samples read
&actualBytesRead)); // number of bytes read
if (hr == AAFRESULT_EOF)
break;
else
check(hr);
if (actualBytesRead!=0)
{
total_samples += samplesRead;
// Write out samples
if ( fwrite(dataBuff, maxSampleBytes, 1, output) != 1 )
{
perror(output_file);
return 1;
}
}
}
printf("\tTotal samples = %u (written to %s)\n", total_samples, output_file);
delete [] dataBuff;
dataBuff = NULL;
pEssenceAccess->Release();
pEssenceAccess = NULL;
pMasterMob->Release();
pMasterMob = NULL;
}
pTimelineMobSlot->Release();
pTimelineMobSlot = NULL;
pDataDef->Release();
pDataDef = NULL;
}
pMobSlot->Release();
pMobSlot = NULL;
}
pMobSlotIter->Release();
pMobSlotIter = NULL;
pMob->Release();
pMob = NULL;
}
pMobIter->Release();
pMobIter = NULL;
return moduleErrorTmp;
}
static HRESULT ReadAAFFile(aafWChar * pFileName)
{
IAAFDictionary *pDictionary = NULL;
IAAFFile *pFile = NULL;
bool bFileOpen = false;
IAAFHeader *pHeader = NULL;
IEnumAAFMobs *mobIter = NULL;
IAAFMob *aMob = NULL;
IEnumAAFMobSlots *slotIter = NULL;
IAAFMobSlot *slot = NULL;
aafNumSlots_t numMobs, n, s;
HRESULT hr = S_OK;
aafUInt32 bufLen = 0;
aafUInt32 bytesRead = 0;
aafUInt32 numFound = 0;
aafWChar value[500];
IEnumAAFTaggedValues *enumTaggedVal = NULL;
IAAFTaggedValue *taggedVal = NULL;
aafUID_t testKey;
IEnumAAFKLVData *klvEnum = NULL;
IAAFKLVData *pKLVData = NULL;
IAAFTypeDef* pBaseType = NULL;
IAAFSourceClip *pSourceClip = NULL;
IAAFSourceReference *pSourceRef = NULL;
IAAFSegment *pSegment = NULL;
aafMobID_t sourceID;
int i;
try
{
// Open the file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// We can't really do anthing in AAF without the header.
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->GetDictionary(&pDictionary));
CAAFBuiltinDefs defs (pDictionary);
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED);
aafSearchCrit_t criteria;
criteria.searchTag = kAAFNoSearch;
checkResult(pHeader->GetMobs (&criteria, &mobIter));
for(n = 0; n < numMobs; n++)
{
aafWChar name[500], slotName[500];
aafNumSlots_t numSlots;
aafMobID_t mobID;
aafSlotID_t trackID;
aafUInt32 nameBufLen = 0;
checkResult(mobIter->NextOne (&aMob));
// Check GetNameBufLen and GetName
checkExpression(aMob->GetNameBufLen(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED);
checkResult(aMob->GetNameBufLen(&nameBufLen));
checkExpression(((wcslen(mobName) + 1) * sizeof(aafCharacter)) == nameBufLen, AAFRESULT_TEST_FAILED);
checkExpression(aMob->GetName (NULL, nameBufLen) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED);
checkExpression(aMob->GetName (name, 4) == AAFRESULT_SMALLBUF, AAFRESULT_TEST_FAILED);
checkResult(aMob->GetName (name, nameBufLen));
checkExpression (wcscmp(mobName, name) == 0, AAFRESULT_TEST_FAILED);
// Check GetMobID
checkExpression(aMob->GetMobID (NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED);
checkResult(aMob->GetMobID (&mobID));
checkExpression(memcmp(&MOBTestID, &mobID, sizeof(mobID)) == 0, AAFRESULT_TEST_FAILED);
// Check the time stamps
aafTimeStamp_t created = { {0,0,0}, {0,0,0,0} };
checkExpression(aMob->GetCreateTime(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED);
checkResult(aMob->GetCreateTime(&created));
checkTimeStampsAreEqual(creationTimeStamp, created);
aafTimeStamp_t modified = { {0,0,0}, {0,0,0,0} };
checkExpression(aMob->GetModTime(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED);
checkResult(aMob->GetModTime(&modified));
checkTimeStampsAreEqual(modificationTimeStamp, modified);
// Check the GetMobInfo data.
memset(&created, 0, sizeof(created));
memset(&modified, 0, sizeof(modified));
checkExpression(aMob->GetMobInfo(NULL, &created,
name, sizeof(name)) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkExpression(aMob->GetMobInfo(&modified, NULL,
name, sizeof(name)) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkExpression(aMob->GetMobInfo(&modified, &created,
NULL, sizeof(name)) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkExpression(aMob->GetMobInfo(&modified, &created,
name, 1) == AAFRESULT_SMALLBUF,
AAFRESULT_TEST_FAILED);
checkResult(aMob->GetMobInfo(&modified, &created, name, sizeof(name)));
checkTimeStampsAreEqual(creationTimeStamp, created);
checkTimeStampsAreEqual(modificationTimeStamp, modified);
checkExpression (wcscmp(mobName, name) == 0, AAFRESULT_TEST_FAILED);
checkExpression(aMob->CountSlots (NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED);
checkResult(aMob->CountSlots (&numSlots));
//seven slots made by IAAFMob and one static slot and event slot made throught IAAFMOb2
checkExpression((7+1+1) == numSlots, AAFRESULT_TEST_FAILED);
checkExpression(aMob->GetSlots(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED);
checkResult(aMob->GetSlots(&slotIter));
for(s = 0; s < numSlots; s++)
{
checkResult(slotIter->NextOne (&slot));
checkResult(slot->GetNameBufLen(&bufLen));
checkResult(slot->GetName (slotName, bufLen));
checkResult(slot->GetSlotID(&trackID));
checkExpression (wcscmp(slotName, slotNames[s]) == 0, AAFRESULT_TEST_FAILED);
checkExpression(trackID == (s+1), AAFRESULT_TEST_FAILED);
slot->Release();
slot = NULL;
bufLen = 0;
trackID = 0;
}
slotIter->Release();
slotIter = NULL;
// GetSlotAt
checkExpression(aMob->GetSlotAt(1, NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkExpression(aMob->GetSlotAt(9, &slot) == AAFRESULT_BADINDEX,
AAFRESULT_TEST_FAILED);
for (s = 0; s < numSlots; ++s)
{
checkResult(aMob->GetSlotAt(s, &slot));
checkResult(slot->GetNameBufLen(&bufLen));
checkResult(slot->GetName(slotName, bufLen));
checkResult(slot->GetSlotID(&trackID));
checkExpression(wcscmp(slotName, slotNames[s]) == 0, AAFRESULT_TEST_FAILED);
checkExpression(trackID == (s+1), AAFRESULT_TEST_FAILED);
if ( 0 < s && s < 5 ) // These are the SourceClips
{
checkResult(slot->GetSegment(&pSegment));
checkResult(pSegment->QueryInterface (IID_IAAFSourceClip, (void **)&pSourceClip));
checkResult(pSourceClip->QueryInterface (IID_IAAFSourceReference, (void **)&pSourceRef));
checkResult(pSourceRef->GetSourceID(&sourceID));
checkExpression(memcmp(&sourceID, &MOBTestID3, sizeof(aafMobID_t)) == 0,
AAFRESULT_TEST_FAILED);
pSourceRef->Release();
pSourceRef = NULL;
pSourceClip->Release();
pSourceClip = NULL;
pSegment->Release();
pSegment = NULL;
}
slot->Release();
slot = NULL;
bufLen = 0;
trackID = 0;
}
// ChangeRef
checkResult(aMob->ChangeRef(MOBTestID3, MOBTestID4));
for (s = 1; s < 5; ++s) // These are the SourceClips
{
checkResult(aMob->GetSlotAt(s, &slot));
checkResult(slot->GetSegment(&pSegment));
checkResult(pSegment->QueryInterface (IID_IAAFSourceClip, (void **)&pSourceClip));
checkResult(pSourceClip->QueryInterface (IID_IAAFSourceReference, (void **)&pSourceRef));
checkResult(pSourceRef->GetSourceID(&sourceID));
checkExpression(memcmp(&sourceID, &MOBTestID4, sizeof(aafMobID_t)) == 0,
AAFRESULT_TEST_FAILED);
pSourceRef->Release();
pSourceRef = NULL;
pSourceClip->Release();
pSourceClip = NULL;
pSegment->Release();
pSegment = NULL;
slot->Release();
slot = NULL;
}
// try it again with a MobID it won't find. Make sure nothing changes
checkResult(aMob->ChangeRef(MOBTestID3, MOBTestID2));
for (s = 1; s < 5; ++s) // These are the SourceClips
{
checkResult(aMob->GetSlotAt(s, &slot));
checkResult(slot->GetSegment(&pSegment));
checkResult(pSegment->QueryInterface (IID_IAAFSourceClip, (void **)&pSourceClip));
checkResult(pSourceClip->QueryInterface (IID_IAAFSourceReference, (void **)&pSourceRef));
checkResult(pSourceRef->GetSourceID(&sourceID));
checkExpression(memcmp(&sourceID, &MOBTestID4, sizeof(aafMobID_t)) == 0,
AAFRESULT_TEST_FAILED);
pSourceRef->Release();
pSourceRef = NULL;
pSourceClip->Release();
pSourceClip = NULL;
pSegment->Release();
pSegment = NULL;
slot->Release();
slot = NULL;
}
// LookUpSlot
checkResult(aMob->LookupSlot(4, &slot));
checkResult(slot->GetSegment(&pSegment));
checkResult(pSegment->QueryInterface (IID_IAAFSourceClip, (void **)&pSourceClip));
checkResult(pSourceClip->QueryInterface (IID_IAAFSourceReference, (void **)&pSourceRef));
checkResult(pSourceRef->GetSourceID(&sourceID));
checkResult(slot->GetNameBufLen(&bufLen));
checkResult(slot->GetName(slotName, bufLen));
checkResult(slot->GetSlotID(&trackID));
checkExpression(wcscmp(slotName, slotNames[3]) == 0, AAFRESULT_TEST_FAILED);
checkExpression(trackID == (4), AAFRESULT_TEST_FAILED);
pSourceRef->Release();
pSourceRef = NULL;
pSourceClip->Release();
pSourceClip = NULL;
pSegment->Release();
pSegment = NULL;
slot->Release();
slot = NULL;
checkExpression(aMob->LookupSlot(10, &slot) == AAFRESULT_SLOT_NOT_FOUND,
AAFRESULT_TEST_FAILED);
checkExpression(aMob->LookupSlot(0, NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
// OffsetToMobTimecode
// 7/5/00 - this method is broken so the tests that will
// make it fail have been commented out. This module test
// will still report Partial Success until implementation has been fixed
aafPosition_t offset = 1;
aafTimecode_t timecode;
// initialize timecode values
timecode.startFrame = 0;
timecode.drop = kAAFTcDrop;
timecode.fps = 24;
checkResult(aMob->LookupSlot(6, &slot));
checkResult(slot->GetSegment(&pSegment));
checkResult(aMob->OffsetToMobTimecode(pSegment, &offset, &timecode));
checkExpression(timecode.startFrame == (TCstartFrame + offset), AAFRESULT_TEST_FAILED);
checkExpression(timecode.drop == TCdrop, AAFRESULT_TEST_FAILED);
checkExpression(timecode.fps == TCfps, AAFRESULT_TEST_FAILED);
checkExpression(aMob->OffsetToMobTimecode(pSegment, NULL, &timecode) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkExpression(aMob->OffsetToMobTimecode(pSegment, &offset, NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
// reinitialize values
timecode.startFrame = 0;
timecode.drop = kAAFTcDrop;
timecode.fps = 24;
// According to IDL this should search for the slot containing the timecode segment
checkResult(aMob->OffsetToMobTimecode(NULL, &offset, &timecode));
checkExpression(timecode.startFrame == (TCstartFrame + offset), AAFRESULT_TEST_FAILED);
checkExpression(timecode.drop == TCdrop, AAFRESULT_TEST_FAILED);
checkExpression(timecode.fps == TCfps, AAFRESULT_TEST_FAILED);
pSegment->Release();
pSegment = NULL;
slot->Release();
slot = NULL;
// Pass in a segment that is not a timecode and make sure it returns correct hr
checkResult(aMob->LookupSlot(1, &slot));
checkResult(slot->GetSegment(&pSegment));
checkExpression(aMob->OffsetToMobTimecode(pSegment, &offset, &timecode) == AAFRESULT_TIMECODE_NOT_FOUND,
AAFRESULT_TEST_FAILED);
pSegment->Release();
pSegment = NULL;
slot->Release();
slot = NULL;
// GetKLVData
checkResult(pDictionary->LookupTypeDef (kAAFTypeID_UInt8Array, &pBaseType));
checkResult(pDictionary->RegisterKLVDataKey(TEST_KLV, pBaseType));
pBaseType->Release();
pBaseType = NULL;
checkResult(aMob->CountKLVData(&numFound));
checkExpression(numFound == 2, AAFRESULT_TEST_FAILED);
checkResult(aMob->GetKLVData(&klvEnum));
checkResult(klvEnum->NextOne(&pKLVData));
checkResult(pKLVData->GetValueBufLen(&bufLen));
checkExpression(sizeof(KLVfrowney) == bufLen, AAFRESULT_TEST_FAILED);
checkResult(pKLVData->GetValue( sizeof(value), (unsigned char *)value, &bytesRead));
checkExpression(memcmp(value, KLVfrowney, sizeof(KLVfrowney)) == 0, AAFRESULT_TEST_FAILED);
checkResult(pKLVData->GetKey(&testKey));
checkExpression(memcmp(&testKey, &TEST_KLV, sizeof(aafUID_t)) == 0, AAFRESULT_TEST_FAILED);
pKLVData->Release();
pKLVData = NULL;
checkResult(klvEnum->NextOne(&pKLVData));
checkResult(pKLVData->GetValueBufLen(&bufLen));
checkExpression(sizeof(KLVsmiley) == bufLen, AAFRESULT_TEST_FAILED);
checkResult(pKLVData->GetValue( sizeof(value), (unsigned char *)value, &bytesRead));
checkExpression(memcmp(value, KLVsmiley, sizeof(KLVsmiley)) == 0, AAFRESULT_TEST_FAILED);
checkResult(pKLVData->GetKey(&testKey));
checkExpression(memcmp(&testKey, &TEST_KLV, sizeof(aafUID_t)) == 0, AAFRESULT_TEST_FAILED);
pKLVData->Release();
pKLVData = NULL;
klvEnum->Release();
klvEnum = NULL;
checkExpression(aMob->GetKLVData(NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
// Check the comments
checkResult(aMob->GetComments(&enumTaggedVal));
for (i = 0; i < 5; ++i)
{
if (i==2)
continue;
checkResult(enumTaggedVal->NextOne(&taggedVal));
checkResult(taggedVal->GetNameBufLen(&bufLen));
checkResult(taggedVal->GetName(name, bufLen));
checkExpression(wcscmp(name, pCategory[i]) == 0, AAFRESULT_TEST_FAILED);
checkResult(taggedVal->GetValueBufLen(&bufLen));
checkResult(taggedVal->GetValue(bufLen, (aafDataBuffer_t)value, &bytesRead));
checkExpression(wcscmp(value, pComment[i]) == 0, AAFRESULT_TEST_FAILED);
taggedVal->Release();
taggedVal = NULL;
}
// Check attributes and usage code.
// Need IAAFMob2 for that;
IAAFMob2* aMobInterface2 = 0;
checkResult( aMob->QueryInterface( IID_IAAFMob2, reinterpret_cast<void**>(&aMobInterface2) ) );
IEnumAAFTaggedValues* pAttributesEnum = 0;
checkResult( aMobInterface2->GetAttributes( &pAttributesEnum ) );
int attributeCount = 0;
HRESULT atthr = AAFRESULT_SUCCESS;
IAAFTaggedValue* pAttribute = 0;
for( atthr = pAttributesEnum->NextOne( &pAttribute );
atthr == AAFRESULT_SUCCESS;
atthr = pAttributesEnum->NextOne( &pAttribute ) ) {
aafUInt32 bufLen = 0;
checkResult( pAttribute->GetNameBufLen(&bufLen) );
// "name" is 500 chars long... sized more than
// large enough for a simple test.
checkExpression( attributeCount < 2, AAFRESULT_TEST_FAILED );
checkResult( pAttribute->GetName( name, bufLen ) );
checkExpression( wcscmp(name, AttributeNames[attributeCount] ) == 0, AAFRESULT_TEST_FAILED );
// check the value
IAAFTypeDef* pAttributeTypeDef = NULL;
checkResult( pAttribute->GetTypeDefinition( &pAttributeTypeDef ) );
// It should be a string.
IAAFTypeDefString* pTDString = NULL;
checkResult( pAttributeTypeDef->QueryInterface( IID_IAAFTypeDefString, reinterpret_cast<void**>(&pTDString) ) );
checkResult( pAttribute->GetValue( sizeof(name),
reinterpret_cast<aafDataBuffer_t>(name), &bufLen ) );
checkExpression( wcscmp( AttributeValues[attributeCount], name ) == 0, AAFRESULT_TEST_FAILED );
pAttributeTypeDef->Release();
pAttributeTypeDef = NULL;
pTDString->Release();
pTDString = NULL;
pAttribute->Release();
pAttribute = NULL;
attributeCount++;
}
checkExpression( 2 == attributeCount && atthr == AAFRESULT_NO_MORE_OBJECTS,
AAFRESULT_TEST_FAILED );
aafUID_t code;
checkResult( aMobInterface2->GetUsageCode( &code ) );
checkExpression( memcmp( &code, &kAAFUsage_SubClip, sizeof(code) ) == 0, AAFRESULT_TEST_FAILED );
pAttributesEnum->Release();
pAttributesEnum = NULL;
enumTaggedVal->Release();
enumTaggedVal = NULL;
aMobInterface2->Release();
aMobInterface2 = NULL;
aMob->Release();
aMob = NULL;
}
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup object references
if (slot)
slot->Release();
if (slotIter)
slotIter->Release();
if (aMob)
aMob->Release();
if (mobIter)
mobIter->Release();
if (pHeader)
pHeader->Release();
if (pDictionary)
pDictionary->Release();
if (pFile)
{ // Close file
if (bFileOpen)
pFile->Close();
pFile->Release();
}
return hr;
}
static HRESULT CreateAAFFile(
aafWChar * pFileName,
aafUID_constref fileKind,
testRawStorageType_t rawStorageType,
aafProductIdentification_constref productID)
{
IAAFFile * pFile = NULL;
bool bFileOpen = false;
IAAFHeader * pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFMob *pMob = NULL;
IAAFMob *pMob2 = NULL;
IAAFMob2 *pMobInterface2 = NULL;
IAAFTimelineMobSlot *newSlot = NULL;
IAAFStaticMobSlot *newStaticSlot=NULL;
IAAFEventMobSlot *newEventSlot=NULL;
IAAFSegment *seg = NULL;
IAAFSourceClip *sclp = NULL;
IAAFEvent *event=NULL;
IAAFComponent* pComponent = NULL;
IAAFClassDef *pcdEventMeta=NULL;
IAAFClassDef *pcdEvent=NULL;
IAAFClassDef *pcdEventConcrete=NULL;
HRESULT hr = S_OK;
aafNumSlots_t numMobs;
aafUInt32 bufLen = 0;
aafUInt32 bytesRead = 0;
aafUInt32 numComments = 0;
aafUInt32 numFound = 0;
aafWChar name[500];
aafWChar value[500];
IEnumAAFTaggedValues *enumTaggedVal = NULL;
IAAFTaggedValue *taggedVal = NULL;
IAAFMobSlot *mSlot = NULL;
IAAFFiller *filler = NULL;
IAAFKLVData *pKLVData = NULL;
IAAFTypeDef* pBaseType = NULL;
IAAFSourceReference *pSourceRef = NULL;
IAAFTimecode *pTimecode = NULL;
aafTimecode_t timecode;
int i;
try
{
// Remove the previous test file if any.
RemoveTestFile(pFileName);
// Create the file.
checkResult(CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile ));
bFileOpen = true;
// We can't really do anthing in AAF without the header.
checkResult(pFile->GetHeader(&pHeader));
// Get the AAF Dictionary so that we can create valid AAF objects.
checkResult(pHeader->GetDictionary(&pDictionary));
CAAFBuiltinDefs defs (pDictionary);
//Make the first mob
long test;
// Create a concrete subclass of Mob
checkResult(defs.cdMasterMob()->
CreateInstance(IID_IAAFMob,
(IUnknown **)&pMob));
checkResult( pMob->QueryInterface(IID_IAAFMob2,(void**)&pMobInterface2));
checkResult(pMob->SetMobID(MOBTestID));
checkExpression(pMob->GetNameBufLen(&bufLen) == AAFRESULT_PROP_NOT_PRESENT, AAFRESULT_TEST_FAILED);
checkExpression(pMob->GetName(name, 0) == AAFRESULT_PROP_NOT_PRESENT, AAFRESULT_TEST_FAILED);
checkExpression(pMob->SetName(NULL) == AAFRESULT_NULL_PARAM, AAFRESULT_TEST_FAILED);
checkResult(pMob->SetName(mobName));
checkResult(pMob->SetCreateTime(creationTimeStamp));
checkResult(pMob->SetModTime(modificationTimeStamp));
// Add some slots
for(test = 1; test < 6; test++)
{
checkResult(defs.cdSourceClip()->
CreateInstance(IID_IAAFSourceClip,
(IUnknown **)&sclp));
checkResult(sclp->QueryInterface(IID_IAAFSourceReference, (void **)&pSourceRef));
checkResult(pSourceRef->SetSourceID(MOBTestID3));
checkResult(sclp->QueryInterface(IID_IAAFComponent, (void **)&pComponent));
checkResult(pComponent->SetDataDef(defs.ddkAAFPicture()));
checkResult(sclp->QueryInterface (IID_IAAFSegment, (void **)&seg));
aafRational_t editRate = { 0, 1};
checkResult(pMob->AppendNewTimelineSlot (editRate,
seg,
test+1,
slotNames[test],
0,
&newSlot));
if(test == 5)
{
checkExpression(pMob->AppendNewTimelineSlot (editRate,
NULL,
test+1,
slotNames[test],
0,
&newSlot) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkExpression(pMob->AppendNewTimelineSlot (editRate,
seg,
test+1,
NULL,
0,
&newSlot) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkExpression(pMob->AppendNewTimelineSlot (editRate,
seg,
test+1,
slotNames[test],
0,
NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
pMob->RemoveSlotAt(4);
checkExpression(pMob->RemoveSlotAt(test+1) == AAFRESULT_BADINDEX,
AAFRESULT_TEST_FAILED);
}
newSlot->Release();
newSlot = NULL;
if(newStaticSlot)
newStaticSlot->Release();
newStaticSlot = NULL;
seg->Release();
seg = NULL;
sclp->Release();
sclp = NULL;
pComponent->Release();
pComponent = NULL;
pSourceRef->Release();
pSourceRef = NULL;
}
// PrependSlot
checkResult(defs.cdStaticMobSlot()->
CreateInstance(IID_IAAFMobSlot,
(IUnknown **)&mSlot));
checkResult(defs.cdFiller()->
CreateInstance(IID_IAAFFiller,
(IUnknown **)&filler));
checkResult(filler->Initialize(defs.ddkAAFSound(), 10));
checkResult(filler->QueryInterface (IID_IAAFSegment, (void **)&seg));
checkResult(mSlot->SetName(slotNames[0]));
checkResult(mSlot->SetPhysicalNum(1));
checkResult(mSlot->SetSlotID(1));
checkResult(mSlot->SetSegment(seg));
checkResult(pMob->PrependSlot(mSlot));
checkExpression(pMob->PrependSlot(mSlot) == AAFRESULT_OBJECT_ALREADY_ATTACHED,
AAFRESULT_TEST_FAILED);
checkExpression(pMob->PrependSlot(NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
mSlot->Release();
mSlot = NULL;
seg->Release();
seg = NULL;
filler->Release();
filler = NULL;
// AppendSlot
checkResult(defs.cdStaticMobSlot()->
CreateInstance(IID_IAAFMobSlot,
(IUnknown **)&mSlot));
checkResult(defs.cdFiller()->
CreateInstance(IID_IAAFFiller,
(IUnknown **)&filler));
checkResult(filler->Initialize(defs.ddkAAFSound(), 10));
checkResult(filler->QueryInterface (IID_IAAFSegment, (void **)&seg));
checkResult(mSlot->SetName(slotNames[6]));
checkResult(mSlot->SetPhysicalNum(1));
checkResult(mSlot->SetSlotID(7));
checkResult(mSlot->SetSegment(seg));
checkResult(pMob->AppendSlot(mSlot));
checkExpression(pMob->AppendSlot(mSlot) == AAFRESULT_OBJECT_ALREADY_ATTACHED,
AAFRESULT_TEST_FAILED);
checkExpression(pMob->AppendSlot(NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
mSlot->Release();
mSlot = NULL;
seg->Release();
seg = NULL;
filler->Release();
filler = NULL;
// InsertSlotAt -- insert a timecode object for OffsetToMobTimecode() testing
timecode.startFrame = TCstartFrame; // One hour
timecode.drop = TCdrop;
timecode.fps = TCfps;
checkResult(defs.cdTimecode()->
CreateInstance(IID_IAAFTimecode,
(IUnknown **)&pTimecode));
checkResult(pTimecode->Initialize(100, &timecode));
checkResult(pTimecode->QueryInterface (IID_IAAFSegment, (void **)&seg));
assert(pComponent == NULL);
checkResult(pTimecode->QueryInterface(IID_IAAFComponent,(void **)&pComponent));
checkResult(pComponent->SetDataDef(defs.ddkAAFTimecode()));
pComponent->Release();
pComponent = NULL;
checkResult(defs.cdStaticMobSlot()->
CreateInstance(IID_IAAFMobSlot,
(IUnknown **)&mSlot));
checkResult(mSlot->SetName(slotNames[5]));
checkResult(mSlot->SetPhysicalNum(1));
checkResult(mSlot->SetSlotID(6));
checkResult(mSlot->SetSegment(seg));
checkExpression(pMob->InsertSlotAt(8, mSlot) == AAFRESULT_BADINDEX,
AAFRESULT_TEST_FAILED);
checkResult(pMob->InsertSlotAt(5, mSlot));
checkExpression(pMob->InsertSlotAt(4, mSlot) == AAFRESULT_OBJECT_ALREADY_ATTACHED,
AAFRESULT_TEST_FAILED);
checkExpression(pMob->InsertSlotAt(1, NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
mSlot->Release();
mSlot = NULL;
seg->Release();
seg = NULL;
pTimecode->Release();
pTimecode = NULL;
//now test AppendNewStaticSlot
checkResult(defs.cdSourceClip()->
CreateInstance(IID_IAAFSourceClip,
(IUnknown **)&sclp));
checkResult(sclp->QueryInterface(IID_IAAFSourceReference, (void **)&pSourceRef));
checkResult(pSourceRef->SetSourceID(MOBTestID_Static));
checkResult(sclp->QueryInterface(IID_IAAFComponent, (void **)&pComponent));
checkResult(pComponent->SetDataDef(defs.ddkAAFPicture()));
checkResult(sclp->QueryInterface (IID_IAAFSegment, (void **)&seg));
checkResult(pMobInterface2->AppendNewStaticSlot ( seg,
8,
slotNames[7],
&newStaticSlot));
if(newStaticSlot)
newStaticSlot->Release();
newStaticSlot = NULL;
seg->Release();
seg = NULL;
pSourceRef->Release();
pSourceRef = NULL;
sclp->Release();
sclp = NULL;
pComponent->Release();
pComponent = NULL;
//now test AppendNewEventSlot
//Create a concrete version of IAAFEvent
checkResult (pDictionary->CreateMetaInstance (AUID_AAFClassDef, IID_IAAFClassDef, (IUnknown**) &pcdEventMeta));
checkResult (pDictionary->LookupClassDef (AUID_AAFEvent, &pcdEvent));
checkResult (pcdEventMeta->Initialize (kClassID_ConcreteEvent, pcdEvent, L"COncreteEvent", kAAFTrue));
checkResult (pDictionary->RegisterClassDef (pcdEventMeta));
//Now instantiate it
checkResult(pDictionary->LookupClassDef(kClassID_ConcreteEvent, &pcdEventConcrete));
checkResult(pcdEventConcrete->CreateInstance(IID_IAAFEvent, (IUnknown **)&event));
//and initialize reqruied properties
checkResult(event->QueryInterface(IID_IAAFComponent, (void **)&pComponent));
checkResult(pComponent->SetDataDef(defs.ddkAAFPicture()));
event->SetPosition(1);
aafRational_t EventeditRate = { 0, 1};
//get the segment
checkResult(event->QueryInterface (IID_IAAFSegment, (void **)&seg));
checkResult(pMobInterface2->AppendNewEventSlot ( EventeditRate,
seg,
9,
slotNames[8],
0,
&newEventSlot));
if(newEventSlot)
newEventSlot->Release();
newEventSlot = NULL;
seg->Release();
seg = NULL;
pComponent->Release();
pComponent = NULL;
event->Release();
event = NULL;
pcdEventConcrete->Release();
pcdEventConcrete = NULL;
pcdEvent->Release();
pcdEvent = NULL;
pcdEventMeta->Release();
pcdEventMeta = NULL;
// Try CountKLVData before any have been attached
numFound = 1;
checkResult(pMob->CountKLVData(&numFound));
checkExpression(numFound == 0, AAFRESULT_TEST_FAILED);
checkExpression(pMob->CountKLVData(NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
// AppendKLVData - attach some objects
checkResult(pDictionary->LookupTypeDef (kAAFTypeID_UInt8Array, &pBaseType));
checkResult(pDictionary->RegisterKLVDataKey(TEST_KLV, pBaseType));
pBaseType->Release();
pBaseType = NULL;
checkExpression(pMob->AppendKLVData(NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkResult(defs.cdKLVData()->
CreateInstance(IID_IAAFKLVData,
(IUnknown **)&pKLVData));
checkResult(pKLVData->Initialize(TEST_KLV, sizeof(KLVfrowney),
(unsigned char *)KLVfrowney));
checkResult(pMob->AppendKLVData(pKLVData));
pKLVData->Release();
pKLVData = NULL;
checkResult(defs.cdKLVData()->
CreateInstance(IID_IAAFKLVData,
(IUnknown **)&pKLVData));
checkResult(pKLVData->Initialize(TEST_KLV, sizeof(KLVfrowney),
(unsigned char *)KLVfrowney));
checkResult(pMob->AppendKLVData(pKLVData));
checkExpression(pMob->AppendKLVData(pKLVData) == AAFRESULT_OBJECT_ALREADY_ATTACHED,
AAFRESULT_TEST_FAILED);
// RemoveKLVData - remove object #2
checkExpression(pMob->RemoveKLVData(NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkResult(pMob->CountKLVData(&numFound));
checkExpression(numFound == 2, AAFRESULT_TEST_FAILED);
checkResult(pMob->RemoveKLVData(pKLVData));
checkResult(pMob->CountKLVData(&numFound));
checkExpression(numFound == 1, AAFRESULT_TEST_FAILED);
pKLVData->Release();
pKLVData = NULL;
// Try removing an object that is not attached
checkResult(defs.cdKLVData()->
CreateInstance(IID_IAAFKLVData,
(IUnknown **)&pKLVData));
checkResult(pKLVData->Initialize(TEST_KLV, sizeof(KLVsmiley),
(unsigned char *)KLVsmiley));
checkExpression(pMob->RemoveKLVData(pKLVData) == AAFRESULT_OBJECT_NOT_ATTACHED,
AAFRESULT_TEST_FAILED);
// Attach it to replace the one removed
checkResult(pMob->AppendKLVData(pKLVData));
pKLVData->Release();
pKLVData = NULL;
// Comments
checkExpression(pMob->GetComments(&enumTaggedVal) == AAFRESULT_PROP_NOT_PRESENT,
AAFRESULT_TEST_FAILED);
// Check CountComments()
checkExpression(pMob->CountComments(NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
numComments = 1;
checkResult(pMob->CountComments(&numComments));
checkExpression(numComments == 0, AAFRESULT_TEST_FAILED);
// Check AppendComments()
checkExpression(pMob->AppendComment(NULL, pComment[0]) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkExpression(pMob->AppendComment(const_cast<aafWChar*>(pCategory[0]), NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
for (i = 0; i < 5; ++i)
{
checkResult(pMob->AppendComment(const_cast<aafWChar*>(pCategory[i]), pComment[i]));
}
checkResult(pMob->CountComments(&numComments));
checkExpression(numComments == 5, AAFRESULT_TEST_FAILED);
// Check GetComments()
checkExpression(pMob->GetComments(NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkResult(pMob->GetComments(&enumTaggedVal));
for (i = 0; i < 5; ++i)
{
checkResult(enumTaggedVal->NextOne(&taggedVal));
checkResult(taggedVal->GetNameBufLen(&bufLen));
checkResult(taggedVal->GetName(name, bufLen));
checkExpression(wcscmp(name, pCategory[i]) == 0, AAFRESULT_TEST_FAILED);
checkResult(taggedVal->GetValueBufLen(&bufLen));
checkResult(taggedVal->GetValue(bufLen, (aafDataBuffer_t)value, &bytesRead));
checkExpression(wcscmp(value, pComment[i]) == 0, AAFRESULT_TEST_FAILED);
taggedVal->Release();
taggedVal = NULL;
}
checkResult(defs.cdTaggedValue()->
CreateInstance(IID_IAAFTaggedValue,
(IUnknown **)&taggedVal));
checkExpression(pMob->RemoveComment(taggedVal) == AAFRESULT_OBJECT_NOT_ATTACHED,
AAFRESULT_TEST_FAILED);
taggedVal->Release();
taggedVal = NULL;
enumTaggedVal->Reset();
enumTaggedVal->Skip(2);
checkResult(enumTaggedVal->NextOne(&taggedVal));
checkExpression(pMob->RemoveComment(NULL) == AAFRESULT_NULL_PARAM,
AAFRESULT_TEST_FAILED);
checkResult(pMob->RemoveComment(taggedVal));
taggedVal->Release();
taggedVal = NULL;
enumTaggedVal->Reset();
for (i = 0; i < 5; ++i)
{
if (i==2)
continue;
checkResult(enumTaggedVal->NextOne(&taggedVal));
checkResult(taggedVal->GetNameBufLen(&bufLen));
checkResult(taggedVal->GetName(name, bufLen));
checkExpression(wcscmp(name, pCategory[i]) == 0, AAFRESULT_TEST_FAILED);
checkResult(taggedVal->GetValueBufLen(&bufLen));
checkResult(taggedVal->GetValue(bufLen, (aafDataBuffer_t)value, &bytesRead));
checkExpression(wcscmp(value, pComment[i]) == 0, AAFRESULT_TEST_FAILED);
taggedVal->Release();
taggedVal = NULL;
}
enumTaggedVal->Release();
enumTaggedVal = NULL;
// Check the Mob2 attribute and usage code implementations.
// Need IAAFMob2 for that;
checkResult( pMobInterface2->AppendAttribute( AttributeNames[0], AttributeValues[0] ) );
checkResult( pMobInterface2->AppendAttribute( AttributeNames[1], AttributeValues[1] ) );
checkResult( pMobInterface2->SetUsageCode( kAAFUsage_SubClip ) );
// Add the mob to the file.
checkResult(pHeader->AddMob(pMob));
// Test changing the mob id after the mob is attached to the
// content store. Change it, then reset to the original id.
checkResult(pMob->SetMobID(MOBTestID2));
checkResult(pMob->SetMobID(MOBTestID));
// Create another Mob, check mob count, then delete and recheck count
checkResult(defs.cdMasterMob()->
CreateInstance(IID_IAAFMob,
(IUnknown **)&pMob2));
checkResult(pMob2->SetMobID(MOBTestID2));
checkResult(pMob2->SetName(mobName));
checkResult(pMob2->SetCreateTime(creationTimeStamp));
checkResult(pMob2->SetModTime(modificationTimeStamp));
// Add the mob to the file.
checkResult(pHeader->AddMob(pMob2));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(numMobs == 2, AAFRESULT_TEST_FAILED);
checkResult(pHeader->RemoveMob(pMob2));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(numMobs == 1, AAFRESULT_TEST_FAILED);
//try Copy()
const aafCharacter *copy_name = L"Name of Copied Mob";
IAAFMobSP spCopiedMob;
checkResult(pMob->Copy(copy_name, &spCopiedMob));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(numMobs == 2, AAFRESULT_TEST_FAILED);
checkResult(pHeader->RemoveMob(spCopiedMob));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(numMobs == 1, AAFRESULT_TEST_FAILED);
//try CloneExternal
IAAFMobSP spClonedMob;
IAAFFileSP spDestFile;
aafCharacter dest_filename[128];
wcscpy(dest_filename, pFileName);
wcscat(dest_filename, L"_clone");
// Remove the previous test file if any.
RemoveTestFile(dest_filename);
checkResult(CreateTestFile( dest_filename, fileKind, rawStorageType, productID, &spDestFile ));
checkResult(pMob->CloneExternal(kAAFNoFollowDepend, kAAFNoIncludeMedia, spDestFile, &spClonedMob));
checkResult(spDestFile->Save());
checkResult(spDestFile->Close());
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (enumTaggedVal)
enumTaggedVal->Release();
if (newSlot)
newSlot->Release();
if (newStaticSlot)
newStaticSlot->Release();
if (seg)
seg->Release();
if (pComponent)
pComponent->Release();
if (sclp)
sclp->Release();
if (pMob)
pMob->Release();
if (pMob2)
pMob2->Release();
if (pMobInterface2)
pMobInterface2->Release();
if (pDictionary)
pDictionary->Release();
if (pHeader)
pHeader->Release();
if(pcdEventMeta)
pcdEventMeta->Release();
if(pcdEvent)
pcdEvent->Release();
if(pcdEventConcrete)
pcdEventConcrete->Release();
if (pFile)
{ // Close file
if (bFileOpen)
{
pFile->Save();
pFile->Close();
}
pFile->Release();
}
return hr;
}
static HRESULT ReadAAFFile(aafWChar * pFileName)
{
IAAFFile * pFile = NULL;
IAAFHeader * pHeader = NULL;
IAAFSourceMob* pSourceMob = NULL;
IAAFMob* pMob = NULL;
IAAFEssenceDescriptor* pEssDesc = NULL;
IAAFBWFImportDescriptor* pBWFImportDesc = NULL;
IEnumAAFRIFFChunks* pEnum = NULL;
IAAFRIFFChunk* pRIFFChunk = NULL;
IEnumAAFMobs* pMobIter = NULL;
aafUInt32 numData, bytesRead, com, testID;
aafLength_t testLength, testRIFFLen;
aafPosition_t dataPos;
aafNumSlots_t numMobs;
char Value[sizeof(RIFFChunksmiley)];
char Value2[sizeof(RIFFChunkfrowney)];
HRESULT hr = AAFRESULT_SUCCESS;
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
checkResult( pFile->GetHeader(&pHeader));
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->CountUnknownBWFChunks(&numData));
checkExpression(1 == numData, AAFRESULT_TEST_FAILED);
checkResult(pBWFImportDesc->GetUnknownBWFChunks(&pEnum));
for(com = 0; com < numData; com++)
{
checkResult(pEnum->NextOne(&pRIFFChunk));
checkResult(pRIFFChunk->GetLength(&testRIFFLen));
checkExpression((sizeof(RIFFChunksmiley)+sizeof(RIFFChunkfrowney)) == testRIFFLen, AAFRESULT_TEST_FAILED);
checkResult(pRIFFChunk->Read( sizeof(Value), (unsigned char *)Value, &bytesRead));
checkExpression(memcmp(Value, RIFFChunksmiley, sizeof(RIFFChunksmiley)) == 0, AAFRESULT_TEST_FAILED);
checkResult(pRIFFChunk->Read( sizeof(Value2), (unsigned char *)Value2, &bytesRead));
checkExpression(memcmp(Value2, RIFFChunkfrowney, sizeof(RIFFChunkfrowney)) == 0, AAFRESULT_TEST_FAILED);
checkResult(pRIFFChunk->GetPosition(&dataPos));
checkExpression(dataPos==(sizeof(RIFFChunksmiley)+sizeof(RIFFChunkfrowney)), AAFRESULT_TEST_FAILED);
checkResult(pRIFFChunk->SetPosition(0));
checkResult(pRIFFChunk->Read( sizeof(Value), (unsigned char *)Value, &bytesRead));
checkExpression(memcmp(Value, RIFFChunksmiley, sizeof(RIFFChunksmiley)) == 0, AAFRESULT_TEST_FAILED);
pRIFFChunk->GetChunkID(&testID);
checkExpression(testID==chunkID, AAFRESULT_TEST_FAILED);
pRIFFChunk->GetLength(&testLength);
checkExpression(testLength == sizeof(RIFFChunksmiley) + sizeof(RIFFChunkfrowney), AAFRESULT_TEST_FAILED);
pRIFFChunk->Release();
pRIFFChunk = NULL;
}
pEnum->Release();
pEnum = NULL;
pEssDesc->Release();
pEssDesc = NULL;
pBWFImportDesc->Release();
pBWFImportDesc = NULL;
pSourceMob->Release();
pSourceMob = NULL;
pMobIter->Release();
pMobIter = NULL;
}
pMob->Release();
pMob = NULL;
pHeader->Release();
pHeader = NULL;
pFile->Close();
pFile->Release();
pFile = NULL;
return hr;
}
static bool testRestore(const wchar_t* fileName)
{
bool passed = true;
IAAFFile* pFile = 0;
IAAFHeader* pHeader = 0;
IAAFDictionary* pDictionary = 0;
IAAFContentStorage* pStorage = 0;
IEnumAAFMobs* pMobs = 0;
IAAFMob* pMob = 0;
try
{
pFile = openFileForReading(fileName);
}
catch (...)
{
return false;
}
try
{
// get the Mob containing the test data
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->GetDictionary(&pDictionary));
checkResult(pHeader->GetContentStorage(&pStorage));
aafSearchCrit_t searchCrit;
searchCrit.searchTag = kAAFByMobKind;
searchCrit.tags.mobKind = kAAFAllMob;
checkResult(pStorage->GetMobs(&searchCrit, &pMobs));
checkResult(pMobs->NextOne(&pMob));
IAAFObject* pObject = 0;
IAAFClassDef* pClassDef = 0;
IAAFPropertyDef* pPropertyDef = 0;
IAAFPropertyValue* pPropertyValue = 0;
IAAFTypeDef* pType = 0;
IAAFTypeDefEnum* pEnumType = 0;
try
{
printf(" * Baseline: ");
const aafUID_t propId =
{0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUInt8 testValue = 5;
const wchar_t* testName = L"VersionPrivateBuild";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType));
aafInt64 value;
aafCharacter name[256];
checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value));
checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256));
if (value == testValue && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pEnumType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
try
{
printf(" * Enum element size 1 : ");
const aafUID_t propId =
{0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUInt8 testValue = 1;
const wchar_t* testName = L"AAA";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType));
aafInt64 value;
aafCharacter name[256];
checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value));
checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256));
if (value == testValue && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pEnumType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
try
{
printf(" * Enum element size 2 : ");
const aafUID_t propId =
{0x20000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUInt8 testValue = 2;
const wchar_t* testName = L"BBB";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType));
aafInt64 value;
aafCharacter name[256];
checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value));
checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256));
if (value == testValue && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pEnumType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
try
{
printf(" * Enum element size 4 : ");
const aafUID_t propId =
{0x30000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUInt8 testValue = 1;
const wchar_t* testName = L"AAA";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType));
aafInt64 value;
aafCharacter name[256];
checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value));
checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256));
if (value == testValue && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pEnumType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
try
{
printf(" * Enum element size 8 : ");
const aafUID_t propId =
{0x40000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUInt8 testValue = 2;
const wchar_t* testName = L"BBB";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefEnum, (void **)&pEnumType));
aafInt64 value;
aafCharacter name[256];
checkResult(pEnumType->GetIntegerValue(pPropertyValue, &value));
checkResult(pEnumType->GetNameFromValue(pPropertyValue, name, 256));
if (value == testValue && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pEnumType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
}
catch (...)
{
passed = false;
}
// cleanup
release(pMob);
release(pMobs);
release(pStorage);
release(pDictionary);
release(pHeader);
checkResult(pFile->Close());
release(pFile);
report(passed);
return passed;
}
static HRESULT 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;
IAAFMasterMob* pMasterMob = NULL;
IAAFSourceMob* pSrcMob = NULL;
IAAFSourceMob* pTapeMob = NULL;
IAAFEssenceDescriptor* pDesc = NULL;
IAAFMob* pTempMob = NULL;
HRESULT hr = S_OK;
long test;
aafSourceRef_t ref;
IAAFEssenceDescriptor* pEssDesc = NULL;
IAAFTapeDescriptor* pTapeDesc = NULL;
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);
// Create a Master Mob
checkResult(defs.cdMasterMob()->
CreateInstance(IID_IAAFMob,
(IUnknown **)&pMob));
// Set the IAAFMob properties
checkResult(pMob->SetMobID(TEST_Master_MobID));
checkResult(pMob->SetName(MobName));
checkResult(pMob->QueryInterface(IID_IAAFMasterMob, (void **) &pMasterMob));
// Create source mob to associate with our MasterMob.
checkResult(defs.cdSourceMob()->
CreateInstance(IID_IAAFSourceMob,
(IUnknown **)&pTapeMob));
hr = defs.cdTapeDescriptor()->
CreateInstance(IID_IAAFTapeDescriptor,
(IUnknown **)&pTapeDesc);
if (AAFRESULT_SUCCESS == hr)
{
hr = pTapeDesc->QueryInterface(IID_IAAFEssenceDescriptor, (void **)&pEssDesc);
if (AAFRESULT_SUCCESS == hr)
{
hr = pTapeMob->SetEssenceDescriptor(pEssDesc);
if (AAFRESULT_SUCCESS == hr)
{
hr = pTapeDesc->SetTapeManufacturer( Manufacturer );
if (AAFRESULT_SUCCESS == hr )
{
hr = pTapeDesc->SetTapeModel( Model );
if (AAFRESULT_SUCCESS == hr )
{
hr = pTapeDesc->SetTapeFormFactor( FormFactor );
if (AAFRESULT_SUCCESS == hr )
{
hr = pTapeDesc->SetSignalType( VideoSignalType );
if (AAFRESULT_SUCCESS == hr )
{
hr = pTapeDesc->SetTapeFormat( TapeFormat );
if (AAFRESULT_SUCCESS == hr )
hr = pTapeDesc->SetTapeLength( TapeLength );
}
}
}
}
}
pEssDesc->Release();
pEssDesc = NULL;
}
pTapeDesc->Release();
pTapeDesc = NULL;
}
for (test = 0; test < NumMobSlots; test++)
{
IAAFDataDefSP pDataDef;
checkResult (pDictionary->LookupDataDef (*slotDDefs[test], &pDataDef));
checkResult(pTapeMob->AddNilReference (test, TAPE_MOB_LENGTH_ARR[test], pDataDef, slotRates[test]));
}
checkResult(pTapeMob->QueryInterface(IID_IAAFMob, (void **) &pTempMob));
checkResult(pTempMob->SetName(TAPE_MOB_NAME));
checkResult(pTempMob->SetMobID(tapeMobID));
//save the id for future (test) reference
// TAPE_MOB_ID = tapeMobID;
checkResult(pHeader->AddMob(pTempMob));
pTempMob->Release();
pTempMob = NULL;
// Add some slots
for (test = 0; test < NumMobSlots; test++)
{
// Create source mob to associate with our MasterMob.
checkResult(defs.cdSourceMob()->
CreateInstance(IID_IAAFSourceMob,
(IUnknown **)&pSrcMob));
ref.sourceID = tapeMobID;
ref.sourceSlotID = test;
ref.startTime = TAPE_MOB_OFFSET_ARR[test];
IAAFDataDefSP pDDef;
checkResult(pDictionary->LookupDataDef(*slotDDefs[test], &pDDef));
checkResult(pSrcMob->AppendPhysSourceRef (slotRates[test],
test,
pDDef,
ref,
TAPE_MOB_LENGTH_ARR[test]));
// Create a concrete subclass of EssenceDescriptor
checkResult(defs.cdAIFCDescriptor()->
CreateInstance(IID_IAAFEssenceDescriptor,
(IUnknown **)&pDesc));
IAAFAIFCDescriptor* pAIFCDesc = NULL;
checkResult(pDesc->QueryInterface (IID_IAAFAIFCDescriptor, (void **)&pAIFCDesc));
checkResult(pAIFCDesc->SetSummary (5, (unsigned char*)"TEST"));
pAIFCDesc->Release();
pAIFCDesc = NULL;
checkResult(pSrcMob->SetEssenceDescriptor(pDesc));
pDesc->Release();
pDesc = NULL;
// Append source MOB to header
checkResult(pSrcMob->QueryInterface(IID_IAAFMob, (void **) &pTempMob));
checkResult(pTempMob->SetMobID(TEST_Source_MobIDs[test]));
checkResult(pTempMob->SetName(L"source mob"));
checkResult(pHeader->AddMob(pTempMob));
pTempMob->Release();
pTempMob = NULL;
IAAFDataDefSP pDataDef;
checkResult (pDictionary->LookupDataDef (*slotDDefs[test], &pDataDef));
checkResult(pMasterMob->AddMasterSlot(pDataDef, test, pSrcMob, test+1, slotNames[test]));
pSrcMob->Release();
pSrcMob = NULL;
}
// Add the master mob to the file and cleanup
checkResult(pHeader->AddMob(pMob));
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (pTempMob)
pTempMob->Release();
if (pEssDesc)
pEssDesc->Release();
if (pTapeDesc)
pTapeDesc->Release();
if (pDesc)
pDesc->Release();
if (pSrcMob)
pSrcMob->Release();
if (pTapeMob)
pTapeMob->Release();
if (pMasterMob)
pMasterMob->Release();
if (pMob)
pMob->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)
{
// IAAFSession * pSession = NULL;
IAAFFile * pFile = NULL;
IAAFHeader * pHeader = NULL;
IEnumAAFMobs *mobIter = NULL;
IAAFMob *aMob = NULL;
IAAFEssenceDescriptor *pEdesc = NULL;
IAAFSourceMob *pSourceMob = NULL;
IEnumAAFLocators * pEnum = NULL;
IAAFLocator * pLocator = NULL;
aafUInt32 numLocators;
aafNumSlots_t numMobs, n;
HRESULT hr = AAFRESULT_SUCCESS;
bool bFileOpen = false;
try
{
// Open the file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// We can't really do anthing in AAF without the header.
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression (1 == numMobs, AAFRESULT_TEST_FAILED);
checkResult(pHeader->GetMobs (NULL, &mobIter));
for(n = 0; n < numMobs; n++)
{
aafWChar name[500];
aafMobID_t mobID;
checkResult(mobIter->NextOne (&aMob));
checkResult(aMob->GetName (name, sizeof(name)));
checkResult(aMob->GetMobID (&mobID));
checkResult(aMob->QueryInterface (IID_IAAFSourceMob, (void **)&pSourceMob));
checkResult(pSourceMob->GetEssenceDescriptor (&pEdesc));
// Verify that there is now one locator
checkResult(pEdesc->CountLocators(&numLocators));
checkExpression(20 == numLocators, AAFRESULT_TEST_FAILED);
checkResult(pEdesc->GetLocators(&pEnum));
// This should read the one real locator
for ( n=0; n<numLocators; n++)
{
checkResult(pEnum->NextOne(&pLocator));
pLocator->Release();
pLocator = NULL;
}
// We had better not succeed or get an unknown failure.
checkExpression(AAFRESULT_NO_MORE_OBJECTS == pEnum->NextOne(&pLocator),
AAFRESULT_TEST_FAILED);
pEnum->Release();
pEnum = NULL;
pEdesc->Release();
pEdesc = NULL;
pSourceMob->Release();
pSourceMob = NULL;
aMob->Release();
aMob = NULL;
}
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup object references
if (pLocator)
pLocator->Release();
if (pEnum)
pEnum->Release();
if (pEdesc)
pEdesc->Release();
if (pSourceMob)
pSourceMob->Release();
if (aMob)
aMob->Release();
if (mobIter)
mobIter->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{ // Close file, clean-up and return
if (bFileOpen)
pFile->Close();
pFile->Release();
}
/*
hr = pSession->EndSession();
if (AAFRESULT_SUCCESS != hr)
return hr;
*/
return hr;
}
static HRESULT ReadAAFFile(aafWChar* pFileName)
{
IAAFFile* pFile = NULL;
bool bFileOpen = false;
IAAFHeader* pHeader = NULL;
IEnumAAFMobs* pMobIter = NULL;
IAAFMob* pMob = NULL;
IAAFMasterMob* pMasterMob = NULL;
IEnumAAFMobSlots* pSlotIter = NULL;
IAAFMobSlot* pSlot;
aafNumSlots_t numMobs;
aafSearchCrit_t criteria;
IAAFSearchSource* pSearchSource = NULL;
IAAFFindSourceInfo* pSourceInfo = NULL;
IAAFMob* si_mob = NULL; //mob used by SourceInfo intf.
HRESULT hr = S_OK;
try
{
// Open the AAF file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// Get the AAF file header.
checkResult(pFile->GetHeader(&pHeader));
// Validate that there is on one master mob in the test file.
checkResult(pHeader->CountMobs(kAAFMasterMob, &numMobs));
checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED);
// Enumerate over Master MOBs
criteria.searchTag = kAAFByMobKind;
criteria.tags.mobKind = kAAFMasterMob;
checkResult(pHeader->GetMobs(&criteria, &pMobIter));
while (pMobIter && pMobIter->NextOne(&pMob) == AAFRESULT_SUCCESS)
{
aafWChar name[500];
aafNumSlots_t numSlots = 0;
aafMobID_t mobID;
// TODO: Test Master MOB specific methods here
checkResult(pMob->QueryInterface(IID_IAAFMasterMob, (void **) &pMasterMob));
checkResult(pMob->GetName(name, sizeof(name)));
checkExpression(wcscmp(name, MobName) == 0, AAFRESULT_TEST_FAILED);
checkResult(pMob->GetMobID(&mobID));
checkExpression(0 == memcmp(&mobID, &TEST_Master_MobID, sizeof(mobID)), AAFRESULT_TEST_FAILED);
checkResult(pMob->CountSlots(&numSlots));
checkExpression(NumMobSlots == numSlots, AAFRESULT_TEST_FAILED);
//AAFRESULT STDMETHODCALLTYPE
// ImplAAFMasterMob::GetTapeNameBufLen (0,
// aafInt32* pLen)
unsigned long s = 0;
// Enumerate over all MOB slots for this MOB
checkResult(pMob->GetSlots(&pSlotIter));
while (pSlotIter && pSlotIter->NextOne(&pSlot) == AAFRESULT_SUCCESS)
{
aafWChar slotName[500];
aafSlotID_t slotID;
//aafUInt32 bufSize = 0;
// Validate the slot name
checkResult(pSlot->GetName(slotName, sizeof(slotName)));
checkExpression(wcscmp(slotName, slotNames[s]) == 0, AAFRESULT_TEST_FAILED);
// Validate the slot id.
checkResult(pSlot->GetSlotID(&slotID));
checkExpression(slotID == s+1, AAFRESULT_TEST_FAILED);
//Now, do a search source ...............
//Get a search source intf.
checkResult( pMasterMob->QueryInterface(IID_IAAFSearchSource, (void**)&pSearchSource) );
//From the searchsource inft, get a FindSourceINfo intf.
checkResult ( pSearchSource->SearchSource(
slotID,
0,
kAAFTapeMob,
NULL, //don't care about Media Criteria
NULL, //don't care about operation choice
&pSourceInfo));
//This is an important milestone! At this point, we were successful - about getting a pSourceInfo intf.
// so, release the search source intf.
if (pSearchSource)
{
pSearchSource->Release();
pSearchSource=NULL;
}
//NOw, simply test the methods on the (final) SourceInfo intf.
aafRational_t si_editRate = {-1};
aafLength_t si_length = {-1};
aafSourceRef_t si_sourceRef = {{{0,0,0,0,0,0,0,0,0,0,0,0},0,0,0,0,{0,0,0,{0,0,0,0,0,0,0,0}}},0,0};
aafMobID_t si_MobID = {{0,0,0,0,0,0,0,0,0,0,0,0},0,0,0,0,
{0,0,0,{0,0,0,0,0,0,0,0}}};
//Call the methods
pSourceInfo->GetEditRate( &si_editRate);
pSourceInfo->GetLength(&si_length);
pSourceInfo->GetMob(&si_mob);
pSourceInfo->GetSourceReference(&si_sourceRef);
//Check the values returned by the methods
//edit rate
checkExpression(si_editRate.numerator == slotRates[s].numerator, AAFRESULT_TEST_FAILED);
checkExpression(si_editRate.denominator == slotRates[s].denominator, AAFRESULT_TEST_FAILED);
//Length
checkExpression(si_length == TAPE_MOB_LENGTH_ARR[s], AAFRESULT_TEST_FAILED);
//Mob
checkExpression(si_mob!=NULL, AAFRESULT_TEST_FAILED);
si_mob->GetMobID(&si_MobID);
checkExpression(memcmp(&si_MobID, &tapeMobID, sizeof(aafMobID_t))==0,
AAFRESULT_TEST_FAILED);
//Source Reference
checkExpression(si_sourceRef.sourceSlotID == s, AAFRESULT_TEST_FAILED);
checkExpression(si_sourceRef.startTime == TAPE_MOB_OFFSET_ARR[s], AAFRESULT_TEST_FAILED);
//Done with tests .. release the FindSourceInfo intf ..
if (pSourceInfo)
{
pSourceInfo->Release();
pSourceInfo=NULL;
}
//Also don't forget to release the si_mob intf.
if (si_mob)
{
si_mob->Release();
si_mob=NULL;
}
pSlot->Release();
pSlot = NULL;
s++;
}
pSlotIter->Release();
pSlotIter = NULL;
pMob->Release();
pMob = NULL;
pMasterMob->Release();
pMasterMob = NULL;
}
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (pSearchSource)
pSearchSource->Release();
if (pSourceInfo)
pSourceInfo->Release();
if (si_mob)
si_mob->Release();
if (pSlot)
pSlot->Release();
if (pMasterMob)
pMasterMob->Release();
if (pMob)
pMob->Release();
if (pMobIter)
pMobIter->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{ // Close file
if (bFileOpen)
pFile->Close();
pFile->Release();
}
return hr;
}
static bool testRestore(const wchar_t* fileName)
{
bool passed = true;
IAAFFile* pFile = 0;
IAAFHeader* pHeader = 0;
IAAFDictionary* pDictionary = 0;
IAAFContentStorage* pStorage = 0;
IEnumAAFMobs* pMobs = 0;
IAAFMob* pMob = 0;
try
{
pFile = openFileForReading(fileName);
}
catch (...)
{
return false;
}
try
{
// get the Mob containing the test data
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->GetDictionary(&pDictionary));
checkResult(pHeader->GetContentStorage(&pStorage));
aafSearchCrit_t searchCrit;
searchCrit.searchTag = kAAFByMobKind;
searchCrit.tags.mobKind = kAAFAllMob;
checkResult(pStorage->GetMobs(&searchCrit, &pMobs));
checkResult(pMobs->NextOne(&pMob));
IAAFObject* pObject = 0;
IAAFClassDef* pClassDef = 0;
IAAFPropertyDef* pPropertyDef = 0;
IAAFPropertyValue* pPropertyValue = 0;
IAAFTypeDef* pType = 0;
IAAFTypeDefExtEnum* pExtEnumType = 0;
// test baseline ext. enum
try
{
printf(" * Baseline: ");
const aafUID_t propId =
{0x00000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUID_t testValue =
{0x0D010102,0x0101,0x0500,{0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01}};
const wchar_t* testName = L"Usage_SubClip";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefExtEnum, (void **)&pExtEnumType));
aafUID_t value;
aafCharacter name[256];
checkResult(pExtEnumType->GetAUIDValue(pPropertyValue, &value));
checkResult(pExtEnumType->GetNameFromValue(pPropertyValue, name, 256));
if (memcmp(&value, &testValue, sizeof(aafUID_t)) ==0 && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pExtEnumType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
// test Int8 enum
try
{
printf(" * Non-baseline Ext Enum: ");
const aafUID_t propId =
{0x10000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUID_t testValue =
{0x6f9685a4,0x0a0d,0x447b,{0x89,0xf3,0x1b,0x75,0x0b,0xc5,0xc7,0xde}};
const wchar_t* testName = L"AAA";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefExtEnum, (void **)&pExtEnumType));
aafUID_t value;
aafCharacter name[256];
checkResult(pExtEnumType->GetAUIDValue(pPropertyValue, &value));
checkResult(pExtEnumType->GetNameFromValue(pPropertyValue, name, 256));
if (memcmp(&value, &testValue, sizeof(aafUID_t)) ==0 && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pExtEnumType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
// test baseline extension
try
{
printf(" * Baseline extension: ");
const aafUID_t propId =
{0x20000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUID_t testValue =
{0x197e78ac,0xb464,0x4bd1,{0x86,0x11,0xb6,0xf2,0xdf,0x0d,0x03,0xfe}};
const wchar_t* testName = L"MyUsage";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefExtEnum, (void **)&pExtEnumType));
aafUID_t value;
aafCharacter name[256];
checkResult(pExtEnumType->GetAUIDValue(pPropertyValue, &value));
checkResult(pExtEnumType->GetNameFromValue(pPropertyValue, name, 256));
if (memcmp(&value, &testValue, sizeof(aafUID_t)) ==0 && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pExtEnumType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
// test non-baseline extension
try
{
printf(" * Non-baseline extension: ");
const aafUID_t propId =
{0x30000000,0x0000,0x0000,{0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00}};
aafUID_t testValue =
{0xe54f0efa,0x15c1,0x468f,{0xb7,0x43,0x9b,0xfd,0x12,0x94,0x04,0x49}};
const wchar_t* testName = L"CCC";
checkResult(pMob->QueryInterface(IID_IAAFObject, (void **)&pObject));
checkResult(pDictionary->LookupClassDef(kAAFClassID_Mob, &pClassDef));
checkResult(pClassDef->LookupPropertyDef(propId, &pPropertyDef));
checkResult(pObject->GetPropertyValue(pPropertyDef, &pPropertyValue));
checkResult(pPropertyValue->GetType(&pType));
checkResult(pType->QueryInterface(IID_IAAFTypeDefExtEnum, (void **)&pExtEnumType));
aafUID_t value;
aafCharacter name[256];
checkResult(pExtEnumType->GetAUIDValue(pPropertyValue, &value));
checkResult(pExtEnumType->GetNameFromValue(pPropertyValue, name, 256));
if (memcmp(&value, &testValue, sizeof(aafUID_t)) ==0 && wcscmp(name, testName) == 0)
{
printf("passed\n");
}
else
{
printf("FAILED\n");
passed = false;
}
}
catch (...)
{
printf("FAILED\n");
passed = false;
}
release(pExtEnumType);
release(pType);
release(pPropertyValue);
release(pPropertyDef);
release(pClassDef);
release(pObject);
}
catch (...)
{
passed = false;
}
// cleanup
release(pMob);
release(pMobs);
release(pStorage);
release(pDictionary);
release(pHeader);
checkResult(pFile->Close());
release(pFile);
report(passed);
return passed;
}
static HRESULT ReadAAFFile(aafWChar * pFileName)
{
// IAAFSession * pSession = NULL;
IAAFFile * pFile = NULL;
bool bFileOpen = false;
IAAFHeader * pHeader = NULL;
IEnumAAFMobs *mobIter = NULL;
IAAFContainerDef* pContainer = NULL;
IAAFDefObject * pDef = NULL;
IAAFEssenceDescriptor *pEdesc = NULL;
IAAFSourceMob *pSourceMob = NULL;
IAAFMob *aMob = NULL;
IEnumAAFMobSlots *slotIter = NULL;
IAAFMobSlot *slot = NULL;
IAAFFileDescriptor *pFileDesc = NULL;
IAAFFileDescriptor2 *pFileDesc2 = NULL;
aafNumSlots_t numMobs, n, s;
HRESULT hr = S_OK;
aafRational_t testSampleRate;
aafUID_t testContainer;
aafLength_t testLength;
aafUInt32 testLinkedSlotID;
// aafBool testBool;
try
{
// Open the file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// We can't really do anthing in AAF without the header.
checkResult(pFile->GetHeader(&pHeader));
// Get the number of mobs in the file (should be one)
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED);
checkResult(pHeader->GetMobs (NULL, &mobIter));
for(n = 0; n < numMobs; n++)
{
aafWChar name[500];
aafNumSlots_t numSlots;
aafMobID_t mobID;
aafSlotID_t trackID;
checkResult(mobIter->NextOne (&aMob));
checkResult(aMob->GetName (name, sizeof(name)));
checkResult(aMob->GetMobID (&mobID));
checkResult(aMob->CountSlots (&numSlots));
if (2 != numSlots)
return AAFRESULT_TEST_FAILED;
if(numSlots != 0)
{
checkResult(aMob->GetSlots(&slotIter));
for(s = 0; s < numSlots; s++)
{
checkResult(slotIter->NextOne (&slot));
checkResult(slot->GetSlotID(&trackID));
slot->Release();
slot = NULL;
}
}
checkResult(aMob->QueryInterface (IID_IAAFSourceMob, (void **)&pSourceMob));
checkResult(pSourceMob->GetEssenceDescriptor (&pEdesc));
checkResult(pEdesc->QueryInterface(IID_IAAFFileDescriptor, (void **) &pFileDesc));
checkResult(pFileDesc->GetSampleRate (&testSampleRate));
checkExpression(testSampleRate.numerator == checkSampleRate.numerator, AAFRESULT_TEST_FAILED);
checkExpression(testSampleRate.denominator == checkSampleRate.denominator, AAFRESULT_TEST_FAILED);
checkResult(pFileDesc->GetContainerFormat (&pContainer));
checkResult(pContainer->QueryInterface(IID_IAAFDefObject, (void **) &pDef));
checkResult(pDef->GetAUID(&testContainer));
pContainer->Release();
pContainer = NULL;
pDef->Release();
pDef = NULL;
checkExpression(memcmp(&testContainer, &checkContainer, sizeof(testContainer)) == 0, AAFRESULT_TEST_FAILED);
checkResult(pFileDesc->GetLength (&testLength));
checkExpression(checkLength == testLength, AAFRESULT_TEST_FAILED);
checkResult(pFileDesc->QueryInterface(IID_IAAFFileDescriptor2, (void **)&pFileDesc2));
checkResult(pFileDesc2->GetLinkedSlotID (&testLinkedSlotID));
checkExpression(checkLinkedSlotID == testLinkedSlotID, AAFRESULT_TEST_FAILED);
// checkResult(pFileDesc->GetIsInContainer (&testBool));
// checkExpression(testBool == kAAFTrue, AAFRESULT_TEST_FAILED);
pEdesc->Release();
pEdesc = NULL;
pFileDesc->Release();
pFileDesc = NULL;
pFileDesc2->Release();
pFileDesc2 = NULL;
pSourceMob->Release();
pSourceMob = NULL;
aMob->Release();
aMob = NULL;
}
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (slot)
slot->Release();
if (pFileDesc)
pFileDesc->Release();
if (pFileDesc2)
pFileDesc2->Release();
if (slotIter)
slotIter->Release();
if (pEdesc)
pEdesc->Release();
if (pSourceMob)
pSourceMob->Release();
if (aMob)
aMob->Release();
if(mobIter)
mobIter->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{
if (bFileOpen)
pFile->Close();
pFile->Release();
}
return hr;
}
static HRESULT 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 ReadAAFFile(aafWChar * pFileName)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IEnumAAFMobs* pMobIter = NULL;
IAAFMob* pMob = NULL;
IAAFSourceMob* pSourceMob = NULL;
IAAFEssenceDescriptor* pEssDesc = NULL;
IAAFTIFFDescriptor* pTIFFDesc = NULL;
aafNumSlots_t numMobs = 0;
HRESULT hr = AAFRESULT_SUCCESS;
aafBool isContiguous, isUniform;
aafInt32 leadingLines, trailingLines;
aafUInt32 size;
aafUInt8 summary[512];
try
{
// Open the AAF file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
// Get the AAF file header.
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression(1 == numMobs, AAFRESULT_TEST_FAILED);
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_IAAFTIFFDescriptor, (void **)&pTIFFDesc));
checkResult(pTIFFDesc->GetIsContiguous(&isContiguous));
checkResult(pTIFFDesc->GetIsUniform(&isUniform));
checkResult(pTIFFDesc->GetLeadingLines(&leadingLines));
checkResult(pTIFFDesc->GetTrailingLines(&trailingLines));
checkResult(pTIFFDesc->GetSummaryBufferSize(&size));
checkExpression(size == 34, AAFRESULT_TEST_FAILED);
checkResult(pTIFFDesc->GetSummary(size, summary));
checkExpression(isContiguous == kAAFTrue, AAFRESULT_TEST_FAILED);
checkExpression(isUniform == kAAFFalse, AAFRESULT_TEST_FAILED);
checkExpression(leadingLines == 10, AAFRESULT_TEST_FAILED);
checkExpression(trailingLines == 20, AAFRESULT_TEST_FAILED);
// The next statement is not true when doing cross-platform tests
//#if defined( OS_WINDOWS )
// checkExpression(memcmp(summary, "II", 2) == 0, AAFRESULT_TEST_FAILED);
//#else
// checkExpression(memcmp(summary, "MM", 2) == 0, AAFRESULT_TEST_FAILED);
//#endif
// NOTE: The elements in the summary structure need to be byte swapped
// on Big Endian system (i.e. the MAC).
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup and return
if (pEssDesc)
pEssDesc->Release();
if (pTIFFDesc)
pTIFFDesc->Release();
if (pMob)
pMob->Release();
if (pSourceMob)
pSourceMob->Release();
if (pHeader)
pHeader->Release();
if (pMobIter)
pMobIter->Release();
if (pFile)
{
pFile->Close();
pFile->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 ReadAAFFile(aafWChar * pFileName)
{
// IAAFSession * pSession = NULL;
IAAFFile * pFile = NULL;
IAAFHeader * pHeader = NULL;
IAAFEssenceDescriptor *pEdesc = NULL;
IAAFSourceMob *pSourceMob = NULL;
IEnumAAFLocators * pEnum = NULL;
IAAFLocator * pLocator = NULL;
IEnumAAFMobs *mobIter = NULL;
IAAFMob *aMob = NULL;
aafUInt32 numLocators;
aafUInt32 readLen;
aafNumSlots_t numMobs, n;
HRESULT hr = AAFRESULT_SUCCESS;
aafWChar readBuf[1024];
bool bFileOpen = false;
try
{
// Open the file.
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
if (1 != numMobs )
checkResult(AAFRESULT_TEST_FAILED);
//!!! aafSearchCrit_t criteria;
//!!! criteria.searchTag = kAAFNoSearch;
checkResult(pHeader->GetMobs (NULL, &mobIter));
for(n = 0; n < numMobs; n++)
{
aafWChar name[500];
aafMobID_t mobID;
checkResult(mobIter->NextOne (&aMob));
checkResult(aMob->GetName (name, sizeof(name)));
checkResult(aMob->GetMobID (&mobID));
checkResult(aMob->QueryInterface (IID_IAAFSourceMob, (void **)&pSourceMob));
checkResult(pSourceMob->GetEssenceDescriptor (&pEdesc));
// Verify that there is now one locator
checkResult(pEdesc->CountLocators(&numLocators));
if (1 != numLocators)
checkResult(AAFRESULT_TEST_FAILED);
checkResult(pEdesc->GetLocators(&pEnum));
// This should read the one real locator
checkResult(pEnum->NextOne(&pLocator));
checkResult(pLocator->GetPathBufLen (&readLen));
// if(readLen != strlen(TEST_PATH))
checkResult(pLocator->GetPath (readBuf, readLen));
// This should run off the end
pLocator->Release();
pLocator = NULL;
hr = pEnum->NextOne(&pLocator);
if (AAFRESULT_NO_MORE_OBJECTS != hr)
checkResult(hr);
else
hr = AAFRESULT_SUCCESS; // reset result
}
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup...
if (pLocator)
pLocator->Release();
if (pEnum)
pEnum->Release();
if (pEdesc)
pEdesc->Release();
if (pSourceMob)
pSourceMob->Release();
if (aMob)
aMob->Release();
if (mobIter)
mobIter->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{
if (bFileOpen)
pFile->Close();
pFile->Release();
}
// hr = pSession->EndSession();
// if (AAFRESULT_SUCCESS != hr)
// return hr;
// if (pSession) pSession->Release();
return hr;
}
static HRESULT ReadAAFFile(const aafWChar * pFileName, testType_t testType)
{
IAAFFile * pFile = NULL;
IAAFHeader * pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFEssenceAccess* pEssenceAccess = NULL;
IAAFEssenceMultiAccess* pMultiEssence = NULL;
IAAFEssenceFormat *fmtTemplate = NULL;
IEnumAAFMobs* pMobIter = NULL;
IAAFMob* pMob = NULL;
IAAFMasterMob* pMasterMob = NULL;
IAAFEssenceFormat* pFormat = NULL;
aafNumSlots_t numMobs, numSlots;
aafSearchCrit_t criteria;
aafRational_t readSampleRate;
aafMobID_t mobID;
aafWChar namebuf[1204];
unsigned char AAFDataBuf[4096];
aafUInt32 AAFBytesRead, samplesRead;
FILE* pWavFile = NULL;
unsigned char WAVDataBuf[4096], *dataPtr;
size_t WAVBytesRead;
aafUInt32 dataOffset, dataLen;
aafUInt16 bitsPerSample, numCh;
check(AAFFileOpenExistingRead ( pFileName, 0, &pFile));
check(pFile->GetHeader(&pHeader));
// Get the AAF Dictionary so that we can create valid AAF objects.
check(pHeader->GetDictionary(&pDictionary));
// Here we check on the number of mobs in the file.
// Get the number of master mobs in the file (should be one)
check(pHeader->CountMobs(kAAFMasterMob, &numMobs));
// ** causes leak
if (1 == numMobs )
{
printf("Found %d Master Mobs\n", numMobs);
criteria.searchTag = kAAFByMobKind;
criteria.tags.mobKind = kAAFMasterMob;
check(pHeader->GetMobs(&criteria, &pMobIter));
while(AAFRESULT_SUCCESS == pMobIter->NextOne(&pMob))
{
char mobIDstr[256];
char mobName[256];
check(pMob->GetMobID (&mobID));
check(pMob->GetName (namebuf, sizeof(namebuf)));
convert(mobName, sizeof(mobName), namebuf);
MobIDtoString(mobID, mobIDstr);
printf(" MasterMob Name = '%s'\n", mobName);
printf(" (mobID %s)\n", mobIDstr);
// Make sure we have two slots
check(pMob->CountSlots(&numSlots));
if (2 == numSlots)
{
// The essence data is in SlotID 1
// Get a Master Mob interface
check(pMob->QueryInterface(IID_IAAFMasterMob, (void **)&pMasterMob));
// Open the Essence Data
check(pMasterMob->OpenEssence( 1, // SlotID 1
NULL, // mediaCriteria (Don't care)
kAAFMediaOpenReadOnly, // Open mode
kAAFCompressionDisable,// Compress disabled
&pEssenceAccess));
// Open and read the Wave file (for comparison)
pWavFile = fopen("Laser.wav", "r");
if (pWavFile)
{
// read in the essence data
WAVBytesRead = fread(WAVDataBuf, sizeof(unsigned char), sizeof(WAVDataBuf), pWavFile);
fclose(pWavFile);
pWavFile = NULL;
check(loadWAVEHeader(WAVDataBuf,
&bitsPerSample,
&numCh,
&readSampleRate,
&dataOffset,
&dataLen));
dataPtr = WAVDataBuf + dataOffset;
aafUInt32 sampleBits;
aafInt32 bytesRead;
check(pEssenceAccess->GetEmptyFileFormat (&fmtTemplate));
check(fmtTemplate->AddFormatSpecifier (kAAFAudioSampleBits, 0, NULL));
check(pEssenceAccess->GetFileFormat (fmtTemplate, &pFormat));
fmtTemplate->Release();
fmtTemplate = NULL;
check(pFormat->GetFormatSpecifier (kAAFAudioSampleBits, sizeof(sampleBits),
(aafDataBuffer_t)&sampleBits, &bytesRead));
pFormat->Release();
pFormat = NULL;
if(sampleBits != bitsPerSample)
{
printf("***Wrong sample size read ( was %d , should be %d)\n",
sampleBits, bitsPerSample);
}
// Read the Data from the AAF file
if(testType == testStandardCalls)
{
check(pEssenceAccess->ReadSamples( dataLen, //!!! Hardcoded // Number of Samples
sizeof(AAFDataBuf), // Maximum buffer size
AAFDataBuf, // Buffer for the data
&samplesRead, // Actual number of samples read
&AAFBytesRead)); // Actual number of bytes read
}
else if(testType == testMultiCalls)
{
aafmMultiXfer_t xfer;
aafmMultiResult_t result;
check(pEssenceAccess->QueryInterface(IID_IAAFEssenceMultiAccess, (void **)&pMultiEssence));
xfer.numSamples = dataLen; //!!! Hardcoded // Number of Samples
xfer.buflen = sizeof(AAFDataBuf);
xfer.buffer = AAFDataBuf;
result.bytesXfered = 0;
check(pMultiEssence->ReadMultiSamples(1, &xfer, &result));
samplesRead = result.samplesXfered;
AAFBytesRead = result.bytesXfered;
pMultiEssence->Release();
pMultiEssence = NULL;
}
// Now compare the data read from the AAF file to the actual WAV file
if (dataLen != AAFBytesRead)
{
printf("***Wrong number of bytes read (was %u , should be %zu)\n",
AAFBytesRead, WAVBytesRead);
}
if (memcmp( dataPtr, AAFDataBuf, dataLen) != 0)
{
printf("*** Data Read is different than the data in the WAV file ***\n");
}
}
else
{
printf("***Failed to open Wave file Laser.wav for comparison\n");
}
}
else
{
printf("***Wrong number of slots in the Master Mob (was %d should be %d)\n",
numSlots, 2);
}
if (pMasterMob)
{
pMasterMob->Release();
pMasterMob = NULL;
}
pMob->Release();
pMob = NULL;
if (pEssenceAccess)
{
pEssenceAccess->Release();
pEssenceAccess = NULL;
}
} // while pMobIter->NextOne
pMobIter->Release();
pMobIter = NULL;
}
else
{
printf("***Wrong number of Master mobs in the file (was %d should be %d)\n",
numMobs, 1);
}
printf("--------\n");
cleanup:
// Cleanup and return
if (pWavFile)
fclose(pWavFile);
if (pMultiEssence)
pMultiEssence->Release();
pMultiEssence=NULL;
if(fmtTemplate)
{
fmtTemplate->Release();
fmtTemplate = NULL;
}
if (pEssenceAccess)
{
pEssenceAccess->Release();
pEssenceAccess = NULL;
}
if (pDictionary)
pDictionary->Release();
pDictionary=NULL;
if (pHeader)
pHeader->Release();
pHeader=NULL;
if (pMobIter)
pMobIter->Release();
pMobIter=NULL;
if (pFormat)
pFormat->Release();
pFormat=NULL;
if (pFile)
{
pFile->Close();
pFile->Release();
pFile=NULL;
}
return moduleErrorTmp;
}
static HRESULT ReadAAFFile(aafWChar * pFileName)
{
// IAAFSession * pSession = NULL;
IAAFFile * pFile = NULL;
IAAFHeader * pHeader = NULL;
IEnumAAFMobs *mobIter = NULL;
IAAFMob *aMob = NULL;
IAAFEssenceDescriptor *pEdesc = NULL;
IAAFSourceMob *pSourceMob = NULL;
IEnumAAFLocators * pEnum = NULL;
IEnumAAFLocators * pCloneEnum = NULL;
IAAFLocator * pLocator = NULL;
aafUInt32 numLocators;
aafNumSlots_t numMobs, n;
HRESULT hr = AAFRESULT_SUCCESS;
bool bFileOpen = false;
wchar_t testname[256];
IAAFLocator * pArray[2] = { NULL, NULL };
IAAFLocator ** pArrayPoint = pArray;
aafUInt32 resultCount;
try
{
// Open the file
checkResult(AAFFileOpenExistingRead(pFileName, 0, &pFile));
bFileOpen = true;
// We can't really do anthing in AAF without the header.
checkResult(pFile->GetHeader(&pHeader));
checkResult(pHeader->CountMobs(kAAFAllMob, &numMobs));
checkExpression (1 == numMobs, AAFRESULT_TEST_FAILED);
checkResult(pHeader->GetMobs (NULL, &mobIter));
for(n = 0; n < numMobs; n++)
{
aafWChar name[500];
aafMobID_t mobID;
checkResult(mobIter->NextOne (&aMob));
checkResult(aMob->GetName (name, sizeof(name)));
checkResult(aMob->GetMobID (&mobID));
checkResult(aMob->QueryInterface (IID_IAAFSourceMob, (void **)&pSourceMob));
checkResult(pSourceMob->GetEssenceDescriptor (&pEdesc));
// Verify that there is now two locators
checkResult(pEdesc->CountLocators(&numLocators));
checkExpression(2 == numLocators, AAFRESULT_TEST_FAILED);
checkResult(pEdesc->GetLocators(&pEnum));
/* Read and check the first element */
checkResult(pEnum->NextOne(&pLocator));
checkResult(pLocator->GetPath (testname, sizeof(testname)));
checkExpression(wcscmp(testname, locator1) == 0, AAFRESULT_TEST_FAILED);
pLocator->Release();
pLocator = NULL;
/**/
/* Read and check the second element */
checkResult(pEnum->NextOne(&pLocator));
checkResult(pLocator->GetPath (testname, sizeof(testname)));
checkExpression(wcscmp(testname, locator2) == 0, AAFRESULT_TEST_FAILED);
pLocator->Release();
pLocator = NULL;
/*****/
/* Reset, and check the first element again*/
checkResult(pEnum->Reset());
checkResult(pEnum->NextOne(&pLocator));
checkResult(pLocator->GetPath (testname, sizeof(testname)));
checkExpression(wcscmp(testname, locator1) == 0, AAFRESULT_TEST_FAILED);
pLocator->Release();
pLocator = NULL;
/* Reset, Skip, and check the second element again*/
checkResult(pEnum->Reset());
checkResult(pEnum->Skip(1));
checkResult(pEnum->NextOne(&pLocator));
checkResult(pLocator->GetPath (testname, sizeof(testname)));
checkExpression(wcscmp(testname, locator2) == 0, AAFRESULT_TEST_FAILED);
pLocator->Release();
pLocator = NULL;
/* Reset, and read both elements */
checkResult(pEnum->Reset());
checkResult(pEnum->Next (2, (IAAFLocator **)&pArray, &resultCount));
checkExpression (resultCount == 2, AAFRESULT_TEST_FAILED);
checkResult(pArrayPoint[0]->GetPath (testname, sizeof(testname)));
checkExpression(wcscmp(testname, locator1) == 0, AAFRESULT_TEST_FAILED);
pArrayPoint[0]->Release();
pArrayPoint[0] = NULL;
checkResult(pArrayPoint[1]->GetPath (testname, sizeof(testname)));
checkExpression(wcscmp(testname, locator2) == 0, AAFRESULT_TEST_FAILED);
pArrayPoint[1]->Release();
pArrayPoint[1] = NULL;
/* Read one past to make sure that it fails */
checkExpression(pEnum->NextOne(&pLocator) != AAFRESULT_SUCCESS, AAFRESULT_TEST_FAILED);
/* Clone the enumerator, and read one element */
checkResult(pEnum->Clone(&pCloneEnum));
checkResult(pCloneEnum->Reset());
checkResult(pCloneEnum->NextOne(&pLocator));
checkResult(pLocator->GetPath (testname, sizeof(testname)));
checkExpression(wcscmp(testname, locator1) == 0, AAFRESULT_TEST_FAILED);
pLocator->Release();
pLocator = NULL;
pEnum->Release();
pEnum = NULL;
pEdesc->Release();
pEdesc = NULL;
pSourceMob->Release();
pSourceMob = NULL;
aMob->Release();
aMob = NULL;
pCloneEnum->Release();
pCloneEnum = NULL;
}
}
catch (HRESULT& rResult)
{
hr = rResult;
}
// Cleanup object references
if (pLocator)
pLocator->Release();
if (pEnum)
pEnum->Release();
if (pEdesc)
pEdesc->Release();
if (pSourceMob)
pSourceMob->Release();
if (aMob)
aMob->Release();
if (mobIter)
mobIter->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{ // Close file, clean-up and return
if (bFileOpen)
pFile->Close();
pFile->Release();
}
/*
hr = pSession->EndSession();
if (AAFRESULT_SUCCESS != hr)
return hr;
*/
return hr;
}
