// 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:

// Not for public use

// Abstract threaded relay between Image{Decoder,Encoder} and Priv object

// 

//

#ifndef __THREAD_RELAY_H__

#define __THREAD_RELAY_H__

#include "GenThreadRelay.h"

#include "ImageRelay.h"

#include "iclextproxystubutil.h"

class TCustomSyncParams

	{

public:

	TRequestStatus* iRequestStatus;

	TInt iParam;

	};

class TDecodeSetFileParams

	{

public:

	const TDesC* iSourceFilename;

	CImageDecoder::TOptions iOptions;

	};

class TDecodeSetFileHandleParams

	{

public:

	RFile* iFile;

	CImageDecoder::TOptions iOptions;		

	};

class TDecodeSetDataParams

	{

public:

	const TDesC8* iSourceData;

	CImageDecoder::TOptions iOptions;	

	};

class TDecodeConvertParams

	{

public:

	TRequestStatus* iRequestStatus;

	TInt iDestinationHandle;

	TInt iDestinationMaskHandle;

	TInt iFrameNumber;

	};

class TEncodeSetFileParams

	{

public:

	const TDesC* iDestinationFilename;

	CImageEncoder::TOptions iOptions;

	};

class TEncodeSetFileHandleParams

	{

public:

	RFile* iFile;

	CImageEncoder::TOptions iOptions;		

	};

class TEncodeSetDataParams

	{

public:

	HBufC8** iDestinationData;

	CImageEncoder::TOptions iOptions;	

	};

class TEncodeConvertParams

	{

public:

	TRequestStatus* iRequestStatus;

	TInt iSourceHandle;

	const CFrameImageData* iFrameImageData;

	};

class CBufferCopyListener; // declared here

/**

 *

 * This class is not for public use

 * To avoid simultaneous update problems on buffer copy on descriptors,

 * this will be done in the main thread. This AO wait for buffer copy requests

 * and do the copy in the main thread.

 *

 */

NONSHARABLE_CLASS( CBufferCopyListener ): public CActive

	{

public:

	static CBufferCopyListener* NewL(const RThread* aSubThread);

	virtual ~CBufferCopyListener();

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

protected:

	//From CActive

	void RunL();

	void DoCancel();

private:

	CBufferCopyListener(const RThread* aSubThread);

	void Prime();

	void DoBufferCopy();

private:

	TRequestStatus* iCallerStatus; //not owned

	TDes8* iBuffer; //not owned

	const TDesC8* iSource; //not owned

	TInt iPosition;

	TInt iSize;

	const RThread* iSubThread; //not owned

	};

/**

 *

 * This class is not for public use

 * Implement client side thread interface for threaded De/Encoding

 *

 */

class CImageConvOperationStub;

class CImageConvScalerStub;

class CImageConvStreamedDecodeStub;

class CThreadDecoderRelay;

class CSubThreadDecoderRelay; // declared here

