// 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 <e32base.h>

#include "icl/ICL_UIDS.hrh"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <icl/icl_uids_const.hrh>

#include <icl/icl_uids_def.hrh>

#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<MImageConvOperation*>(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<MImageConvOperation*>(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<TUidExecCmdParams*>(&aExecuteCommandBase);

			uid->iReturn = iExtension->Uid();

			break;

			}

		case EImgConvExtIncrementRef:

			{

			iExtension->IncrementRef();

			break;

			}

		case EImgConvExtRelease:

			{

			iExtension->Release();

			break;

			}

		case EImgConvExtCapabilities:

			{

			TCapabilitiesExecCmdParams* capabilities = static_cast<TCapabilitiesExecCmdParams*>(&aExecuteCommandBase);

			capabilities->iReturn = iExtension->Capabilities();

			break;

			}

		case EImgConvExtAddOperationL:

			{

			TAddOperationLExecCmdParams* addOperationL = static_cast<TAddOperationLExecCmdParams*>(&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<MImageConvScaler*>(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<MImageConvScaler*>(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<TUidExecCmdParams*>(&aExecuteCommandBase);

			uid->iReturn = iExtension->Uid();

			break;

			}

		case EImgConvExtIncrementRef:

			{

			iExtension->IncrementRef();

			break;

			}

		case EImgConvExtRelease:

			{

			iExtension->Release();

			break;

			}

		case EImgConvExtGetCapabilitiesScaler:

			{

			TGetCapabilitiesScalerExecCmdParams* scalerCaps = static_cast<TGetCapabilitiesScalerExecCmdParams*>(&aExecuteCommandBase);

			iExtension->GetCapabilities(*scalerCaps->iCaps);

			break;

			}

		case EImgConvExtSetScalingLSize:

			{

			TSetScalingLSizeExecCmdParams* setScalingLSize = static_cast<TSetScalingLSizeExecCmdParams*>(&aExecuteCommandBase);

			iExtension->SetScalingL(*setScalingLSize->iDesiredSize, setScalingLSize->iQuality, setScalingLSize->iLockAspectRatio);

			break;

			}

		case EImgConvExtSetScalingLCoeff:

			{

			TSetScalingLCoeffExecCmdParams* setScalingLCoeff = static_cast<TSetScalingLCoeffExecCmdParams*>(&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<MImageConvStreamedDecode*>(aExtension);

	aExtension = this;

	}

TUid CImageConvStreamedDecodeStraightProxy::Uid() const

	{

	return iExtension->Uid();

	}

void CImageConvStreamedDecodeStraightProxy::IncrementRef()

	{

	iExtension->IncrementRef();

	}

void CImageConvStreamedDecodeStraightProxy::Release()

	{

	iExtension->Release();