STDAPI ImplAAFCreateRawStorageCached2 (IAAFRawStorage * pRawStorage, aafUInt32 pageCount, aafUInt32 pageSize, IAAFCachePageAllocator * pCachePageAllocator, ImplAAFRawStorage ** ppNewRawStorage) { if (! pRawStorage) return AAFRESULT_NULL_PARAM; if (! pCachePageAllocator) return AAFRESULT_NULL_PARAM; if (! ppNewRawStorage) return AAFRESULT_NULL_PARAM; CHECK_CLIENT_IMPLEMENTED_QI(pRawStorage, IID_IAAFRawStorage); CHECK_CLIENT_IMPLEMENTED_QI(pCachePageAllocator, IID_IAAFCachePageAllocator); HRESULT hr; aafBoolean_t isReadable; hr = pRawStorage->IsReadable(&isReadable); if (FAILED(hr)) return hr; aafBoolean_t isWriteable; hr = pRawStorage->IsWriteable(&isWriteable); if (FAILED(hr)) return hr; aafFileAccess_t access = kAAFFileAccess_none; if (isReadable && isWriteable) access = kAAFFileAccess_modify; else if (isReadable) access = kAAFFileAccess_read; else if (isWriteable) access = kAAFFileAccess_write; hr = pCachePageAllocator->Initialize(pageCount, pageSize); if (FAILED(hr)) return hr; OMCachePageAllocator* pAllocator = new ImplAAFOMCachePageAllocator(pCachePageAllocator, pageCount, pageSize); ASSERTU(pAllocator); ImplAAFOMCachedRawStorage* pStg = new ImplAAFOMCachedRawStorage(pRawStorage, pageCount, pageSize, pAllocator); ASSERTU(pStg); ImplAAFRawStorage * prs = static_cast<ImplAAFRawStorage *> (::CreateImpl(CLSID_AAFRandomRawStorage)); prs->Initialize (pStg, access); *ppNewRawStorage = prs; return AAFRESULT_SUCCESS; }
STDAPI ImplAAFSetDiagnosticOutput (IAAFDiagnosticOutput* pOutput) { if (pOutput == 0) { return AAFRESULT_NULL_PARAM; } CHECK_CLIENT_IMPLEMENTED_QI(pOutput, IID_IAAFDiagnosticOutput); HRESULT hr = AAFRESULT_SUCCESS; ImplAAFClientDiagnostics* pDiagnosticStream = new ImplAAFClientDiagnostics (pOutput); ASSERTU (pDiagnosticStream); // Set the pDiagnosticStream to be the toolkit's // default diagnostic output stream. // Note that omlog::setStream() takes over the ownership // of the pDiagnosticStream pointer. omlog.setStream (pDiagnosticStream); return hr; }
STDAPI ImplAAFSetProgressCallback (IAAFProgress * pProgress) { if (pProgress == 0) return AAFRESULT_NULL_PARAM; AAFRESULT hr = AAFRESULT_SUCCESS; CHECK_CLIENT_IMPLEMENTED_QI(pProgress, IID_IAAFProgress); ImplAAFContext *context = ImplAAFContext::GetInstance(); ASSERTU(context != 0); hr = context->SetProgressCallback(pProgress); return hr; }
AAFRESULT STDMETHODCALLTYPE ImplAAFTypeDefStream::SetCallback ( ImplAAFPropertyValue * pPropertyValue, IAAFStreamAccess* pCallbackIF, aafMemPtr_t pUserData) { ImplAAFOMDataStreamAccess *access; IAAFPropertyValue *pvalInterface; CHECK_CLIENT_IMPLEMENTED_QI(pCallbackIF, IID_IAAFStreamAccess); PROPERTYVALUE_TO_STREAMPROPERTYVALUE(pPropertyValue, pStreamPropertyValue); IUnknown *iUnk = static_cast<IUnknown *> (pPropertyValue->GetContainer()); iUnk->QueryInterface(IID_IAAFPropertyValue, (void **)&pvalInterface); //This call increments the reference counter access = new ImplAAFOMDataStreamAccess(pvalInterface, pCallbackIF, pUserData); pvalInterface->Release(); //Decrement reference counter pStreamPropertyValue->setStreamAccess(access); return AAFRESULT_SUCCESS; }
//*********************************************************** // // ImplAAFRawStorageIsAAFFileKind() // // STDAPI ImplAAFRawStorageIsAAFFileKind ( IAAFRawStorage * pRawStorage, aafUID_constptr pAAFFileKind, aafBool * pRawStorageIsAAFFile) { if (pRawStorage == 0) return AAFRESULT_NULL_PARAM; if (pAAFFileKind == 0) return AAFRESULT_NULL_PARAM; if (pRawStorageIsAAFFile == 0) return AAFRESULT_NULL_PARAM; CHECK_CLIENT_IMPLEMENTED_QI(pRawStorage, IID_IAAFRawStorage); HRESULT hr = S_OK; aafBool is_file_kind = kAAFFalse; // Obtain OM representation of pRawStorage. IAAFRoot* p_root_object = 0; hr = pRawStorage->QueryInterface( IID_IAAFRoot, reinterpret_cast<void**>(&p_root_object)); ASSERTU(p_root_object != 0); ImplAAFRoot* p_impl_root_object = 0; p_root_object->GetImplRep( reinterpret_cast<void**>(&p_impl_root_object) ); ASSERTU(p_impl_root_object != 0); p_root_object->Release(); p_root_object = 0; ImplAAFRawStorage* p_impl_raw_storage = dynamic_cast<ImplAAFRawStorage*>(p_impl_root_object); ASSERTU(p_impl_raw_storage != 0); OMRawStorage* p_om_raw_storage = p_impl_raw_storage->GetOMStorage(); ASSERTU(p_om_raw_storage != 0); const OMStoredObjectEncoding* p_om_encoding = reinterpret_cast<const OMStoredObjectEncoding*>(pAAFFileKind); const bool has_factory = OMFile::hasFactory (*p_om_encoding); if (has_factory) { OMStoredObjectFactory* p_factory = OMFile::findFactory (*p_om_encoding); // Does the factory recognize this file? if( p_factory->isRecognized( p_om_raw_storage ) ) { is_file_kind = kAAFTrue; } else { is_file_kind = kAAFFalse; } hr = S_OK; } else { is_file_kind = false; hr = AAFRESULT_FILEKIND_NOT_REGISTERED; } if( hr == S_OK ) { *pRawStorageIsAAFFile = is_file_kind; } return hr; }
STDAPI ImplAAFCreateAAFFileOnRawStorage (IAAFRawStorage * pRawStorage, aafFileExistence_t existence, aafFileAccess_t access, aafUID_constptr pFileKind, aafUInt32 modeFlags, aafProductIdentification_constptr pIdent, ImplAAFFile ** ppNewFile) { if (! pRawStorage) return AAFRESULT_NULL_PARAM; if (! ppNewFile) return AAFRESULT_NULL_PARAM; CHECK_CLIENT_IMPLEMENTED_QI(pRawStorage, IID_IAAFRawStorage); HRESULT hr = S_OK; ImplAAFFileSP pFile; // Create an instance of an uninitialized file object. Check the // raw storage to determine if this should be an AAFFile, or an // AAFRandomFile. If the RawStorage is a RandomRawStorage, create // an AAFRandomFile. IAAFRandomRawStorage * prrs = 0; hr = pRawStorage->QueryInterface (IID_IAAFRandomRawStorage, (void **) &prrs); if (SUCCEEDED (hr)) pFile = static_cast<ImplAAFFile *>(::CreateImpl(CLSID_AAFRandomFile)); else pFile = static_cast<ImplAAFFile *>(::CreateImpl(CLSID_AAFFile)); if (prrs) { prrs->Release (); prrs = 0; } if(!pFile) return AAFRESULT_NOMEMORY; // Smart pointer had already incremented reference count, so bump it // back down to 1 here... pFile->ReleaseReference (); // Make sure the file is initialized (not open yet...) hr = pFile->Initialize(); if (SUCCEEDED(hr)) { // Attempt to open the file for modification. hr = pFile->CreateAAFFileOnRawStorage(pRawStorage, existence, access, pFileKind, modeFlags, pIdent); if (SUCCEEDED(hr)) { *ppNewFile = pFile; (*ppNewFile)->AcquireReference (); } } return hr; }