NONSHARABLE_CLASS( CSubThreadDecoderRelay ): public CSubThreadRelay,

							                 public MImageDecoderPrivSupport

	{

public:

	enum TFunctionCode

		{

		EFunctionTerminate = KTerminationFunction,

		EFunctionCancel,

		EFunctionSetFile,

		EFunctionSetData,

		EFunctionContinueHeader,

		EFunctionConvert,

		EFunctionConvertMask,

		EFunctionContinueConvert,

		EFunctionHandleNewImage,

		EFunctionCustomSync,

		EFunctionCustomAsync,

		EFunctionSetFileHandle,

		EFunctionGetExtension,

		EFunctionExecuteCommandL,

		EFunctionExecuteAsyncCommand

		};

public:

	static CSubThreadRelay* NewL(TThreadId aMainThreadId, TAny* aDecoderParam);

	virtual ~CSubThreadDecoderRelay();

	void SetFunctionInProgress();

	void ResetFunctionInProgress();

	void AbortDecode();

	void CancelBody();

	TInt FrameCount() const;

	void SetFileL(const TDesC& aSourceFilename, const CImageDecoder::TOptions aOptions);

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

	void SetDataL(const TDesC8& aSourceData, const CImageDecoder::TOptions aOptions);

	void ContinueProcessingHeaderL();

	void Convert(TRequestStatus* aRequestStatus, TInt aDestinationHandle, TInt aFrameNumber);

	void Convert(TRequestStatus* aRequestStatus, TInt aDestinationHandle, TInt aDestinationMaskHandle, TInt aFrameNumber);

	void ContinueConvert(TRequestStatus* aRequestStatus);

	void HandleNewlyOpenedImageL();

	void CustomSyncL(TInt aParam);

	void CustomAsync(TRequestStatus* aRequestStatus, TInt aParam);

	void GetExtensionL(TUid aExtUid, MImageConvExtension*& aExtPtr);

	void HandleExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase);

	void HandleExecuteAsyncCommand(TExecuteCommandParamsAsyncBase& aExecuteCommandBase);

	//From MImageDecoderPrivSupport

	TBool MustUseBufferWithDescriptor() const;

	void CopyBufferToDescriptor(TDes8& aBuffer, const TDesC8& aSource, TInt aPosition, TInt aSize);

	TBool AmInThread() const;

	TBool ShouldAbort() const;

	void Lock();

	void Unlock();

	void SaveFrameCount(TInt aFrameCount);

	//From MImageDecoderPriv

	void SetIntent(TIntent aIntent);

	void SetUniqueIdL(const TDesC& aUniqueId);

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

protected:

	//From CThreadRelay

	void RunFunctionL(TInt aFunctionCode, TAny* aParameters);

private:

	CSubThreadDecoderRelay(CBufferCopyListener* aBufferCopyListener);

	void ConstructL(TThreadId aMainThreadId, CImageDecodeConstruct* aConstruct);

private:

	CImageDecoderPriv* iBody;

	CFbsBitmap* iDestination; //Duplicate the client bitmap in this thread

	CFbsBitmap* iDestinationMask; //Duplicate the client mask bitmap in this thread

	RFs iFileSession; //This thread uses its own file session

	TInt iFrameCount;

	TBool iAbortDecode;

	RMutex iFrameTableMutex;

	RMutex iBufferCopyMutex;

	TBool iFunctionCallInProgress; //ETrue if a function call to this thread is in progress

	CBufferCopyListener* iBufferCopyListener; //not owned 

	TRequestStatus* iCallerStatus; //not owned

	TDes8* iBuffer; //not owned

	const TDesC8* iSource; //not owned

	TInt iPosition;

	TInt iSize;

	// Framework Extension stubs

	RPointerArray<CImageConvStubBase> iStubs;

friend class CThreadDecoderRelay;

	};

/**

 *

 * This class is not for public use

 * Implement client side thread interface for threaded De/Encoding

 *

 */

class CThreadEncoderRelay;

class CSubThreadEncoderRelay;

NONSHARABLE_CLASS( CSubThreadEncoderRelay ): public CSubThreadRelay,

							                 public MImageEncoderPrivSupport

	{

public:

	enum TFunctionCode

		{

		EFunctionTerminate = KTerminationFunction,

		EFunctionCancel,

		EFunctionSetFile,

		EFunctionSetData,

		EFunctionConvert,

		EFunctionCustomSync,

		EFunctionCustomAsync,

		EFunctionSetFileHandle,

		EFunctionGetExtension,

		EFunctionExecuteCommandL,

		EFunctionExecuteAsyncCommand

		};

public:

	static CSubThreadRelay* NewL(TThreadId aMainThreadId, TAny* aEncoderParam);

	virtual ~CSubThreadEncoderRelay();

	void AbortEncode();

	void CancelBody();

	void SetFileL(const TDesC& aDestinationFilename, const CImageEncoder::TOptions aOptions);

	void SetFileL(RFile& aFile, const CImageEncoder::TOptions aOptions);

	void SetDataL(HBufC8*& aDestinationData, const CImageEncoder::TOptions aOptions);

	void Convert(TRequestStatus* aRequestStatus, TInt aSourceHandle, const CFrameImageData* aFrameImageData);

	void CustomSyncL(TInt aParam);

	void CustomAsync(TRequestStatus* aRequestStatus, TInt aParam);

	void GetExtensionL(TUid aExtUid, MImageConvExtension*& aExtPtr);

	void HandleExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase);

	void HandleExecuteAsyncCommand(TExecuteCommandParamsAsyncBase& aExecuteCommandBase);

	//From MImageEncoderPrivSupport

	TBool AmInThread() const;

	TBool ShouldAbort() const;

