// Copyright (c) 1997-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 <bitdev.h>

#include <mdaimageconverter.h>

#include "MdaImageConverterPriv.h"

#include <ecom/ecom.h>

#include <imageconversion.h>

#include <bitmaptransforms.h>

#include "CompatAids.h"

#if defined(__ECOM_POWERDOWN_WORKAROUND)

	const TInt KWaitTimeMax = 8;

	const TInt KWaitTimeIncrement = 250000; // 0.25s

#endif  // defined(__ECOM_POWERDOWN_WORKAROUND)

GLDEF_C void Panic (TInt aPanic)

	{

	_LIT(KMdaImageConverter, "MDA Image Converter");

	User::Panic(KMdaImageConverter, aPanic);

	}

//

// CMdaImageUtilityPriv

//

CMdaImageUtilityPriv::CMdaImageUtilityPriv(MMdaImageUtilObserver& aObserver, CMdaImageUtility* aParent):

	iObserver(aObserver), iParent(aParent)

	{}

CMdaImageUtilityPriv::~CMdaImageUtilityPriv()

	{

	delete iImageData;

	delete iFrameData;

	iFs.Close();

	CloseEcomSession();

#if defined(__ECOM_POWERDOWN_WORKAROUND)

	iWaitTimer.Close(); 

#endif  // defined(__ECOM_POWERDOWN_WORKAROUND)

	}

void CMdaImageUtilityPriv::CloseEcomSession()

	{

	if (iEcomSession)

		iEcomSession->Close();

	iEcomSession = NULL;

	}

void CMdaImageUtilityPriv::OpenEcomSessionL()

	{

	if (iEcomSession==NULL)

		iEcomSession = &(REComSession::OpenL());

	}

/**

 *

 * Closes the open file-based or descriptor-based image.

 *

 * Any conversion operation in progress is cancelled.

 *

 */

void CMdaImageUtilityPriv::Close()

	{

	Close(ETrue);

	}

// officially reset at end - in practice we always make this call before opening too

void CMdaImageUtilityPriv::Close(TBool aFullClose)

	{

	ASSERT(iParent);

	iParent->Cancel();

	DoClose();

	if (aFullClose)

		CloseEcomSession();

#if defined(__ECOM_POWERDOWN_WORKAROUND)

	iWaitTimeCount = 0; 

#endif  // defined(__ECOM_POWERDOWN_WORKAROUND)

	}

void CMdaImageUtilityPriv::DoClose()

	{

	}

void CMdaImageUtilityPriv::Initialize()

	{

	ASSERT(iParent);

	CActiveScheduler::Add(iParent);

	}

void CMdaImageUtilityPriv::OpenFsSessionL()

	{

	ASSERT(iFs.Handle()==0); // intended for use from ConstructL only

	User::LeaveIfError(iFs.Connect());

	}

#if defined(__ECOM_POWERDOWN_WORKAROUND)

void CMdaImageUtilityPriv::OpenWaitTimerL()

	{

	ASSERT(iWaitTimer.Handle()==0); // intended for use from ConstructL etc only

	User::LeaveIfError(iWaitTimer.CreateLocal());

	}

#endif  // defined(__ECOM_POWERDOWN_WORKAROUND)

/**

Retrieves information about the specified frame.

This function should only be called after an existing image has been

successfully opened or a new image successfully created.

@param     aFrame

           The frame number. This value is relative to zero. The

           value must be less than the total number of frames in

           the image, otherwise the function raises a USER 0

           panic

@param     aInfo

           Frame information.

*/

void CMdaImageUtilityPriv::FrameInfo(TInt /*aFrame*/,TFrameInfo& /*aInfo*/) const

	{

	__PANIC_COMPAT(Panic(EMDAImConvPanicNotImplemented)); // only implemented for data read

	}

/**

Returns the number of frames in the image.

@return   The number of frames in the image

*/

TInt CMdaImageUtilityPriv::FrameCount() const

	{

	__PANIC_COMPAT(Panic(EMDAImConvPanicNotImplemented)); // only implemented for data read

	return 0; 

	}

//

// Performs a User::RequestComplete() operation on this itself.

//

void CMdaImageUtilityPriv::SelfComplete(TInt aError)

	{

	ASSERT(iParent);

	iParent->SelfComplete(aError);

	}

// Effectively converts the old format converts to the new ones. The

// results are placed in iImageType and iImageSubType, plus perhaps iImageData

//

//	TMdaClipFormat* aFormat = NULL

//		The data format. This is optional.

//	TMdaPackage* aCodec = NULL

//		The codec to use. This is optional.

//	TMdaPackage* aExtra = NULL

