AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefExtEnum::GetNameBufLenFromAUID ( const aafUID_t & value, aafUInt32 * pLen) { if (! pLen) return AAFRESULT_NULL_PARAM; aafUInt32 i; aafUInt32 count; AAFRESULT hr; hr = CountElements(&count); if (AAFRESULT_FAILED(hr)) return hr; for (i = 0; i < count; i++) { aafUID_t val; hr = GetElementValue (i, &val); if (AAFRESULT_FAILED(hr)) return hr; if (EqualAUID (&val, &value)) { aafUInt32 len; hr = GetElementNameBufLen(i, &len); if (AAFRESULT_FAILED(hr)) return hr; ASSERTU (pLen); *pLen = len; return AAFRESULT_SUCCESS; } } // fell out of for() loop, so we didn't find it. return AAFRESULT_ILLEGAL_VALUE; }
// Get the value of the OMObjectVector at position index. AAFRESULT STDMETHODCALLTYPE ImplAAFRefArrayValue::GetElementAt( aafUInt32 index, ImplAAFPropertyValue** ppPropertyValue) const { AAFRESULT result = AAFRESULT_SUCCESS; if (NULL == ppPropertyValue) return AAFRESULT_NULL_PARAM; *ppPropertyValue = NULL; ImplAAFStorableSP pObject; result = GetObjectAt(index, &pObject); if (AAFRESULT_FAILED(result)) return result; ImplAAFTypeDefObjectRef *pElementType = GetElementType(); ASSERTU(NULL != pElementType); if (NULL == pElementType) return AAFRESULT_INVALID_OBJ; result = pElementType->CreateValue((ImplAAFStorable *)pObject, ppPropertyValue); if (AAFRESULT_FAILED(result)) return result; return result; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefRename::GetBaseValue ( ImplAAFPropertyValue * pInPropVal, ImplAAFPropertyValue ** ppOutPropVal) { if (! pInPropVal) return AAFRESULT_NULL_PARAM; if (! ppOutPropVal) return AAFRESULT_NULL_PARAM; // Get the property value's embedded type and // check if it's the same as the base type. ImplAAFTypeDefSP pInPropType; if( AAFRESULT_FAILED( pInPropVal->GetType( &pInPropType ) ) ) return AAFRESULT_BAD_TYPE; ASSERTU (pInPropType); if( (ImplAAFTypeDef *)pInPropType != this ) return AAFRESULT_BAD_TYPE; aafUInt32 inBitsSize; ImplAAFPropValDataSP pOutPVData; ImplAAFPropValDataSP pvd; ImplAAFTypeDefSP ptd; AAFRESULT hr; hr = GetBaseType (&ptd); if (AAFRESULT_FAILED (hr)) return hr; ASSERTU (ptd); // aafUInt32 elementSize = ptd->PropValSize(); ASSERTU (pInPropVal); pvd = dynamic_cast<ImplAAFPropValData*> (pInPropVal); ASSERTU (pvd); hr = pvd->GetBitsSize (&inBitsSize); if (! AAFRESULT_SUCCEEDED (hr)) return hr; pOutPVData = (ImplAAFPropValData *)CreateImpl(CLSID_AAFPropValData); if (! pOutPVData) return AAFRESULT_NOMEMORY; // Bobt: Hack bugfix! SmartPointer operator= will automatically // AddRef; CreateImpl *also* will addref, so we've got one too // many. Put us back to normal. pOutPVData->ReleaseReference (); ASSERTU (ptd); hr = pOutPVData->Initialize (ptd); if (AAFRESULT_FAILED(hr)) return hr; hr = pOutPVData->AllocateFromPropVal (pvd, 0, inBitsSize, NULL); if (AAFRESULT_FAILED(hr)) return hr; ASSERTU (ppOutPropVal); *ppOutPropVal = pOutPVData; (*ppOutPropVal)->AcquireReference (); ASSERTU (*ppOutPropVal); return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefArray::CreateValueFromCArray ( aafMemPtr_t pInitData, aafUInt32 initDataSize, ImplAAFPropertyValue ** ppPropVal) { if (! pInitData) return AAFRESULT_NULL_PARAM; if (! ppPropVal) return AAFRESULT_NULL_PARAM; ImplAAFTypeDefSP pElementType; AAFRESULT result = GetType(&pElementType); if (AAFRESULT_FAILED(result)) return result; if (dynamic_cast<ImplAAFTypeDefObjectRef*>((ImplAAFTypeDef*) pElementType)) { // This interface is not type-safe for accessing objects! There is also no // mechanism in place to convert between a buffer pointer and an array // of interface pointers; this convertion would not be necessary for // arrays of non-objects. return AAFRESULT_BAD_TYPE; } ImplAAFPropValDataSP pvd; ImplAAFPropValData * tmp; tmp = (ImplAAFPropValData*) CreateImpl (CLSID_AAFPropValData); if (!tmp) return AAFRESULT_NOMEMORY; pvd = tmp; // the pvd smart pointer will maintain a reference for us... aafUInt32 refCount; refCount = tmp->ReleaseReference (); // ...make sure it really does ASSERTU (1 == refCount); AAFRESULT hr; hr = pvd->Initialize(this); if (! AAFRESULT_SUCCEEDED (hr)) return hr; hr = SetCArray (pvd, pInitData, initDataSize); if (AAFRESULT_FAILED (hr)) return hr; ASSERTU (ppPropVal); *ppPropVal = pvd; ASSERTU (*ppPropVal); (*ppPropVal)->AcquireReference (); return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefArray::ValidateInputParams ( ImplAAFPropertyValue ** ppElementValues, aafUInt32 numElements) { //first validate params + basic stuff ... if (!ppElementValues) return AAFRESULT_NULL_PARAM; //verify that all the individual elem types are the same as each other, HRESULT hr; //get Base TD ImplAAFTypeDefSP spTargetTD; hr = GetType(&spTargetTD); //gets base elem type if (AAFRESULT_FAILED (hr)) return hr; if (! spTargetTD->IsRegistered ()) return AAFRESULT_NOT_REGISTERED; //Get size aafUInt32 targetElemSize = spTargetTD->NativeSize(); for (aafUInt32 i=0; i<numElements; i++) { //get source type ImplAAFTypeDefSP spSourceTD; hr = ppElementValues[i]->GetType (&spSourceTD); if (AAFRESULT_FAILED (hr)) return hr; //verify that spTargetTD == spSourceTD if (spSourceTD != spTargetTD ) return AAFRESULT_BAD_TYPE; //verify FIXED/VARIABLE Arrayable if (! IsArrayable(spSourceTD) ) return AAFRESULT_BAD_TYPE; //verify that the target elem size is equal to that of source aafUInt32 sourceSize = spSourceTD->NativeSize(); if (sourceSize != targetElemSize ) return AAFRESULT_BAD_SIZE; }//for each elem return AAFRESULT_SUCCESS; }//ValidateInputParams()
AAFRESULT STDMETHODCALLTYPE ImplAAFControlPoint::SetValue ( aafUInt32 valueSize, aafDataBuffer_t pValue) { if (!pValue) return(AAFRESULT_NULL_PARAM); if (valueSize > OMPROPERTYSIZE_MAX) return(AAFRESULT_BAD_SIZE); // _value.setValue(pValue, valueSize); if (!_cachedTypeDef) { // Lookup the type definition from this constrol point. If it fails // then the control point is invalid! AAFRESULT result = GetTypeDefinition (&_cachedTypeDef); if (AAFRESULT_FAILED (result)) return result; } // Validate the property and get the property definition and type definition, // and the actual length of the data return (ImplAAFTypeDefIndirect::SetActualPropertyValue (_value, _cachedTypeDef, pValue, valueSize)); }
AAFRESULT STDMETHODCALLTYPE ImplAAFRawStorage::Read (aafMemPtr_t buf, aafUInt32 bufSize, aafUInt32 * pNumRead) { if (! _rep) return AAFRESULT_NOT_INITIALIZED; if (! buf) return AAFRESULT_NULL_PARAM; if (! pNumRead) return AAFRESULT_NULL_PARAM; aafBoolean_t readable = kAAFFalse; AAFRESULT hr = IsReadable (&readable); if (AAFRESULT_FAILED (hr)) return hr; if (! readable) return AAFRESULT_NOT_READABLE; _rep->read (buf, bufSize, *pNumRead); return AAFRESULT_SUCCESS; }
AAFRESULT ImplAAFPropertyDef::pvtInitialize ( const aafUID_t & propertyAuid, OMPropertyId omPid, const aafCharacter * pPropName, const aafUID_t & typeId, aafBoolean_t isOptional, aafBoolean_t isUniqueIdentifier, OMClassDefinition* pContainingClass) { AAFRESULT hr; if (! pPropName) return AAFRESULT_NULL_PARAM; if (! pContainingClass) return AAFRESULT_NULL_PARAM; hr = ImplAAFMetaDefinition::Initialize(propertyAuid, pPropName, NULL); if (AAFRESULT_FAILED (hr)) return hr; _Type = typeId; _pid = omPid; _IsOptional = isOptional; if (isUniqueIdentifier) { // Only set this optional property if true. _IsUniqueIdentifier = isUniqueIdentifier; } _containingClass = pContainingClass; return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFPluginDef::GetLocatorAt ( aafUInt32 index, ImplAAFLocator ** ppLocator) { if(ppLocator == NULL) return(AAFRESULT_NULL_PARAM); aafUInt32 count; AAFRESULT hr; hr = CountLocators (&count); if (AAFRESULT_FAILED (hr)) return hr; if (index >= count) return AAFRESULT_BADINDEX; ImplAAFLocator *pLocator; _locators.getValueAt(pLocator,index); ASSERTU(pLocator); pLocator->AcquireReference(); (*ppLocator)=pLocator; return AAFRESULT_SUCCESS; }
// Insert the given object into this contain property. AAFRESULT STDMETHODCALLTYPE ImplAAFRefContainerValue::InsertObject( ImplAAFStorable* pObject) { AAFRESULT result = AAFRESULT_SUCCESS; if (NULL == pObject) return AAFRESULT_NULL_PARAM; result = ValidateNewObject(pObject); if (AAFRESULT_FAILED(result)) return result; ASSERTU (isInitialized()); if (!isInitialized()) return AAFRESULT_NOT_INITIALIZED; // Hand off to the OMReferenceContainer OMReferenceContainer* pReferenceContainer = referenceContainer(); // Object refernce containers should only contain a single reference // to an object. if (!pReferenceContainer->containsObject(pObject)) { pReferenceContainer->insertObject(pObject); if (usesReferenceCounting()) { pObject->AcquireReference(); } } return result; }
AAFRESULT STDMETHODCALLTYPE ImplAAFRawStorage::Write (aafMemConstPtr_t buf, aafUInt32 bufSize, aafUInt32 * pNumWritten) { if (! _rep) return AAFRESULT_NOT_INITIALIZED; if (! buf) return AAFRESULT_NULL_PARAM; if (! pNumWritten) return AAFRESULT_NULL_PARAM; aafBoolean_t writeable = kAAFFalse; AAFRESULT hr = IsWriteable (&writeable); if (AAFRESULT_FAILED (hr)) return hr; if (! writeable) return AAFRESULT_NOT_WRITEABLE; _rep->write (buf, bufSize, *pNumWritten); if (*pNumWritten < bufSize) // Note! This violates one tenet, that if a method fails, no // action is taken. However, this failure notice is given *after* // some bytes have been written... return AAFRESULT_SMALLBUF; return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFSetFileBits::WriteAt ( aafMemPtr_t buf, aafUInt32 bufSize, aafUInt64 position) { if (! _rep) return AAFRESULT_NOT_INITIALIZED; if ( ! buf) return AAFRESULT_NULL_PARAM; aafUInt64 s = _rep->extent (); if (s < (position + bufSize)) { AAFRESULT hr; hr = SetSize (position + bufSize); if (AAFRESULT_FAILED (hr)) return hr; } aafUInt32 bytesWritten; _rep->writeAt (position, buf, bufSize, bytesWritten); if (bytesWritten != bufSize) return AAFRESULT_INVALID_PARAM; return AAFRESULT_SUCCESS; }
// // private method // AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefExtEnum::GetElementName ( aafUInt32 index, wchar_t * pName, aafUInt32 bufSize) { AAFRESULT hr; aafUInt32 count; aafUInt32 indexIntoProp; aafUInt32 currentIndex; if (!pName) return AAFRESULT_NULL_PARAM; hr = CountElements(&count); if (AAFRESULT_FAILED(hr)) return hr; if (index >= count) return AAFRESULT_ILLEGAL_VALUE; wchar_t c; size_t numChars = _ElementNames.count(); indexIntoProp = 0; currentIndex = 0; if (0 != index) { for (OMUInt32 i = 0; i < numChars; i++) { indexIntoProp++; _ElementNames.getValueAt(&c, i); if (0 == c) { // We've found the null just before the string we want. // We'll increment the indexIntoProp to the start of the // string and break out of the loop, but first make sure // there's more string there to index into. ASSERTU (i < numChars); currentIndex++; if (index == currentIndex) break; } } // Make sure we didn't terminate the loop by dropping out before // the correct index was found. ASSERTU (indexIntoProp < numChars); } // indexIntoProp now indicates the starting char we want. Copy it // into the client's buffer. do { if (! bufSize) return AAFRESULT_SMALLBUF; _ElementNames.getValueAt(&c, indexIntoProp++); // BobT Note!!! We're cheating here, modifying client data // before we're sure this method will succeed. *pName++ = c; bufSize--; } while (c); return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefExtEnum::GetNameFromAUID ( const aafUID_t & value, wchar_t * pName, aafUInt32 bufSize) { if (! pName) return AAFRESULT_NULL_PARAM; AAFRESULT hr; aafUInt32 len; // following call may return AAFRESULT_ILLEGAL_VALUE if value isn't // recognized hr = GetNameBufLenFromAUID (value, &len); if (AAFRESULT_FAILED(hr)) return hr; // len includes space for trailing null if (bufSize < len) return AAFRESULT_SMALLBUF; aafUInt32 i; aafUInt32 count; hr = CountElements(&count); if (AAFRESULT_FAILED(hr)) return hr; for (i = 0; i < count; i++) { aafUID_t val; hr = GetElementValue (i, &val); if (AAFRESULT_FAILED(hr)) return hr; if (EqualAUID (&val, &value)) { // given integer value matches value of "i"th element. hr = GetElementName(i, pName, bufSize); if (AAFRESULT_FAILED(hr)) return hr; return AAFRESULT_SUCCESS; } } // fell out of for() loop, so we didn't find it. // redundant, since GetNameBufLenFromInteger() should have already // found it. return AAFRESULT_ILLEGAL_VALUE; }
AAFRESULT ImplAAFPropertyDef::pvtInitialize ( aafUID_constref propertyAuid, OMPropertyId omPid, aafCharacter_constptr pPropName, ImplAAFTypeDef *pType, aafBoolean_t isOptional, aafBoolean_t isUniqueIdentifier, OMClassDefinition* pContainingClass) { AAFRESULT hr; if (! pPropName) return AAFRESULT_NULL_PARAM; if (! pType) return AAFRESULT_NULL_PARAM; if (! pContainingClass) return AAFRESULT_NULL_PARAM; aafUID_t typeId; hr = pType->GetAUID(&typeId); if (AAFRESULT_FAILED (hr)) return hr; hr = ImplAAFMetaDefinition::Initialize(propertyAuid, pPropName, NULL); if (AAFRESULT_FAILED (hr)) return hr; _cachedType = pType; _cachedType->AcquireReference(); _Type = typeId; _pid = omPid; _IsOptional = isOptional; if (isUniqueIdentifier) { // Only set this optional property if true. _IsUniqueIdentifier = isUniqueIdentifier; } _containingClass = pContainingClass; return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefString::GetElements ( ImplAAFPropertyValue * pInPropVal, aafMemPtr_t pBuffer, aafUInt32 bufferSize) { AAFRESULT hr; if (! pInPropVal) return AAFRESULT_NULL_PARAM; if (! pBuffer) return AAFRESULT_NULL_PARAM; if (! IsRegistered ()) return AAFRESULT_NOT_REGISTERED; // Get the property value's embedded type and // check if it's the same as the base type. ImplAAFTypeDefSP pIncomingType; if( AAFRESULT_FAILED( pInPropVal->GetType( &pIncomingType ) ) ) return AAFRESULT_BAD_TYPE; ASSERTU (pIncomingType); if( (ImplAAFTypeDef *)pIncomingType != this ) return AAFRESULT_BAD_TYPE; ImplAAFPropValDataSP pvd; pvd = dynamic_cast<ImplAAFPropValData*>(pInPropVal); if (!pvd) return AAFRESULT_BAD_TYPE; aafUInt32 propBitsSize; hr = pvd->GetBitsSize(&propBitsSize); if (AAFRESULT_FAILED(hr)) return hr; if (bufferSize < propBitsSize) return AAFRESULT_SMALLBUF; aafMemPtr_t pBits = NULL; hr = pvd->GetBits (&pBits); if (AAFRESULT_FAILED(hr)) return hr; ASSERTU (pBits); ASSERTU (pBuffer); ASSERTU (propBitsSize <= bufferSize); memcpy (pBuffer, pBits, propBitsSize); return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefArray::CreateEmptyValue (ImplAAFPropertyValue ** ppPropVal) { AAFRESULT result = AAFRESULT_SUCCESS; if (NULL == ppPropVal) return AAFRESULT_NULL_PARAM; ImplAAFTypeDefSP pElementType; result = GetType(&pElementType); if (AAFRESULT_FAILED(result)) return result; if (dynamic_cast<ImplAAFTypeDefStrongObjRef*>((ImplAAFTypeDef*) pElementType)) { // element is strong ref ImplAAFStrongRefArrayValue* pStrongRefArray = NULL; pStrongRefArray = (ImplAAFStrongRefArrayValue*) CreateImpl (CLSID_AAFStrongRefArrayValue); if (!pStrongRefArray) return AAFRESULT_NOMEMORY; result = pStrongRefArray->Initialize(this, kAAFTrue == IsFixedSize()); if (AAFRESULT_SUCCEEDED(result)) { *ppPropVal = pStrongRefArray; } else { pStrongRefArray->ReleaseReference(); } } else if (dynamic_cast<ImplAAFTypeDefWeakObjRef*>((ImplAAFTypeDef*) pElementType)) { // element is weak ref ImplAAFWeakRefArrayValue* pWeakRefArray = NULL; pWeakRefArray = (ImplAAFWeakRefArrayValue*) CreateImpl (CLSID_AAFWeakRefArrayValue); if (!pWeakRefArray) return AAFRESULT_NOMEMORY; result = pWeakRefArray->Initialize(this, kAAFTrue == IsFixedSize()); if (AAFRESULT_SUCCEEDED(result)) { *ppPropVal = pWeakRefArray; } else { pWeakRefArray->ReleaseReference(); } } else { //simply defer to base impl (size is 0) result = CreateValue(ppPropVal); } return result; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefRename::CreateValue ( ImplAAFPropertyValue * pInPropVal, ImplAAFPropertyValue ** ppOutPropVal) { if (! pInPropVal) return AAFRESULT_NULL_PARAM; if (! ppOutPropVal) return AAFRESULT_NULL_PARAM; aafUInt32 inBitsSize; ImplAAFPropValDataSP pOutPVData; ImplAAFPropValDataSP pvd; AAFRESULT hr; ASSERTU (pInPropVal); pvd = dynamic_cast<ImplAAFPropValData*> (pInPropVal); ASSERTU (pvd); hr = pvd->GetBitsSize (&inBitsSize); if (! AAFRESULT_SUCCEEDED (hr)) return hr; pOutPVData = (ImplAAFPropValData *)CreateImpl(CLSID_AAFPropValData); if (! pOutPVData) return AAFRESULT_NOMEMORY; // SmartPointer operator= will automatically AddRef; CreateImpl *also* will // addref, so we've got one too many. Put us back to normal. pOutPVData->ReleaseReference (); hr = pOutPVData->Initialize (this); if (AAFRESULT_FAILED(hr)) return hr; hr = pOutPVData->AllocateFromPropVal (pvd, 0, inBitsSize, NULL); if (AAFRESULT_FAILED(hr)) return hr; ASSERTU (ppOutPropVal); *ppOutPropVal = pOutPVData; (*ppOutPropVal)->AcquireReference (); ASSERTU (*ppOutPropVal); return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFKLVData::SetValue (aafUInt32 valueSize, aafDataBuffer_t pValue) { AAFRESULT result = AAFRESULT_SUCCESS; ImplAAFTypeDef *pDef = NULL; ImplAAFDictionary *pDict = NULL; aafUID_t keyUID; if (!pValue) return AAFRESULT_NULL_PARAM; if (valueSize > OMPROPERTYSIZE_MAX) return AAFRESULT_BAD_SIZE; if (!_cachedRenameTypeDef) { // Lookup the type definition from this KLV data. If it fails // then the control point is invalid! result = GetKey(&keyUID); if (AAFRESULT_FAILED(result)) return result; result = GetDictionary(&pDict); if (AAFRESULT_FAILED(result)) return result; result = pDict->LookupTypeDef(keyUID, &pDef); pDict->ReleaseReference(); pDict = 0; if (AAFRESULT_FAILED(result)) return result; pDef->ReleaseReference(); // This object is owned by the dictionary! _cachedRenameTypeDef = dynamic_cast<ImplAAFTypeDefRename*>(pDef); if (NULL == _cachedRenameTypeDef) return AAFRESULT_INVALID_OBJ; } // Validate the property and get the property definition and type definition, // and the actual length of the data return (ImplAAFTypeDefIndirect::SetActualPropertyValue (_value, _cachedRenameTypeDef, pValue, valueSize)); }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefExtEnum::SetAUIDValue ( ImplAAFPropertyValue * pPropValToSet, const aafUID_t & valueIn) { ImplAAFTypeDef* ptd; ImplAAFTypeDefRecord* ptAuid; if (! pPropValToSet) return AAFRESULT_NULL_PARAM; // Get the property value's embedded type and // check if it's the same as the local type. ImplAAFTypeDefSP spPropType; if( AAFRESULT_FAILED( pPropValToSet->GetType( &spPropType ) ) ) return AAFRESULT_BAD_TYPE; ASSERTU (spPropType); if( (ImplAAFTypeDef *)spPropType != this ) return AAFRESULT_BAD_TYPE; AAFRESULT hr; // Call this method to find out if this is a legal value aafUInt32 tmp; // unused hr = GetNameBufLenFromAUID (valueIn, &tmp); if (AAFRESULT_FAILED (hr)) return hr; ptd = NonRefCountedBaseType (); ASSERTU (ptd); ptAuid = dynamic_cast<ImplAAFTypeDefRecord*> ((ImplAAFTypeDef*) ptd); ASSERTU (ptAuid); hr = ptAuid->SetStruct (pPropValToSet, (aafMemPtr_t) &valueIn, sizeof (aafUID_t)); if (AAFRESULT_FAILED(hr)) return hr; return AAFRESULT_SUCCESS; }
/* static */ ImplAAFStorable * ImplAAFRefContainerValue::GetStorableFromPropertyValue( ImplAAFPropertyValue* pPropertyValue, AAFRESULT & result) { result = AAFRESULT_SUCCESS; ASSERTU(NULL != pPropertyValue); ImplAAFStorable* storable = NULL; // initialize the returned parameter // Make sure that the type definition can contain a single object // reference. ImplAAFTypeDefSP pPropertyValueType; result = pPropertyValue->GetType(&pPropertyValueType); if (AAFRESULT_FAILED(result)) return NULL; ImplAAFTypeDefObjectRef* pObjectRefType = NULL; pObjectRefType = dynamic_cast<ImplAAFTypeDefObjectRef *>((ImplAAFTypeDef *)pPropertyValueType); if (NULL == pObjectRefType) { result = AAFRESULT_INVALID_PARAM; return NULL; } // Use the type to extract the object from the input property // value. ImplAAFRoot *pObject = NULL; result = pObjectRefType->GetObject(pPropertyValue, &pObject); // returns reference counted object! if (AAFRESULT_FAILED(result)) return NULL; // the returned object is NOT reference counted. pObject->ReleaseReference(); storable = ImplAAFRefValue::ConvertRootToOMStorable(pObject); ASSERTU(NULL != storable); if (NULL == storable) result = AAFRESULT_INVALID_OBJ; return storable; }
AAFRESULT STDMETHODCALLTYPE ImplAAFPropertyDef::GetTypeDef ( ImplAAFTypeDef ** ppTypeDef) const { if (! ppTypeDef) return AAFRESULT_NULL_PARAM; if (! _cachedType) { ImplAAFDictionarySP pDict; AAFRESULT hr; hr = GetDictionary(&pDict); if (AAFRESULT_FAILED (hr)) return hr; ASSERTU (pDict); ImplAAFPropertyDef * pNonConstThis = (ImplAAFPropertyDef *) this; aafUID_t typeId = _Type; ImplAAFTypeDef * tmp = 0; hr = pDict->LookupTypeDef (typeId, &tmp); if (AAFRESULT_FAILED (hr)) return hr; ASSERTU (tmp); if (!_cachedType) { pNonConstThis->_cachedType = tmp; _cachedType->AcquireReference(); } // If lookup caused this to already be put into the cache, just // throw away the current copy (in tmp) tmp->ReleaseReference (); tmp = 0; } ASSERTU (ppTypeDef); *ppTypeDef = _cachedType; ASSERTU (*ppTypeDef); (*ppTypeDef)->AcquireReference (); return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefExtEnum::GetAUIDValue ( ImplAAFPropertyValue * pPropValIn, aafUID_t * pValueOut) { ImplAAFTypeDef* ptd; ImplAAFTypeDefRecord* ptAuid; if (! pPropValIn) return AAFRESULT_NULL_PARAM; if (! pValueOut) return AAFRESULT_NULL_PARAM; // Get the property value's embedded type and // check if it's the same as the local type. ImplAAFTypeDefSP spPropType; if( AAFRESULT_FAILED( pPropValIn->GetType( &spPropType ) ) ) return AAFRESULT_BAD_TYPE; ASSERTU (spPropType); if( (ImplAAFTypeDef *)spPropType != this ) return AAFRESULT_BAD_TYPE; AAFRESULT hr; aafUID_t retval; ptd = NonRefCountedBaseType (); ASSERTU (ptd); ptAuid = dynamic_cast<ImplAAFTypeDefRecord*> ((ImplAAFTypeDef*) ptd); ASSERTU (ptAuid); hr = ptAuid->GetStruct (pPropValIn, (aafMemPtr_t) &retval, sizeof (retval)); if (AAFRESULT_FAILED(hr)) return hr; ASSERTU (pValueOut); *pValueOut = retval; return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefString::GetCount ( ImplAAFPropertyValue * pPropVal, aafUInt32 * pCount) { ImplAAFTypeDefSP pIncomingType; ImplAAFTypeDefSP ptd; AAFRESULT hr; if (! pPropVal) return AAFRESULT_NULL_PARAM; if (! pCount) return AAFRESULT_NULL_PARAM; // Get the property value's embedded type and // check if it's the same as the base type. if( AAFRESULT_FAILED( pPropVal->GetType( &pIncomingType ) ) ) return AAFRESULT_BAD_TYPE; ASSERTU (pIncomingType); if( (ImplAAFTypeDef *)pIncomingType != this ) return AAFRESULT_BAD_TYPE; hr = GetType (&ptd); if (AAFRESULT_FAILED(hr)) return hr; ASSERTU (ptd); ASSERTU (ptd->IsFixedSize()); aafUInt32 elemSize = ptd->ActualSize(); aafUInt32 propSize; ASSERTU (pPropVal); ImplAAFPropValDataSP pvd; pvd = dynamic_cast<ImplAAFPropValData *>(pPropVal); ASSERTU (pvd); hr = pvd->GetBitsSize (&propSize); if (AAFRESULT_FAILED(hr)) return hr; ASSERTU (pCount); *pCount = propSize / elemSize; return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDef::pvtGetUInt8Array8Type ( ImplAAFTypeDef ** ppRawTypeDef) { if (! ppRawTypeDef) return AAFRESULT_NULL_PARAM; ImplAAFDictionarySP pDict; AAFRESULT hr = GetDictionary(&pDict); if (AAFRESULT_FAILED (hr)) return hr; return pDict->LookupTypeDef (kAAFTypeID_UInt8Array, ppRawTypeDef); }
AAFRESULT STDMETHODCALLTYPE ImplAAFOperationDef::RemoveDegradeToOperationAt ( aafUInt32 index) { aafUInt32 count; AAFRESULT hr; hr = CountDegradeToOperations (&count); if (AAFRESULT_FAILED (hr)) return hr; if (index >= count) return AAFRESULT_BADINDEX; _degradeTo.removeAt(index); return AAFRESULT_SUCCESS; }
// Remove the given object from the container property. AAFRESULT STDMETHODCALLTYPE ImplAAFRefContainerValue::RemoveElement( ImplAAFPropertyValue* pPropertyValue) { AAFRESULT result = AAFRESULT_SUCCESS; if (NULL == pPropertyValue) return AAFRESULT_NULL_PARAM; ImplAAFStorable * pObject = GetStorableFromPropertyValue(pPropertyValue, result); if (AAFRESULT_FAILED(result)) return result; result = RemoveObject(pObject); return result; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefArray::CreateValue(ImplAAFPropertyValue ** ppPropVal, aafUInt32 dataSize) { if (! ppPropVal) return AAFRESULT_NULL_PARAM; ImplAAFPropValDataSP pvd; ImplAAFPropValData * tmp; tmp = (ImplAAFPropValData*) CreateImpl (CLSID_AAFPropValData); if (!tmp) return AAFRESULT_NOMEMORY; pvd = tmp; // the pvd smart pointer will maintain a reference for us... tmp->ReleaseReference (); //Initialize pvd to this type HRESULT hr = pvd->Initialize(this); if (AAFRESULT_FAILED(hr)) return hr; //deal with dataSize - Allocate bits if this param is non-zero if (dataSize) { //Allocate the necesary bits aafMemPtr_t pTargetData = 0; hr = pvd->AllocateBits(dataSize, &pTargetData); if (AAFRESULT_FAILED (hr)) return hr; }//if dataSize else //we're effectively creating an "Empty" value ; *ppPropVal = pvd; ASSERTU (*ppPropVal); (*ppPropVal)->AcquireReference (); return AAFRESULT_SUCCESS; }//CreateValue()
// Insert pObject into the OMObjectVector at position index. // Existing objects at index> and higher are shifted up one index position. AAFRESULT STDMETHODCALLTYPE ImplAAFRefArrayValue::InsertElementAt( ImplAAFPropertyValue* pPropertyValue, aafUInt32 index) { AAFRESULT result = AAFRESULT_SUCCESS; if (NULL == pPropertyValue) return AAFRESULT_NULL_PARAM; ImplAAFStorable * pObject = GetStorableFromPropertyValue(pPropertyValue, result); if (AAFRESULT_FAILED(result)) return result; result = InsertObjectAt(pObject, index); return result; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefExtEnum::Initialize ( const aafUID_t & id, const aafCharacter * pTypeName) { if (!pTypeName) return AAFRESULT_NULL_PARAM; AAFRESULT hr; hr = ImplAAFMetaDefinition::Initialize(id, pTypeName, NULL); if (AAFRESULT_FAILED (hr)) return hr; return AAFRESULT_SUCCESS; }