protected:

	virtual void RunFunctionL(TInt aFunctionCode, TAny* aParameters);

private:

	CSubThreadEncoderRelay();

	void ConstructL(TThreadId aMainThreadId, CImageEncodeConstruct* aConstruct);

private:

	CImageEncoderPriv* iBody;

	CFbsBitmap* iSource;

	RFs iFileSession; //This thread use its own file session

	TBool iAbortEncode;

	// Framework Extension stubs

	RPointerArray<CImageConvStubBase> iStubs;

friend class CThreadEncoderRelay;

	};

class CThreadDecoderRelay;

/**

 *

 * This class is not for public use

 * Implement client side thread interface for threaded Decoding

 *

 */

NONSHARABLE_CLASS( CThreadDecoderRelay ): public CThreadRelay,

							              public MImageDecoderRelay,

							              public MImageConvExtensionThreadedSupport

	{

public:

	static CThreadDecoderRelay* NewL(CImageDecodeConstruct* aConstruct);

	virtual ~CThreadDecoderRelay();

	//From MImageDecoderRelay

	void Cancel();

	void SetFileL(RFs& aFs, const TDesC& aSourceFilename, const CImageDecoder::TOptions aOptions = CImageDecoder::EOptionNone);

	void SetFileL(RFile& name, const CImageDecoder::TOptions aOptions = CImageDecoder::EOptionNone);

	void SetDataL(RFs& aFs, const TDesC8& aSourceData, const CImageDecoder::TOptions aOptions = CImageDecoder::EOptionNone);

	CImageDecoderPlugin* Plugin() const;

	void HandleNewlyOpenedImageL();

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

	void Convert(TRequestStatus* aRequestStatus, CFbsBitmap& aDestination, CFbsBitmap& aDestinationMask, TInt aFrameNumber = 0);

	void ContinueConvert(TRequestStatus* aRequestStatus);

	void ContinueProcessingHeaderL();

	const TFrameInfo& FrameInfo(TInt aFrameNumber) const;

	CFrameInfoStrings* FrameInfoStringsLC(TInt aFrameNumber);

	TUid ImplementationUid() const;

	TInt FrameCount() const;

	TBool IsImageHeaderProcessingComplete() const;

	const CFrameImageData& FrameData(TInt aFrameNumber) const;

	TInt NumberOfImageComments() const;

	HBufC* ImageCommentL(TInt aCommentNumber) const;

	TInt NumberOfFrameComments(TInt aFrameNumber) const;

	HBufC* FrameCommentL(TInt aFrameNumber, TInt aCommentNumber) const;

	// custom command support

	void CustomSyncL(TInt aParam);

	void CustomAsync(TRequestStatus* aRequestStatus, TInt aParam);

	void TransferConstructOwnership();

	void SetIntent(TIntent aIntent);

	void SetUniqueIdL(const TDesC& aUniqueId);

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

	void SetImageTypeL(TInt aImageType);

	TInt ReductionFactor(const TSize& aOriginalSize, const TSize& aReducedSize) const;

	TInt ReducedSize(const TSize& aOriginalSize, TInt aReductionFactor, TSize& aReducedSize) const;

	TInt SetDecoderThreadPriority(TThreadPriority aPriority);

	// from MImageDecoderRelay

	void GetExtensionL(TUid aExtUid, MImageConvExtension*& aExtPtr);

	void SetClippingRectL(const TRect* aClipRect);

	TInt GetDestinationSize(TSize& aSize, TInt aFrameNumber = 0);

	CImageConvExtensionCache& ExtensionCache();

	// from MImageConvExtensionThreadedSupport

	void ExecuteCommand(TExecuteCommandParamsBase& aExecuteCommandBase);

	void ExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase);

	void ExecuteAsyncCommand(TExecuteCommandParamsBase& aExecuteCommandBase);

