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

//

/**

 @file

 @internalComponent 

*/

#include "GenericIclWrapper.h"

#include <icl/imagedisplaypaniccodes.h>

#include "MiscUtils.h"

#include "ExifImageDisplayPanic.h"

#define KZeroDelay TTimeIntervalMicroSeconds(0)

_LIT(KGenIclWrapperPanicCategory, "GenIclWrapperImgDisplay");

CGenericImageDisplayPlugin* CGenericImageDisplayPlugin::NewL()

	{

	CGenericImageDisplayPlugin* self = new(ELeave) CGenericImageDisplayPlugin(KGenIclWrapperPanicCategory);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CGenericImageDisplayPlugin::ConstructL()

	{

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

	iPlayer		= new (ELeave) CImagePlayer(*this);

	iDelayedCb	= CDelayedCallback::NewL(*this);

	}

CGenericImageDisplayPlugin::~CGenericImageDisplayPlugin()

	{

	if (iTransformer != NULL)

		{

		iTransformer->Cancel();

		delete iTransformer;

		}

	if (iMaskTransformer != NULL)

		{

		iMaskTransformer->Cancel();

		delete iMaskTransformer;

		}

	delete iDelayedCb;

	delete iPlayer;

	delete iDecoder;

	iFs.Close();

	}

CGenericImageDisplayPlugin::CGenericImageDisplayPlugin(const TDesC& aPanicCategoryStr):

							iPanicCategory(aPanicCategoryStr),

							iMaxReductionFactor(KMaxReductionFactor),

							iMaxUnscaledSize(KMaxTInt,KMaxTInt),

							iExtHandler(*this),

							iScaleQuality(-1),

							iPluginImgStatus(CImageDisplay::EImageTypeUnknown)

	{

	}

void CGenericImageDisplayPlugin::Panic(TInt aPanicNumber) const

	{

	User::Panic(iPanicCategory, aPanicNumber);

	}

void CGenericImageDisplayPlugin::OpenL()

	{

	iValidBitmap = EFalse;

	const TUint option=(Options() & (CImageDisplay::EOptionThumbnail|CImageDisplay::EOptionMainImage));

	if (option==CImageDisplay::EOptionsUndefined || 

			option == (CImageDisplay::EOptionThumbnail|CImageDisplay::EOptionMainImage))

		{

		User::Leave(KErrNotSupported);

		}

	switch ( SourceType() )

		{

		case CImageDisplayPlugin::EImgSrcFileName:

			{

			TMMFileSource src(SourceFilename(), SourceDataId(), SourceDataIntent());

			iDecoder = CImageDecoder::FileNewL(iFs, src, CImageDecoder::EAllowGeneratedMask, KNullUid, KNullUid, RequiredImageClass());

			}

			break;

		case CImageDisplayPlugin::EImgSrcFileHandle:

			{

			TMMFileHandleSource src(SourceFileHandle(), SourceDataId(), SourceDataIntent());

			iDecoder = CImageDecoder::FileNewL(iFs, src, CImageDecoder::EAllowGeneratedMask, KNullUid, KNullUid, RequiredImageClass());

			}

			break;

		case CImageDisplayPlugin::EImgSrcDescriptor:

			iDecoder = CImageDecoder::DataNewL(iFs, SourceData(), CImageDecoder::EAllowGeneratedMask, KNullUid, KNullUid, RequiredImageClass());

			break;

		default:

			ASSERT(EFalse);

			User::Leave(KErrArgument);

		}

	iValidBitmap		= EFalse;

	iImageIsThumbnail	= (option==CImageDisplay::EOptionThumbnail);

	if (iImageIsThumbnail)

		{

		iDecoder->SetImageTypeL(CImageDecoder::EImageTypeThumbnail ); // leaves if there is no thumbnail

		}

	AfterOpenL(); // allow derived plug-in to perform some initialization

	iRotationOptions = EffectiveRotation();

	FillRecommendedSizesL();

	CacheImageStatus();

	}

void CGenericImageDisplayPlugin::Play()

	{

	iIsPaused = EFalse;

	if (iCallBackIsPending)

		{

		iDelayedCb->CallAfter(KZeroDelay);

		iCallBackIsPending = EFalse;

		return;

		}

	if (IsStatusSet(EStatusNoMoreToDecode))

		{

		ASSERT(IsStatusSet(EStatusPaused)==EFalse);

		if (iState < EInitCompleted)

			{

			Panic(EPanicNotInitialized);

			}

		if (iValidBitmap && iLastError==KErrNone)

			{

			ClearStatusFlag(EStatusPaused|EStatusBusy);

			iDelayedCb->CallAfter(KZeroDelay);

			return;

			}

		ClearStatusFlag(EStatusNoMoreToDecode);

		iState = EInitCompleted;

		}

	else if (IsStatusSet(EStatusPaused)==EFalse && iState>=EInitCompleted)

		{

		if (iState==EInitCompleted && IsStatusSet(EStatusBusy)==EFalse)

			{

			iPlayer->Play(*iDecoder, EffectiveDispMode(), (iImageIsThumbnail? 1 : CImagePlayer::KNoFrameLimit) );

			iState = EProcessing;

			}

		return;

		}

	ClearStatusFlag(EStatusPaused|EStatusNoMoreToDecode|EStatusBusy);

	switch (iState)

		{

		case EIdle:

			TRAPD(err,	

						CompleteInitL();

				);

			iOutputRect=TRect(0,0,DestinationSizeInPixels().iWidth, DestinationSizeInPixels().iHeight);

			if (err != KErrNone)

				{

				AsyncCallbackImageReady(NULL, EStatusNoMoreToDecode, iOutputRect, err);

				iState = EInitFailed;

				return;

				}

			iPlayer->Play(*iDecoder, EffectiveDispMode(), (iImageIsThumbnail? 1 : CImagePlayer::KNoFrameLimit) );

			iState = EProcessing;

			break;

		case EInitFailed:

			Panic(EPanicInitFailed);

			break;

		case EInitCompleted:

		case EProcessing:

			iPlayer->Resume();

			iState = EProcessing;

			break;

		case ETransforming:

			iTransformer->Restart();

			break;

		case ETransformingMask:

			iMaskTransformer->Restart();

			break;

		default:

			ASSERT(EFalse);

		}

	SetStatusFlag(EStatusBusy);

	}

void CGenericImageDisplayPlugin::Pause()

	{

	if (iIsPaused)

		{

		return;

		}

	if ( CallbackIsRunning() )

		{

		CancelCallback();

		// actually the framework may not be able to cancel the callback

		// if the execution point has already passed to the client code and it yielded to AS somehow

		// so we check if the callback was actually cancelled by trying it after cancel attempt

		iCallBackIsPending = !CallbackIsRunning(); 

		}

	else

		{

		if (iTransformer != NULL && iState == ETransforming)

			{

			iTransformer->Cancel();

			}

		else if (iMaskTransformer != NULL  && iState == ETransformingMask)

			{

			iMaskTransformer->Cancel();

			}

		else

			{

			iPlayer->Pause();

			}

		if (!IsStatusSet(EStatusNoMoreToDecode))

			{

			SetStatusFlag(EStatusPaused);

			iIsPaused = ETrue;

			}			

		}			

	ClearStatusFlag(EStatusBusy);

	}

void CGenericImageDisplayPlugin::StopPlay()

	{

	CancelCallback();

	iNextFrameDelay	= 0;

	iIsPaused		= EFalse;

	iValidBitmap	= EFalse;

	iCallBackIsPending = EFalse;

	if (iState >= EInitCompleted)

		{

		iState = EInitCompleted;

		}

	if (iTransformer != NULL)

		{

		iTransformer->Cancel();

		}

	if (iMaskTransformer != NULL)

		{

		iMaskTransformer->Cancel();

		}

	if (iPlayer != NULL)

		{

		iPlayer->Cancel();

		}

	if (iDelayedCb != NULL)

		{

		iDelayedCb->Cancel();

		}

	ClearStatusFlag(EStatusBusy|EStatusPaused);

	}

void CGenericImageDisplayPlugin::GetBitmap(const CFbsBitmap*& aBitmap, const CFbsBitmap*& aMask) const

	{

	if (iState < EInitCompleted)

		{

		Panic(EPanicNotInitialized);

		}

	if (ValidBitmap())

		{

		aBitmap = iCurrentFrame;

		aMask	= iCurrentMask;

		}

	else

		{

		aBitmap = NULL;

		aMask	= NULL;

		}

	}

const CImageDisplay::RImageSizeArray& CGenericImageDisplayPlugin::RecommendedImageSizes() const

	{

	return iImageSizes;

	}

TInt CGenericImageDisplayPlugin::NumFrames(TInt& aNumFrames) const

	{

	if (iDecoder->IsImageHeaderProcessingComplete())

		{

		aNumFrames = iDecoder->FrameCount();

		return KErrNone;

		}

	aNumFrames = -1;

	return KErrNotReady;

	}

TUint CGenericImageDisplayPlugin::ImageStatus() const

	{

	return iPluginImgStatus;

	}

TBool CGenericImageDisplayPlugin::ValidBitmap() const

	{

	return iValidBitmap;

	}

void CGenericImageDisplayPlugin::CacheImageStatus()

	{

	TInt numFrames;

	iPluginImgStatus=(NumFrames(numFrames)==KErrNone && numFrames > 1)? CImageDisplay::EImageMultiFrame : CImageDisplay::EImageSingleFrame;

	for (TInt i=0; i<numFrames; ++i)

		{

		if (iDecoder->FrameInfo(i).iDelay.Int64() != 0)

			{

			iPluginImgStatus|= CImageDisplay::EImageAnimated;

			if (iImageHasFloatingSubImgs)

				{

				break;

				}

			}

		if (iDecoder->FrameInfo(i).iFrameCoordsInPixels != iDecoder->FrameInfo(0).iFrameCoordsInPixels)

			{

			iImageHasFloatingSubImgs = ETrue;

			if (iPluginImgStatus & CImageDisplay::EImageAnimated)

				{

				break;

				}

			}

		}

	iPluginImgStatus|=((iDecoder->FrameInfo().iFlags&TFrameInfo::ETransparencyPossible) ? CImageDisplay::EImageMasked : 0);

	iPluginImgStatus|=(ThumbnailExists()?CImageDisplay::EImageHasThumbnail : 0);

	iPluginImgStatus|=((iDecoder->FrameInfo().iFlags&TFrameInfo::EFullyScaleable)?CImageDisplay::EImageIsFullyScalable : 0);

	}

void CGenericImageDisplayPlugin::OnPlayEvent(TInt aErrorCode, TUint aEventFlags, CFbsBitmap* aFrame, CFbsBitmap* aMask)

	{

	ASSERT(IsStatusSet(EStatusPaused)==EFalse);

	iLastError = aErrorCode;

	if (aErrorCode == KErrNone)

		{

		iValidBitmap	= EFalse;

		iPluginStatus	= aEventFlags;

		iCurrentMask	= aMask;

		if (iTransformer != NULL ) 

			{

			SetStatusFlag(EStatusBusy);

			iState = ETransforming;

			iTransformer->Singleton().SetTrueSrcSize( iPlayer->OriginalFrameSize() );

			iTransformer->Transform(aFrame, MaintainAspectRatio());

			}

		else

			{

			iValidBitmap	= ETrue;

			iCurrentFrame	= aFrame;

			ClearStatusFlag(EStatusBusy);

			if ((aEventFlags&EStatusNoMoreToDecode)==0)

				{

				SetStatusFlag(EStatusPaused);	

				}

			const TTimeIntervalMicroSeconds delay(iNextFrameDelay);

			iNextFrameDelay = iPlayer->CurrentFrameInfo().iDelay;

			iDelayedCb->CallAfter(delay);

			}

		}

	else	

		{

		iState = EInitFailed;

		iPluginStatus = EStatusNoMoreToDecode;

		iCurrentFrame = NULL;

// we've got error, so there is no need to go via delayed callback

		AsyncCallbackImageReady(iCurrentFrame, iPluginStatus, iOutputRect, aErrorCode);

		}

	}

void CGenericImageDisplayPlugin::OnTransformDone(TInt aError)

	{

	TTimeIntervalMicroSeconds delay(0);

	if (aError == KErrNone)

		{

		if (iCurrentMask != NULL && iState == ETransforming)

			{

			iMaskTransformer->Transform(iCurrentMask, MaintainAspectRatio());

			iState = ETransformingMask;

			return;

			}

		SetStatusFlag(EStatusFrameReady);

		if (!IsStatusSet(EStatusNoMoreToDecode))

			{

			SetStatusFlag(EStatusPaused);

			}

		iTransformer->GetBitmap(iCurrentFrame);

		if (iCurrentMask)

			{

			iMaskTransformer->GetBitmap(iCurrentMask);

			}

		if (iCurrentFrame != NULL)

			{

			iValidBitmap= ETrue;

			delay		= iNextFrameDelay;

			}

		iNextFrameDelay = iPlayer->CurrentFrameInfo().iDelay;

		iState = EProcessing;

		}

	else

		{

		iState			= EInitFailed;

		iValidBitmap	= EFalse;

		iCurrentFrame	= NULL;

		SetStatusFlag(EStatusNoMoreToDecode);

		ClearStatusFlag(EStatusBusy|EStatusPaused);

		}

	ClearStatusFlag(EStatusBusy);

	iLastError = aError;

	iDelayedCb->CallAfter(delay);

	}

void CGenericImageDisplayPlugin::FillRecommendedSizesL()

	{

	ASSERT( iDecoder->IsImageHeaderProcessingComplete() );

	TRect clipRect;

	const TBool clipDefined=SourceRect(clipRect);

	const TFrameInfo& FrameInfo=iDecoder->FrameInfo();

	TSize imageSize(clipDefined? clipRect.Size() : FrameInfo.iFrameCoordsInPixels.Size() );

	RotateSize(imageSize, iRotationOptions);

	GenRecommendedSizesL(iImageSizes, imageSize, KMaxReductionFactor);

	}

void CGenericImageDisplayPlugin::GenRecommendedSizesL(RSizeArray& aArray,const TSize& aOriginalSize,TInt aMaxReduction )

	{

	aArray.Reset();

	TSize reducedSize(aOriginalSize);

	TInt i=0;

	do 

		{

		User::LeaveIfError( aArray.Append(reducedSize) );

		if (KErrNone != iDecoder->ReducedSize(aOriginalSize, ++i, reducedSize))

			{

			break;

			}

		} while ( i<=aMaxReduction &&

					reducedSize.iWidth <= MaxUnscaledSize().iWidth && reducedSize.iHeight <= MaxUnscaledSize().iHeight);

	}

TBool CGenericImageDisplayPlugin::SetupPlayerGetScalingNeeded(const TSize& aImageSize, const TSize& aTrueImgSize)

	{

	TSize effectiveDestSize( DestinationSizeInPixels() );

	RotateSize(effectiveDestSize, iRotationOptions);

	const TSize askSize( effectiveDestSize );

	// in case of clipping and upscaling  - decode to original size, clip then upscale

	// in case of clipping and downscaling- decode to downscaled, then clip

	const TSize destSize( aImageSize == aTrueImgSize ? askSize : // no clipping so decode to dest size

			(IsSize2Exceeds1(aTrueImgSize, askSize)?aTrueImgSize: 

													ScaleSize(effectiveDestSize, aImageSize, aTrueImgSize) )

						);

	if ((iDecoder->FrameInfo().iFlags&TFrameInfo::EFullyScaleable))

		{

		iPlayer->Setup( destSize, KZeroReductionFactor, KZeroReductionFactor);

		return EFalse;

		}

	TBool scalingNeeded=EFalse;

	TInt neededReduction=iDecoder->ReductionFactor(aTrueImgSize, destSize);

	TSize reducedSize(-1,-1);

	// if given reduction factor is not supported we'd go using scaler

	iDecoder->ReducedSize(aTrueImgSize, neededReduction, reducedSize);

	// animated images suffer from "1 pixel difference" problems when they are composed of reduced parts

	// so always use scaling for such images

	const TBool KNoReductionAllowed=(iImageHasFloatingSubImgs && (iPluginImgStatus & CImageDisplay::EImageAnimated));

	if (neededReduction>=0 && neededReduction<=KMaxReductionFactor && reducedSize==destSize 

			&& !KNoReductionAllowed)

		{

		// destination size is achivable through reduction factor

		TInt maxReduction=(IsSize2Exceeds1(iMaxUnscaledSize,destSize)? Max(iMaxReductionFactor,neededReduction) : neededReduction);

		iPlayer->Setup(reducedSize, maxReduction ,neededReduction);

		scalingNeeded=(maxReduction != neededReduction);

		}

	else

		{

		scalingNeeded=ETrue;

		if (IsSize2Exceeds1(aTrueImgSize, destSize) || KNoReductionAllowed)// we've got upscaling, or no reduction is allowed

			{

			iPlayer->Setup(aTrueImgSize, KZeroReductionFactor, KZeroReductionFactor); 

			}

		else

			{

			// we do not apply reduction for sizes smaller than iMaxUnscaledSize

			TInt reduction=iDecoder->ReductionFactor(destSize, iMaxUnscaledSize);

			reduction=Max(0, Min(iMaxReductionFactor, reduction));

			iPlayer->Setup(aTrueImgSize, reduction, KZeroReductionFactor); 

			// and we have to use further downscaling to achieve final target size

			}

		}

	return scalingNeeded;

	}

void CGenericImageDisplayPlugin::CompleteInitL()

	{

	ASSERT( iDecoder->IsImageHeaderProcessingComplete() );

	iNumberOfFrames = iDecoder->FrameCount();

	TBool needsMask=EFalse;

	for (TInt i=0; i<iNumberOfFrames && !needsMask; ++i)

		{

		needsMask = ( (iDecoder->FrameInfo(i).iFlags & TFrameInfo::ETransparencyPossible) != 0 );

		}

	const TFrameInfo& frameInfo=iDecoder->FrameInfo();

	TRect frameRect(frameInfo.iFrameCoordsInPixels);

	const TSize imageSize(frameRect.Size());

	TRect clipRect;

	const TBool clipDefined=SourceRect(clipRect);

	if (!clipDefined)

		{