//		Additional information which the Media Server may need

//		to recognise the data format. This is optional.

//

void CMdaImageUtilityPriv::SetUidsFromOrigFormatsL(TMdaClipFormat* aFormat,

											   TMdaPackage* aCodec,

											   TMdaPackage* /*aExtra*/)

	{

	// set default values first

	delete iImageData; iImageData=NULL;

	iImageType = KNullUid;

	iImageSubType = KNullUid;

	// Note in general below we ignore the codec settings, unless the latter is used

	// to indicate format. 

	if (aFormat)

		{

		TUid formatUid = aFormat->Uid();

		if (formatUid==KUidMdaBmpClipFormat)

			{

			iImageType = KImageTypeBMPUid;

			if (aCodec)

				{

				iImageData = new (ELeave) TBmpImageData;

				TBmpImageData *data = STATIC_CAST(TBmpImageData*,iImageData);

				if (aCodec->Uid() == KUidMda1BppBmpCodec)

					data->iBitsPerPixel = 1;

				else if (aCodec->Uid() == KUidMda4BppBmpCodec)

					data->iBitsPerPixel = 4;

				else if (aCodec->Uid() == KUidMda8BppBmpCodec)

					data->iBitsPerPixel = 8;

				else if (aCodec->Uid() == KUidMda24BppBmpCodec)

					data->iBitsPerPixel = 24;

				else

					{

					// unknown value - so leave undefined

					delete iImageData; iImageData = NULL;

					}

				}

			}

		else if (formatUid==KUidMdaGif87aClipFormat || formatUid==KUidMdaGif89aClipFormat) 

			iImageType = KImageTypeGIFUid; 

		else if (formatUid==KUidMdaJfifClipFormat)

			{

			TMdaJfifClipFormat *jfifFormat = STATIC_CAST(TMdaJfifClipFormat*, aFormat);

			TMdaJpgSettings::TColorSampling sampling = jfifFormat->iSettings.iSampleScheme;

			iImageType = KImageTypeJPGUid; 

			iImageData = new (ELeave) TJpegImageData;

			TJpegImageData* data = STATIC_CAST(TJpegImageData*, iImageData);

			ASSERT(TInt(TMdaJpgSettings::EMonochrome)==TInt(TJpegImageData::EMonochrome)); // check old sample type = new one

			ASSERT(TInt(TMdaJpgSettings::EColor420)==TInt(TJpegImageData::EColor420));

			ASSERT(TInt(TMdaJpgSettings::EColor422)==TInt(TJpegImageData::EColor422));

			ASSERT(TInt(TMdaJpgSettings::EColor444)==TInt(TJpegImageData::EColor444));

			ASSERT(sampling>=TMdaJpgSettings::EMonochrome && sampling <= TMdaJpgSettings::EColor444); // valid range

			data->iSampleScheme = TJpegImageData::TColorSampling(sampling); // can just copy value

			data->iQualityFactor = jfifFormat->iSettings.iQualityFactor;

			}

		else if (formatUid==KUidMdaMbmClipFormat)

			{

			TMdaMbmClipFormat *mbmFormat = STATIC_CAST(TMdaMbmClipFormat*, aFormat);

			TDisplayMode displayMode = mbmFormat->iDisplayMode;

			iImageType = KImageTypeMBMUid;

			iFrameData = new (ELeave) TMbmEncodeData;

			TMbmEncodeData* data = STATIC_CAST(TMbmEncodeData*, iFrameData);

			data->iDisplayMode = displayMode;

			}

		else if (formatUid==KUidMdaOtaClipFormat) // SMS OTA format

			iImageType = KImageTypeOTAUid; 

		else if (formatUid==KUidMdaWbmpClipFormat)

			iImageType = KImageTypeWBMPUid;

		else if (formatUid==KUidMdaPngClipFormat)

			iImageType = KImageTypePNGUid;

		else if (formatUid==KUidMdaTiffLittleEndianClipFormat ||

				 formatUid==KUidMdaTiffBigEndianClipFormat)

			{

			iImageType=KImageTypeTIFFUid;

			if (formatUid==KUidMdaTiffLittleEndianClipFormat)

				iImageSubType=KImageTypeTIFFSubTypeLittleEndianUid;

			else

				{

				ASSERT(formatUid==KUidMdaTiffBigEndianClipFormat);

				iImageSubType=KImageTypeTIFFSubTypeBigEndianUid;

				}

			}

		else if (formatUid==KUidMdaTiffBigEndianClipFormat)

			{

			iImageType = KImageTypeTIFFUid;

			iImageSubType = KImageTypeTIFFSubTypeBigEndianUid;

			}

		else if (formatUid==KUidMdaWmfClipFormat ||

			     formatUid==KUidMdaWmfApmClipFormat ||

			     formatUid==KUidMdaWmfClpClipFormat)

			{

			iImageType = KImageTypeWMFUid;

			if (formatUid==KUidMdaWmfApmClipFormat)

				iImageSubType = KImageTypeWMFSubTypeApmUid;

			else if (formatUid==KUidMdaWmfClpClipFormat)

				iImageSubType = KImageTypeWMFSubTypeClpUid;

			else

				{

				ASSERT(formatUid==KUidMdaWmfClipFormat);

				iImageSubType = KImageTypeWMFSubTypeStdUid;

				}

			}

		else

			User::Leave(KErrNotSupported);

		}

	}

