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 ImplAAFOperationDef::GetDegradeToOperations ( ImplEnumAAFOperationDefs **ppEnum) { if (NULL == ppEnum) return AAFRESULT_NULL_PARAM; *ppEnum = 0; ImplEnumAAFOperationDefs *theEnum = (ImplEnumAAFOperationDefs *)CreateImpl (CLSID_EnumAAFOperationDefs); XPROTECT() { OMWeakReferenceVectorIterator<OMUniqueObjectIdentification, ImplAAFOperationDef>* iter = new OMWeakReferenceVectorIterator<OMUniqueObjectIdentification, ImplAAFOperationDef>(_degradeTo); if(iter == 0) RAISE(AAFRESULT_NOMEMORY); CHECK(theEnum->Initialize(&CLSID_EnumAAFOperationDefs, this, iter)); *ppEnum = theEnum; } XEXCEPT { if (theEnum) { theEnum->ReleaseReference(); theEnum = 0; } } XEND; return(AAFRESULT_SUCCESS); }
AAFRESULT STDMETHODCALLTYPE ImplAAFMultipleDescriptor::GetFileDescriptors ( ImplEnumAAFFileDescriptors **ppEnum) { if (ppEnum == NULL) return AAFRESULT_NULL_PARAM; ImplEnumAAFFileDescriptors *theEnum = (ImplEnumAAFFileDescriptors *)CreateImpl(CLSID_EnumAAFFileDescriptors); XPROTECT() { OMStrongReferenceVectorIterator<ImplAAFFileDescriptor> *iter = new OMStrongReferenceVectorIterator<ImplAAFFileDescriptor>(_Descriptors); if (iter == 0) RAISE(AAFRESULT_NOMEMORY); CHECK(theEnum->Initialize(&CLSID_EnumAAFFileDescriptors, this, iter)); *ppEnum = theEnum; } XEXCEPT { if (theEnum) theEnum->ReleaseReference(); theEnum = 0; } XEND; return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFContentStorage::GetMobs (aafSearchCrit_t *pSearchCriteria, ImplEnumAAFMobs **ppEnum) { if (NULL == ppEnum) return AAFRESULT_NULL_PARAM; *ppEnum = 0; ImplEnumAAFMobs *theEnum = (ImplEnumAAFMobs *)CreateImpl (CLSID_EnumAAFMobs); XPROTECT() { OMStrongReferenceSetIterator<OMMaterialIdentification, ImplAAFMob>* iter = new OMStrongReferenceSetIterator<OMMaterialIdentification, ImplAAFMob>(_mobs); if(iter == 0) RAISE(AAFRESULT_NOMEMORY); CHECK(theEnum->Initialize(&CLSID_EnumAAFMobs, this, iter)); CHECK(theEnum->SetCriteria(pSearchCriteria)); *ppEnum = theEnum; } XEXCEPT { if (theEnum) { theEnum->ReleaseReference(); theEnum = 0; } } XEND; return(AAFRESULT_SUCCESS); }
AAFRESULT STDMETHODCALLTYPE ImplAAFContentStorage::EnumEssenceData (ImplEnumAAFEssenceData ** ppEnum) { if (NULL == ppEnum) return AAFRESULT_NULL_PARAM; *ppEnum = 0; ImplEnumAAFEssenceData *theEnum = (ImplEnumAAFEssenceData *)CreateImpl (CLSID_EnumAAFEssenceData); XPROTECT() { OMStrongReferenceSetIterator<OMMaterialIdentification, ImplAAFEssenceData>* iter = new OMStrongReferenceSetIterator<OMMaterialIdentification, ImplAAFEssenceData>(_essenceData); if(iter == 0) RAISE(AAFRESULT_NOMEMORY); CHECK(theEnum->Initialize(&CLSID_EnumAAFEssenceData, this, iter)); *ppEnum = theEnum; } XEXCEPT { if (theEnum) { theEnum->ReleaseReference(); theEnum = 0; } } XEND; return(AAFRESULT_SUCCESS); }
//*********************************************************** // // EnumAlternateSegments() // // Places an IEnumAlternateSegments enumerator for the alterante segmemts contained // in the selector into the *ppEnum argument. // // Succeeds if all of the following are true: // - the ppEnum pointer is valid. // // If this method fails nothing will be written to *ppEnum. // // This method will return the following codes. If more than one of // the listed errors is in effect, it will return the first one // encountered in the order given below: // // AAFRESULT_SUCCESS // - succeeded. (This is the only code indicating success.) // // AAFRESULT_NULL_PARAM // - ppEnum is null. // // E_FAIL // - Failed to create the enumerator. // // AAFRESULT STDMETHODCALLTYPE ImplAAFSelector::EnumAlternateSegments (ImplEnumAAFSegments** ppEnum) { if(ppEnum == NULL) return(AAFRESULT_NULL_PARAM); *ppEnum = (ImplEnumAAFSegments *)CreateImpl(CLSID_EnumAAFSegments); if(*ppEnum == NULL) return(AAFRESULT_NOMEMORY); XPROTECT() { OMStrongReferenceVectorIterator<ImplAAFSegment>* iter = new OMStrongReferenceVectorIterator<ImplAAFSegment>(_alternates); if(iter == 0) RAISE(AAFRESULT_NOMEMORY); CHECK((*ppEnum)->Initialize(&CLSID_EnumAAFSegments, this, iter)); } XEXCEPT { if (*ppEnum) (*ppEnum)->ReleaseReference(); (*ppEnum) = 0; } XEND; return(AAFRESULT_SUCCESS); }
AAFRESULT STDMETHODCALLTYPE ImplAAFEssenceData::GetPlainEssenceData ( aafUInt32 reserved, ImplAAFPlainEssenceData ** pPlainEssenceData) { AAFRESULT result = AAFRESULT_NOT_IMPLEMENTED; if (reserved != 0) return AAFRESULT_INVALID_PARAM; ImplAAFPlainEssenceData* pResult = (ImplAAFPlainEssenceData*) CreateImpl (CLSID_AAFPlainEssenceData); if (pResult) { pResult->pvtInitialize(this); *pPlainEssenceData = pResult; result = AAFRESULT_SUCCESS; } else { result = AAFRESULT_INTERNAL_ERROR; } return result; }
AAFRESULT STDMETHODCALLTYPE ImplAAFOperationDef::GetParameterDefs ( ImplEnumAAFParameterDefs **ppEnum) { ImplEnumAAFParameterDefs *theEnum; if(ppEnum == NULL) return(AAFRESULT_NULL_PARAM); *ppEnum = NULL; theEnum = (ImplEnumAAFParameterDefs *)CreateImpl(CLSID_EnumAAFParameterDefs); if(theEnum == NULL) return(AAFRESULT_NOMEMORY); XPROTECT() { OMWeakReferenceSetIterator<OMUniqueObjectIdentification, ImplAAFParameterDef>* iter = new OMWeakReferenceSetIterator<OMUniqueObjectIdentification, ImplAAFParameterDef>(_paramDefined); if(iter == 0) RAISE(AAFRESULT_NOMEMORY); CHECK(theEnum->Initialize(&CLSID_EnumAAFParameterDefs, this, iter)); *ppEnum = theEnum; } XEXCEPT { if (theEnum) { theEnum->ReleaseReference(); theEnum = 0; } } XEND; return(AAFRESULT_SUCCESS); }
AAFRESULT STDMETHODCALLTYPE ImplAAFPluginDef::GetLocators ( ImplEnumAAFPluginLocators **ppEnum) { ImplEnumAAFPluginLocators *theEnum = (ImplEnumAAFPluginLocators *)CreateImpl (CLSID_EnumAAFPluginLocators); XPROTECT() { OMStrongReferenceVectorIterator<ImplAAFLocator>* iter = new OMStrongReferenceVectorIterator<ImplAAFLocator>(_locators); if(iter == 0) RAISE(AAFRESULT_NOMEMORY); CHECK(theEnum->Initialize(&CLSID_EnumAAFPluginLocators, this, iter)); *ppEnum = theEnum; } XEXCEPT { if (theEnum) theEnum->ReleaseReference(); theEnum = 0; } XEND; return(AAFRESULT_SUCCESS); }
// Allocate and initialize the correct subclass of ImplAAFPropertyValue // for the given OMProperty. AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefStream::CreatePropertyValue( OMProperty *property, ImplAAFPropertyValue ** ppPropertyValue ) const { AAFRESULT result = AAFRESULT_SUCCESS; ASSERTU (property && ppPropertyValue); if (NULL == property || NULL == ppPropertyValue) return AAFRESULT_NULL_PARAM; *ppPropertyValue = NULL; // initialize out parameter ImplAAFStreamPropertyValue *pStreamValue = NULL; pStreamValue = (ImplAAFStreamPropertyValue*) CreateImpl (CLSID_AAFStreamPropertyValue); if (!pStreamValue) return AAFRESULT_NOMEMORY; // Attempt to initialize the stream value. This will fail if given property is not a valid // stream property. result = pStreamValue->Initialize (this, property); if (AAFRESULT_SUCCEEDED(result)) { *ppPropertyValue = pStreamValue; // The reference count is already 1. pStreamValue = NULL; } else { pStreamValue->ReleaseReference(); } return result; }
AAFRESULT STDMETHODCALLTYPE ImplEnumAAFCodecFlavours::Clone ( ImplEnumAAFCodecFlavours **ppEnum) { ImplEnumAAFCodecFlavours *result; AAFRESULT hr; result = (ImplEnumAAFCodecFlavours *)CreateImpl(CLSID_EnumAAFCodecFlavours); if (!result) return E_FAIL; hr = result->SetEnumCodec(_codec); if (SUCCEEDED(hr)) { result->_current = _current; *ppEnum = result; } else { result->ReleaseReference(); result = 0; *ppEnum = 0; } return hr; }
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; }
XnStatus ExportedMockNodeBase::Create(xn::Context& context, const XnChar* strInstanceName, const XnChar* /*strCreationInfo*/, xn::NodeInfoList* /*pNeededTrees*/, const XnChar* /*strConfigurationDir*/, xn::ModuleProductionNode** ppInstance) { XN_VALIDATE_OUTPUT_PTR(ppInstance); *ppInstance = CreateImpl(context, strInstanceName); XN_VALIDATE_ALLOC_PTR(*ppInstance); return XN_STATUS_OK; }
void ImplAAFContext::InitPluginManager (void) { if(_plugins == NULL) { _plugins = (ImplAAFPluginManager *)CreateImpl(CLSID_AAFPluginManager); ASSERTU(NULL != _plugins); if (_plugins) _plugins->Init(); } }
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 ImplAAFTypeDefString::CreateValueFromCString ( aafMemPtr_t pInitData, aafUInt32 initDataSize, ImplAAFPropertyValue ** ppPropVal) { if (! pInitData) return AAFRESULT_NULL_PARAM; if (! ppPropVal) return AAFRESULT_NULL_PARAM; if (! IsRegistered ()) return AAFRESULT_NOT_REGISTERED; if (initDataSize > OMPROPERTYSIZE_MAX) return AAFRESULT_BAD_SIZE; 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 = SetCString (pvd, pInitData, initDataSize); if (AAFRESULT_FAILED (hr)) return hr; ASSERTU (ppPropVal); *ppPropVal = pvd; ASSERTU (*ppPropVal); (*ppPropVal)->AcquireReference (); return AAFRESULT_SUCCESS; }
// Get an enumerator for the given container property AAFRESULT STDMETHODCALLTYPE ImplAAFRefContainerValue::GetElements( ImplEnumAAFPropertyValues** ppEnum) { AAFRESULT result = AAFRESULT_SUCCESS; if (NULL == ppEnum) return AAFRESULT_NULL_PARAM; *ppEnum = NULL; // initialize the return parameter. ASSERTU (isInitialized()); if (!isInitialized()) return AAFRESULT_NOT_INITIALIZED; ImplAAFRoot* pRoot = CreateImpl(CLSID_EnumAAFStorablePropVals); if (NULL == pRoot) return AAFRESULT_NOMEMORY; ImplEnumAAFStorablePropVals* pNewEnum = dynamic_cast<ImplEnumAAFStorablePropVals*>(pRoot); if (NULL != pNewEnum) { OMReferenceContainerIterator* newIterator = referenceContainer()->createIterator(); if (NULL != newIterator) { result = pNewEnum->Initialize(this, newIterator); if (AAFRESULT_SUCCEEDED(result)) { *ppEnum = pNewEnum; pNewEnum->AcquireReference(); } } else { // _containerIterator->copy() failed... result = AAFRESULT_NOMEMORY; } } // This will free the newly created object if the initialzation has failed. pRoot->ReleaseReference(); 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 ImplAAFPluginManager::EnumLoadedPlugins ( aafUID_t categoryID, ImplEnumAAFLoadedPlugins **ppEnum) { ImplEnumAAFLoadedPlugins *theEnum = (ImplEnumAAFLoadedPlugins *)CreateImpl (CLSID_EnumAAFLoadedPlugins); XPROTECT() { CHECK(theEnum->SetCategory(&categoryID)); CHECK(theEnum->Reset()); *ppEnum = theEnum; } XEXCEPT { if (theEnum) theEnum->ReleaseReference(); } XEND; return(AAFRESULT_SUCCESS); }
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()
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefCharacter::CreateValueFromCharacter ( aafCharacter character, ImplAAFPropertyValue ** ppCharacterValue) { TRACE("ImplAAFTypeDefCharacter::CreateValueFromCharacter"); if (! ppCharacterValue) return AAFRESULT_NULL_PARAM; aafUInt32 cbChar = NativeSize(); // Create a temporary pointer to copy to the smartptr ImplAAFPropValData * tmp = (ImplAAFPropValData *)CreateImpl(CLSID_AAFPropValData); if (NULL == tmp) return AAFRESULT_NOMEMORY; ImplAAFPropValDataSP pv; pv = tmp; tmp->ReleaseReference(); // we don't need this reference anymore. tmp = 0; //Initialize check_hr ( pv->Initialize(this) ); //Allocate appropriate bits aafMemPtr_t pBits = NULL; check_hr ( pv->AllocateBits (cbChar, &pBits) ); //Set the bits to incoming character ASSERT("Valid bits", pBits != 0); memcpy (pBits, &character, cbChar); *ppCharacterValue = pv; (*ppCharacterValue)->AcquireReference (); return AAFRESULT_SUCCESS; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefStream::GetPlainStreamData ( aafUInt32 reserved, ImplAAFPlainStreamData ** pPlainStreamData) { AAFRESULT result = AAFRESULT_NOT_IMPLEMENTED; if (reserved != 0) return AAFRESULT_INVALID_PARAM; ImplAAFPlainStreamData* pResult = (ImplAAFPlainStreamData*) CreateImpl (CLSID_AAFPlainStreamData); if (pPlainStreamData) { *pPlainStreamData = pResult; result = AAFRESULT_SUCCESS; } else { result = AAFRESULT_INTERNAL_ERROR; } return result; }
Sprite::Sprite() { CreateImpl(); }
// Allocate and initialize the correct subclass of ImplAAFPropertyValue // for the given OMProperty. AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDef::CreatePropertyValue( OMProperty *property, ImplAAFPropertyValue ** ppPropertyValue ) const { AAFRESULT result = AAFRESULT_SUCCESS; ASSERTU (property && ppPropertyValue); if (NULL == property || NULL == ppPropertyValue) return AAFRESULT_NULL_PARAM; *ppPropertyValue = NULL; // initialize out parameter ASSERTU (property->definition()); if (NULL == property->definition()) return AAFRESULT_INVALID_PARAM; const OMType *type = property->definition()->type(); ASSERTU (type); ImplAAFTypeDef *ptd = const_cast<ImplAAFTypeDef *> (dynamic_cast<const ImplAAFTypeDef *>(type)); ASSERTU (ptd); if (NULL == ptd) return AAFRESULT_INVALID_PARAM; ImplAAFPropValData *pvd = NULL; pvd = (ImplAAFPropValData*) CreateImpl (CLSID_AAFPropValData); if (!pvd) return AAFRESULT_NOMEMORY; result = pvd->Initialize (ptd); if (AAFRESULT_SUCCEEDED(result)) { // set the storage in the prop value OMUInt32 bitsSize; ASSERTU (property); bitsSize = property->bitsSize (); aafMemPtr_t pBits = NULL; // Bobt hack! This should be removed once we have proper // integration with OM property def support. if (! property->isOptional() || property->isPresent ()) { result = pvd->AllocateBits (bitsSize, &pBits); if (AAFRESULT_SUCCEEDED (result)) { if (bitsSize) { ASSERTU (pBits); property->getBits (pBits, bitsSize); } } } } if (AAFRESULT_SUCCEEDED(result)) { *ppPropertyValue = pvd; // ref count is already 1. pvd = NULL; } else { pvd->ReleaseReference(); // delete the new object. } return (result) ; }
Renderer::Renderer() { CreateImpl(); }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefArray::GetElementValue ( ImplAAFPropertyValue * pInPropVal, aafUInt32 index, 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 pIncomingType; if( AAFRESULT_FAILED( pInPropVal->GetType( &pIncomingType ) ) ) return AAFRESULT_BAD_TYPE; ASSERTU (pIncomingType); if( (ImplAAFTypeDef *)pIncomingType != this ) return AAFRESULT_BAD_TYPE; ImplAAFRefArrayValue* pRefArray = dynamic_cast<ImplAAFRefArrayValue*>(pInPropVal); if (NULL != pRefArray) { return pRefArray->GetElementAt(index, ppOutPropVal); } if (index >= pvtCount (pInPropVal)) return AAFRESULT_BADINDEX; aafUInt32 inBitsSize; ImplAAFPropValDataSP pOutPVData; ImplAAFPropValDataSP pvd; ImplAAFTypeDefSP ptd; AAFRESULT hr; hr = GetType (&ptd); if (AAFRESULT_FAILED (hr)) return hr; // aafUInt32 elementSize = ptd->PropValSize(); aafUInt32 elementSize = ptd->ActualSize(); // okay for data not to be registered? ASSERTU (pInPropVal); pvd = dynamic_cast<ImplAAFPropValData*> (pInPropVal); hr = pvd->GetBitsSize (&inBitsSize); if (! AAFRESULT_SUCCEEDED (hr)) return hr; ASSERTU ((index+1) * elementSize <= inBitsSize); 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 (); hr = pOutPVData->Initialize (ptd); if (AAFRESULT_FAILED(hr)) return hr; hr = pOutPVData->AllocateFromPropVal (pvd, index * elementSize, elementSize, NULL); if (AAFRESULT_FAILED(hr)) return hr; ASSERTU (ppOutPropVal); *ppOutPropVal = pOutPVData; ASSERTU (*ppOutPropVal); (*ppOutPropVal)->AcquireReference (); return AAFRESULT_SUCCESS; }