// Copyright (c) 2001-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 <caf/caf.h>

using namespace ContentAccess;

#include "ThreadRelay.h"

#include "icl/ImageConstruct.h"

#include "icl/ImagePlugin.h"

#include "ImageClientMain.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 "fwextconstants.h"

#include "iclextproxystubutil.h"

//

// CBufferCopyListener

//

/**

 * Factory function for this class.

 *

 * @param	"const RThread* aSubThread"

 *			Thread to signal when buffer copy has been completed

 */

CBufferCopyListener* CBufferCopyListener::NewL(const RThread* aSubThread)

	{

	CBufferCopyListener* self;

	self = new (ELeave) CBufferCopyListener(aSubThread);

	return self;

	}

/**

 * Constructor for this class.

 *

 * @param	"const RThread* aSubThread"

 *			Thread to signal when buffer copy has been completed

 */

CBufferCopyListener::CBufferCopyListener(const RThread* aSubThread) :

	CActive(EPriorityIdle)

	{

	iSubThread = aSubThread;

	CActiveScheduler::Add(this);

	}

/**

 * Activate the buffer copy listener to listen for copy requests.

 *

 */

void CBufferCopyListener::Prime()

	{

	ASSERT(IsActive() == EFalse);

	iStatus = KRequestPending;

	SetActive();

	}

/**

 * Initilise the listener for a buffer copy.

 *

 * @param	"TRequestStatus& aCallerStatus"

 *			Request to signal when copy has been comlpeted. Signalled in thread

 *			passed to the listener at construction.

 * @param	"TDes8& aBuffer"

 *			Destination buffer for copy.

 * @param	"const TDesC8& aSource"

 *			Source descriptor for copy.

 * @param	"TInt aPosition"

 *			Position in buffer to start copy.

 * @param	"TInt aSize"

 *			Number of elements to copy.

 */

void CBufferCopyListener::CopyBufferToDescriptor(TRequestStatus& aCallerStatus, TDes8& aBuffer, const TDesC8& aSource, TInt aPosition, TInt aSize)

	{

	Prime();

	iCallerStatus = &aCallerStatus;

	iBuffer = &aBuffer;

	iSource = &aSource;

	iPosition = aPosition;

	iSize = aSize;

	}

/**

 *

 * Perform the buffer copy.

 *

 */

void CBufferCopyListener::RunL()

	{

	ASSERT(iStatus==KErrNone);

	DoBufferCopy();

	}

/**

 *

 * Perform the buffer copy and signal the requesting thread when the copy has completed.

 *

 */

void CBufferCopyListener::DoBufferCopy()

	{

	ASSERT(iStatus == KErrNone);

	ASSERT(iSource != NULL);

	ASSERT(iBuffer != NULL);

	ASSERT(iSubThread != NULL);

	*iBuffer = iSource->Mid(iPosition, iSize);

	TRequestStatus *status = iCallerStatus;

	iSubThread->RequestComplete(status,KErrNone);

	}

/**

 *

 * Cancel an outstanding copy request.

 *

 */

void CBufferCopyListener::DoCancel()

	{

	}

/**

 *

 * Destructor for this class.

 *

 */

CBufferCopyListener::~CBufferCopyListener()

	{

	}

//

// CThreadDecoderRelay

//

/**

 * Actual factory function for this class

 *

 * @param	"CImageDecodeConstruct* aConstruct"

 *			A object to construct a decoder.

 * @return	"CThreadDecoderRelay*"

 *			A pointer to the constructed object

 */

