diff -r 000000000000 -r 5752a19fdefe imaging/imagingfws/src/iclextproxystubutil.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imaging/imagingfws/src/iclextproxystubutil.cpp Wed Aug 25 12:29:52 2010 +0300 @@ -0,0 +1,1186 @@ +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include "icl/ICL_UIDS.hrh" +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#include +#endif +#include "ThreadRelay.h" +#include "ImageClientMain.h" +#include "fwextconstants.h" +#include "fwextensionparams.h" + +// Static utility class +CImageConvProxyBase* ProxyStubUtility::GetNewProxyL(TUid aUid, MImageConvExtensionThreadedSupport* aParent) + { + switch(aUid.iUid) + { + case KUidImageConvExtOperationValue: + { + return CImageConvOperationProxy::NewL(aParent); + } + case KUidImageConvExtScalerValue: + { + return CImageConvScalerProxy::NewL(aParent); + } + case KUidImageConvExtStreamedDecodeValue: + { + return CImageConvStreamedDecodeProxy::NewL(aParent); + } + case KUidImageConvExtStreamedEncodeValue: + { + return CImageConvStreamedEncodeProxy::NewL(aParent); + } + case KUidImageConvExtPrepareValue: + { + return CImageConvPrepareProxy::NewL(aParent); + } + default: + { + Panic(EInvalidFwExtensionUid); + } + } + return NULL; + } + +CImageConvProxyBase* ProxyStubUtility::GetNewStraightProxyL(TUid aUid, MFrameworkExtAsyncInterface* aStatusOwner, + RThread& aRequestThread) + { + switch(aUid.iUid) + { + case KUidImageConvExtOperationValue: + { + return CImageConvOperationStraightProxy::NewL(aStatusOwner, aRequestThread); + } + case KUidImageConvExtScalerValue: + { + return CImageConvScalerStraightProxy::NewL(aStatusOwner, aRequestThread); + } + case KUidImageConvExtStreamedDecodeValue: + { + return CImageConvStreamedDecodeStraightProxy::NewL(aStatusOwner, aRequestThread); + } + case KUidImageConvExtStreamedEncodeValue: + { + return CImageConvStreamedEncodeStraightProxy::NewL(aStatusOwner, aRequestThread); + } + case KUidImageConvExtPrepareValue: + { + return CImageConvPrepareStraightProxy::NewL(aStatusOwner, aRequestThread); + } + default: + { + Panic(EInvalidFwExtensionUid); + } + } + return NULL; + } + +CImageConvStubBase* ProxyStubUtility::NewStubL(TUid aUid, + MImageConvExtension* aExtension, + MFrameworkExtAsyncInterface* aStatusOwner, + RThread& aRequestThread) + { + switch(aUid.iUid) + { + case KUidImageConvExtOperationValue: + { + return CImageConvOperationStub::NewL(aExtension, aStatusOwner, aRequestThread); + } + case KUidImageConvExtScalerValue: + { + return CImageConvScalerStub::NewL(aExtension, aStatusOwner, aRequestThread); + } + case KUidImageConvExtStreamedDecodeValue: + { + return CImageConvStreamedDecodeStub::NewL(aExtension, aStatusOwner, aRequestThread); + } + case KUidImageConvExtStreamedEncodeValue: + { + return CImageConvStreamedEncodeStub::NewL(aExtension, aStatusOwner, aRequestThread); + } + case KUidImageConvExtPrepareValue: + { + return CImageConvPrepareStub::NewL(aExtension, aStatusOwner, aRequestThread); + } + default: + { + Panic(EInvalidFwExtensionUid); + } + } + return NULL; + } + +// Operation straight proxy +CImageConvOperationStraightProxy* CImageConvOperationStraightProxy::NewL(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvOperationStraightProxy(aStatusOwner, aRequestThread); + } + +CImageConvOperationStraightProxy::CImageConvOperationStraightProxy(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + } + +CImageConvOperationStraightProxy::~CImageConvOperationStraightProxy() + { + if(iExtension) + { + iExtension->Release(); + } + } + +void CImageConvOperationStraightProxy::SetupExtension(MImageConvExtension*& aExtension) + { + iExtension = static_cast(aExtension); + aExtension = this; + } + +TUid CImageConvOperationStraightProxy::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvOperationStraightProxy::IncrementRef() + { + iExtension->IncrementRef(); + } + +void CImageConvOperationStraightProxy::Release() + { + iExtension->Release(); + } + +TUint CImageConvOperationStraightProxy::Capabilities() const + { + return iExtension->Capabilities(); + } + +void CImageConvOperationStraightProxy::AddOperationL(TImageConvOperation::TOperation aOperation) + { + iExtension->AddOperationL(aOperation); + } + +void CImageConvOperationStraightProxy::ClearOperationStack() + { + iExtension->ClearOperationStack(); + } + +// Operation proxy +CImageConvOperationProxy* CImageConvOperationProxy::NewL(MImageConvExtensionThreadedSupport* aParent) + { + return new (ELeave) CImageConvOperationProxy(aParent); + } + +CImageConvOperationProxy::CImageConvOperationProxy(MImageConvExtensionThreadedSupport* aParent) +:iParent(aParent) + { + } + +void CImageConvOperationProxy::SetupExtension(MImageConvExtension*& aExtension) + { + aExtension = this; + } + +TUid CImageConvOperationProxy::Uid() const + { + TUidExecCmdParams uid(KICLOperationUid, EImgConvExtUid); + iParent->ExecuteCommand(uid); + return uid.iReturn; + } + +void CImageConvOperationProxy::IncrementRef() + { + ASSERT(EFalse); + } + +void CImageConvOperationProxy::Release() + { + ASSERT(EFalse); + } + +TUint CImageConvOperationProxy::Capabilities() const + { + TCapabilitiesExecCmdParams capabilities(KICLOperationUid, EImgConvExtCapabilities); + iParent->ExecuteCommand(capabilities); + return capabilities.iReturn; + } + +void CImageConvOperationProxy::AddOperationL(TImageConvOperation::TOperation aOperation) + { + TAddOperationLExecCmdParams addOperationL(KICLOperationUid, EImgConvExtAddOperationL, aOperation); + iParent->ExecuteCommandL(addOperationL); + } + +void CImageConvOperationProxy::ClearOperationStack() + { + TClearOperationStackExecCmdParams clearOperationStack(KICLOperationUid, EImgConvExtClearOperationStack); + iParent->ExecuteCommand(clearOperationStack); + } + +// Operation stub +CImageConvOperationStub* CImageConvOperationStub::NewL(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvOperationStub(aExtension, aStatusOwner, aRequestThread); + } + +CImageConvOperationStub::CImageConvOperationStub(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + iExtension = static_cast(aExtension); + } + +CImageConvOperationStub::~CImageConvOperationStub() + { + if(iExtension) + { + iExtension->Release(); + } + } + +TUid CImageConvOperationStub::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvOperationStub::HandleExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase) + { + switch(aExecuteCommandBase.iCmdNum) + { + case EImgConvExtUid: + { + // cast to appropriate extension TClass + TUidExecCmdParams* uid = static_cast(&aExecuteCommandBase); + uid->iReturn = iExtension->Uid(); + break; + } + case EImgConvExtIncrementRef: + { + iExtension->IncrementRef(); + break; + } + case EImgConvExtRelease: + { + iExtension->Release(); + break; + } + case EImgConvExtCapabilities: + { + TCapabilitiesExecCmdParams* capabilities = static_cast(&aExecuteCommandBase); + capabilities->iReturn = iExtension->Capabilities(); + break; + } + case EImgConvExtAddOperationL: + { + TAddOperationLExecCmdParams* addOperationL = static_cast(&aExecuteCommandBase); + iExtension->AddOperationL(addOperationL->iOperation); + break; + } + case EImgConvExtClearOperationStack: + { + iExtension->ClearOperationStack(); + break; + } + default: + { + Panic(EInvalidFwExtensionCall); + } + } + } + +void CImageConvOperationStub::HandleExecuteAsyncCommand(TExecuteCommandParamsAsyncBase& /*aExecuteCommandBase*/) + { + // No async calls for transform + } + +// Straight scaler proxy +CImageConvScalerStraightProxy* CImageConvScalerStraightProxy::NewL(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvScalerStraightProxy(aStatusOwner, aRequestThread); + } + +CImageConvScalerStraightProxy::CImageConvScalerStraightProxy(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + } + +CImageConvScalerStraightProxy::~CImageConvScalerStraightProxy() + { + if(iExtension) + { + iExtension->Release(); + } + } + +void CImageConvScalerStraightProxy::SetupExtension(MImageConvExtension*& aExtension) + { + iExtension = static_cast(aExtension); + aExtension = this; + } + +TUid CImageConvScalerStraightProxy::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvScalerStraightProxy::IncrementRef() + { + iExtension->IncrementRef(); + } + +void CImageConvScalerStraightProxy::Release() + { + iExtension->Release(); + } + +void CImageConvScalerStraightProxy::GetCapabilities(TScalerCaps& aCaps) const + { + iExtension->GetCapabilities(aCaps); + } + +void CImageConvScalerStraightProxy::SetScalingL(const TSize& aDesiredSize, TImageConvScaler::TScalerQuality aQuality, TBool aLockAspectRatio) + { + iExtension->SetScalingL(aDesiredSize, aQuality, aLockAspectRatio); + } + +void CImageConvScalerStraightProxy::SetScalingL(TInt aScalingCoeff, TImageConvScaler::TScalerQuality aScalingQuality) + { + iExtension->SetScalingL(aScalingCoeff, aScalingQuality); + } + +// Scaler proxy +CImageConvScalerProxy* CImageConvScalerProxy::NewL(MImageConvExtensionThreadedSupport* aParent) + { + return new (ELeave) CImageConvScalerProxy(aParent); + } + +CImageConvScalerProxy::CImageConvScalerProxy(MImageConvExtensionThreadedSupport* aParent) +:iParent(aParent) + { + } + +void CImageConvScalerProxy::SetupExtension(MImageConvExtension*& aExtension) + { + aExtension = this; + } + +TUid CImageConvScalerProxy::Uid() const + { + TUidExecCmdParams uid(KICLScalerUid, EImgConvExtUid); + iParent->ExecuteCommand(uid); + return uid.iReturn; + } + +void CImageConvScalerProxy::IncrementRef() + { + ASSERT(EFalse); + } + +void CImageConvScalerProxy::Release() + { + ASSERT(EFalse); + } + +void CImageConvScalerProxy::GetCapabilities(TScalerCaps& aCaps) const + { + TGetCapabilitiesScalerExecCmdParams scalerCaps(KICLScalerUid, EImgConvExtGetCapabilitiesScaler, aCaps); + iParent->ExecuteCommand(scalerCaps); + } + +void CImageConvScalerProxy::SetScalingL(const TSize& aDesiredSize, TImageConvScaler::TScalerQuality aQuality, TBool aLockAspectRatio) + { + TSetScalingLSizeExecCmdParams setScalingL(KICLScalerUid, EImgConvExtSetScalingLSize, aDesiredSize, aQuality, aLockAspectRatio); + iParent->ExecuteCommandL(setScalingL); + } + +void CImageConvScalerProxy::SetScalingL(TInt aScalingCoeff, TImageConvScaler::TScalerQuality aScalingQuality) + { + TSetScalingLCoeffExecCmdParams setScaling(KICLScalerUid, EImgConvExtSetScalingLCoeff, aScalingCoeff, aScalingQuality); + iParent->ExecuteCommandL(setScaling); + } + +// Scaler stub +CImageConvScalerStub* CImageConvScalerStub::NewL(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvScalerStub(aExtension, aStatusOwner, aRequestThread); + } + +CImageConvScalerStub::CImageConvScalerStub(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + iExtension = static_cast(aExtension); + } + +CImageConvScalerStub::~CImageConvScalerStub() + { + if(iExtension) + { + iExtension->Release(); + } + } + +TUid CImageConvScalerStub::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvScalerStub::HandleExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase) + { + switch(aExecuteCommandBase.iCmdNum) + { + case EImgConvExtUid: + { + // cast to appropriate extension TClass + TUidExecCmdParams* uid = static_cast(&aExecuteCommandBase); + uid->iReturn = iExtension->Uid(); + break; + } + case EImgConvExtIncrementRef: + { + iExtension->IncrementRef(); + break; + } + case EImgConvExtRelease: + { + iExtension->Release(); + break; + } + case EImgConvExtGetCapabilitiesScaler: + { + TGetCapabilitiesScalerExecCmdParams* scalerCaps = static_cast(&aExecuteCommandBase); + iExtension->GetCapabilities(*scalerCaps->iCaps); + break; + } + case EImgConvExtSetScalingLSize: + { + TSetScalingLSizeExecCmdParams* setScalingLSize = static_cast(&aExecuteCommandBase); + iExtension->SetScalingL(*setScalingLSize->iDesiredSize, setScalingLSize->iQuality, setScalingLSize->iLockAspectRatio); + break; + } + case EImgConvExtSetScalingLCoeff: + { + TSetScalingLCoeffExecCmdParams* setScalingLCoeff = static_cast(&aExecuteCommandBase); + iExtension->SetScalingL(setScalingLCoeff->iScalingCoeff, setScalingLCoeff->iScalingQuality); + break; + } + default: + { + Panic(EInvalidFwExtensionCall); + } + } + } + +void CImageConvScalerStub::HandleExecuteAsyncCommand(TExecuteCommandParamsAsyncBase& /*aExecuteCommandBase*/) + { + // No async calls for scaler + } + +// Streamed decode straight proxy +CImageConvStreamedDecodeStraightProxy* CImageConvStreamedDecodeStraightProxy::NewL(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvStreamedDecodeStraightProxy(aStatusOwner, aRequestThread); + } + +CImageConvStreamedDecodeStraightProxy::CImageConvStreamedDecodeStraightProxy(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + } + +CImageConvStreamedDecodeStraightProxy::~CImageConvStreamedDecodeStraightProxy() + { + if(iExtension) + { + iExtension->Release(); + } + } + +void CImageConvStreamedDecodeStraightProxy::SetupExtension(MImageConvExtension*& aExtension) + { + iExtension = static_cast(aExtension); + aExtension = this; + } + +TUid CImageConvStreamedDecodeStraightProxy::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvStreamedDecodeStraightProxy::IncrementRef() + { + iExtension->IncrementRef(); + } + +void CImageConvStreamedDecodeStraightProxy::Release() + { + iExtension->Release(); + } + +void CImageConvStreamedDecodeStraightProxy::GetSupportedFormatsL(RArray& aFormats, TUid& aOptimalFormat) const + { + iExtension->GetSupportedFormatsL(aFormats, aOptimalFormat); + } + +void CImageConvStreamedDecodeStraightProxy::GetCapabilities(TUid aFormat, TInt aFrameNumber, TDecodeStreamCaps& aCaps) const + { + iExtension->GetCapabilities(aFormat, aFrameNumber, aCaps); + } + +TInt CImageConvStreamedDecodeStraightProxy::GetBufferSize(TUid aFormat, TSize& aBlockSizeInPixels, TInt aNumBlocks) const + { + return iExtension->GetBufferSize(aFormat, aBlockSizeInPixels, aNumBlocks); + } + +void CImageConvStreamedDecodeStraightProxy::InitFrameL(TUid aFormat, TInt aFrameNumber, TDecodeStreamCaps::TNavigation aNavigation) + { + iExtension->InitFrameL(aFormat, aFrameNumber, aNavigation); + } + +void CImageConvStreamedDecodeStraightProxy::GetBlocks(TRequestStatus* aStatus, CImageFrame* aFrame, TInt aSeqPosition, TInt aNumBlocksToGet, TInt* aNumBlocksRead) + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aStatus); + iExtension->GetBlocks(NULL, aFrame, aSeqPosition, aNumBlocksToGet, aNumBlocksRead); + if(*aStatus == KRequestPending) + { + iStatusOwner->StartActivity(); + } + } + +void CImageConvStreamedDecodeStraightProxy::GetNextBlocks(TRequestStatus* aStatus, CImageFrame* aFrame, TInt aNumBlocksToGet, TInt* aNumBlocksRead, TBool* aHaveMoreBlocks) + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aStatus); + iExtension->GetNextBlocks(NULL, aFrame, aNumBlocksToGet, aNumBlocksRead, aHaveMoreBlocks); + if(*aStatus == KRequestPending) + { + iStatusOwner->StartActivity(); + } + } + +// Streamed decode proxy +CImageConvStreamedDecodeProxy* CImageConvStreamedDecodeProxy::NewL(MImageConvExtensionThreadedSupport* aParent) + { + return new (ELeave) CImageConvStreamedDecodeProxy(aParent); + } + +CImageConvStreamedDecodeProxy::CImageConvStreamedDecodeProxy(MImageConvExtensionThreadedSupport* aParent) +:iParent(aParent) + { + } + +void CImageConvStreamedDecodeProxy::SetupExtension(MImageConvExtension*& aExtension) + { + aExtension = this; + } + +TUid CImageConvStreamedDecodeProxy::Uid() const + { + TUidExecCmdParams uid(KICLStreamedDecodeUid, EImgConvExtUid); + iParent->ExecuteCommand(uid); + return uid.iReturn; + } + +void CImageConvStreamedDecodeProxy::IncrementRef() + { + ASSERT(EFalse); + } + +void CImageConvStreamedDecodeProxy::Release() + { + ASSERT(EFalse); + } + +void CImageConvStreamedDecodeProxy::GetSupportedFormatsL(RArray& aFormats, TUid& aOptimalFormat) const + { + TGetSupportedFormatsLStrDecExecCmdParams supportedFormats(KICLStreamedDecodeUid, EImgConvExtGetSupportedFormatsLStreamDec, aFormats, aOptimalFormat); + iParent->ExecuteCommandL(supportedFormats); + } + +void CImageConvStreamedDecodeProxy::GetCapabilities(TUid aFormat, TInt aFrameNumber, TDecodeStreamCaps& aCaps) const + { + TGetCapabilitiesStrDecExecCmdParams streamCaps(KICLStreamedDecodeUid, EImgConvExtGetCapabilitiesStreamDec, aFormat, aFrameNumber, aCaps); + iParent->ExecuteCommand(streamCaps); + } + +TInt CImageConvStreamedDecodeProxy::GetBufferSize(TUid aFormat, TSize& aBlockSizeInPixels, TInt aNumBlocks) const + { + TGetBufferSizeExecCmdParams bufferSize(KICLStreamedDecodeUid, EImgConvExtGetBufferSize, aFormat, aBlockSizeInPixels, aNumBlocks); + iParent->ExecuteCommand(bufferSize); + return bufferSize.iReturn; + } + +void CImageConvStreamedDecodeProxy::InitFrameL(TUid aFormat, TInt aFrameNumber, TDecodeStreamCaps::TNavigation aNavigation) + { + TInitFrameLStrDecExecCmdParams initFrame(KICLStreamedDecodeUid, EImgConvExtInitFrameLStreamDec, aFormat, aFrameNumber, aNavigation); + iParent->ExecuteCommandL(initFrame); + } + +void CImageConvStreamedDecodeProxy::GetBlocks(TRequestStatus* aStatus, CImageFrame* aFrame, TInt aSeqPosition, TInt aNumBlocksToGet, TInt* aNumBlocksRead) + { + TGetBlocksExecCmdParams getBlocks(KICLStreamedDecodeUid, EImgConvExtGetBlocks, aStatus, aFrame, aSeqPosition, aNumBlocksToGet, aNumBlocksRead); + iParent->ExecuteAsyncCommand(getBlocks); + } + +void CImageConvStreamedDecodeProxy::GetNextBlocks(TRequestStatus* aStatus, CImageFrame* aFrame, TInt aNumBlocksToGet, TInt* aNumBlocksRead, TBool* aHaveMoreBlocks) + { + TGetNextBlocksExecCmdParams getNextBlocks(KICLStreamedDecodeUid, EImgConvExtGetNextBlocks, aStatus, aFrame, aNumBlocksToGet, aNumBlocksRead, aHaveMoreBlocks); + iParent->ExecuteAsyncCommand(getNextBlocks); + } + +// Streamed decode stub +CImageConvStreamedDecodeStub* CImageConvStreamedDecodeStub::NewL(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvStreamedDecodeStub(aExtension, aStatusOwner, aRequestThread); + } + +CImageConvStreamedDecodeStub::CImageConvStreamedDecodeStub(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + iExtension = static_cast(aExtension); + } + +CImageConvStreamedDecodeStub::~CImageConvStreamedDecodeStub() + { + if(iExtension) + { + iExtension->Release(); + } + } + +TUid CImageConvStreamedDecodeStub::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvStreamedDecodeStub::HandleExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase) + { + switch(aExecuteCommandBase.iCmdNum) + { + case EImgConvExtUid: + { + // cast to appropriate extension TClass + TUidExecCmdParams* uid = static_cast(&aExecuteCommandBase); + uid->iReturn = iExtension->Uid(); + break; + } + case EImgConvExtIncrementRef: + { + iExtension->IncrementRef(); + break; + } + case EImgConvExtRelease: + { + iExtension->Release(); + break; + } + case EImgConvExtGetBufferSize: + { + TGetBufferSizeExecCmdParams* getBufferSize = static_cast(&aExecuteCommandBase); + getBufferSize->iReturn = iExtension->GetBufferSize(getBufferSize->iFormat, *getBufferSize->iBlockSizeInPixels, getBufferSize->iNumBlocks); + break; + } + case EImgConvExtGetCapabilitiesStreamDec: + { + TGetCapabilitiesStrDecExecCmdParams* getStreamCaps = static_cast(&aExecuteCommandBase); + iExtension->GetCapabilities(getStreamCaps->iFormat, getStreamCaps->iFrameNumber, *getStreamCaps->iCaps); + break; + } + case EImgConvExtGetSupportedFormatsLStreamDec: + { + TGetSupportedFormatsLStrDecExecCmdParams* getSupportedFormats = static_cast(&aExecuteCommandBase); + iExtension->GetSupportedFormatsL(*getSupportedFormats->iFormats, *getSupportedFormats->iOptimalFormat); + break; + } + case EImgConvExtInitFrameLStreamDec: + { + TInitFrameLStrDecExecCmdParams* initFrame = static_cast(&aExecuteCommandBase); + iExtension->InitFrameL(initFrame->iFormat, initFrame->iFrameNumber, initFrame->iNavigation); + break; + } + default: + { + Panic(EInvalidFwExtensionCall); + } + } + } + +void CImageConvStreamedDecodeStub::HandleExecuteAsyncCommand(TExecuteCommandParamsAsyncBase& aExecuteCommandBase) + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aExecuteCommandBase.iRequestStatus); + + switch(aExecuteCommandBase.iCmdNum) + { + case EImgConvExtGetBlocks: + { + TGetBlocksExecCmdParams* getBlocks = static_cast(&aExecuteCommandBase); + iExtension->GetBlocks(NULL, + getBlocks->iFrame, + getBlocks->iSeqPosition, + getBlocks->iNumBlocksToGet, + getBlocks->iNumBlocksRead); + break; + } + case EImgConvExtGetNextBlocks: + { + TGetNextBlocksExecCmdParams* getNextBlocks = static_cast(&aExecuteCommandBase); + iExtension->GetNextBlocks(NULL, + getNextBlocks->iFrame, + getNextBlocks->iNumBlocksToGet, + getNextBlocks->iNumBlocksRead, + getNextBlocks->iHaveMoreBlocks); + break; + } + default: + { + Panic(EInvalidFwExtensionCall); + } + } + if(*(aExecuteCommandBase.iRequestStatus) == KRequestPending) + { + iStatusOwner->StartActivity(); + } + } + +// Straight streamed encode proxy +CImageConvStreamedEncodeStraightProxy* CImageConvStreamedEncodeStraightProxy::NewL(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvStreamedEncodeStraightProxy(aStatusOwner, aRequestThread); + } + +CImageConvStreamedEncodeStraightProxy::CImageConvStreamedEncodeStraightProxy(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + } + +CImageConvStreamedEncodeStraightProxy::~CImageConvStreamedEncodeStraightProxy() + { + if(iExtension) + { + iExtension->Release(); + } + } + +void CImageConvStreamedEncodeStraightProxy::SetupExtension(MImageConvExtension*& aExtension) + { + iExtension = static_cast(aExtension); + aExtension = this; + } + +TUid CImageConvStreamedEncodeStraightProxy::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvStreamedEncodeStraightProxy::IncrementRef() + { + iExtension->IncrementRef(); + } + +void CImageConvStreamedEncodeStraightProxy::Release() + { + iExtension->Release(); + } + +void CImageConvStreamedEncodeStraightProxy::GetSupportedFormatsL(RArray& aFormats, TUid& aOptimalFormat) const + { + iExtension->GetSupportedFormatsL(aFormats, aOptimalFormat); + } + +void CImageConvStreamedEncodeStraightProxy::GetCapabilities(TUid aFormat, TEncodeStreamCaps& aCaps) const + { + iExtension->GetCapabilities(aFormat, aCaps); + } + +void CImageConvStreamedEncodeStraightProxy::InitFrameL(TUid aFormat, TInt aFrameNumber, const TSize& aFrameSizeInPixels, const TSize& aBlockSizeInPixels, TEncodeStreamCaps::TNavigation aNavigation, const CFrameImageData* aFrameImageData) + { + iExtension->InitFrameL(aFormat, aFrameNumber, aFrameSizeInPixels, aBlockSizeInPixels, aNavigation, aFrameImageData); + } + +void CImageConvStreamedEncodeStraightProxy::AppendBlocks(TRequestStatus* aStatus, const CImageFrame& aBlocks, TInt aNumBlocksToAdd) + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aStatus); + iExtension->AppendBlocks(NULL, aBlocks, aNumBlocksToAdd); + if(*aStatus == KRequestPending) + { + iStatusOwner->StartActivity(); + } + } + +void CImageConvStreamedEncodeStraightProxy::AddBlocks(TRequestStatus* aStatus, const CImageFrame& aBlocks, const TInt& aSeqPosition) + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aStatus); + iExtension->AddBlocks(NULL, aBlocks, aSeqPosition); + if(*aStatus == KRequestPending) + { + iStatusOwner->StartActivity(); + } + } + +void CImageConvStreamedEncodeStraightProxy::Complete(TRequestStatus* aStatus) + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aStatus); + iExtension->Complete(NULL); + if(*aStatus == KRequestPending) + { + iStatusOwner->StartActivity(); + } + } + +// Streamed encode proxy +CImageConvStreamedEncodeProxy* CImageConvStreamedEncodeProxy::NewL(MImageConvExtensionThreadedSupport* aParent) + { + return new (ELeave) CImageConvStreamedEncodeProxy(aParent); + } + +CImageConvStreamedEncodeProxy::CImageConvStreamedEncodeProxy(MImageConvExtensionThreadedSupport* aParent) +:iParent(aParent) + { + } + +void CImageConvStreamedEncodeProxy::SetupExtension(MImageConvExtension*& aExtension) + { + aExtension = this; + } + +TUid CImageConvStreamedEncodeProxy::Uid() const + { + TUidExecCmdParams uid(KICLStreamedEncodeUid, EImgConvExtUid); + iParent->ExecuteCommand(uid); + return uid.iReturn; + } + +void CImageConvStreamedEncodeProxy::IncrementRef() + { + ASSERT(EFalse); + } + +void CImageConvStreamedEncodeProxy::Release() + { + ASSERT(EFalse); + } + +void CImageConvStreamedEncodeProxy::GetSupportedFormatsL(RArray& aFormats, TUid& aOptimalFormat) const + { + TGetSupportedFormatsLStrEncExecCmdParams supportedFormats(KICLStreamedEncodeUid, EImgConvExtGetSupportedFormatsLStreamEnc, aFormats, aOptimalFormat); + iParent->ExecuteCommandL(supportedFormats); + } + +void CImageConvStreamedEncodeProxy::GetCapabilities(TUid aFormat, TEncodeStreamCaps& aCaps) const + { + TGetCapabilitiesStrEncExecCmdParams getCapabilities(KICLStreamedEncodeUid, EImgConvExtGetCapabilitiesStreamEnc, aFormat, aCaps); + iParent->ExecuteCommand(getCapabilities); + } + +void CImageConvStreamedEncodeProxy::InitFrameL(TUid aFormat, TInt aFrameNumber, const TSize& aFrameSizeInPixels, const TSize& aBlockSizeInPixels, TEncodeStreamCaps::TNavigation aNavigation, const CFrameImageData* aFrameImageData) + { + TInitFrameLStrEncExecCmdParams initFrame(KICLStreamedEncodeUid, EImgConvExtInitFrameLStreamEnc, aFormat, aFrameNumber, aFrameSizeInPixels, aBlockSizeInPixels, aNavigation, aFrameImageData); + iParent->ExecuteCommandL(initFrame); + } + +void CImageConvStreamedEncodeProxy::AppendBlocks(TRequestStatus* aStatus, const CImageFrame& aBlocks, TInt aNumBlocksToAdd) + { + TAppendBlocksExecCmdParams appendBlocks(KICLStreamedEncodeUid, EImgConvExtAppendBlocks, aStatus, aBlocks, aNumBlocksToAdd); + iParent->ExecuteAsyncCommand(appendBlocks); + } + +void CImageConvStreamedEncodeProxy::AddBlocks(TRequestStatus* aStatus, const CImageFrame& aBlocks, const TInt& aSeqPosition) + { + TAddBlocksExecCmdParams addBlocks(KICLStreamedEncodeUid, EImgConvExtAddBlocks, aStatus, aBlocks, aSeqPosition); + iParent->ExecuteAsyncCommand(addBlocks); + } + +void CImageConvStreamedEncodeProxy::Complete(TRequestStatus* aStatus) + { + TCompleteExecCmdParams complete(KICLStreamedEncodeUid, EImgConvExtComplete, aStatus); + iParent->ExecuteAsyncCommand(complete); + } + +// Streamed encode stub +CImageConvStreamedEncodeStub* CImageConvStreamedEncodeStub::NewL(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvStreamedEncodeStub(aExtension, aStatusOwner, aRequestThread); + } + +CImageConvStreamedEncodeStub::CImageConvStreamedEncodeStub(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + iExtension = static_cast(aExtension); + } + +CImageConvStreamedEncodeStub::~CImageConvStreamedEncodeStub() + { + if(iExtension) + { + iExtension->Release(); + } + } + +TUid CImageConvStreamedEncodeStub::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvStreamedEncodeStub::HandleExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase) + { + switch(aExecuteCommandBase.iCmdNum) + { + case EImgConvExtUid: + { + // cast to appropriate extension TClass + TUidExecCmdParams* uid = static_cast(&aExecuteCommandBase); + uid->iReturn = iExtension->Uid(); + break; + } + case EImgConvExtIncrementRef: + { + iExtension->IncrementRef(); + break; + } + case EImgConvExtRelease: + { + iExtension->Release(); + break; + } + case EImgConvExtGetSupportedFormatsLStreamEnc: + { + TGetSupportedFormatsLStrEncExecCmdParams* getSupportedFormats = static_cast(&aExecuteCommandBase); + iExtension->GetSupportedFormatsL(*getSupportedFormats->iFormats, *getSupportedFormats->iOptimalFormat); + break; + } + case EImgConvExtGetCapabilitiesStreamEnc: + { + TGetCapabilitiesStrEncExecCmdParams* getStreamCaps = static_cast(&aExecuteCommandBase); + iExtension->GetCapabilities(getStreamCaps->iFormat, *getStreamCaps->iCaps); + break; + } + case EImgConvExtInitFrameLStreamEnc: + { + TInitFrameLStrEncExecCmdParams* initFrame = static_cast(&aExecuteCommandBase); + iExtension->InitFrameL(initFrame->iFormat, initFrame->iFrameNumber, + initFrame->iFrameSizeInPixels, initFrame->iBlockSizeInPixels, + initFrame->iNavigation, initFrame->iFrameImageData); + break; + } + default: + { + Panic(EInvalidFwExtensionCall); + } + } + } + +void CImageConvStreamedEncodeStub::HandleExecuteAsyncCommand(TExecuteCommandParamsAsyncBase& aExecuteCommandBase) + { + switch(aExecuteCommandBase.iCmdNum) + { + case EImgConvExtAppendBlocks: + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aExecuteCommandBase.iRequestStatus); + TAppendBlocksExecCmdParams* appendBlocks = static_cast(&aExecuteCommandBase); + iExtension->AppendBlocks(NULL, + *appendBlocks->iBlocks, + appendBlocks->iNumBlocksToAdd); + break; + } + case EImgConvExtAddBlocks: + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aExecuteCommandBase.iRequestStatus); + TAddBlocksExecCmdParams* addBlocks = static_cast(&aExecuteCommandBase); + iExtension->AddBlocks(NULL, + *addBlocks->iBlocks, + *addBlocks->iSeqPosition); + break; + } + case EImgConvExtComplete: + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aExecuteCommandBase.iRequestStatus); + iExtension->Complete(NULL); + break; + } + default: + { + Panic(EInvalidFwExtensionCall); + } + } + if(*(aExecuteCommandBase.iRequestStatus) == KRequestPending) + { + iStatusOwner->StartActivity(); + } + } + + + +// Prepare straight proxy +CImageConvPrepareStraightProxy* CImageConvPrepareStraightProxy::NewL(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvPrepareStraightProxy(aStatusOwner, aRequestThread); + } + +CImageConvPrepareStraightProxy::CImageConvPrepareStraightProxy(MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + } + +CImageConvPrepareStraightProxy::~CImageConvPrepareStraightProxy() + { + if(iExtension) + { + iExtension->Release(); + } + } + +void CImageConvPrepareStraightProxy::SetupExtension(MImageConvExtension*& aExtension) + { + iExtension = static_cast(aExtension); + aExtension = this; + } + +TUid CImageConvPrepareStraightProxy::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvPrepareStraightProxy::IncrementRef() + { + iExtension->IncrementRef(); + } + +void CImageConvPrepareStraightProxy::Release() + { + iExtension->Release(); + } + +void CImageConvPrepareStraightProxy::Prepare(TRequestStatus* aStatus) + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aStatus); + iExtension->Prepare(NULL); + if(*aStatus == KRequestPending) + { + iStatusOwner->StartActivity(); + } + } + +// Prepare proxy +CImageConvPrepareProxy* CImageConvPrepareProxy::NewL(MImageConvExtensionThreadedSupport* aParent) + { + return new (ELeave) CImageConvPrepareProxy(aParent); + } + +CImageConvPrepareProxy::CImageConvPrepareProxy(MImageConvExtensionThreadedSupport* aParent) +:iParent(aParent) + { + } + +void CImageConvPrepareProxy::SetupExtension(MImageConvExtension*& aExtension) + { + aExtension = this; + } + +TUid CImageConvPrepareProxy::Uid() const + { + TUidExecCmdParams uid(KICLPrepareUid, EImgConvExtUid); + iParent->ExecuteCommand(uid); + return uid.iReturn; + } + +void CImageConvPrepareProxy::IncrementRef() + { + ASSERT(EFalse); + } + +void CImageConvPrepareProxy::Release() + { + ASSERT(EFalse); + } + +void CImageConvPrepareProxy::Prepare(TRequestStatus* aStatus) + { + TPrepareExecCmdParams prepare(KICLPrepareUid, EImgConvExtPrepare, aStatus); + iParent->ExecuteAsyncCommand(prepare); + } + +// Prepare stub +CImageConvPrepareStub* CImageConvPrepareStub::NewL(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) + { + return new (ELeave) CImageConvPrepareStub(aExtension, aStatusOwner, aRequestThread); + } + +CImageConvPrepareStub::CImageConvPrepareStub(MImageConvExtension* aExtension, MFrameworkExtAsyncInterface* aStatusOwner, RThread& aRequestThread) +:iStatusOwner(aStatusOwner), iThread(&aRequestThread) + { + iExtension = static_cast(aExtension); + } + +CImageConvPrepareStub::~CImageConvPrepareStub() + { + if(iExtension) + { + iExtension->Release(); + } + } + +TUid CImageConvPrepareStub::Uid() const + { + return iExtension->Uid(); + } + +void CImageConvPrepareStub::HandleExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase) + { + switch(aExecuteCommandBase.iCmdNum) + { + case EImgConvExtUid: + { + // cast to appropriate extension TClass + TUidExecCmdParams* uid = static_cast(&aExecuteCommandBase); + uid->iReturn = iExtension->Uid(); + break; + } + case EImgConvExtIncrementRef: + { + iExtension->IncrementRef(); + break; + } + case EImgConvExtRelease: + { + iExtension->Release(); + break; + } + default: + { + Panic(EInvalidFwExtensionCall); + } + } + } + +void CImageConvPrepareStub::HandleExecuteAsyncCommand(TExecuteCommandParamsAsyncBase& aExecuteCommandBase) + { + switch(aExecuteCommandBase.iCmdNum) + { + case EImgConvExtPrepare: + { + iStatusOwner->RegisterClientRequestStatus(*iThread, aExecuteCommandBase.iRequestStatus); + iExtension->Prepare(NULL); + break; + } + default: + { + Panic(EInvalidFwExtensionCall); + } + } + + if(*(aExecuteCommandBase.iRequestStatus) == KRequestPending) + { + iStatusOwner->StartActivity(); + } + }