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;
}