//

// CMdaImageDataReadUtilityPriv

//

CMdaImageDataReadUtilityPriv::CMdaImageDataReadUtilityPriv(MMdaImageUtilObserver& aObserver,

														   CMdaImageDataReadUtility* aParent):

	CMdaImageUtilityPriv(aObserver, aParent)

	{

	}

CMdaImageDataReadUtilityPriv::~CMdaImageDataReadUtilityPriv()

	{

	Close(ETrue);

	ASSERT(iDecoder==NULL); // should have been deleted by Close

	}

void CMdaImageDataReadUtilityPriv::ConvertL(CFbsBitmap& aBitmap,TInt aFrameNumber)

	{

	ASSERT(Parent());

	if (iState != EStateOpen)

		User::Leave(KErrNotReady);

	ASSERT(iDecoder);

	TBool doContinue = EFalse;

	if (iPrevConvertUnderflowed && iKeptFrameNumber == aFrameNumber)

		{

		// if previous convert Underflowed, and same bitmap, we ContinueConvert instead of Convert

		if (iDestinationHandle == aBitmap.Handle() && 

			iDestinationDisplayMode == aBitmap.DisplayMode() && 

			iDestinationMaskHandle == 0 &&

			iDestinationSize == aBitmap.SizeInPixels())

			doContinue = ETrue;

		}

	if (doContinue)

		iDecoder->ContinueConvert(&Parent()->iStatus);

	else

		{

		iDestinationHandle = aBitmap.Handle();

		iDestinationMaskHandle = 0;

		if (aBitmap.Handle())

			{

			iDestinationDisplayMode = aBitmap.DisplayMode();

			iDestinationSize = aBitmap.SizeInPixels();

			}

		iDecoder->Convert(&Parent()->iStatus, aBitmap, aFrameNumber); 

		}

	Parent()->SetActive();

	iState = EStateConverting;

	}

void CMdaImageDataReadUtilityPriv::ConvertL(CFbsBitmap& aBitmap,CFbsBitmap& aMaskBitmap,TInt aFrameNumber)

	{

	ASSERT(Parent());

	if (iState != EStateOpen)

		User::Leave(KErrNotReady);

	ASSERT(iDecoder);

	TBool doContinue = EFalse;

	if (iPrevConvertUnderflowed && iKeptFrameNumber == aFrameNumber)

		{

		// if previous convert Underflowed, and same bitmap, we ContinueConvert instead of Convert

		if (iDestinationHandle == aBitmap.Handle() && 

			iDestinationDisplayMode == aBitmap.DisplayMode() && 

			iDestinationMaskHandle == aMaskBitmap.Handle() &&

			iDestinationMaskDisplayMode == aMaskBitmap.DisplayMode() && 

			iDestinationSize == aBitmap.SizeInPixels())

			doContinue = ETrue;

		}

	if (doContinue)

		iDecoder->ContinueConvert(&Parent()->iStatus);

	else

		{

		iDestinationHandle = aBitmap.Handle();

		iDestinationMaskHandle = aMaskBitmap.Handle();

		if (aBitmap.Handle())

			{

			iDestinationDisplayMode = aBitmap.DisplayMode();

			iDestinationSize = aBitmap.SizeInPixels();

			}

		if (aMaskBitmap.Handle())

			iDestinationMaskDisplayMode = aMaskBitmap.DisplayMode();

		iDecoder->Convert(&Parent()->iStatus, aBitmap, aMaskBitmap, aFrameNumber); 

		}

	Parent()->SetActive();

	iState = EStateConverting;

	}

void CMdaImageDataReadUtilityPriv::CancelConvertL()

	{

	Parent()->Cancel();

	}

