// Copyright (c) 1998-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:

// MdaImageConverter.h

// Implementation of the API interfaces defined in MdaImageConverter.h

// 

//

#ifndef __MDAIMAGECONVERTERPRIV_H__

#define __MDAIMAGECONVERTERPRIV_H__

#include <fbs.h>

#include <bitdev.h>

#include <icl/imagedata.h>

#include <mda/client/resource.h>

#include <mda/client/utility.h>

#include "BitmapConverter.h"

#include <bitmaptransforms.h>

#include <mda/common/video.h>

enum 

	{

	EMDAImConvPanicNotImplemented=1,

	EMDAImConvPanicNotYetOpen

	};

class CMdaServer;

class REComSession;

class MMdaImageUtilObserver;

class TFrameDataBlock;

class TImageDataBlock;

// CMdaImageUtilityPriv

class CMdaImageUtilityPriv; // declared here

NONSHARABLE_CLASS( CMdaImageUtilityPriv ): public CBase

	{

friend class CMdaImageUtility;

friend class CMdaImageDataReadUtility;

friend class CMdaImageBitmapToBitmapUtility;

public:

	virtual ~CMdaImageUtilityPriv();

protected:

	virtual void Close();

	virtual void ConvertL(CFbsBitmap& aBitmap,TInt aFrameNumber = 0) = 0;

	virtual void ConvertL(CFbsBitmap& aBitmap,CFbsBitmap& aMaskBitmap,TInt aFrameNumber = 0) = 0;

	virtual void CancelConvertL() = 0;

	virtual void FrameInfo(TInt aFrame,TFrameInfo& aInfo) const;

	virtual TInt FrameCount() const;

protected:

	CMdaImageUtilityPriv(MMdaImageUtilObserver& aObserver, CMdaImageUtility* aParent);

	void Close(TBool aFullClose);

	void Initialize();

	virtual void DoClose();

	void SelfComplete(TInt aError);

	void SetUidsFromOrigFormatsL(TMdaClipFormat* aFormat,TMdaPackage* aCodec,TMdaPackage* aExtra);

	void OpenFsSessionL();

	void OpenEcomSessionL();

	void CloseEcomSession();

#if defined(__ECOM_POWERDOWN_WORKAROUND)

	void OpenWaitTimerL();

#endif defined(__ECOM_POWERDOWN_WORKAROUND)

	// Calls from CActive derived parent objects

	virtual void RunL()=0;

	virtual void DoCancel()=0;

protected:

	MMdaImageUtilObserver&	iObserver;

	CMdaImageUtility*		iParent;	// link back to the handle class

	TUid					iImageType;

	TUid					iImageSubType;

	TFrameDataBlock*		iFrameData;

	TImageDataBlock*		iImageData;

	RFs						iFs;

	REComSession*			iEcomSession; // not owned

#if defined(__ECOM_POWERDOWN_WORKAROUND)

	RTimer iWaitTimer;

	TInt iWaitTimeCount;

#endif defined(__ECOM_POWERDOWN_WORKAROUND)

	};

// CMdaImageDataReadUtilityPriv

class CImageDecoder;

class CMdaImageDataReadUtility;

class CMdaImageDataReadUtilityPriv; // declared here

NONSHARABLE_CLASS( CMdaImageDataReadUtilityPriv ): public CMdaImageUtilityPriv

	{

public:

	virtual ~CMdaImageDataReadUtilityPriv();

	// From CMdaImageUtility

	virtual void ConvertL(CFbsBitmap& aBitmap,TInt aFrameNumber = 0);

	virtual void ConvertL(CFbsBitmap& aBitmap,CFbsBitmap& aMaskBitmap,TInt aFrameNumber = 0);

	virtual void CancelConvertL();

	virtual void RunL();

	virtual void DoCancel();

public:

	virtual void FrameInfo(TInt aFrame,TFrameInfo& aInfo) const;

	virtual TInt FrameCount() const;

	virtual void DoClose();

	const TDesC& FrameCommentL(TInt aFrameNumber);

protected:

	enum TState

		{

		EStateClosed,

		EStateOpening,

		EStateOpeningWait,

		EStateOpen,

		EStateConverting

		};

	CMdaImageDataReadUtilityPriv(MMdaImageUtilObserver& aObserver, CMdaImageDataReadUtility* aParent);

	// Creates relevant iDecoder property - depending on subclass.

	// Called by "background" AO processing.

 	virtual void DoOpenL()=0;

private:

	inline CMdaImageDataReadUtility* Parent() const;

	void GetCommentL();

protected:

	CImageDecoder* iDecoder;

	TState iState;

	TBool iPrevConvertUnderflowed;

	TSize iDestinationSize; // used to check we don't continue with different bitmap

	TInt iDestinationHandle;

	TInt iDestinationMaskHandle; 

	TInt iKeptFrameNumber;

	TDisplayMode iDestinationDisplayMode;

	TDisplayMode iDestinationMaskDisplayMode;

	RPointerArray<HBufC> iComment;

	};

