ardour/livetrax
13
0
Fork 0
Code
5d2a25827e
livetrax/libs/aaf/AAFCore.c

1905 lines
54 KiB
C
Raw Blame History

/*
* Copyright (C) 2017-2023 Adrien Gesta-Fline
*
* This file is part of libAAF.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "aaf/AAFCore.h"
#include "aaf/AAFDump.h"
#include "aaf/AAFToText.h"
#include "aaf/AAFTypes.h"
#include "aaf/AAFDefs/AAFClassDefUIDs.h"
#include "aaf/AAFDefs/AAFFileKinds.h"
#include "aaf/AAFDefs/AAFPropertyIDs.h"
#include "aaf/AAFDefs/AAFTypeDefUIDs.h"
#include "aaf/debug.h"
#include "aaf/AAFClass.h"
#include "aaf/utils.h"
#define debug(...) \
_dbg (aafd->dbg, aafd, DEBUG_SRC_ID_AAF_CORE, VERB_DEBUG, __VA_ARGS__)
#define warning(...) \
_dbg (aafd->dbg, aafd, DEBUG_SRC_ID_AAF_CORE, VERB_WARNING, __VA_ARGS__)
#define error(...) \
_dbg (aafd->dbg, aafd, DEBUG_SRC_ID_AAF_CORE, VERB_ERROR, __VA_ARGS__)
/**
* Loops through each aafPropertyIndexEntry_t of a "properties" node stream.
*
* @param Header Pointer to the stream's aafPropertyIndexHeader_t struct.
* @param Entry Pointer that will receive each aafPropertyIndexEntry_t struct.
* @param Value Pointer to each property's data value, of aafPropertyIndexEntry_t._length
* bytes length.
* @param i uint32_t iterator.
*/
#define foreachPropertyEntry(propStream, Header, Entry, Value, valueOffset, i) \
for (valueOffset = sizeof (aafPropertyIndexHeader_t) + (Header._entryCount * sizeof (aafPropertyIndexEntry_t)), \
i = 0; \
i < Header._entryCount && \
memcpy (&Entry, (propStream + ((sizeof (aafPropertyIndexHeader_t)) + (sizeof (aafPropertyIndexEntry_t) * i))), sizeof (aafPropertyIndexEntry_t)) && \
(Value = propStream + valueOffset); \
valueOffset += Entry._length, \
i++)
/**
* Loops through each aafStrongRefSetEntry_t of a StrongRefSet Index node stream.
*
* @param Header Pointer to the stream's aafStrongRefSetHeader_t struct.
* @param Entry Pointer that will receive each aafStrongRefSetEntry_t struct.
* @param i uint32_t iterator.
*/
#define foreachStrongRefSetEntry(Header, Entry, i) \
for (i = 0; \
i < Header->_entryCount && \
memcpy (&Entry, ((char*)(Header)) + (sizeof (aafStrongRefSetHeader_t) + (Header->_identificationSize + sizeof (aafStrongRefSetEntry_t)) * i), sizeof (aafStrongRefSetEntry_t) + Header->_identificationSize); \
i++)
/**
* Loops through each aafStrongRefVectorEntry_t of a StrongRefVector Index node stream.
*
* @param Header Pointer to the stream's aafStrongRefVectorHeader_t struct.
* @param Entry Pointer that will receive each aafStrongRefVectorEntry_t struct.
* @param i uint32_t iterator.
*/
#define foreachStrongRefVectorEntry(vectorStream, Header, Entry, i) \
for (i = 0; \
i < Header._entryCount && \
memcpy (&Entry, (vectorStream + (sizeof (aafStrongRefVectorHeader_t) + (sizeof (aafStrongRefVectorEntry_t) * i))), sizeof (aafStrongRefVectorEntry_t)); \
i++)
#define attachNewProperty(Class, PDef, Pid, IsReq) \
PDef = calloc (sizeof (aafPropertyDef), sizeof (unsigned char)); \
if (PDef == NULL) { \
error ("%s.", strerror (errno)); \
return NULL; \
} \
PDef->pid = Pid; \
PDef->isReq = IsReq; \
PDef->meta = 0; \
PDef->name = NULL; \
PDef->next = Class->Properties; \
Class->Properties = PDef;
/*
* Retrieves useful file informations out of Header Object.
*
* @param aafd Pointer to the AAF_Data structure.
*
* @return 0 on success\n
* -1 on error.
*/
static int
parse_Header (AAF_Data* aafd);
/*
* Retrieves useful file informations out of Identification Object.
*
* @param aafd Pointer to the AAF_Data structure.
*
* @return 0 on success\n
* -1 on error.
*/
static int
parse_Identification (AAF_Data* aafd);
/*
* Tests the CFB_Data.hdr._clsid field for a valid AAF file.
*
* @note The spec says that the AAFFileKind signature should be retrieved from the CLSID
* of the Root IStorage. In practice, this CLSID holds the #AAFClassID_Root value, and
* the AAFFileKind is (sometimes) found in the CLSID of the CFB_Header, which according
* to the CFB spec should be zero. All of this has been observed in AAF files built with
* the official AAFSDK.
*
* As a conclusion, the way to test for a valid AAF file is not a valid test itself.. or
* not sufficiently documented. Thus, this function shall not be trusted until further
* knowledge improvement.
*
* @param aafd Pointer to the AAF_Data structure.
*
* @return 1 if the file *looks like* a valid AAF\n
* 0 otherwise.
*/
// static int isValidAAF( AAF_Data *aafd );
/**
* Sets the AAF_Data structure's pointers to the main AAF Tree objects. These pointers
* can then be used for quick conveniant objects access.
*
* @param aafd Pointer to the AAF_Data structure.
*/
static void
setObjectShortcuts (AAF_Data* aafd);
/**
* Parses the entire Compound File Binary Tree and retrieves Objets and Properties.
*
* This function first parses the Root Object, then follows the Root::MetaDictionary to
* retrieve potential custom Classes and Properties with retrieveMetaDictionaryClass(),
* and then parses the rest of the Tree starting at Root::Header.
*
* This function should be called after the AAF Classes has been defined by
* #aafclass_setDefaultClasses(). This function is called by aaf_load_file().
*
* @param aafd Pointer to the AAF_Data structure.
*/
static int
retrieveObjectTree (AAF_Data* aafd);
/**
* Parses the entire MetaDictionary, retrieving potential custom classes and properties.
* This function is to be called within a loop that iterates through the
* MetaDictionary::ClassDefinitions Objects, and by itself when looking for parent
* Classes.
*
* @param aafd Pointer to the AAF_Data structure.
* @param TargetClassDef Pointer to the current ClassDefinition Object.
*
* @return A pointer to the retrieved Class.
*/
static aafClass*
retrieveMetaDictionaryClass (AAF_Data* aafd, aafObject* TargetClassDef);
/**
* Allocates a new aafObject structure, and adds it to the AAF_Data.Objects list.
*
* @param aafd Pointer to the AAF_Data structure.
* @param node Pointer to the corresponding cfbNode structure.
* @param Class Pointer to the corresponding class definition aafClass structure.
* @param parent Pointer to the new Object's parent object, that is the one that has an
* ownership reference (Strong Ref Set/Vector) to the new Object.
*
* @return A pointer to the newly created aafObject.
*/
static aafObject*
newObject (AAF_Data* aafd, cfbNode* node, aafClass* Class, aafObject* parent);
/**
* Allocates a new aafProperty structure.
*
* @param Def Pointer to the corresponding property definition aafPropertyDef structure.
*
* @return A pointer to the newly created aafProperty.
*/
static aafProperty*
newProperty (AAF_Data* aafd, aafPropertyDef* Def);
/**
* Test whether or not, a property ID (property definition) was already retrieved for a given Class.
*
* @param Class Pointer to the aafClass.
* @param Pid Property ID.
*
* @return A pointer to the retrieved property definition\n
* NULL otherwise.
*/
static aafPropertyDef*
propertyIdExistsInClass (aafClass* Class, aafPID_t Pid);
/**
* Sets the aafStrongRefSetHeader_t Obj->Header and aafStrongRefSetEntry_t Obj->Entry,
* when parsing an Object from a StrongReferenceSet. This function is called by the
* #retrieveStrongReferenceSet() function.
*
* @param Obj Pointer to an aafObject structure.
* @param Header Pointer to an aafStrongRefSetHeader_t structure.
* @param Entry Pointer to an aafStrongRefSetEntry_t structure.
*/
static int
setObjectStrongRefSet (aafObject* Obj, aafStrongRefSetHeader_t* Header, aafStrongRefSetEntry_t* Entry);
/**
* Sets the aafStrongRefVectorHeader_t Obj->Header and aafStrongRefVectorEntry_t
* Obj->Entry, when parsing an Object from a StrongReferenceSet. This function is called
* by the retrieveStrongReferenceVector() function.
*
* @param Obj Pointer to an aafObject structure.
* @param Header Pointer to an aafStrongRefVectorHeader_t structure.
* @param Entry Pointer to an aafStrongRefVectorEntry_t structure.
*/
static int
setObjectStrongRefVector (aafObject* Obj, aafStrongRefVectorHeader_t* Header, aafStrongRefVectorEntry_t* Entry);
/**
* Retrieves and parses a single StrongReference Object. This function is called by
* retrieveProperty() when it encounters an SF_STRONG_OBJECT_REFERENCE property.
*
* @param aafd Pointer to the AAF_Data structure.
* @param Prop Pointer to the property holding the SF_STRONG_OBJECT_REFERENCE.
* @param parent Pointer to the parent Object which holds the Prop property.
*/
static int
retrieveStrongReference (AAF_Data* aafd, aafProperty* Prop, aafObject* parent);
/**
* Retrieves and parses StrongReferenceSet Objects. This function is called by
* retrieveProperty() when it encounters an SF_STRONG_OBJECT_REFERENCE_SET property.
*
* @param aafd Pointer to the AAF_Data structure.
* @param Prop Pointer to the property holding the SF_STRONG_OBJECT_REFERENCE_SET.
* @param parent Pointer to the parent Object which holds the Prop property.
*/
static int
retrieveStrongReferenceSet (AAF_Data* aafd, aafProperty* Prop, aafObject* parent);
/**
* Retrieve and parse StrongReferenceVector Objects. This function is called by
* retrieveProperty() when it encounters an SF_STRONG_OBJECT_REFERENCE_VECTOR property.
*
* @param aafd Pointer to the AAF_Data structure.
* @param Prop Pointer to the property holding the SF_STRONG_OBJECT_REFERENCE_VECTOR.
* @param parent Pointer to the parent Object which holds the Prop property.
*/
static int
retrieveStrongReferenceVector (AAF_Data* aafd, aafProperty* Prop, aafObject* parent);
/**
* Adds a new aafProperty to an Object->properties list. If the property Stored Form is
* either SF_STRONG_OBJECT_REFERENCE, SF_STRONG_OBJECT_REFERENCE_SET or
* SF_STRONG_OBJECT_REFERENCE_VECTOR, then the function follows the "link" to the
* Object(s) by calling respectively retrieveStrongReference(),
* retrieveStrongReferenceSet() or retrieveStrongReferenceVector(). This function is
* called by retrieveObjectProperties().
*
* @param aafd Pointer to the AAF_Data structure.
* @param Obj Pointer to the aafObject structure holding this property.
* @param Def Pointer to the aafPropertyDef structure defining this property.
* @param p Pointer to the aafPropertyIndexEntry_t structure representing the property
* in the file.
* @param v Pointer to a p->_length long byte array holding the actual property value.
* @param bo uint8_t specifying the property's Byte Order. TO BE IMPLEMENTED
*
* @TODO Take ByteOrder into account
*/
static int
retrieveProperty (AAF_Data* aafd, aafObject* Obj, aafPropertyDef* Def, aafPropertyIndexEntry_t* p, aafByte_t* v, uint8_t bo);
/**
* Retrieves the properties for a given aafObject.
*
* @param aafd Pointer to the AAF_Data structure.
* @param Obj Pointer to the aafObject holding the properties.
*/
static int
retrieveObjectProperties (AAF_Data* aafd, aafObject* Obj);
/**
* Retrieves a StrongRef Set/Vector Index Node in the Compound File Tree. This function
* is called by both retrieveStrongReferenceSet() and retrieveStrongReferenceVector().
*
* @param aafd Pointer to the AAF_Data structure.
* @param parent Pointer to the parent aafObject.
* @param refName Pointer to a null terminated string holding the reference name.
*
* @return Pointer to the retrieved Node cfbNode structure.
*/
static cfbNode*
getStrongRefIndexNode (AAF_Data* aafd, aafObject* parent, const wchar_t* refName);
/**
* Retrieves a StrongRef Set or Vector Entry Node in the Compound File Tree. This
* function is called by both retrieveStrongReferenceSet() and
* retrieveStrongReferenceVector().
*
* @param aafd Pointer to the AAF_Data structure.
* @param parent Pointer to the parent Index Node.
* @param baseName Pointer to a null terminated string holding the reference base name.
* @param index uint32_t number representing the index number of the reference.
*
* @return Pointer to the retrieved Node cfbNode structure.
*/
static cfbNode*
getStrongRefEntryNode (AAF_Data* aafd, aafObject* parent, const wchar_t* baseName, uint16_t index);
/**
* Retrieves and returns a list of aafPropertyIndexHeader_t.
* For a given cfbNode, retrieves its /properties Stream Node and returns the stream as
* a pointer to an aafPropertyIndexHeader_t structure, wich the stream should begin with.
*
* @param aafd Pointer to the AAF_Data structure.
* @param node Pointer to a cfbNode structure.
*
* @return Pointer to an aafPropertyIndexHeader_t structure, followed by _entryCount
* aafPropertyIndexEntry_t structures.
*/
static aafByte_t*
getNodeProperties (AAF_Data* aafd, cfbNode* node);
/**
* Retrieves and returns a list of StrongReferenceSet.
*
* For a given Index cfbNode, retrieves its Stream and returns it as a pointer to an
* aafStrongRefSetHeader_t structure, wich the stream should begin with.
*
* @param aafd Pointer to the AAF_Data structure.
* @param node Pointer to an Index cfbNode structure.
* @param parent Pointer to the aafObject parent, only used on error printing.
*
* @return Pointer to an aafStrongRefSetHeader_t structure, followed by _entryCount
* aafStrongRefSetEntry_t structures.
*/
static aafStrongRefSetHeader_t*
getStrongRefSetList (AAF_Data* aafd, cfbNode* node, aafObject* parent);
/**
* Retrieves and returns a list of StrongReferenceVectors.
*
* For a given Index cfbNode, retrieves its Stream and returns it as a pointer to an
* aafStrongRefVectorHeader_t structure, wich the stream should begin with.
*
* @param aafd Pointer to the AAF_Data structure.
* @param node Pointer to an Index cfbNode structure.
* @param parent Pointer to the aafObject parent, only used on error printing.
*
* @return Pointer to an aafStrongRefVectorHeader_t structure, followed by
* _entryCount aafStrongRefVectorEntry_t structures.
*/
static aafByte_t*
getStrongRefVectorList (AAF_Data* aafd, cfbNode* node, aafObject* parent);
AAF_Data*
aaf_alloc (struct dbg* dbg)
{
AAF_Data* aafd = calloc (sizeof (AAF_Data), sizeof (unsigned char));
if (aafd == NULL)
error ("%s.", strerror (errno));
aafd->cfbd = NULL;
// aafd->verb = VERB_QUIET;
aafd->Identification.CompanyName = NULL;
aafd->Identification.ProductName = NULL;
aafd->Identification.ProductVersionString = NULL;
aafd->Identification.Platform = NULL;
aafd->Classes = NULL;
aafd->Objects = NULL;
// aafd->debug_callback = &laaf_debug_callback;
aafd->dbg = dbg;
aafd->cfbd = cfb_alloc (dbg);
if (aafd->cfbd == NULL) {
return NULL;
}
// aafd->cfbd->verb = aafd->verb;
return aafd;
}
int
aaf_load_file (AAF_Data* aafd, const char* file)
{
if (file == NULL)
return 1;
aafd->Objects = NULL;
aafd->Classes = NULL;
if (cfb_load_file (&aafd->cfbd, file) < 0) {
return 1;
}
/*
* NOTE: at least Avid Media Composer doesn't respect
* the standard clsid AAFFileKind_Aaf4KBinary identifier.
* Therefore isValidAAF() is useless until futher findings..
*/
// if ( isValidAAF( aafd ) == 0 ) {
// return 1;
// }
if (aafclass_setDefaultClasses (aafd) < 0) {
return -1;
}
if (retrieveObjectTree (aafd) < 0) {
return -1;
}
if (parse_Header (aafd) < 0) {
return -1;
}
if (parse_Identification (aafd) < 0) {
return -1;
}
return 0;
}
void
aaf_release (AAF_Data** aafd)
{
if (aafd == NULL || *aafd == NULL)
return;
if ((*aafd)->cfbd != NULL)
cfb_release (&((*aafd)->cfbd));
aafClass* Class = NULL;
aafClass* tmpClass = NULL;
for (Class = (*aafd)->Classes; Class != NULL; Class = tmpClass) {
tmpClass = Class->next;
aafPropertyDef* PDef = NULL;
aafPropertyDef* tmpPDef = NULL;
if (Class->name != NULL) {
free (Class->name);
}
for (PDef = Class->Properties; PDef != NULL; PDef = tmpPDef) {
tmpPDef = PDef->next;
// if ( PDef->meta ) {
if (PDef->name != NULL)
free (PDef->name);
// }
free (PDef);
}
free (Class);
}
aafObject* Object = NULL;
aafObject* tmpObject = NULL;
for (Object = (*aafd)->Objects; Object != NULL; Object = tmpObject) {
tmpObject = Object->nextObj;
if (Object->Header != NULL)
free (Object->Header);
if (Object->Entry != NULL)
free (Object->Entry);
aafProperty* Prop = NULL;
aafProperty* tmpProp = NULL;
for (Prop = Object->Properties; Prop != NULL; Prop = tmpProp) {
tmpProp = Prop->next;
switch (Prop->sf) {
case SF_STRONG_OBJECT_REFERENCE:
case SF_STRONG_OBJECT_REFERENCE_SET:
case SF_STRONG_OBJECT_REFERENCE_VECTOR:
break;
default:
free (Prop->val);
}
free (Prop);
}
free (Object);
}
if ((*aafd)->Identification.CompanyName != NULL) {
free ((*aafd)->Identification.CompanyName);
}
if ((*aafd)->Identification.ProductName != NULL) {
free ((*aafd)->Identification.ProductName);
}
if ((*aafd)->Identification.ProductVersionString != NULL) {
free ((*aafd)->Identification.ProductVersionString);
}
if ((*aafd)->Identification.Platform != NULL) {
free ((*aafd)->Identification.Platform);
}
/* free once in AAFIface */
// if ( (*aafd)->dbg ) {
// laaf_free_debug( (*aafd)->dbg );
// }
free (*aafd);
*aafd = NULL;
}
wchar_t*
aaf_get_ObjectPath (aafObject* Obj)
{
static wchar_t path[CFB_PATH_NAME_SZ];
uint32_t offset = CFB_PATH_NAME_SZ;
path[--offset] = 0x0000; // NULL terminating byte
while (Obj != NULL) {
for (int i = wcslen (Obj->Name) - 1; i >= 0 && offset > 0; i--) {
path[--offset] = Obj->Name[i];
}
if (offset == 0)
break;
path[--offset] = '/';
Obj = Obj->Parent;
}
return path + offset;
}
int
_aaf_foreach_ObjectInSet (aafObject** Obj, aafObject* head, const aafUID_t* filter)
{
if (*Obj == NULL)
*Obj = head;
else
*Obj = (*Obj)->next;
if (filter != NULL)
for (; *Obj != NULL; *Obj = (*Obj)->next)
if (aafUIDCmp ((*Obj)->Class->ID, filter))
break;
return (*Obj == NULL) ? 0 : 1;
}
aafObject*
aaf_get_ObjectByWeakRef (aafObject* list, aafWeakRef_t* ref)
{
if (ref == NULL ||
list == NULL ||
list->Entry == NULL) {
return NULL;
}
AAF_Data* aafd = list->aafd;
/* Target is a Reference Vector */
if (list->Header->_identificationSize == 0) {
// debug( "Has local key" );
for (; list != NULL; list = list->next) {
if (list->Entry->_localKey == ref->_referencedPropertyIndex) {
// debug( "list->Entry->_localKey : 0x%x", list->Entry->_localKey );
// debug( "list->Header->_identificationSize : %u", list->Header->_identificationSize );
// debug( "FOUND : 0x%x", list->Entry->_localKey );
return list;
}
}
}
/* Target is a Reference Set */
else {
for (; list != NULL; list = list->next) {
if (memcmp (list->Entry->_identification, ref->_identification, ref->_identificationSize) == 0) {
if (list->Header->_identificationSize != ref->_identificationSize) {
/* TODO : is it possible ? is it an error ? */
debug ("list->Header->_identificationSize (%i bytes) doesn't match ref->_identificationSize (%i bytes)", list->Header->_identificationSize, ref->_identificationSize);
}
return list;
}
}
}
return NULL;
}
aafObject*
aaf_get_MobByID (aafObject* Mobs, aafMobID_t* MobID)
{
aafObject* Mob = NULL;
if (MobID == NULL)
return NULL;
aaf_foreach_ObjectInSet (&Mob, Mobs, NULL)
{
aafMobID_t* Current = aaf_get_propertyValue (Mob, PID_Mob_MobID, &AAFTypeID_MobIDType);
if (Current == NULL || aafMobIDCmp (Current, MobID))
break;
}
return Mob;
}
aafObject*
aaf_get_MobSlotBySlotID (aafObject* MobSlots, aafSlotID_t SlotID)
{
aafObject* MobSlot = NULL;
aaf_foreach_ObjectInSet (&MobSlot, MobSlots, NULL)
{
aafSlotID_t* CurrentSlotID = aaf_get_propertyValue (MobSlot, PID_MobSlot_SlotID, &AAFTypeID_UInt32);
if (CurrentSlotID == NULL || *CurrentSlotID == SlotID)
break;
}
return MobSlot;
}
/*
* TODO Works when the property was retrieved from MetaDictionary. What if the property is standard ?
*/
aafPID_t
aaf_get_PropertyIDByName (AAF_Data* aafd, const wchar_t* name)
{
aafClass* Class = NULL;
foreachClass (Class, aafd->Classes)
{
aafPropertyDef* PDef = NULL;
foreachPropertyDefinition (PDef, Class->Properties)
{
if (PDef->name != NULL && wcscmp (PDef->name, name) == 0) {
return PDef->pid;
}
}
}
return 0;
}
aafProperty*
aaf_get_property (aafObject* Obj, aafPID_t pid)
{
if (Obj == NULL)
return NULL;
AAF_Data* aafd = Obj->aafd;
aafProperty* Prop = NULL;
for (Prop = Obj->Properties; Prop != NULL; Prop = Prop->next)
if (Prop->pid == pid)
break;
if (Prop == NULL) {
aafPropertyDef* PDef = aafclass_getPropertyDefinitionByID (Obj->Class, pid);
if (PDef == NULL) {
warning ("Unknown property 0x%04x (%ls) of Class %ls", pid, aaft_PIDToText (aafd, pid), aaft_ClassIDToText (aafd, Obj->Class->ID));
return NULL;
}
if (PDef->isReq) {
error ("Could not retrieve %ls required property 0x%04x (%ls)", aaft_ClassIDToText (aafd, Obj->Class->ID), pid, aaft_PIDToText (aafd, pid));
} else {
debug ("Could not retrieve %ls optional property 0x%04x (%ls)", aaft_ClassIDToText (aafd, Obj->Class->ID), pid, aaft_PIDToText (aafd, pid));
}
}
return Prop;
}
void*
aaf_get_propertyValue (aafObject* Obj, aafPID_t pid, const aafUID_t* typeID)
{
if (Obj == NULL) {
return NULL;
}
AAF_Data* aafd = Obj->aafd;
aafProperty* Prop = aaf_get_property (Obj, pid);
if (Prop == NULL) {
return NULL;
}
void* value = Prop->val;
uint16_t len = Prop->len;
if (Prop->sf == SF_DATA_STREAM || aafUIDCmp (typeID, &AAFTypeID_Indirect)) {
/*
* DATA_STREAM stored form and IndirectValues start with a byte identifying byte order : 0x4c, 0x42, 0x55
* We must skip that byte.
*/
value = (void*)(((char*)value) + 1);
len--;
}
if (aafUIDCmp (typeID, &AAFTypeID_String)) {
if (((uint16_t*)value)[(len / 2) - 1] != 0x0000) {
error ("Object %ls string property 0x%04x (%ls) does not end with NULL", aaft_ClassIDToText (aafd, Obj->Class->ID), pid, aaft_PIDToText (aafd, pid));
return NULL;
}
return cfb_w16towchar (NULL, value, len);
}
if (aafUIDCmp (typeID, &AAFTypeID_Indirect)) {
/*
* In case of Indirect with string value we check NULL termination here,
* because when calling next aaf_get_indirectValue() we wont have access
* to Prop->len anymore.
*/
aafIndirect_t* Indirect = value;
if (aafUIDCmp (&Indirect->TypeDef, &AAFTypeID_String) && ((uint16_t*)value)[(len / 2) - 1] != 0x0000) {
error ("Object %ls Indirect::string property 0x%04x (%ls) does not end with NULL", aaft_ClassIDToText (aafd, Obj->Class->ID), pid, aaft_PIDToText (aafd, pid));
return NULL;
}
}
if ((aafUIDCmp (typeID, &AAFTypeID_Boolean) && len != sizeof (aafBoolean_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_Int8) && len != sizeof (int8_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_UInt8) && len != sizeof (uint8_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_Int16) && len != sizeof (int16_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_UInt16) && len != sizeof (uint16_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_Int32) && len != sizeof (int32_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_UInt32) && len != sizeof (uint32_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_Int64) && len != sizeof (int64_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_UInt64) && len != sizeof (uint64_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_PositionType) && len != sizeof (aafPosition_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_LengthType) && len != sizeof (aafLength_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_Rational) && len != sizeof (aafRational_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_TimeStamp) && len != sizeof (aafTimeStamp_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_VersionType) && len != sizeof (aafVersionType_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_ProductVersion) && len != sizeof (aafProductVersion_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_UsageType) && len != sizeof (aafUID_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_AUID) && len != sizeof (aafUID_t)) ||
(aafUIDCmp (typeID, &AAFTypeID_MobIDType) && len != sizeof (aafMobID_t))) {
error ("Object %ls property 0x%04x (%ls) size (%u) does not match type %ls", aaft_ClassIDToText (aafd, Obj->Class->ID), pid, aaft_PIDToText (aafd, pid), len, aaft_TypeIDToText (typeID));
return NULL;
}
return value;
}
void*
aaf_get_indirectValue (AAF_Data* aafd, aafIndirect_t* Indirect, const aafUID_t* typeDef)
{
if (Indirect == NULL) {
error ("Indirect is NULL");
return NULL;
}
if (typeDef && aafUIDCmp (&Indirect->TypeDef, typeDef) == 0) {
error ("Requested Indirect value of type %ls but has type %ls", aaft_TypeIDToText (typeDef), aaft_TypeIDToText (&Indirect->TypeDef));
return NULL;
}
if (aafUIDCmp (typeDef, &AAFTypeID_String)) {
/*
* Indirect->Value is guaranted by aaf_get_property() to be NULL terminated
*/
size_t indirectValueSize = 0;
for (size_t i = 0; (i % 2 || !(Indirect->Value[i] == 0x00 && Indirect->Value[i + 1] == 0x00)); i++) {
indirectValueSize++;
}
indirectValueSize += 2;
uint16_t* w16 = malloc (indirectValueSize);
if (w16 == NULL) {
error ("%s.", strerror (errno));
return NULL;
}
memcpy (w16, Indirect->Value, indirectValueSize);
wchar_t* str = cfb_w16towchar (NULL, w16, indirectValueSize);
free (w16);
return str;
}
return &Indirect->Value;
}
static int
parse_Header (AAF_Data* aafd)
{
aafObject* Header = aafd->Header.obj;
if (Header == NULL) {
error ("Missing Header Object.");
return -1;
}
int16_t* ByteOrder = aaf_get_propertyValue (Header, PID_Header_ByteOrder, &AAFTypeID_Int16);
if (ByteOrder == NULL) {
warning ("Missing Header::ByteOrder.");
} else {
aafd->Header.ByteOrder = *ByteOrder;
}
aafTimeStamp_t* LastModified = aaf_get_propertyValue (Header, PID_Header_LastModified, &AAFTypeID_TimeStamp);
if (LastModified == NULL) {
warning ("Missing Header::LastModified.");
} else {
aafd->Header.LastModified = LastModified;
}
aafVersionType_t* Version = aaf_get_propertyValue (Header, PID_Header_Version, &AAFTypeID_VersionType);
if (Version == NULL) {
warning ("Missing Header::Version.");
} else {
aafd->Header.Version = Version;
}
uint32_t* ObjectModelVersion = aaf_get_propertyValue (Header, PID_Header_ObjectModelVersion, &AAFTypeID_UInt32);
if (ObjectModelVersion == NULL) {
warning ("Missing Header::ObjectModelVersion.");
} else {
aafd->Header.ObjectModelVersion = *ObjectModelVersion;
}
const aafUID_t* OperationalPattern = aaf_get_propertyValue (Header, PID_Header_OperationalPattern, &AAFTypeID_AUID);
if (OperationalPattern == NULL) {
warning ("Missing Header::OperationalPattern.");
aafd->Header.OperationalPattern = (const aafUID_t*)&AUID_NULL;
} else {
aafd->Header.OperationalPattern = OperationalPattern;
}
return 0;
}
static int
parse_Identification (AAF_Data* aafd)
{
aafObject* Identif = aafd->Identification.obj;
if (Identif == NULL) {
error ("Missing Identification Object.");
return -1;
}
wchar_t* Company = aaf_get_propertyValue (Identif, PID_Identification_CompanyName, &AAFTypeID_String);
if (Company == NULL) {
warning ("Missing Identification::CompanyName.");
} else {
aafd->Identification.CompanyName = Company;
}
wchar_t* ProductName = aaf_get_propertyValue (Identif, PID_Identification_ProductName, &AAFTypeID_String);
if (ProductName == NULL) {
warning ("Missing Identification::ProductName.");
} else {
aafd->Identification.ProductName = ProductName;
}
aafProductVersion_t* ProductVersion = aaf_get_propertyValue (Identif, PID_Identification_ProductVersion, &AAFTypeID_ProductVersion);
if (ProductVersion == NULL) {
warning ("Missing Identification::ProductVersion.");
} else {
aafd->Identification.ProductVersion = ProductVersion;
}
wchar_t* ProductVersionString = aaf_get_propertyValue (Identif, PID_Identification_ProductVersionString, &AAFTypeID_String);
if (ProductVersionString == NULL) {
warning ("Missing Identification::ProductVersionString.");
} else {
aafd->Identification.ProductVersionString = ProductVersionString;
}
aafUID_t* ProductID = aaf_get_propertyValue (Identif, PID_Identification_ProductID, &AAFTypeID_AUID);
if (ProductID == NULL) {
warning ("Missing Identification::ProductID.");
} else {
aafd->Identification.ProductID = ProductID;
}
aafTimeStamp_t* Date = aaf_get_propertyValue (Identif, PID_Identification_Date, &AAFTypeID_TimeStamp);
if (Date == NULL) {
warning ("Missing Identification::Date.");
} else {
aafd->Identification.Date = Date;
}
aafProductVersion_t* ToolkitVersion = aaf_get_propertyValue (Identif, PID_Identification_ToolkitVersion, &AAFTypeID_ProductVersion);
if (ToolkitVersion == NULL) {
warning ("Missing Identification::ToolkitVersion.");
} else {
aafd->Identification.ToolkitVersion = ToolkitVersion;
}
wchar_t* Platform = aaf_get_propertyValue (Identif, PID_Identification_Platform, &AAFTypeID_String);
if (Platform == NULL) {
warning ("Missing Identification::Platform.");
} else {
aafd->Identification.Platform = Platform;
}
aafUID_t* GenerationAUID = aaf_get_propertyValue (Identif, PID_Identification_GenerationAUID, &AAFTypeID_AUID);
if (GenerationAUID == NULL) {
warning ("Missing Identification::GenerationAUID.");
} else {
aafd->Identification.GenerationAUID = GenerationAUID;
}
return 0;
}
// static int isValidAAF( AAF_Data *aafd )
// {
// aafUID_t *hdrClsID = (aafUID_t*)&aafd->cfbd->hdr->_clsid;
//
// if ( aafUIDCmp( hdrClsID, &AAFFileKind_Aaf512Binary ) ||
// aafUIDCmp( hdrClsID, &AAFFileKind_Aaf4KBinary ) )
// return 1;
//
// // warning( "Unsuported AAF encoding (%ls).", aaft_FileKindToText( hdrClsID ) );
//
// return 0;
// }
static void
setObjectShortcuts (AAF_Data* aafd)
{
// aafd->Root = aafd->Root;
aafd->Header.obj = aaf_get_propertyValue (aafd->Root, PID_Root_Header, &AAFUID_NULL);
// aafd->MetaDictionary = aaf_get_propertyValue( aafd->Root, PID_Root_MetaDictionary );
aafd->ClassDefinition = aaf_get_propertyValue (aafd->MetaDictionary, PID_MetaDictionary_ClassDefinitions, &AAFTypeID_ClassDefinitionStrongReferenceSet);
aafd->TypeDefinition = aaf_get_propertyValue (aafd->MetaDictionary, PID_MetaDictionary_TypeDefinitions, &AAFTypeID_TypeDefinitionStrongReferenceSet);
aafd->Identification.obj = aaf_get_propertyValue (aafd->Header.obj, PID_Header_IdentificationList, &AAFTypeID_IdentificationStrongReferenceVector);
aafd->Content = aaf_get_propertyValue (aafd->Header.obj, PID_Header_Content, &AAFTypeID_ContentStorageStrongReference);
aafd->Dictionary = aaf_get_propertyValue (aafd->Header.obj, PID_Header_Dictionary, &AAFTypeID_DictionaryStrongReference);
aafd->Mobs = aaf_get_propertyValue (aafd->Content, PID_ContentStorage_Mobs, &AAFTypeID_MobStrongReferenceSet);
aafd->EssenceData = aaf_get_propertyValue (aafd->Content, PID_ContentStorage_EssenceData, &AAFTypeID_EssenceDataStrongReferenceSet);
aafd->OperationDefinition = aaf_get_propertyValue (aafd->Dictionary, PID_Dictionary_OperationDefinitions, &AAFTypeID_OperationDefinitionStrongReferenceSet);
aafd->ParameterDefinition = aaf_get_propertyValue (aafd->Dictionary, PID_Dictionary_ParameterDefinitions, &AAFTypeID_ParameterDefinitionStrongReferenceSet);
aafd->DataDefinition = aaf_get_propertyValue (aafd->Dictionary, PID_Dictionary_DataDefinitions, &AAFTypeID_DataDefinitionStrongReferenceSet);
aafd->PluginDefinition = aaf_get_propertyValue (aafd->Dictionary, PID_Dictionary_PluginDefinitions, &AAFTypeID_PluginDefinitionStrongReferenceSet);
aafd->CodecDefinition = aaf_get_propertyValue (aafd->Dictionary, PID_Dictionary_CodecDefinitions, &AAFTypeID_CodecDefinitionStrongReferenceSet);
aafd->ContainerDefinition = aaf_get_propertyValue (aafd->Dictionary, PID_Dictionary_ContainerDefinitions, &AAFTypeID_ContainerDefinitionStrongReferenceSet);
aafd->InterpolationDefinition = aaf_get_propertyValue (aafd->Dictionary, PID_Dictionary_InterpolationDefinitions, &AAFTypeID_InterpolationDefinitionStrongReferenceSet);
aafd->KLVDataDefinition = aaf_get_propertyValue (aafd->Dictionary, PID_Dictionary_KLVDataDefinitions, &AAFTypeID_KLVDataDefinitionStrongReferenceSet);
aafd->TaggedValueDefinition = aaf_get_propertyValue (aafd->Dictionary, PID_Dictionary_TaggedValueDefinitions, &AAFTypeID_TaggedValueDefinitionStrongReferenceSet);
}
static int
retrieveObjectTree (AAF_Data* aafd)
{
int rc = 0;
aafByte_t* propStream = NULL;
cfbNode* Node = &aafd->cfbd->nodes[0];
aafClass* Class = aafclass_getClassByID (aafd, (aafUID_t*)&Node->_clsId);
if (Class == NULL && aafUIDCmp (Class->ID, (aafUID_t*)&Node->_clsId) != 0) {
error ("Looks like the fist Object is not the Root Class : %ls.", aaft_ClassIDToText (aafd, Class->ID));
goto err;
}
aafd->Root = newObject (aafd, Node, Class, NULL);
if (aafd->Root == NULL) {
goto err;
}
/* retrieveObjectProperties() */
propStream = getNodeProperties (aafd, aafd->Root->Node);
if (propStream == NULL) {
error ("Could not retrieve properties for %ls.", aaf_get_ObjectPath (aafd->Root));
goto err;
}
aafPropertyIndexHeader_t Header;
aafPropertyIndexEntry_t Prop;
aafPropertyIndexEntry_t AAFHeaderProp;
aafPropertyIndexEntry_t AAFMetaDcProp;
memcpy (&Header, propStream, sizeof (aafPropertyIndexHeader_t));
aafByte_t* AAFHeaderVal = NULL;
aafByte_t* AAFMetaDcVal = NULL;
aafByte_t* value = NULL;
aafPropertyDef* PDef = NULL;
uint32_t i = 0;
int valueOffset = 0;
foreachPropertyEntry (propStream, Header, Prop, value, valueOffset, i)
{
if (Prop._pid == PID_Root_Header) {
memcpy (&AAFHeaderProp, &Prop, sizeof (aafPropertyIndexEntry_t));
AAFHeaderVal = value;
}
if (Prop._pid == PID_Root_MetaDictionary) {
memcpy (&AAFMetaDcProp, &Prop, sizeof (aafPropertyIndexEntry_t));
AAFMetaDcVal = value;
}
}
PDef = aafclass_getPropertyDefinitionByID (aafd->Root->Class, PID_Root_MetaDictionary);
/* Start recursive parsing of /Root/Header/{*} */
rc = retrieveProperty (aafd, aafd->Root, PDef, &AAFMetaDcProp, AAFMetaDcVal, Header._byteOrder);
if (rc < 0) {
error ("Could not retrieve property %ls.", aaft_PIDToText (aafd, PDef->pid));
goto err;
}
/*
* Retrieve MetaDictionary.
*/
aafObject* MetaDic = aaf_get_propertyValue (aafd->Root, PID_Root_MetaDictionary, &AAFUID_NULL);
if (MetaDic == NULL) {
error ("Missing PID_Root_MetaDictionary.");
goto err;
}
aafObject* ClassDefs = aaf_get_propertyValue (MetaDic, PID_MetaDictionary_ClassDefinitions, &AAFTypeID_ClassDefinitionStrongReferenceSet);
if (ClassDefs == NULL) {
error ("Missing PID_MetaDictionary_ClassDefinitions.");
goto err;
}
aafObject* ClassDef = NULL;
aaf_foreach_ObjectInSet (&ClassDef, ClassDefs, NULL)
{
retrieveMetaDictionaryClass (aafd, ClassDef);
}
PDef = aafclass_getPropertyDefinitionByID (aafd->Root->Class, PID_Root_Header);
/* Starts recursive parsing of /Root/Header/{*} */
rc = retrieveProperty (aafd, aafd->Root, PDef, &AAFHeaderProp, AAFHeaderVal, Header._byteOrder);
if (rc < 0) {
error ("Could not retrieve property %ls.", aaft_PIDToText (aafd, PDef->pid));
goto err;
}
setObjectShortcuts (aafd);
rc = 0;
goto end;
err:
rc = -1;
end:
if (propStream)
free (propStream);
return rc;
}
static aafClass*
retrieveMetaDictionaryClass (AAF_Data* aafd, aafObject* TargetClassDef)
{
aafObject* MetaDic = aaf_get_propertyValue (aafd->Root, PID_Root_MetaDictionary, &AAFUID_NULL);
aafObject* ClassDefs = aaf_get_propertyValue (MetaDic, PID_MetaDictionary_ClassDefinitions, &AAFTypeID_ClassDefinitionStrongReferenceSet);
aafObject* ClassDef = NULL;
if (ClassDefs == NULL) {
error ("Could not retrieve PID_MetaDictionary_ClassDefinitions property from MetaDic.");
return NULL;
}
aaf_foreach_ObjectInSet (&ClassDef, ClassDefs, NULL)
{
if (ClassDef == TargetClassDef)
break;
}
if (ClassDef == NULL) {
error ("Could not retrieve ClassDefinition %p.", (void*)TargetClassDef);
return NULL;
}
aafUID_t* ClassID = aaf_get_propertyValue (ClassDef, PID_MetaDefinition_Identification, &AAFTypeID_AUID);
aafWeakRef_t* parent = aaf_get_propertyValue (ClassDef, PID_ClassDefinition_ParentClass, &AAFTypeID_ClassDefinitionWeakReference);
aafObject* Parent = aaf_get_ObjectByWeakRef (ClassDefs, parent);
aafClass* ParentClass = NULL;
if (Parent != ClassDef) {
ParentClass = retrieveMetaDictionaryClass (aafd, Parent);
} else if (aafUIDCmp (ClassID, &AAFClassID_InterchangeObject) == 0 &&
aafUIDCmp (ClassID, &AAFClassID_MetaDefinition) == 0 &&
aafUIDCmp (ClassID, &AAFClassID_MetaDictionary) == 0) {
/*
* TODO: what is this ? when does it happen ?
*/
error ("Parent's Class equals Child's : %ls.", aaft_ClassIDToText (aafd, ClassID));
return NULL;
}
aafClass* Class = aafclass_getClassByID (aafd, ClassID);
if (Class == NULL) {
aafBoolean_t* isCon = aaf_get_propertyValue (ClassDef, PID_ClassDefinition_IsConcrete, &AAFTypeID_Boolean);
if (isCon == NULL) {
error ("Missing ClassDefinition::IsConcrete.");
return NULL;
}
Class = aafclass_defineNewClass (aafd, ClassID, *isCon, ParentClass);
Class->name = aaf_get_propertyValue (ClassDef, PID_MetaDefinition_Name, &AAFTypeID_String);
Class->meta = 1;
} else { // if class is standard, we only set its name
if (Class->name == NULL) {
Class->name = aaf_get_propertyValue (ClassDef, PID_MetaDefinition_Name, &AAFTypeID_String);
}
}
aafObject* Props = aaf_get_propertyValue (ClassDef, PID_ClassDefinition_Properties, &AAFTypeID_PropertyDefinitionStrongReferenceSet);
aafObject* Prop = NULL;
aaf_foreach_ObjectInSet (&Prop, Props, NULL)
{
aafPID_t* Pid = aaf_get_propertyValue (Prop, PID_PropertyDefinition_LocalIdentification, &AAFTypeID_UInt16);
if (Pid == NULL) {
error ("Missing PropertyDefinition::LocalIdentification.");
return NULL;
}
aafBoolean_t* isOpt = aaf_get_propertyValue (Prop, PID_PropertyDefinition_IsOptional, &AAFTypeID_Boolean);
if (isOpt == NULL) {
error ("Missing PropertyDefinition::IsOptional.");
return NULL;
}
/*
* We skip all the properties that were already defined in aafclass_setDefaultClasses().
*/
aafPropertyDef* PDef = NULL;
if (!(PDef = propertyIdExistsInClass (Class, *Pid))) {
attachNewProperty (Class, PDef, *Pid, (*isOpt) ? 0 : 1);
PDef->meta = 1;
} else {
// debug( "Property %d exists.", *Pid );
continue;
}
PDef->name = aaf_get_propertyValue (Prop, PID_MetaDefinition_Name, &AAFTypeID_String);
aafObject* TypeDefs = aaf_get_propertyValue (MetaDic, PID_MetaDictionary_TypeDefinitions, &AAFTypeID_TypeDefinitionStrongReferenceSet);
if (TypeDefs == NULL) {
error ("Missing TypeDefinitions from MetaDictionary");
return NULL;
}
aafWeakRef_t* WeakRefToType = aaf_get_propertyValue (Prop, PID_PropertyDefinition_Type, &AAFTypeID_PropertyDefinitionWeakReference);
if (WeakRefToType == NULL) {
error ("Missing PID_PropertyDefinition_Type");
return NULL;
}
aafObject* TypeDef = aaf_get_ObjectByWeakRef (TypeDefs, WeakRefToType);
if (TypeDef == NULL) {
error ("Could not retrieve TypeDefinition from dictionary.");
return NULL;
}
aafUID_t* typeUID = aaf_get_propertyValue (TypeDef, PID_MetaDefinition_Identification, &AAFTypeID_AUID);
if (typeUID == NULL) {
error ("Missing PID_MetaDefinition_Identification");
return NULL;
}
/*
* Looks like nobody cares about AAF standard TypeDefinition. All observed files
* had incorrect values for Type Name and Identification, even Avid's files. So...
*/
memcpy (&PDef->type, typeUID, sizeof (aafUID_t));
// wchar_t *typeName = aaf_get_propertyValue( TypeDef, PID_MetaDefinition_Name, &AAFTypeID_String );
//
// debug( "TypeName : %ls (%ls) | name : %ls.",
// // AUIDToText(typeUID),
// typeName,
// aaft_TypeIDToText( typeUID ),
// PDef->name );
//
// free( typeName );
}
return Class;
}
static aafObject*
newObject (AAF_Data* aafd, cfbNode* Node, aafClass* Class, aafObject* Parent)
{
aafObject* Obj = calloc (sizeof (aafObject), sizeof (unsigned char));
if (Obj == NULL) {
error ("%s.", strerror (errno));
return NULL;
}
cfb_w16towchar (Obj->Name, Node->_ab, Node->_cb);
Obj->aafd = aafd;
Obj->Class = Class;
Obj->Node = Node;
Obj->Properties = NULL;
Obj->Parent = Parent;
Obj->Header = NULL;
Obj->Entry = NULL;
Obj->next = NULL;
Obj->prev = NULL;
Obj->nextObj = aafd->Objects;
aafd->Objects = Obj;
return Obj;
}
static aafProperty*
newProperty (AAF_Data* aafd, aafPropertyDef* Def)
{
aafProperty* Prop = calloc (sizeof (aafProperty), sizeof (unsigned char));
if (Prop == NULL) {
error ("%s.", strerror (errno));
return NULL;
}
Prop->pid = Def->pid;
Prop->def = Def;
return Prop;
}
static aafPropertyDef*
propertyIdExistsInClass (aafClass* Class, aafPID_t Pid)
{
aafPropertyDef* PDef = NULL;
foreachPropertyDefinition (PDef, Class->Properties) if (PDef->pid == Pid) return PDef;
return NULL;
}
static int
setObjectStrongRefSet (aafObject* Obj, aafStrongRefSetHeader_t* Header, aafStrongRefSetEntry_t* Entry)
{
AAF_Data* aafd = Obj->aafd;
Obj->Header = malloc (sizeof (aafStrongRefSetHeader_t));
if (Obj->Header == NULL) {
error ("%s.", strerror (errno));
return -1;
}
memcpy (Obj->Header, Header, sizeof (aafStrongRefSetHeader_t));
/* Real entrySize, taking _identification into account. */
uint32_t entrySize = sizeof (aafStrongRefSetEntry_t) + Header->_identificationSize;
Obj->Entry = malloc (entrySize);
if (Obj->Entry == NULL) {
error ("%s.", strerror (errno));
return -1;
}
memcpy (Obj->Entry, Entry, entrySize);
return 0;
}
static int
setObjectStrongRefVector (aafObject* Obj, aafStrongRefVectorHeader_t* Header, aafStrongRefVectorEntry_t* Entry)
{
/*
* aafStrongRefVectorHeader_t and aafStrongRefSetHeader_t begins with the same
* data bytes, so we can safely memcpy to the first one from the second one,
* the remaining bytes simply remaining null.
* The same applies to aafStrongRefVectorEntry_t and aafStrongRefVectorHeader_t.
*/
AAF_Data* aafd = Obj->aafd;
Obj->Header = calloc (sizeof (aafStrongRefSetHeader_t), sizeof (unsigned char));
if (Obj->Header == NULL) {
error ("%s.", strerror (errno));
return -1;
}
memcpy (Obj->Header, Header, sizeof (aafStrongRefVectorHeader_t));
Obj->Entry = calloc (sizeof (aafStrongRefSetEntry_t), sizeof (unsigned char));
if (Obj->Entry == NULL) {
error ("%s.", strerror (errno));
return -1;
}
memcpy (Obj->Entry, Entry, sizeof (aafStrongRefVectorEntry_t));
return 0;
}
static int
retrieveStrongReference (AAF_Data* aafd, aafProperty* Prop, aafObject* Parent)
{
/*
* Initial property value is a wchar string holding the name of a child node.
* This child node being the object referenced, we store that object dirctly
* as the property value, instead of the initial child node name.
*/
wchar_t name[CFB_NODE_NAME_SZ];
cfb_w16towchar (name, Prop->val, Prop->len);
free (Prop->val);
Prop->val = NULL;
cfbNode* Node = cfb_getChildNode (aafd->cfbd, name, Parent->Node);
if (Node == NULL) {
error ("Could not find child node.");
return -1;
}
aafClass* Class = aafclass_getClassByID (aafd, (aafUID_t*)&Node->_clsId);
if (Class == NULL) {
error ("Could not retrieve Class %ls @ \"%ls\".", aaft_ClassIDToText (aafd, (aafUID_t*)&Node->_clsId), aaf_get_ObjectPath (Parent));
return -1;
}
Prop->val = newObject (aafd, Node, Class, Parent);
if (Prop->val == NULL) {
return -1;
}
int rc = retrieveObjectProperties (aafd, Prop->val);
if (rc < 0) {
return -1;
}
return 0;
}
static int
retrieveStrongReferenceSet (AAF_Data* aafd, aafProperty* Prop, aafObject* Parent)
{
aafStrongRefSetHeader_t* Header = NULL;
aafStrongRefSetEntry_t* Entry = NULL;
wchar_t refName[CFB_NODE_NAME_SZ];
cfb_w16towchar (refName, Prop->val, Prop->len);
free (Prop->val);
Prop->val = NULL;
cfbNode* Node = getStrongRefIndexNode (aafd, Parent, refName);
if (Node == NULL) {
error ("Could not retrieve StrongReferenceSet's Index node.");
goto err;
}
Header = getStrongRefSetList (aafd, Node, Parent);
if (Header == NULL) {
error ("Could not retrieve StrongReferenceSet's CFB Stream.");
goto err;
}
Entry = malloc (sizeof (aafStrongRefSetEntry_t) + Header->_identificationSize);
if (Entry == NULL) {
error ("%s.", strerror (errno));
goto err;
}
memset (Entry, 0x00, sizeof (aafStrongRefSetEntry_t));
uint32_t i = 0;
int rc = 0;
foreachStrongRefSetEntry (Header, (*Entry), i)
{
Node = getStrongRefEntryNode (aafd, Parent, refName, Entry->_localKey);
if (Node == NULL) {
continue;
}
aafClass* Class = aafclass_getClassByID (aafd, (aafUID_t*)&Node->_clsId);
if (Class == NULL) {
error ("Could not retrieve Class %ls.", aaft_ClassIDToText (aafd, (aafUID_t*)&Node->_clsId));
continue;
}
aafObject* Obj = newObject (aafd, Node, Class, Parent);
if (Obj == NULL) {
goto err;
}
rc = setObjectStrongRefSet (Obj, Header, Entry);
if (rc < 0) {
goto err;
}
rc = retrieveObjectProperties (aafd, Obj);
if (rc < 0) {
goto err;
}
Obj->next = Prop->val;
Prop->val = Obj;
}
rc = 0;
goto end;
err:
rc = -1;
end:
if (Header)
free (Header);
if (Entry)
free (Entry);
return rc;
}
static int
retrieveStrongReferenceVector (AAF_Data* aafd, aafProperty* Prop, aafObject* Parent)
{
int rc = 0;
aafByte_t* vectorStream = NULL;
wchar_t refName[CFB_NODE_NAME_SZ];
cfb_w16towchar (refName, Prop->val, Prop->len);
free (Prop->val);
Prop->val = NULL;
cfbNode* Node = getStrongRefIndexNode (aafd, Parent, refName);
if (Node == NULL) {
goto err;
}
vectorStream = getStrongRefVectorList (aafd, Node, Parent);
if (vectorStream == NULL) {
error ("Could not retrieve StrongRefVectorList");
goto err;
}
aafStrongRefVectorHeader_t Header;
aafStrongRefVectorEntry_t Entry;
memcpy (&Header, vectorStream, sizeof (aafStrongRefVectorHeader_t));
uint32_t i = 0;
foreachStrongRefVectorEntry (vectorStream, Header, Entry, i)
{
Node = getStrongRefEntryNode (aafd, Parent, refName, Entry._localKey);
if (Node == NULL) {
continue;
}
aafClass* Class = aafclass_getClassByID (aafd, (aafUID_t*)&Node->_clsId);
if (Class == NULL) {
warning ("Could not retrieve Class ID %ls.", aaft_ClassIDToText (aafd, (aafUID_t*)&Node->_clsId));
continue;
}
aafObject* Obj = newObject (aafd, Node, Class, Parent);
if (Obj == NULL) {
goto err;
}
rc = setObjectStrongRefVector (Obj, &Header, &Entry);
if (rc < 0) {
goto err;
}
rc = retrieveObjectProperties (aafd, Obj);
if (rc < 0) {
goto err;
}
/*
* Vectors are ordered.
*/
if (Prop->val != NULL) {
aafObject* tmp = Prop->val;
for (; tmp != NULL; tmp = tmp->next)
if (tmp->next == NULL)
break;
Obj->prev = tmp;
tmp->next = Obj;
} else {
Obj->prev = NULL;
Prop->val = Obj;
}
}
rc = 0;
goto end;
err:
rc = -1;
end:
if (vectorStream)
free (vectorStream);
return rc;
}
static int
retrieveProperty (AAF_Data* aafd, aafObject* Obj, aafPropertyDef* Def, aafPropertyIndexEntry_t* p, aafByte_t* v, uint8_t bo)
{
(void)bo; // TODO: ByteOrder support ?
aafProperty* Prop = newProperty (aafd, Def);
if (Prop == NULL) {
return -1;
}
Prop->sf = p->_storedForm;
/*
TODO Prop->len / Prop->val ---> retrieveStrongReference() retrieveStrongReferenceSet() retrieveStrongReferenceVector()
only used to retrieve node name ? There could be a better approach.
*/
Prop->len = p->_length;
Prop->val = malloc (p->_length);
if (Prop->val == NULL) {
error ("%s.", strerror (errno));
return -1;
}
memcpy (Prop->val, v, p->_length);
Prop->next = Obj->Properties;
Obj->Properties = Prop;
switch (p->_storedForm) {
case SF_STRONG_OBJECT_REFERENCE:
return retrieveStrongReference (aafd, Prop, Obj);
case SF_STRONG_OBJECT_REFERENCE_SET:
return retrieveStrongReferenceSet (aafd, Prop, Obj);
case SF_STRONG_OBJECT_REFERENCE_VECTOR:
return retrieveStrongReferenceVector (aafd, Prop, Obj);
default:
break;
}
return 0;
}
static int
retrieveObjectProperties (AAF_Data* aafd, aafObject* Obj)
{
int rc = 0;
aafByte_t* propStream = getNodeProperties (aafd, Obj->Node);
if (propStream == NULL) {
error ("Could not retrieve object %ls properties : %ls", aaft_ClassIDToText (aafd, Obj->Class->ID), aaf_get_ObjectPath (Obj));
goto err;
}
aafPropertyIndexHeader_t Header;
aafPropertyIndexEntry_t Prop;
memcpy (&Header, propStream, sizeof (aafPropertyIndexHeader_t));
aafByte_t* value = NULL;
aafPropertyDef* PDef = NULL;
int valueOffset = 0;
uint32_t i = 0;
foreachPropertyEntry (propStream, Header, Prop, value, valueOffset, i)
{
PDef = aafclass_getPropertyDefinitionByID (Obj->Class, Prop._pid);
if (PDef == NULL) {
warning ("Unknown property 0x%04x (%ls) of object %ls", Prop._pid, aaft_PIDToText (aafd, Prop._pid), aaft_ClassIDToText (aafd, Obj->Class->ID));
continue;
}
rc = retrieveProperty (aafd, Obj, PDef, &Prop, value, Header._byteOrder);
if (rc < 0) {
error ("Could not retrieve property %ls of object %ls", aaft_PIDToText (aafd, PDef->pid), aaft_ClassIDToText (aafd, Obj->Class->ID));
goto err;
}
}
rc = 0;
goto end;
err:
rc = -1;
end:
if (propStream)
free (propStream);
return rc;
}
static cfbNode*
getStrongRefIndexNode (AAF_Data* aafd, aafObject* Parent, const wchar_t* refName)
{
wchar_t name[CFB_NODE_NAME_SZ];
swprintf (name, CFB_NODE_NAME_SZ, L"%" WPRIws L" index", refName);
cfbNode* Node = cfb_getChildNode (aafd->cfbd, name, Parent->Node);
if (Node == NULL) {
error ("Could not retrieve Reference Set/Vector Index Node @ \"%ls/%ls index\"", aaf_get_ObjectPath (Parent), refName);
return NULL;
}
return Node;
}
static cfbNode*
getStrongRefEntryNode (AAF_Data* aafd, aafObject* Parent, const wchar_t* refName, uint16_t index)
{
wchar_t name[CFB_NODE_NAME_SZ];
swprintf (name, CFB_NODE_NAME_SZ, L"%" WPRIws L"{%x}", refName, index);
cfbNode* Node = cfb_getChildNode (aafd->cfbd, name, Parent->Node);
if (Node == NULL) {
error ("Could not retrieve Reference Set/vector Entry Node @ \"%ls/%ls index\"", aaf_get_ObjectPath (Parent), refName);
return NULL;
}
return Node;
}
static aafByte_t*
getNodeProperties (AAF_Data* aafd, cfbNode* Node)
{
if (Node == NULL) {
error ("Node is NULL");
return NULL;
}
uint64_t stream_sz = 0;
aafByte_t* stream = NULL;
cfbNode* propNode = cfb_getChildNode (aafd->cfbd, L"properties", Node);
if (propNode == NULL) {
error ("Could not retrieve Property Node");
return NULL;
}
cfb_getStream (aafd->cfbd, propNode, &stream, &stream_sz);
if (stream == NULL) {
error ("Could not retrieve Property Stream");
return NULL;
}
/*
* Ensures PropHeader + all PropEntries + all PropValues matches the Stream size.
* TODO : is the following test important ?
*/
/*
uint32_t prop_sz = sizeof(aafPropertyIndexHeader_t);
uint32_t i = 0;
for ( i = 0; i < ((aafPropertyIndexHeader_t*)stream)->_entryCount; i++ )
prop_sz += (((aafPropertyIndexEntry_t*)(stream+((sizeof(aafPropertyIndexEntry_t)*i)+sizeof(aafPropertyIndexHeader_t))))->_length) + sizeof(aafPropertyIndexEntry_t);
if ( prop_sz != stream_sz )
warning( "Stream length (%lu Bytes) does not match property length (%u Bytes).",
stream_sz,
prop_sz );
*/
return stream;
}
static aafStrongRefSetHeader_t*
getStrongRefSetList (AAF_Data* aafd, cfbNode* Node, aafObject* Parent)
{
if (Node == NULL)
return NULL;
aafByte_t* stream = NULL;
uint64_t stream_sz = 0;
cfb_getStream (aafd->cfbd, Node, &stream, &stream_sz);
if (stream == NULL) {
wchar_t refName[CFB_NODE_NAME_SZ];
cfb_w16towchar (refName, Node->_ab, Node->_cb);
error ("Could not retrieve StrongReferenceSet Index Stream @ \"%ls/%ls index\"", aaf_get_ObjectPath (Parent), refName);
return NULL;
}
return (aafStrongRefSetHeader_t*)stream;
}
static aafByte_t*
getStrongRefVectorList (AAF_Data* aafd, cfbNode* Node, aafObject* Parent)
{
if (Node == NULL)
return NULL;
aafByte_t* stream = NULL;
uint64_t stream_sz = 0;
cfb_getStream (aafd->cfbd, Node, &stream, &stream_sz);
if (stream == NULL) {
wchar_t refName[CFB_NODE_NAME_SZ];
cfb_w16towchar (refName, Node->_ab, Node->_cb);
error ("Could not retrieve StrongReferenceVector Index Stream \"%ls/%ls index\"", aaf_get_ObjectPath (Parent), refName);
return NULL;
}
return stream;
}
View Git Blame Copy Permalink