void CMdaImageDataReadUtilityPriv::RunL()

	{

	ASSERT(Parent());

	switch (iState)

		{

		case EStateClosed:

			ASSERT(EFalse); // should not happen

			break;

		case EStateOpening:

			{

			TInt error = Parent()->iStatus.Int();

			if (error==KErrNone)

				TRAP(error, OpenEcomSessionL());

			if (error==KErrNone)

				TRAP(error, DoOpenL());

			ASSERT(error!=KErrNone || iDecoder); // if successful should have an iDecoder

			if (error==KErrNone)

				{

				iState=EStateOpen;

				iObserver.MiuoOpenComplete(error);

				}

			else

				{

#if defined(__ECOM_POWERDOWN_WORKAROUND)

				if (error==KEComErrListCurrentlyUnavailable && iWaitTimeCount < KWaitTimeMax)

					{

					iWaitTimeCount ++;

					TInt waitTime = iWaitTimeCount * KWaitTimeIncrement;

					iState = EStateOpeningWait;

					iWaitTimer.After(Parent()->iStatus, waitTime);

					Parent()->SetActive();

					}

				else

#endif  // defined(__ECOM_POWERDOWN_WORKAROUND)

					{

					if (error!=KErrUnderflow) // keep ecom session on streaming

						CloseEcomSession();

					iState=EStateClosed;

					iObserver.MiuoOpenComplete(error);

					}

				}

			}

			break;

		case EStateOpeningWait:

#if defined(__ECOM_POWERDOWN_WORKAROUND)

			{

			TInt error = Parent()->iStatus.Int();	

			if (error!=KErrNone)

				{

				CloseEcomSession();

				iState = EStateClosed;

				iObserver.MiuoOpenComplete(error);

				}

			else

				{

				iState = EStateOpening;

				SelfComplete(error);

				}

			}

#else

			ASSERT(EFalse); // should not get here if __ECOM_POWERDOWN_WORKAROUND not defined

#endif  // defined(__ECOM_POWERDOWN_WORKAROUND)

			break;

		case EStateOpen:

			ASSERT(EFalse); // should not happen

			break;

		case EStateConverting:

			{

			TInt error = Parent()->iStatus.Int();

			//Add comments

			if(error==KErrNone)

				TRAP(error,GetCommentL());

			iState = EStateOpen; // clear first to allow immediate re-conversion

			iPrevConvertUnderflowed = error==KErrUnderflow;

			iObserver.MiuoConvertComplete(error);

			}

			break;

		default:

			ASSERT(EFalse); // unknown state

		}

	}

void CMdaImageDataReadUtilityPriv::DoCancel()

	{

	switch (iState)

		{

		case EStateClosed:

			ASSERT(EFalse); // should not happen

			break;

		case EStateOpening:

			// ignore - makes no difference to do something here

			break;

		case EStateOpeningWait:

#if defined(__ECOM_POWERDOWN_WORKAROUND)

			iWaitTimer.Cancel();

#else

			ASSERT(EFalse);

#endif  // defined(__ECOM_POWERDOWN_WORKAROUND)

			break;

		case EStateOpen:

			ASSERT(EFalse); // should not happen

			break;

		case EStateConverting:

			{

			iDecoder->Cancel(); 

			iState = EStateOpen; 

			}

			break;

		default:

			ASSERT(EFalse); // unknown state

		}

	}

void CMdaImageDataReadUtilityPriv::DoClose()

	{

	ASSERT(Parent());

	ASSERT(!Parent()->IsActive()); // Cancel should be called by this point

	if (iDecoder)

		iDecoder->Cancel();

	delete iDecoder; iDecoder = NULL;

	iComment.ResetAndDestroy();

	iPrevConvertUnderflowed = EFalse;

	iState = EStateClosed;

	}

const TDesC& CMdaImageDataReadUtilityPriv::FrameCommentL(TInt aFrameNumber)

	{

	if (aFrameNumber >= iComment.Count())

		User::Leave(KErrArgument);

	if (iComment[aFrameNumber])

		return *iComment[aFrameNumber];

	return KNullDesC;

	}

void CMdaImageDataReadUtilityPriv::GetCommentL()

	{

	if(iDecoder->IsImageHeaderProcessingComplete()&&iComment.Count()==0)

		{

		TInt noOfComments = 0;

		TInt commentNo = 0;

		const TInt noOfFrames = iDecoder->FrameCount();

		for(TInt currentFrame=0; currentFrame<noOfFrames; currentFrame++)

			{

			HBufC* nullComment = KNullDesC().AllocL();

			CleanupStack::PushL(nullComment);

			User::LeaveIfError(iComment.Append(nullComment));

			CleanupStack::Pop(nullComment);

			//Add the general comments if it is the first frame

			if(currentFrame==0)

				{

				noOfComments = iDecoder->NumberOfImageComments();