static HRESULT CreateAAFFile(const aafWChar * pFileName, testDataFile_t *dataFile, testType_t testType)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFMob* pMob = NULL;
IAAFMasterMob* pMasterMob = NULL;
IAAFEssenceAccess* pEssenceAccess = NULL;
IAAFEssenceFormat* pFormat = NULL;
IAAFEssenceFormat *format = NULL;
IAAFLocator *pLocator = NULL;
aafMobID_t masterMobID;
aafProductIdentification_t ProductInfo;
aafRational_t editRate = {44100, 1};
aafRational_t sampleRate = {44100, 1};
FILE* pWavFile = NULL;
unsigned char dataBuff[4096], *dataPtr;
aafUInt32 dataOffset, dataLen;
aafUInt16 bitsPerSample, numCh;
aafInt32 n, numSpecifiers;
aafUID_t essenceFormatCode, testContainer;
IAAFClassDef *pMasterMobDef = NULL;
IAAFClassDef *pNetworkLocatorDef = NULL;
IAAFDataDef *pSoundDef = NULL;
aafUInt32 samplesWritten, bytesWritten;
// Delete any previous test file before continuing...
char chFileName[1000];
convert(chFileName, sizeof(chFileName), pFileName);
remove(chFileName);
if(dataFile != NULL)
{
// Delete any previous test file before continuing...
char chFileName[1000];
convert(chFileName, sizeof(chFileName), dataFile->dataFilename);
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;
/* Create a new AAF file */
check(AAFFileOpenNewModifyEx (pFileName, &kAAFFileKind_Aaf4KBinary, 0, &ProductInfo, &pFile));
check(pFile->GetHeader(&pHeader));
/* Get the AAF Dictionary from the file */
check(pHeader->GetDictionary(&pDictionary));
/* Lookup class definitions for the objects we want to create. */
check(pDictionary->LookupClassDef(AUID_AAFMasterMob, &pMasterMobDef));
check(pDictionary->LookupClassDef(AUID_AAFNetworkLocator, &pNetworkLocatorDef));
/* Lookup any necessary data definitions. */
check(pDictionary->LookupDataDef(kAAFDataDef_Sound, &pSoundDef));
/* Create a Mastermob */
// Get a Master MOB Interface
check(pMasterMobDef->
CreateInstance(IID_IAAFMasterMob,
(IUnknown **)&pMasterMob));
// Get a Mob interface and set its variables.
check(pMasterMob->QueryInterface(IID_IAAFMob, (void **)&pMob));
check(pMob->GetMobID(&masterMobID));
check(pMob->SetName(L"A Master Mob"));
// Add it to the file
check(pHeader->AddMob(pMob));
if(dataFile != NULL)
{
// Make a locator, and attach it to the EssenceDescriptor
check(pNetworkLocatorDef->
CreateInstance(IID_IAAFLocator,
(IUnknown **)&pLocator));
check(pLocator->SetPath (dataFile->dataFilename));
testContainer = dataFile->dataFormat;
}
else
{
pLocator = NULL;
testContainer = ContainerAAF;
}
// Open the Essence file to be included in this AAF file("Laser.wav")
pWavFile = fopen("Laser.wav", "r");
if (pWavFile)
{
// Read in the essence data
int rc = fread(dataBuff, sizeof(unsigned char), sizeof(dataBuff), pWavFile);
(void)rc;
check(loadWAVEHeader(dataBuff,
&bitsPerSample,
&numCh,
&sampleRate,
&dataOffset,
&dataLen));
assert (numCh == 1, "Input file must be mono audio data");
// The testtype is for Internal Standard calls so set dataPtr
dataPtr = dataBuff + dataOffset;
/* Create the Essence Data specifying the codec, container, edit rate and sample rate */
check(pMasterMob->CreateEssence(1, // Slot ID
pSoundDef, // MediaKind
kAAFCodecWAVE, // codecID
editRate, // edit rate
sampleRate, // sample rate
kAAFCompressionDisable,
pLocator, // In current file
testContainer, // In AAF Format
&pEssenceAccess)); // Compress disabled
check(pEssenceAccess->GetFileFormatParameterList (&format));
check(format->NumFormatSpecifiers (&numSpecifiers));
for(n = 0; n < numSpecifiers; n++)
{
check(format->GetIndexedFormatSpecifier (n, &essenceFormatCode, 0, NULL, NULL));
}
format->Release();
format = NULL;
// Tell the AAFEssenceAccess what the format is.
check(pEssenceAccess->GetEmptyFileFormat (&pFormat));
check(pFormat->NumFormatSpecifiers (&numSpecifiers));
/* Set the properties that describe the essence data, such as audio sample size */
aafInt32 sampleSize = bitsPerSample;
check(pFormat->AddFormatSpecifier (kAAFAudioSampleBits, sizeof(sampleSize), (aafUInt8 *)&sampleSize));
check(pEssenceAccess->PutFileFormat (pFormat));
pFormat->Release();
pFormat = NULL;
/* Write the samples */
aafInt32 samplesLeft = dataLen;
aafUInt32 bytesPerSample = bitsPerSample/8;
aafUInt32 samplesToWrite = 0;
if (dataLen*bytesPerSample < (sizeof(dataBuff) - dataOffset))
samplesToWrite = dataLen;
else
samplesToWrite = (sizeof(dataBuff) - dataOffset)/bytesPerSample;
//read input wav file in chunks and write them to Essence stream
while (true)
{
check(pEssenceAccess->WriteSamples( samplesToWrite, // Number of Samples
sizeof(dataBuff), // buffer size
dataPtr, // THE data
&samplesWritten,
&bytesWritten));
samplesLeft = samplesLeft-samplesToWrite;
if (samplesLeft <= 0)
break;
aafUInt32 bytesToWrite = fread(dataBuff, sizeof(unsigned char), sizeof(dataBuff), pWavFile);
samplesToWrite = bytesToWrite/bytesPerSample;
dataPtr = dataBuff;
}
// Close the essence data file
fclose(pWavFile);
/* Set the essence to indicate that you have finished writing the samples */
check(pEssenceAccess->CompleteWrite());
pEssenceAccess->Release();
pEssenceAccess = NULL;
}
else
{
printf("***Failed to open Wave file Laser.wav\n");
}
/* Release COM interfaces */
pMob->Release();
pMob = NULL;
pMasterMob->Release();
pMasterMob = NULL;
pSoundDef->Release();
pSoundDef = NULL;
pNetworkLocatorDef->Release();
pNetworkLocatorDef = NULL;
pMasterMobDef->Release();
pMasterMobDef = NULL;
pDictionary->Release();
pDictionary = NULL;
pHeader->Release();
pHeader = NULL;
/* Save the AAF file */
pFile->Save();
/* Close the AAF file */
pFile->Close();
pFile->Release();
pFile = NULL;
cleanup:
// Cleanup and return
if(pFormat)
pFormat->Release();
if(format)
format->Release();
if(pLocator)
pLocator->Release();
if (pEssenceAccess)
pEssenceAccess->Release();
if (pMasterMob)
pMasterMob->Release();
if (pMob)
pMob->Release();
if (pSoundDef)
pSoundDef->Release();
if (pNetworkLocatorDef)
pNetworkLocatorDef->Release();
if (pMasterMobDef)
pMasterMobDef->Release();
if (pDictionary)
pDictionary->Release();
if (pHeader)
pHeader->Release();
if (pFile)
{
pFile->Close();
pFile->Release();
}
return moduleErrorTmp;
}
static HRESULT CreateAAFFile(aafWChar * pFileName, bool comp_enable)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IAAFHeader2* pHeader2 = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFMob* pMob = NULL;
IAAFMasterMob* pMasterMob = NULL;
IAAFEssenceAccess* pEssenceAccess = NULL;
aafMobID_t masterMobID;
aafProductIdentification_t ProductInfo;
IAAFClassDef *pCDMasterMob = NULL;
IAAFDataDef *pPictureDef = NULL;
aafUInt32 samplesWritten, bytesWritten;
// Delete any previous test file before continuing...
char cFileName[FILENAME_MAX];
convert(cFileName, sizeof(cFileName), pFileName);
remove(cFileName);
cout << "Creating file " << cFileName << " using WriteSamples with " <<
(comp_enable ? "CompressionEnable" : "CompressionDisable") << endl;
aafProductVersion_t ver = {1, 0, 0, 0, kAAFVersionBeta};
ProductInfo.companyName = const_cast<wchar_t *>(L"none");
ProductInfo.productName = const_cast<wchar_t *>(L"AAF SDK");
ProductInfo.productVersion = &ver;
ProductInfo.productVersionString = const_cast<wchar_t *>(L"1.0.0.0 Beta");
ProductInfo.productID = NIL_UID;
ProductInfo.platform = NULL; // Set by SDK when saving
// select the file kind
const aafUID_t* fileKind = &kAAFFileKind_DontCare;
if( FormatMXF ) fileKind = &kAAFFileKind_AafKlvBinary;
else if( FormatSS512 ) fileKind = &kAAFFileKind_Aaf512Binary;
else fileKind = &kAAFFileKind_Aaf4KBinary;
// Create a new AAF file
check(AAFFileOpenNewModifyEx(pFileName, fileKind, 0, &ProductInfo, &pFile));
check(pFile->GetHeader(&pHeader));
// Set the operational pattern
check(pHeader->QueryInterface(IID_IAAFHeader2, (void **)&pHeader2));
check(pHeader2->SetOperationalPattern(kAAFOpDef_Atom));
// Get the AAF Dictionary from the file
check(pHeader->GetDictionary(&pDictionary));
/* Lookup class definitions for the objects we want to create. */
check(pDictionary->LookupClassDef(AUID_AAFMasterMob, &pCDMasterMob));
/* Lookup any necessary data definitions. */
check(pDictionary->LookupDataDef(kAAFDataDef_Picture, &pPictureDef));
/* Create a Mastermob */
// Get a Master MOB Interface
check(pCDMasterMob->CreateInstance(IID_IAAFMasterMob, (IUnknown **)&pMasterMob));
// Get a Mob interface and set its variables.
check(pMasterMob->QueryInterface(IID_IAAFMob, (void **)&pMob));
check(pMob->GetMobID(&masterMobID));
if (input_video == NULL)
{
check(pMob->SetName(L"DNX_color_bars"));
}
else
{
check(pMob->SetName(pFileName));
}
// Add Mobs to the Header
check(pHeader->AddMob(pMob));
/* Create the Essence Data specifying the codec, container, edit rate and sample rate */
check(pMasterMob->CreateEssence(
1, // Slot ID within MasterMob
pPictureDef, // MediaKind
UseDNX? kAAFCodecDNxHD : kAAFCodecVC3, // codecID
editRate, // edit rate
editRate, // sample rate
comp_enable ? kAAFCompressionEnable : kAAFCompressionDisable,
NULL, // No Locator used
ContainerAAF, // Essence embedded in AAF file
&pEssenceAccess)); //
// Set the codec flavour for desired video format
switch(ComprID)
{
case 1235:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1235 );
break;
case 1238:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1238 );
break;
case 1237:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1237 );
break;
case 1241:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1241 );
break;
case 1243:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1243 );
break;
case 1244:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1244 );
break;
case 1242:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1242 );
break;
case 1250:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1250 );
break;
case 1251:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1251 );
break;
case 1252:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1252 );
break;
case 1253:
pEssenceAccess->SetEssenceCodecFlavour( kAAFCodecFlavour_VC3_1253 );
break;
default:
break;
}
switch( input_type )
{
case P_UYVY:
case BarsUYVY:
default:
layout = UseDNX?Layout_P_UYVY:Layout_UYVYM;
break;
case UYVY:
layout = UseDNX?Layout_UYVY:Layout_Unknown;
break;
case BGRAI:
case BarsRGB:
layout = UseDNX?Layout_BGRAI:Layout_Unknown;
break;
case BGRA:
layout = UseDNX?Layout_BGRA:Layout_Unknown;
break;
}
// Set up the information about the format of the data
IAAFEssenceFormat * fmtTemplate=NULL;
check(pEssenceAccess->GetEmptyFileFormat (&fmtTemplate));
if( UseLegacyUIDs )
check(fmtTemplate->AddFormatSpecifier (kAAFLegacyAUIDs, sizeof(UseLegacyUIDs), (aafDataBuffer_t)&UseLegacyUIDs));
if( UseDNX )
check(fmtTemplate->AddFormatSpecifier (kAAFNumThreads, sizeof(nCodecThreads), (aafDataBuffer_t)&nCodecThreads));
if( UseDNX )
check(fmtTemplate->AddFormatSpecifier (kAAFBufferLayout, sizeof(layout), (aafDataBuffer_t)&layout));
// codec will automatically SetEssenceKey() for MXF if !UseLegacyUIDs
// codec will automatically SetEssenceKey() for Avid legacy if UseLegacyUIDs
// future: if other kAAFEssenceElementKey, set it here
// future: if other kAAFPhysicalTrackNum, set it here
// Put the format specifiers into the codec
check(pEssenceAccess->PutFileFormat( fmtTemplate ));
// For fun, print the name of the selected codec flavour
aafWChar codec_name[128] = L"";
check(pEssenceAccess->GetCodecName(sizeof(codec_name), codec_name));
printf(" using codec flavour \"%ls\"\n", codec_name);
// Write the video samples
int total_samples = 0;
if( input_type==Raw )
{
// Read one frame of raw VC3 video at a time, repeat last frame until end
FILE * ip=fopen( input_video,"rb" );
if(!ip) return false;
aafUInt32 nwant = GetBytesPerEditUnit(ComprID);
unsigned char* raw_buff = new unsigned char [ nwant ];
size_t nread=0;
while( Duration-- )
{
// keep on trying to read
if( !feof( ip ) ) nread=fread( raw_buff, 1, nwant, ip );
// abandon if partial frame (complete frame or zero is ok
if ( nread!=nwant && nread!= 0 ) { perror(input_video); break; }
samplesWritten=0;
check(pEssenceAccess->WriteSamples(1, nwant, raw_buff, &samplesWritten, &bytesWritten));
total_samples += samplesWritten;
}
delete[] raw_buff;
fclose( ip );
}
else if( input_type==P_UYVY || input_type==UYVYI || input_type==UYVYM )
{
// Load a single frame of uncompressed
aafUInt32 nwant = GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1)*(GetPixelsPerLine(ComprID)/2)*(UseDNX?5:8);
unsigned char* video_buffer = new unsigned char [ nwant ];
// int LoadXYUV( BufferLayout_t target, byte *video_buffer, int len, int H, int V, const char *input_video,
// bool isLittleEndian=true, bool isBigEndian=false, bool isP_UYVY=false );
LoadXYUV( UseDNX?Layout_P_UYVY:Layout_UYVYM,
video_buffer, nwant,
GetPixelsPerLine(ComprID), GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1),
input_video,
input_type==UYVYI, input_type==UYVYM, input_type==P_UYVY );
while( Duration-- )
{
samplesWritten=0;
check(pEssenceAccess->WriteSamples(1, nwant, video_buffer, &samplesWritten, &bytesWritten));
total_samples += samplesWritten;
}
delete[] video_buffer;
}
else if( input_type==UYVY )
{
// Load a single frame of uncompressed
aafUInt32 nwant = GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1)*(GetPixelsPerLine(ComprID)/2)*(UseDNX?4:8);
unsigned char* video_buffer = new unsigned char [ nwant ];
// int LoadXYUV( BufferLayout_t target, byte *video_buffer, int len, int H, int V, const char *input_video,
// bool isLittleEndian=true, bool isBigEndian=false, bool isP_UYVY=false );
LoadXYUV( UseDNX?Layout_UYVY:Layout_UYVYM,
video_buffer, nwant,
GetPixelsPerLine(ComprID), GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1),
input_video,
false, false, false );
while( Duration-- )
{
samplesWritten=0;
check(pEssenceAccess->WriteSamples(1, nwant, video_buffer, &samplesWritten, &bytesWritten));
total_samples += samplesWritten;
}
delete[] video_buffer;
}
else if( input_type==BGRAI )
{
// never get here with VC3Codec
// Load a single frame of uncompressed
aafUInt32 nwant = GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1)*GetPixelsPerLine(ComprID)*8;
unsigned char* video_buffer = new unsigned char [ nwant ];
// int LoadXRGB( BufferLayout_t target, byte *video_buffer, int len, int H, int V, const char *input_video,
// bool isLittleEndian=true, bool isBigEndian=false, bool hasA=false, bool isRGB=false );
LoadXRGB( Layout_BGRAI,
video_buffer, nwant,
GetPixelsPerLine(ComprID), GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1),
input_video,
input_type==BGRAI, false, true, false );
while( Duration-- )
{
samplesWritten=0;
check(pEssenceAccess->WriteSamples(1, nwant, video_buffer, &samplesWritten, &bytesWritten));
total_samples += samplesWritten;
}
delete[] video_buffer;
}
else if( input_type==BGRA )
{
// never get here with VC3Codec
// Load a single frame of uncompressed
aafUInt32 nwant = GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1)*GetPixelsPerLine(ComprID)*8;
unsigned char* video_buffer = new unsigned char [ nwant ];
// int LoadXRGB( BufferLayout_t target, byte *video_buffer, int len, int H, int V, const char *input_video,
// bool isLittleEndian=true, bool isBigEndian=false, bool hasA=false, bool isRGB=false );
LoadXRGB( Layout_BGRA,
video_buffer, nwant,
GetPixelsPerLine(ComprID), GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1),
input_video,
input_type==BGRAI, false, true, false );
while( Duration-- )
{
samplesWritten=0;
check(pEssenceAccess->WriteSamples(1, nwant, video_buffer, &samplesWritten, &bytesWritten));
total_samples += samplesWritten;
}
delete[] video_buffer;
}
else if( input_type==BarsRGB ) // using generated rgb colo(u)r bars
{
// never get here with VC3Codec
// Create a frame of colour bars
aafUInt32 nwant = GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1)*GetPixelsPerLine(ComprID)*8;
unsigned char* video_buffer = new unsigned char [ nwant ];
LoadXBars( Layout_BGRAI, video_buffer, nwant, GetPixelsPerLine(ComprID), GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1) );
while( Duration-- )
{
samplesWritten=0;
check(pEssenceAccess->WriteSamples(1, nwant, video_buffer, &samplesWritten, &bytesWritten));
total_samples += samplesWritten;
}
delete[] video_buffer;
}
else // if( input_type==BarsUYVY || input_video == NULL || others... ) // using generated component colo(u)r bars
{
// Create a frame of colour bars
aafUInt32 nwant = GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1)*(GetPixelsPerLine(ComprID)/2)*(UseDNX?5:8);
unsigned char* video_buffer = new unsigned char [ nwant ];
LoadXBars( UseDNX?Layout_P_UYVY:Layout_UYVYM, video_buffer, nwant, GetPixelsPerLine(ComprID), GetLinesPerField(ComprID)*(IsInterlaced(ComprID)?2:1) );
while( Duration-- )
{
samplesWritten=0;
check(pEssenceAccess->WriteSamples(1, nwant, video_buffer, &samplesWritten, &bytesWritten));
total_samples += samplesWritten;
}
delete[] video_buffer;
}
printf("Completed Write\n");
/* Set the essence to indicate that you have finished writing the samples */
check(pEssenceAccess->CompleteWrite());
check(pHeader2->UpdateEssenceContainers());
pEssenceAccess->Release();
pMob->Release();
pMasterMob->Release();
pPictureDef->Release();
pCDMasterMob->Release();
pDictionary->Release();
pHeader->Release();
pHeader2->Release();
/* Save the AAF file */
pFile->Save();
/* Close the AAF file */
pFile->Close();
pFile->Release();
return moduleErrorTmp;
}
static HRESULT CreateAAFFile(const aafWChar * pFileName, testDataFile_t *dataFile, testType_t /* testType */)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFMob* pMob = NULL;
IAAFMasterMob* pMasterMob = NULL;
IAAFClassDef* pKLVDataCD=NULL;
IAAFClassDef* pCommentMarkerCD=NULL;
IAAFTypeDef* pUnknownBaseType=NULL;
IAAFTypeDef* pInt32BaseType=NULL;
// IAAFTypeDef* pASCIIStringBaseType=NULL;
IAAFKLVData* pKLVData=NULL;
IAAFEssenceAccess* pEssenceAccess = NULL;
IAAFEssenceMultiAccess* pMultiEssence = NULL;
IAAFEssenceFormat* pFormat = NULL;
IAAFEssenceFormat* format = NULL;
IAAFLocator* pLocator = NULL;
IAAFClassDef* pCDMasterMob = 0;
IAAFClassDef *pCDNetworkLocator = 0;
IAAFDataDef *pDdefSound = 0;
IAAFDataDef* pDDefSceneDesc=0;
IAAFEventMobSlot *pEventSlot=0;
IAAFMobSlot *pSlot=0;
IAAFSequence *pSeqSceneDesc=0;
IAAFSegment *pSegment=0;
IAAFEvent *pEventSceneDesc=0;
IAAFComponent *pComp=0;
HRESULT hr = AAFRESULT_SUCCESS;
// !!!Previous revisions of this file contained variables here required to handle external essence
aafMobID_t masterMobID;
aafProductIdentification_t ProductInfo;
aafRational_t editRate = {30000, 1001};
aafRational_t sampleRate = {44100, 1};
aafRational_t eventTimebase = {30000, 1001};
aafPosition_t position=0;
FILE* pWavFile = NULL;
unsigned char dataBuff[4096], *dataPtr;
// aafUInt32 bytesWritten;
aafUInt32 dataOffset, dataLen;
aafUInt16 bitsPerSample, numCh;
aafInt32 n, numSpecifiers;
aafUID_t essenceFormatCode, testContainer;
aafUInt32 samplesWritten, bytesWritten;
// delete any previous test file before continuing...
char chFileName[1000];
convert(chFileName, sizeof(chFileName), pFileName);
remove(chFileName);
if(dataFile != NULL)
{
// delete any previous test file before continuing...
char chFileName[1000];
convert(chFileName, sizeof(chFileName), dataFile->dataFilename);
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;
check(AAFFileOpenNewModifyEx (pFileName, &kAAFFileKind_Aaf4KBinary, 0, &ProductInfo, &pFile));
check(pFile->GetHeader(&pHeader));
// test
// Get the AAF Dictionary so that we can create valid AAF objects.
check(pHeader->GetDictionary(&pDictionary));
check(pDictionary->LookupClassDef(AUID_AAFMasterMob,
&pCDMasterMob));
check(pDictionary->LookupClassDef(AUID_AAFNetworkLocator,
&pCDNetworkLocator));
check(pDictionary->LookupDataDef(kAAFDataDef_Sound,
&pDdefSound));
// !!!Previous revisions of this file contained code here required to handle external essence
// Get a Master MOB Interface
check(pCDMasterMob->
CreateInstance(IID_IAAFMasterMob,
(IUnknown **)&pMasterMob));
// Get a Mob interface and set its variables.
check(pMasterMob->QueryInterface(IID_IAAFMob, (void **)&pMob));
check(pMob->GetMobID(&masterMobID));
check(pMob->SetName(L"A Master Mob"));
// Add it to the file
check(pHeader->AddMob(pMob));
// !!!Previous revisions of this file contained code here required to handle external essence
if(dataFile != NULL)
{
// Make a locator, and attach it to the EssenceDescriptor
check(pCDNetworkLocator->
CreateInstance(IID_IAAFLocator,
(IUnknown **)&pLocator));
check(pLocator->SetPath (dataFile->dataFilename));
testContainer = dataFile->dataFormat;
}
else
{
pLocator = NULL;
testContainer = ContainerAAF;
}
// open the Essence file to be included in this AAF file("Laser.wav")
pWavFile = fopen("Laser.wav", "r");
if (pWavFile)
{
// read in the essence data
fread(dataBuff, sizeof(unsigned char), sizeof(dataBuff), pWavFile);
check(loadWAVEHeader(dataBuff,
&bitsPerSample,
&numCh,
&sampleRate,
&dataOffset,
&dataLen));
dataPtr = dataBuff + dataOffset;
// now create the Essence data file
check(pMasterMob->CreateEssence(1, // Slot ID
pDdefSound, // MediaKind
kAAFCodecWAVE, // codecID
editRate, // edit rate
sampleRate, // sample rate
kAAFCompressionDisable,
pLocator, // In current file
testContainer, // In AAF Format
&pEssenceAccess));// Compress disabled
check(pEssenceAccess->GetFileFormatParameterList (&format));
check(format->NumFormatSpecifiers (&numSpecifiers));
for(n = 0; n < numSpecifiers; n++)
{
check(format->GetIndexedFormatSpecifier (n, &essenceFormatCode, 0, NULL, NULL));
}
format->Release();
format = NULL;
// Tell the AAFEssenceAccess what the format is.
check(pEssenceAccess->GetEmptyFileFormat (&pFormat));
check(pFormat->NumFormatSpecifiers (&numSpecifiers));
aafInt32 sampleSize = bitsPerSample;
check(pFormat->AddFormatSpecifier (kAAFAudioSampleBits, sizeof(sampleSize), (aafUInt8 *)&sampleSize));
check(pEssenceAccess->PutFileFormat (pFormat));
pFormat->Release();
pFormat = NULL;
// write out the data
check(pEssenceAccess->WriteSamples( dataLen,//!!! hardcoded bytes/sample ==1// Number of Samples
sizeof(dataBuff), // buffer size
dataPtr, // THE data
&samplesWritten,
&bytesWritten));
// close essence data file
fclose(pWavFile);
pWavFile = NULL;
// Finish writing the destination
check(pEssenceAccess->CompleteWrite());
pEssenceAccess->Release();
pEssenceAccess=NULL;
// First register DataDef for SceneDescription
// Is SceneDescription in dictionary already
// Try using Timecode for MC compat
hr = pDictionary->LookupDataDef(kAAFDataDef_Timecode,
&pDDefSceneDesc);
// hr = pDictionary->LookupDataDef(kAAFDataDef_SceneDescription,
// &pDDefSceneDesc);
if (hr != AAFRESULT_SUCCESS)
{
check(pDictionary->CreateInstance(AUID_AAFDataDef,IID_IAAFDataDef,
(IUnknown **)&pDDefSceneDesc));
check(pDDefSceneDesc->Initialize(kAAFDataDef_SceneDescription,
L"SceneDescEvent",L"DataDefinition for Scene Description Events"));
check(pDictionary->RegisterDataDef(pDDefSceneDesc));
}
// Add EventSlot to MasterMob
// Create Slot
check(pDictionary->CreateInstance(AUID_AAFEventMobSlot, IID_IAAFEventMobSlot,
(IUnknown **)&pEventSlot));
check(pEventSlot->SetEditRate(&eventTimebase));
// Get the mob slot interface so that we can add the event segment.
check(pEventSlot->QueryInterface(IID_IAAFMobSlot, (void **)&pSlot));
pEventSlot->Release();
pEventSlot = NULL;
aafSlotID_t eventSlotID=5;
check(pSlot->SetSlotID(eventSlotID));
check(pSlot->SetName(L"SceneDescriptions"));
// Set up Sequence for Scene Descriptors
check(pDictionary->CreateInstance(AUID_AAFSequence,IID_IAAFSequence,
(IUnknown **)&pSeqSceneDesc));
check(pSeqSceneDesc->Initialize(pDDefSceneDesc));
// Create first Comment Marker
check(pDictionary->LookupClassDef(AUID_AAFCommentMarker,
&pCommentMarkerCD));
check(pCommentMarkerCD->CreateInstance(IID_IAAFEvent,
(IUnknown **)&pEventSceneDesc));
position=0;
check(pEventSceneDesc->SetPosition(position));
check(pEventSceneDesc->SetComment(L"Racers heading up the hill"));
check(pEventSceneDesc->QueryInterface(IID_IAAFComponent, (void **)&pComp));
check(pComp->SetDataDef(pDDefSceneDesc));
// Add it to the sequence
check(pSeqSceneDesc->AppendComponent(pComp));
pComp->Release();
pComp = NULL;
pEventSceneDesc->Release();
pEventSceneDesc=NULL;
// Create second Comment Marker
check(pCommentMarkerCD->CreateInstance(IID_IAAFEvent,
(IUnknown **)&pEventSceneDesc));
position=100;
check(pEventSceneDesc->SetPosition(position));
check(pEventSceneDesc->SetComment(L"Racer pulls away from crowd"));
check(pEventSceneDesc->QueryInterface(IID_IAAFComponent, (void **)&pComp));
check(pComp->SetDataDef(pDDefSceneDesc));
// Add it to the sequence
check(pSeqSceneDesc->AppendComponent(pComp));
pComp->Release();
pComp = NULL;
pEventSceneDesc->Release();
pEventSceneDesc=NULL;
check(pSeqSceneDesc->QueryInterface(IID_IAAFSegment, (void **)&pSegment));
// Create third Comment Marker
check(pCommentMarkerCD->CreateInstance(IID_IAAFEvent,
(IUnknown **)&pEventSceneDesc));
position=250;
check(pEventSceneDesc->SetPosition(position));
check(pEventSceneDesc->SetComment(L"Racer passes finish line"));
check(pEventSceneDesc->QueryInterface(IID_IAAFComponent, (void **)&pComp));
check(pComp->SetDataDef(pDDefSceneDesc));
// Add it to the sequence
check(pSeqSceneDesc->AppendComponent(pComp));
pComp->Release();
pComp = NULL;
pEventSceneDesc->Release();
pEventSceneDesc=NULL;
// Add the event sequence to the event mob slot
// Sequence must have at least one component to ensure event mob slot is valid
check(pSlot->SetSegment(pSegment));
pSegment->Release();
pSegment = NULL;
// Append the event slot to the Master Mob
check(pMob->AppendSlot(pSlot));
// Add the KLV data to the Master Mob
// Register the two KLVKeys
check(pDictionary->LookupTypeDef(kAAFTypeID_UInt8Array,
&pUnknownBaseType));
check(pDictionary->RegisterKLVDataKey(KLVKey_BinaryBlob1,
pUnknownBaseType));
check(pDictionary->LookupTypeDef(kAAFTypeID_Int32,
&pInt32BaseType));
check(pDictionary->RegisterKLVDataKey(KLVKey_Int32_1,
pInt32BaseType));
// Next define new ASCII string data def
// check(pDictionary->RegisterKLVDataKey(KLVKey_ASCIIString1,
// pASCIIStringBaseType));
// Get the KLVData ClassDefinition
check(pDictionary->LookupClassDef(AUID_AAFKLVData,
&pKLVDataCD));
// Create KLVData and append it to Mob
check(pKLVDataCD->CreateInstance(IID_IAAFKLVData,
(IUnknown **)&pKLVData));
check(pKLVData->Initialize(KLVKey_BinaryBlob1,
sizeof(blobData), (aafUInt8 *)blobData));
check(pMob->AppendKLVData(pKLVData));
pKLVData->Release();
pKLVData=NULL;
// Create KLVData and append it to Mob
check(pKLVDataCD->CreateInstance(IID_IAAFKLVData,
(IUnknown **)&pKLVData));
check(pKLVData->Initialize(KLVKey_Int32_1,
sizeof(int32Data), (aafUInt8 *)&int32Data));
check(pMob->AppendKLVData(pKLVData));
pKLVData->Release();
pKLVData=NULL;
}
else
{
printf("***Failed to open Wave file Laser.wav\n");
}
// Release all unnecesary interfaces
if (pInt32BaseType)
pInt32BaseType->Release();
pInt32BaseType=NULL;
if (pUnknownBaseType)
pUnknownBaseType->Release();
pUnknownBaseType=NULL;
if (pKLVDataCD)
pKLVDataCD->Release();
pKLVDataCD=NULL;
if (pCommentMarkerCD)
pCommentMarkerCD->Release();
pCommentMarkerCD=NULL;
if(pComp)
pComp->Release();
pComp=NULL;
if(pEventSceneDesc)
pEventSceneDesc->Release();
pEventSceneDesc=0;
if(pSegment)
pSegment->Release();
pSegment=NULL;
if(pSeqSceneDesc)
pSeqSceneDesc->Release();
pSeqSceneDesc=NULL;
if(pSlot)
pSlot->Release();
pSlot=NULL;
if(pEventSlot)
pEventSlot->Release();
pEventSlot=NULL;
if(pDDefSceneDesc)
pDDefSceneDesc->Release();
pDDefSceneDesc=NULL;
if(pMasterMob)
pMasterMob->Release();
pMasterMob = NULL;
if(pMob)
pMob->Release();
pMob = NULL;
if(pDictionary)
pDictionary->Release();
pDictionary = NULL;
if(pHeader)
pHeader->Release();
pHeader = NULL;
//!!!DebugOnly
pFile->Save();
pFile->Close();
pFile->Release();
pFile = NULL;
if (pEssenceAccess)
{
pEssenceAccess->Release();
pEssenceAccess= NULL;
}
cleanup:
// Cleanup and return
if(pFormat)
pFormat->Release();
if(format)
format->Release();
if(pLocator)
pLocator->Release();
if (pWavFile)
fclose(pWavFile);
if (pEssenceAccess)
pEssenceAccess->Release();
if (pMultiEssence)
pMultiEssence->Release();
if (pMasterMob)
pMasterMob->Release();
if (pMob)
pMob->Release();
if (pDictionary)
pDictionary->Release();
if (pHeader)
pHeader->Release();
if (pCDMasterMob)
{
pCDMasterMob->Release();
pCDMasterMob = 0;
}
if (pCDNetworkLocator)
{
pCDNetworkLocator->Release();
pCDNetworkLocator = 0;
}
if (pDdefSound)
{
pDdefSound->Release ();
pDdefSound = 0;
}
if (pFile)
{
pFile->Close();
pFile->Release();
}
return moduleErrorTmp;
}
static HRESULT CreateAAFFile(const aafWChar * pFileName)
{
IAAFFile* pFile = NULL;
IAAFHeader* pHeader = NULL;
IAAFDictionary* pDictionary = NULL;
IAAFMob* pMob = NULL;
IAAFMasterMob* pMasterMob = NULL;
IAAFEssenceAccess* pEssenceAccess = NULL;
IAAFEssenceFormat* pFormat = NULL;
IAAFLocator *pLocator = NULL;
aafMobID_t masterMobID;
aafProductIdentification_t ProductInfo;
aafRational_t editRate = {11025, 1};
aafRational_t sampleRate = {11025, 1};
IAAFClassDef *pCDMasterMob = NULL;
IAAFDataDef *pSoundDef = NULL;
aafUInt32 samplesWritten, bytesWritten;
// Delete any previous test file before continuing...
char cFileName[FILENAME_MAX];
convert(cFileName, sizeof(cFileName), pFileName);
remove(cFileName);
aafProductVersion_t ver = {1, 0, 0, 0, kAAFVersionBeta};
ProductInfo.companyName = companyName;
ProductInfo.productName = productName;
ProductInfo.productVersion = &ver;
ProductInfo.productVersionString = NULL;
ProductInfo.productID = NIL_UID;
ProductInfo.platform = NULL; // Set by SDK when saving
// Create a new AAF file
check(AAFFileOpenNewModify (pFileName, 0, &ProductInfo, &pFile));
check(pFile->GetHeader(&pHeader));
// Get the AAF Dictionary from the file
check(pHeader->GetDictionary(&pDictionary));
/* Lookup class definitions for the objects we want to create. */
check(pDictionary->LookupClassDef(AUID_AAFMasterMob, &pCDMasterMob));
/* Lookup any necessary data definitions. */
check(pDictionary->LookupDataDef(kAAFDataDef_Sound, &pSoundDef));
/* Create a Mastermob */
// Get a Master MOB Interface
check(pCDMasterMob->CreateInstance(IID_IAAFMasterMob, (IUnknown **)&pMasterMob));
// Get a Mob interface and set its variables.
check(pMasterMob->QueryInterface(IID_IAAFMob, (void **)&pMob));
check(pMob->GetMobID(&masterMobID));
if (input_video == NULL)
{
check(pMob->SetName(L"Laser"));
}
else
{
check(pMob->SetName(pFileName));
}
// Add Mobs to the Header
check(pHeader->AddMob(pMob));
// Locator needed for non-embedded essence
IAAFClassDef *classDef = NULL;
check(pDictionary->LookupClassDef(AUID_AAFNetworkLocator, &classDef));
check(classDef->CreateInstance(IID_IAAFLocator, (IUnknown **)&pLocator));
classDef->Release();
classDef = NULL;
if (container == NIL_UID)
{
pLocator = NULL;
}
else if (container == ContainerAAF)
{
check(pLocator->SetPath(L"Laser.aaf"));
remove("Laser.aaf");
}
else if (container == ContainerFile)
{
check(pLocator->SetPath(L"Laser.pcm"));
remove("Laser.pcm");
}
else // RIFFWAVE container
{
check(pLocator->SetPath(L"Laser.wav"));
remove("Laser.wav");
}
// Get a pointer to video data for WriteSamples
unsigned char *dataPtr, buf[4096];
memcpy(buf, uncompressedWAVE_Laser+44, sizeof(uncompressedWAVE_Laser));
dataPtr = buf;
/* Create the Essence Data specifying the codec, container, edit rate and sample rate */
check(pMasterMob->CreateEssence(1, // Slot ID within MasterMob
pSoundDef, // MediaKind
kAAFCodecPCM, // codecID
editRate, // edit rate
sampleRate, // sample rate
kAAFCompressionDisable,
pLocator, // Locator
container, // Container
&pEssenceAccess)); //
pEssenceAccess->SetEssenceCodecFlavour( kAAFNilCodecFlavour );
// Set Format specifiers that describe the essence data
// Sample rate is already specified in the CreateEssence() call
aafUInt32 sampleBits = 8;
aafUInt32 numChannels = 1;
check(pEssenceAccess->GetEmptyFileFormat(&pFormat));
check(pFormat->AddFormatSpecifier(kAAFAudioSampleBits, sizeof(sampleBits), (aafUInt8 *)&sampleBits));
check(pFormat->AddFormatSpecifier(kAAFNumChannels, sizeof(numChannels), (aafUInt8 *)&numChannels));
check(pEssenceAccess->PutFileFormat(pFormat));
pFormat->Release();
/* Write the samples */
int total_samples = 0;
if (input_video == NULL) // using generated uncompressed video?
{
for (int i = 0; i < 1793; i++) // Laser example has 1793 samples
{
check(pEssenceAccess->WriteSamples(
1, //
sizeof(buf), // buffer size
dataPtr++, // pointer to video frame
&samplesWritten,
&bytesWritten));
total_samples += samplesWritten;
}
}
printf("Wrote %d samples\n", total_samples);
/* Set the essence to indicate that you have finished writing the samples */
check(pEssenceAccess->CompleteWrite());
pEssenceAccess->Release();
pEssenceAccess = NULL;
/* Release COM interfaces */
pMob->Release();
pMasterMob->Release();
pSoundDef->Release();
pCDMasterMob->Release();
pDictionary->Release();
pHeader->Release();
/* Save the AAF file */
pFile->Save();
/* Close the AAF file */
pFile->Close();
pFile->Release();
return moduleErrorTmp;
}