class CImageEncoder;

class CFrameImageData;

class CMdaImageDataWriteUtility;

class CMdaImageDataWriteUtilityPriv; // declared here

NONSHARABLE_CLASS( CMdaImageDataWriteUtilityPriv ): public CMdaImageUtilityPriv

	{

friend class CMdaImageDataWriteUtility;

public:

	virtual ~CMdaImageDataWriteUtilityPriv();

	// From CMdaImageUtility

	virtual void ConvertL(CFbsBitmap& aBitmap,TInt aFrameNumber = 0);

	virtual void ConvertL(CFbsBitmap& aBitmap,const TRect& aSourceRect,TInt aFrameNumber = 0);

	virtual void ConvertL(CFbsBitmap& aBitmap,CFbsBitmap& aMaskBitmap,TInt aFrameNumber = 0);

	virtual void CancelConvertL();

	CImageEncoder* Encoder() const;

protected:

	virtual void RunL();

	virtual void DoCancel();

protected:

	enum TState

		{

		EStateClosed,

		EStateCreating,

		EStateOpen,

		EStateConverting,

		EStateCopying,

		EStateCancelled

		};

	CMdaImageDataWriteUtilityPriv(MMdaImageUtilObserver& aObserver, CMdaImageDataWriteUtility* aParent);

	virtual void DoClose();

	// Creates relevant <code>iEncoder</code> property - depending on subclass.

	// Called by "background" AO processing.

	virtual void DoCreateL(TBool aFullCreate=ETrue)=0;

	// Used at end to copy any data to destination if req. Default is no-op.

	virtual void DoFinalCopyL();

	// Complete iEncoder initialisation once created

	void CompleteEncoderCreationL();

private:

	inline CMdaImageDataWriteUtility* Parent() const;

protected:

	CImageEncoder* iEncoder;

	CFrameImageData* iFrameImageData;

	TState iState;

	};

class CMdaImageFileToBitmapUtility;

class CMdaImageFileToBitmapUtilityPriv; // declared here

NONSHARABLE_CLASS( CMdaImageFileToBitmapUtilityPriv ): public CMdaImageDataReadUtilityPriv

	{

public:

	static CMdaImageFileToBitmapUtilityPriv* NewL(MMdaImageUtilObserver& aObserver, CMdaImageFileToBitmapUtility* aParent);

	virtual ~CMdaImageFileToBitmapUtilityPriv();

	void OpenL(const TDesC& aFileName,TMdaClipFormat* aFormat = NULL,TMdaPackage* aCodec = NULL,TMdaPackage* aExtra = NULL);

protected:

	CMdaImageFileToBitmapUtilityPriv(MMdaImageUtilObserver& aObserver, CMdaImageFileToBitmapUtility* aParent);

	void ConstructL();

	// from CMdaImageDataReadUtility

	void DoOpenL();

private:

	inline CMdaImageFileToBitmapUtility* Parent() const;

protected:

	HBufC *iFileName;

	};

class CMdaImageDescToBitmapUtility;

class CMdaImageDescToBitmapUtilityPriv; // declared here

NONSHARABLE_CLASS( CMdaImageDescToBitmapUtilityPriv ): public CMdaImageDataReadUtilityPriv

	{

public:

	static CMdaImageDescToBitmapUtilityPriv* NewL(MMdaImageUtilObserver& aObserver,CMdaImageDescToBitmapUtility* aParent);

	void OpenL(const TDesC8& aDescriptor,TMdaClipFormat* aFormat = NULL,TMdaPackage* aCodec = NULL,TMdaPackage* aExtra = NULL);

protected:

	CMdaImageDescToBitmapUtilityPriv(MMdaImageUtilObserver& aObserver, CMdaImageDescToBitmapUtility* aParent);

	void ConstructL();

	// from CMdaImageDataReadUtilityPriv

	void DoOpenL();

private:

	inline CMdaImageDescToBitmapUtility* Parent() const;

protected:

	const TDesC8* iDescriptor; // not owned

	};

class CMdaImageBitmapToFileUtility;

class CMdaImageBitmapToFileUtilityPriv; // declared here

NONSHARABLE_CLASS( CMdaImageBitmapToFileUtilityPriv ): public CMdaImageDataWriteUtilityPriv

	{

public:

	static CMdaImageBitmapToFileUtilityPriv* NewL(MMdaImageUtilObserver& aObserver,CMdaImageBitmapToFileUtility* aParent);

	virtual ~CMdaImageBitmapToFileUtilityPriv();

	void CreateL(const TDesC& aFileName,TMdaClipFormat* aFormat,TMdaPackage* aCodec,TMdaPackage* aExtra);

protected:

	CMdaImageBitmapToFileUtilityPriv(MMdaImageUtilObserver& aObserver, CMdaImageBitmapToFileUtility* aParent);

	void ConstructL();

	// from CMdaImageDataWriteUtility

	void DoCreateL(TBool aFullCreate=ETrue);

private:

	inline CMdaImageBitmapToFileUtility* Parent() const;

protected:

	HBufC *iFileName;

	};