CThreadDecoderRelay* CThreadDecoderRelay::NewL(CImageDecodeConstruct* aConstruct)

	{

	CThreadDecoderRelay* self;

	self = new (ELeave) CThreadDecoderRelay(aConstruct);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 * Second phase constructor for this class.

 * Create a buffer copy listener and send it and a factory function

 * to create a decoder as parameters to the thread.

 *

 */

void CThreadDecoderRelay::ConstructL()

	{

	//Start a buffer copy listener and prime it to listen for requests

	iBufferCopyListener = CBufferCopyListener::NewL(SubThread());

	//Package the parameters to create a CSubThreadDecoderRelay

	TThreadDecoderRelayParam params;

	//Send the status of the buffer copy AO to the sub thread

	params.iBufferCopyListener = iBufferCopyListener;

	//Add the CImageDecodeConstruct object that will create the decoder

	params.iConstruct = iConstruct;

	CThreadRelay::ConstructL(CSubThreadDecoderRelay::NewL, &params);

	iSubThreadDecoderRelay = STATIC_CAST(CSubThreadDecoderRelay*, SubThreadRelay());

	iBody = iSubThreadDecoderRelay->iBody;

	iExtensionCache = CImageConvExtensionCache::NewL();

	}

/**

 * Constructor for this class.

 *

 */

CThreadDecoderRelay::CThreadDecoderRelay(CImageDecodeConstruct* aConstruct) :

	iConstruct(aConstruct)

	{

	}

/**

 * Destructor for this class.

 * If a buffer copy listener was created cancel and delete it.

 * If ownership for the construct object was passed, delete it.

 *

 */

CThreadDecoderRelay::~CThreadDecoderRelay()

	{

	delete iExtensionCache;

	if(iBufferCopyListener)

		{

		iBufferCopyListener->Cancel();

		delete iBufferCopyListener;

		}

	if(iOwnConstruct)

		delete iConstruct;

	}

/**

 * Run a function that should not leave in the codec thread.

 * Let the thread know a function call will follow (to allow the thread to do 

 * local buffer copies) and request the function to run. If the function does leave

 * panic the current thread.

 * 

 * @param	"TInt aFunctionCode"

 *			The function to run in the codec thread.

 * @param	"TAny* aParameters"

 *			The parameters to the function.

 * @panic	"KInvalidFunctionLeave"

 *			If the function in the codec thread leaves.

 */

void CThreadDecoderRelay::RunFunction(TInt aFunctionCode, TAny* aParameters)

	{

	ASSERT(iSubThreadDecoderRelay!=NULL);

	iSubThreadDecoderRelay->SetFunctionInProgress();

	TInt error = CThreadRelay::RunFunction(aFunctionCode, aParameters);

	iSubThreadDecoderRelay->ResetFunctionInProgress();

	if(error!=KErrNone)

		Panic(EInvalidFunctionLeave);

	}

/**

 * Run a function that can leave in the codec thread.

 * Let the thread know a function call will follow (to allow the thread to do 

 * local buffer copies) and request the function ro run. If the function do leave

 * leave in this thread with the same error code.

 * 

 * @param	"TInt aFunctionCode"

 *			The function to run in the codec thread.

 * @param	"TAny* aParameters"

 *			The parameters to the function.

 */

void CThreadDecoderRelay::RunFunctionL(TInt aFunctionCode, TAny* aParameters)

	{

	ASSERT(iSubThreadDecoderRelay!=NULL);

	iSubThreadDecoderRelay->SetFunctionInProgress();

	TInt error = CThreadRelay::RunFunction(aFunctionCode, aParameters);

	iSubThreadDecoderRelay->ResetFunctionInProgress();

	if(error!=KErrNone)

		User::Leave(error);

	}

/**

 * Cancel the threaded decoding in progress.

 * Use a straight call to request plugins that do not use AO functionallity

 * to abort and then request a normal decoding cancel in the codec thread.

 */

void CThreadDecoderRelay::Cancel()

	{

	//Use straight call to inform decoder to cancel

	iSubThreadDecoderRelay->AbortDecode();

	//Up the decoding thread's priority for increased Cancel() response

	SetPriority(RThread().Priority());

	//Cancel need no parameters

	RunFunction(CSubThreadDecoderRelay::EFunctionCancel, NULL);

	//Restore the priority

	SetPriority(KSubThreadPriority);

	}

void CThreadDecoderRelay::SetFileL(RFs& /*aFs*/, const TDesC& aSourceFilename, const CImageDecoder::TOptions aOptions)

	{

	TDecodeSetFileParams params;

	params.iSourceFilename = &aSourceFilename;

	params.iOptions = aOptions;

	RunFunctionL(CSubThreadDecoderRelay::EFunctionSetFile, &params);

	}

void CThreadDecoderRelay::SetFileL(RFile& aFile, const CImageDecoder::TOptions aOptions)

	{

	TDecodeSetFileHandleParams params;

	params.iFile = &aFile;

	params.iOptions = aOptions;

	RunFunctionL(CSubThreadDecoderRelay::EFunctionSetFileHandle, &params);

	}

void CThreadDecoderRelay::SetDataL(RFs& /*aFs*/, const TDesC8& aSourceData, const CImageDecoder::TOptions aOptions)

	{

	TDecodeSetDataParams params;

	params.iSourceData = &aSourceData;

	params.iOptions = aOptions;

	RunFunctionL(CSubThreadDecoderRelay::EFunctionSetData, &params);

	}

CImageDecoderPlugin* CThreadDecoderRelay::Plugin() const

	{

	return iBody->Plugin();

	}

void CThreadDecoderRelay::HandleNewlyOpenedImageL()

	{

	RunFunctionL(CSubThreadDecoderRelay::EFunctionHandleNewImage, NULL);

	}

void CThreadDecoderRelay::Convert(TRequestStatus* aRequestStatus, CFbsBitmap& aDestination, TInt aFrameNumber)

	{

	*aRequestStatus = KRequestPending;

	TDecodeConvertParams params;	

	params.iRequestStatus = aRequestStatus;

	params.iDestinationHandle = aDestination.Handle();

	params.iFrameNumber = aFrameNumber;

	RunFunction(CSubThreadDecoderRelay::EFunctionConvert, &params);

	}

void CThreadDecoderRelay::Convert(TRequestStatus* aRequestStatus, CFbsBitmap& aDestination, CFbsBitmap& aDestinationMask, TInt aFrameNumber)

	{

	*aRequestStatus = KRequestPending;

	TDecodeConvertParams params;

	params.iRequestStatus = aRequestStatus;

	params.iDestinationHandle = aDestination.Handle();

	params.iDestinationMaskHandle = aDestinationMask.Handle();

	params.iFrameNumber = aFrameNumber;

	RunFunction(CSubThreadDecoderRelay::EFunctionConvertMask, &params);

	}

void CThreadDecoderRelay::ContinueConvert(TRequestStatus* aRequestStatus)

	{

	*aRequestStatus = KRequestPending;

	TDecodeConvertParams params;

	params.iRequestStatus = aRequestStatus;

	RunFunction(CSubThreadDecoderRelay::EFunctionContinueConvert, &params);

	}

void CThreadDecoderRelay::ContinueProcessingHeaderL()

	{

	RunFunctionL(CSubThreadDecoderRelay::EFunctionContinueHeader, NULL);

	}

void CThreadDecoderRelay::SetImageTypeL(TInt aImageType)

	{

	iBody->SetImageTypeL(aImageType);

	}

const TFrameInfo& CThreadDecoderRelay::FrameInfo(TInt aFrameNumber) const

	{

	iSubThreadDecoderRelay->Lock();

	const TFrameInfo& frameInfo = iBody->FrameInfo(aFrameNumber);

	iSubThreadDecoderRelay->Unlock();

	return frameInfo;

	}

const CFrameImageData& CThreadDecoderRelay::FrameData(TInt aFrameNumber) const

	{

	iSubThreadDecoderRelay->Lock();

	const CFrameImageData& frameData = iBody->FrameData(aFrameNumber);

	iSubThreadDecoderRelay->Unlock();

	return frameData;

	}

TInt CThreadDecoderRelay::NumberOfImageComments() const

	{

	iSubThreadDecoderRelay->Lock();

	TInt noOfImageComments = iBody->Plugin()->NumberOfImageComments();

	iSubThreadDecoderRelay->Unlock();

	return noOfImageComments;

	}

HBufC* CThreadDecoderRelay::ImageCommentL(TInt aCommentNumber) const

	{

	iSubThreadDecoderRelay->Lock();

	HBufC* imageComment = iBody->Plugin()->ImageCommentL(aCommentNumber);

	iSubThreadDecoderRelay->Unlock();

	return imageComment;

	}

TInt CThreadDecoderRelay::NumberOfFrameComments(TInt aFrameNumber) const

	{

	iSubThreadDecoderRelay->Lock();

	TInt noOfFrameComments = iBody->Plugin()->NumberOfFrameComments(aFrameNumber);

	iSubThreadDecoderRelay->Unlock();

	return noOfFrameComments;

	}

HBufC* CThreadDecoderRelay::FrameCommentL(TInt aFrameNumber, TInt aCommentNumber) const

	{

	iSubThreadDecoderRelay->Lock();

	HBufC* frameComment =  iBody->Plugin()->FrameCommentL(aFrameNumber, aCommentNumber);

	iSubThreadDecoderRelay->Unlock();

	return frameComment;

	}

CFrameInfoStrings* CThreadDecoderRelay::FrameInfoStringsLC(TInt aFrameNumber)

	{

	return iBody->FrameInfoStringsLC(aFrameNumber);

	}

TUid CThreadDecoderRelay::ImplementationUid() const

	{

	return iBody->ImplementationUid();

	}

TInt CThreadDecoderRelay::FrameCount() const

	{

	return iSubThreadDecoderRelay->FrameCount();

	}

TBool CThreadDecoderRelay::IsImageHeaderProcessingComplete() const

	{

	return iBody->IsImageHeaderProcessingComplete();

	}

void CThreadDecoderRelay::CustomSyncL(TInt aParam)

	{

	TCustomSyncParams params;

	params.iParam = aParam;

	RunFunctionL(CSubThreadDecoderRelay::EFunctionCustomSync, &params);

	}

void CThreadDecoderRelay::CustomAsync(TRequestStatus* aRequestStatus, TInt aParam)

	{

	*aRequestStatus = KRequestPending;

	TCustomSyncParams params;

	params.iRequestStatus = aRequestStatus;

	params.iParam = aParam;

	RunFunction(CSubThreadDecoderRelay::EFunctionCustomAsync, &params);

	}

void CThreadDecoderRelay::TransferConstructOwnership()

	{

	iOwnConstruct = ETrue;

	}

void CThreadDecoderRelay::SetIntent(TIntent aIntent)

	{

	iBody->SetIntent(aIntent);

	}

void CThreadDecoderRelay::SetUniqueIdL(const TDesC& aUniqueId)

	{

	iBody->SetUniqueIdL(aUniqueId);

	}

TInt CThreadDecoderRelay::SetAgentProperty(ContentAccess::TAgentProperty aProperty, TInt aValue)

	{

	return iBody->SetAgentProperty(aProperty, aValue);

	}

TInt CThreadDecoderRelay::ReductionFactor(const TSize& aOriginalSize, const TSize& aReducedSize) const

	{

	return iBody->ReductionFactor(aOriginalSize, aReducedSize);

	}

TInt CThreadDecoderRelay::ReducedSize(const TSize& aOriginalSize, TInt aReductionFactor, TSize& aReducedSize) const

	{

	return iBody->ReducedSize(aOriginalSize, aReductionFactor, aReducedSize);

	}

TInt CThreadDecoderRelay::SetDecoderThreadPriority(TThreadPriority aPriority)

	{

	SetPriority(aPriority);

	return KErrNone;

	}

void CThreadDecoderRelay::GetExtensionL(TUid aExtUid, MImageConvExtension*& aExtPtr)

	{

	__ASSERT_ALWAYS(aExtPtr == NULL, Panic(ENonNullImageConvExtension));

	CImageConvProxyBase* proxy = ProxyStubUtility::GetNewProxyL(aExtUid, this);

	CleanupStack::PushL(proxy);

	TGetExtensionParams params;

	params.iUid = aExtUid;

	params.iExtension = &aExtPtr;

	RunFunctionL(CSubThreadDecoderRelay::EFunctionGetExtension, &params);

	proxy->SetupExtension(aExtPtr);

	iExtensionCache->SetProxyL(proxy);

	CleanupStack::Pop(proxy);

	//aExtPtr contains pointer to the proxy

	}

void CThreadDecoderRelay::SetClippingRectL(const TRect* aClipRect)

	{

	iBody->SetClippingRectL(aClipRect);

	}

TInt CThreadDecoderRelay::GetDestinationSize(TSize& aSize, TInt aFrameNumber)

	{

	return iBody->Plugin()->GetDestinationSize(aSize, aFrameNumber);

	}

CImageConvExtensionCache& CThreadDecoderRelay::ExtensionCache()

	{

	return *iExtensionCache;

	}

void CThreadDecoderRelay::ExecuteCommand(TExecuteCommandParamsBase& aExecuteCommandBase)

	{

	RunFunction(CSubThreadDecoderRelay::EFunctionExecuteCommandL, &aExecuteCommandBase);

	}	

void CThreadDecoderRelay::ExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase)

	{

	RunFunctionL(CSubThreadDecoderRelay::EFunctionExecuteCommandL, &aExecuteCommandBase);

	}

void CThreadDecoderRelay::ExecuteAsyncCommand(TExecuteCommandParamsBase& aExecuteCommandBase)

	{

	RunFunction(CSubThreadDecoderRelay::EFunctionExecuteAsyncCommand, &aExecuteCommandBase);

	}

//

// CThreadEncoderRelay