private:

	CThreadDecoderRelay(CImageDecodeConstruct* aConstruct);

	void ConstructL();

	void RunFunction(TInt aFunctionCode, TAny* aParameters);

	void RunFunctionL(TInt aFunctionCode, TAny* aParameters);

private:

	CSubThreadDecoderRelay* iSubThreadDecoderRelay; //not owned

	CImageDecoderPriv* iBody; //not owned (for straight calls)

	TInt iOwnConstruct;

	CImageDecodeConstruct* iConstruct;

	CBufferCopyListener* iBufferCopyListener; //AO in main thread that listen for requests from sub thread

	CImageConvExtensionCache* iExtensionCache;

	};

class CThreadEncoderRelay;

/**

 *

 * This class is not for public use

 * Implement client side thread interface for threaded Encoding

 *

 */

NONSHARABLE_CLASS( CThreadEncoderRelay ): public CThreadRelay,

							              public MImageEncoderRelay,

							              public MImageConvExtensionThreadedSupport

	{

public:

	static CThreadEncoderRelay* NewL(CImageEncodeConstruct* aConstruct);

	virtual ~CThreadEncoderRelay();

	//From MImageEncoderRelay

	void Cancel();

	void SetFileL(RFs& aFs, const TDesC& aDestinationFilename, const CImageEncoder::TOptions aOptions);

	void SetFileL(RFile& name, const CImageEncoder::TOptions aOptions);

	void SetDataL(HBufC8*& aDestinationData, const CImageEncoder::TOptions aOptions);

	CImageEncoderPlugin* Plugin() const;

	void Convert(TRequestStatus* aRequestStatus, const CFbsBitmap& aSource, const CFrameImageData* aFrameImageData);

	TUid ImplementationUid() const;

	// Framework extension

	void GetExtensionL(TUid aExtUid, MImageConvExtension*& aExtPtr);

	CImageConvExtensionCache& ExtensionCache();

	// custom command support

	void CustomSyncL(TInt aParam);

	void CustomAsync(TRequestStatus* aRequestStatus, TInt aParam);

	void TransferConstructOwnership();

	void SetThumbnail(TBool aDoGenerateThumbnail);

	TInt SetEncoderThreadPriority(TThreadPriority aPriority);

	// from MImageConvExtensionThreadedSupport

	void ExecuteCommand(TExecuteCommandParamsBase& aExecuteCommandBase);

	void ExecuteCommandL(TExecuteCommandParamsBase& aExecuteCommandBase);

	void ExecuteAsyncCommand(TExecuteCommandParamsBase& aExecuteCommandBase);

private:

	CThreadEncoderRelay(CImageEncodeConstruct* aConstruct);

	void ConstructL();

	void RunFunction(TInt aFunctionCode, TAny* aParameters);

	void RunFunctionL(TInt aFunctionCode, TAny* aParameters);

private:

	TInt iOwnConstruct;

	CImageEncodeConstruct* iConstruct;

	CSubThreadEncoderRelay* iSubThreadEncoderRelay; //Not owned

	CImageEncoderPriv* iBody; //not owned (for straight calls)

	CImageConvExtensionCache* iExtensionCache;

	};

/**

 *

 * This class is not for public use

 *

 */

class TThreadDecoderRelayParam

	{

public:

	CImageDecodeConstruct* iConstruct;

	CBufferCopyListener* iBufferCopyListener;

	};

/**

 *

 * This class is not for public use

 *

 */

class TThreadEncoderRelayParam

	{

public:

	CImageEncodeConstruct* iConstruct;

	};

#endif // __THREAD_RELAY_H__