class CMdaImageBitmapToDescUtility;

class CMdaImageBitmapToDescUtilityPriv; // declared here

NONSHARABLE_CLASS( CMdaImageBitmapToDescUtilityPriv ): public CMdaImageDataWriteUtilityPriv

	{

public:

	static CMdaImageBitmapToDescUtilityPriv* NewL(MMdaImageUtilObserver& aObserver,CMdaImageBitmapToDescUtility* aParent);

	void CreateL(TDes8& aDescriptor,TMdaClipFormat* aFormat,TMdaPackage* aCodec,TMdaPackage* aExtra);

	virtual ~CMdaImageBitmapToDescUtilityPriv();

protected:

	CMdaImageBitmapToDescUtilityPriv(MMdaImageUtilObserver& aObserver, CMdaImageBitmapToDescUtility* aParent);

	// from CMdaImageDataWriteUtility

	virtual void DoCreateL(TBool aFullCreate=ETrue);

	virtual void DoFinalCopyL();

private:

	inline CMdaImageBitmapToDescUtility* Parent() const;

protected:

	TDes8*	iDescriptor;

	HBufC8* iSecondBuffer; 

	};

class CMdaImageBitmapToBitmapUtilityPriv; // declared here

NONSHARABLE_CLASS( CMdaImageBitmapToBitmapUtilityPriv ): public CMdaImageUtilityPriv

	{

public:

	static CMdaImageBitmapToBitmapUtilityPriv* NewL(MMdaImageUtilObserver& aObserver, CMdaImageBitmapToBitmapUtility* aParent);

	~CMdaImageBitmapToBitmapUtilityPriv();

	void OpenL(CFbsBitmap& aBitmap);

	// from CMdaImageUtility

	virtual void ConvertL(CFbsBitmap& aBitmap, TInt aFrameNumber = 0);

	virtual void ConvertL(CFbsBitmap& aBitmap, CFbsBitmap& aMaskBitmap, TInt aFrameNumber = 0);

	virtual void CancelConvertL();

	virtual void RunL();

	virtual void DoCancel();

	// From CMdaImageUtility

	virtual void DoClose();

protected:

	CMdaImageBitmapToBitmapUtilityPriv(MMdaImageUtilObserver& aObserver, CMdaImageBitmapToBitmapUtility* aParent);

private:

	inline CMdaImageBitmapToBitmapUtility* Parent() const;

protected:

	enum TUtilState

		{

		EClosed,

		EReady,

		EOpening,

		ECopying

		};

protected:

//	RMdaSourceStreamPort iSrcPort;

//	RMdaDestinationStreamPort iDstPort;

private:

	CBitmapConverter* iBitmapCopier;

	TUtilState iState;

	CFbsBitmap* iSrcBitmap;

	};

class CMdaBitmapRotator;

class CMdaBitmapRotatorPriv; // declared here

NONSHARABLE_CLASS( CMdaBitmapRotatorPriv ): public CActive

	{

public:

	static CMdaBitmapRotatorPriv* NewL();

	virtual ~CMdaBitmapRotatorPriv();

	void RotateL(MMdaImageUtilObserver& aObserver,CFbsBitmap& aSrcBitmap,CFbsBitmap& aTgtBitmap,CMdaBitmapRotator::TRotationAngle aAngle);

	void RotateL(MMdaImageUtilObserver& aObserver,CFbsBitmap& aBitmap,CMdaBitmapRotator::TRotationAngle aAngle);

	void CancelRotation();

protected:	

	CMdaBitmapRotatorPriv();

	void ConstructL();

	// from CActive

	virtual void RunL();

	virtual void DoCancel();

	CBitmapRotator::TRotationAngle MapRotationAngle(CMdaBitmapRotator::TRotationAngle aAngle);

protected:

	MMdaImageUtilObserver*	iObserver; // not owned

	CBitmapRotator*			iBitmapRotator;

	};

class CMdaBitmapScaler;

class CMdaBitmapScalerPriv; // declared here

NONSHARABLE_CLASS( CMdaBitmapScalerPriv ): public CActive

	{

public:

	static CMdaBitmapScalerPriv* NewL();

	virtual ~CMdaBitmapScalerPriv();

	void ScaleL(MMdaImageUtilObserver& aObserver,CFbsBitmap& aSrcBitmap,CFbsBitmap& aTgtBitmap,TBool aMaintainAspectRatio = ETrue);

	void ScaleL(MMdaImageUtilObserver& aObserver,CFbsBitmap& aBitmap,TSize aDestSize,TBool aMaintainAspectRatio = ETrue);

	void CancelScaling();

protected:

	CMdaBitmapScalerPriv();

	void ConstructL();

	// from CActive

	virtual void RunL();

	virtual void DoCancel();

protected:

	MMdaImageUtilObserver*	iObserver;	// not owned

	CBitmapScaler*			iBitmapScaler;

	};

#include "MdaImageConverterPriv.inl"

#endif // __MDAIMAGECONVERTERPRIV_H__