/*

* Copyright (c) 2004 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:  Implementation of Image class.

*

*/

// INCLUDE FILES

#include "CIHLFileImage.h"

#include "CIHLBitmap.h"

#include "IHLImplementationIds.h"

#include "IHLDebugPrint.h" // Debug print

#include <IHLInterfaceIds.h>

// Private namespace for constants and functions

namespace

	{

	// Fixed scale factors

	enum TScaleFactors

		{

		EFull		= 1,

		EHalf		= 2,

		EQuarter	= 4,

		EEighth		= 8,

		};

	// Panic function

    _LIT( KIHLPanicString, "IHLImage" );

    void Panic( TInt aPanicCode ) { User::Panic( KIHLPanicString, aPanicCode ); }

	}

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

//

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

CIHLFileImage::CIHLFileImage( TInt aImageIndex )

:CActive( CActive::EPriorityStandard ),

iImageIndex( aImageIndex )

    {

	CActiveScheduler::Add( this );

    }

// -----------------------------------------------------------------------------

//

// Two-phased constructor.

// -----------------------------------------------------------------------------

CIHLFileImage* CIHLFileImage::NewL( RFile& aFile, TInt aImageIndex, const TUint32 aOptions )

	{

    CIHLFileImage* self = new (ELeave) CIHLFileImage( aImageIndex );

	CleanupStack::PushL( self );

	self->ConstructL( aFile, aOptions );

	CleanupStack::Pop(); // self

    return self;

	}

CIHLFileImage* CIHLFileImage::NewL( RFs& aFs, const TDesC8& aDataBuf,

                                    TInt aImageIndex, const TUint32 aOptions )

    {

    CIHLFileImage* self = new (ELeave) CIHLFileImage( aImageIndex );

	CleanupStack::PushL( self );

	self->ConstructL( aFs, aDataBuf, aOptions );

	CleanupStack::Pop(); // self

    return self;

    }

// -----------------------------------------------------------------------------

//

// Symbian constructor can leave.

// -----------------------------------------------------------------------------

void CIHLFileImage::ConstructL( RFile& aFile, const TUint32 aOptions )

	{

    TInt decoderOptions( CImageDecoder::EOptionNoDither | CImageDecoder::EOptionUseFrameSizeInPixels );

	// Open decoder

    IHL_DEBUG1( KIHLDebug1, "IHL - CIHLFileImage - Start create ICL image decoder" );

	if( aOptions & MIHLFileImage::EOptionNoDRMConsume )

	    {

	    iDecoder = CImageDecoder::FileNewL( aFile, ContentAccess::EPeek,

	                             (CImageDecoder::TOptions)decoderOptions );

	    }

	else

	    {

	    iDecoder = CImageDecoder::FileNewL( aFile, ContentAccess::EView,

	                             (CImageDecoder::TOptions)decoderOptions );

	    }

	ConstructCommonL();

    IHL_DEBUG1( KIHLDebug2, "IHL - CIHLFileImage - ICL image decoder ready!" );

	}

void CIHLFileImage::ConstructL( RFs& aFs, const TDesC8& aDataBuf, const TUint32 /*aOptions*/ )

    {

    TInt decoderOptions( CImageDecoder::EOptionNoDither | CImageDecoder::EOptionUseFrameSizeInPixels );

    IHL_DEBUG1( KIHLDebug1, "IHL - CIHLFileImage - Start create buffered ICL image decoder" );

    iDecoder = CImageDecoder::DataNewL( aFs, aDataBuf, (CImageDecoder::TOptions)decoderOptions );

	ConstructCommonL();

    IHL_DEBUG1( KIHLDebug2, "IHL - CIHLFileImage - Buffered ICL image decoder ready!" );

    }

// -----------------------------------------------------------------------------

// CIHLFileImage::ConstructCommonL

// -----------------------------------------------------------------------------

void CIHLFileImage::ConstructCommonL()

    {

	// Check frame count and image index

	iImageCount = iDecoder->FrameCount();

	__ASSERT_ALWAYS( iImageCount > 0, User::Leave( KErrCorrupt ) );

	// Get image types

	iDecoder->ImageType( iImageIndex, iImageType, iImageSubType );

	if( KImageTypeGIFUid == iImageType )

		{

		iGif = ETrue;

		if( iImageCount > 1 )

		    {

    		iAnimation = ETrue;

    		iAnimationFrameCount = iImageCount;

    		iImageCount = 1; // Handled as one animated image

		    }

		}

	__ASSERT_ALWAYS( iImageIndex >= 0 && iImageIndex < iImageCount, User::Leave( KErrArgument ) );

	// cache frame info and set scale sizes

	iFrameInfo = iDecoder->FrameInfo( iImageIndex );

	if( !iAnimation )

		{

        // Animation must always be loaded 1:1

		if( !iGif &&

		    iFrameInfo.iFlags & TFrameInfo::EFullyScaleable )

			{

			// Gif cannot be fully scaleable

			iFullyScaleable = ETrue;

			}

		else

			{

			TSize size( iFrameInfo.iOverallSizeInPixels );

			iLoadSizeArray.AppendL( ScaledLoadSize( size, EEighth ) );

			iLoadSizeArray.AppendL( ScaledLoadSize( size, EQuarter ) );

			iLoadSizeArray.AppendL( ScaledLoadSize( size, EHalf ) );

			}

		}

    }

// -----------------------------------------------------------------------------

// Destructor

// -----------------------------------------------------------------------------

CIHLFileImage::~CIHLFileImage()

    {

	Cancel();

	delete iPrevAnimationFrame;

	delete iSubFrameBitmap;

	delete iDecoder;

	iLoadSizeArray.Reset();

    }

// -----------------------------------------------------------------------------

// CIHLFileImage::Type

// -----------------------------------------------------------------------------

TIHLInterfaceType CIHLFileImage::Type() const

	{

	return TIHLInterfaceType( KIHLInterfaceIdFileImage,

							  KIHLImplementationIdFileImage );

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::ImageType

// -----------------------------------------------------------------------------

const TUid& CIHLFileImage::ImageType() const

	{

	return iImageType;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::ImageSubType

// -----------------------------------------------------------------------------

const TUid& CIHLFileImage::ImageSubType() const

	{

	return iImageSubType;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::ImageIndex

// -----------------------------------------------------------------------------

TInt CIHLFileImage::ImageIndex() const

	{

	return iImageIndex;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::ImageCount

// -----------------------------------------------------------------------------

TInt CIHLFileImage::ImageCount() const

	{

	return iImageCount;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::Size

// -----------------------------------------------------------------------------

TSize CIHLFileImage::Size() const

	{

	return iFrameInfo.iOverallSizeInPixels;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::DisplayMode

// -----------------------------------------------------------------------------

TDisplayMode CIHLFileImage::DisplayMode() const

	{

	if( iGif )

		{

		// We cannot trust iFrameDisplayMode for GIF images. It always return EColor256.

		// This is error because palette sure holds only 256 colors but these colors can

		// be still any RGB values and so for cannot be directly put to 8 bit bitmap (EColor256).

		// To decrypt image correctly and without color dithering, we must use 24 bit (EColor16M)

		// destination bitmap. Note that CFbsBitmap has palette methods but they are

		// not supported currently.

		// Return maximum color mode to ensure best image quality.

		return EColor16MU;

		}

	else if( iFrameInfo.iFrameDisplayMode < EColor16MU ||

	         iFrameInfo.iFrameDisplayMode == EColor4K )

		{

		return EColor64K;

		}

	return EColor16MU;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::MaskDisplayMode

// -----------------------------------------------------------------------------

TDisplayMode CIHLFileImage::MaskDisplayMode() const

	{

	if( iFrameInfo.iFlags & TFrameInfo::ETransparencyPossible )

		{

		if( iFrameInfo.iFlags & TFrameInfo::EAlphaChannel )

			{

			return EGray256;

			}

		return EGray2;

		}

	return ENone;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::BackgroundColor

// -----------------------------------------------------------------------------

TRgb CIHLFileImage::BackgroundColor() const

	{

	return iFrameInfo.iBackgroundColor;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::CustomLoadSizeArray

// -----------------------------------------------------------------------------

const RArray<TSize>& CIHLFileImage::CustomLoadSizeArray() const

	{

	return iLoadSizeArray;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::CustomLoadSizeArray

// -----------------------------------------------------------------------------

TBool CIHLFileImage::IsFullyScaleable() const

	{

	return iFullyScaleable;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::IsAnimation

// -----------------------------------------------------------------------------

TBool CIHLFileImage::IsAnimation() const

	{

	return iAnimation;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::AnimationFrameCount

// -----------------------------------------------------------------------------

TInt CIHLFileImage::AnimationFrameCount() const

	{

	return iAnimationFrameCount;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::AnimationFrameDelay

// -----------------------------------------------------------------------------

TTimeIntervalMicroSeconds32 CIHLFileImage::AnimationFrameDelay( TInt aAnimationFrameIndex ) const

	{

	__ASSERT_ALWAYS( aAnimationFrameIndex >= 0 &&

		aAnimationFrameIndex < iAnimationFrameCount, Panic( KErrArgument ) );

	return I64INT( iDecoder->FrameInfo( aAnimationFrameIndex ).iDelay.Int64() );

	}

// ------------------------------------------------------------------------------

// CIHLFileImage::Load

// ------------------------------------------------------------------------------

TInt CIHLFileImage::Load( TRequestStatus& aStatus, MIHLBitmap& aDestination, TInt aFrameIndex )

	{

	iImageIndex = aFrameIndex;	

	return LoadRequest( aStatus, aDestination, iImageIndex );

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::LoadAnimation

// -----------------------------------------------------------------------------

TInt CIHLFileImage::LoadAnimation( TRequestStatus& aStatus, MIHLBitmap& aDestination,

							  TInt aAnimationFrameIndex )

	{

	__ASSERT_ALWAYS( aAnimationFrameIndex >= 0 &&

		aAnimationFrameIndex < iAnimationFrameCount, Panic( KErrArgument ) );

	return LoadRequest( aStatus, aDestination, aAnimationFrameIndex );

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::IsBusy

// -----------------------------------------------------------------------------

TBool CIHLFileImage::IsBusy() const

	{

	return ( iImageState != EInactive );

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::CancelLoad

// -----------------------------------------------------------------------------

void CIHLFileImage::CancelLoad()

	{

	Cancel();

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::SetFilter

// -----------------------------------------------------------------------------

void CIHLFileImage::SetFilter( MIHLFilter* /*aFilter*/ )

	{

	// Not in use

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::Decoder

// -----------------------------------------------------------------------------

const CImageDecoder& CIHLFileImage::Decoder() const

	{

	return *iDecoder;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::DoCancel

// -----------------------------------------------------------------------------

void CIHLFileImage::DoCancel()

	{

	iDecoder->Cancel();

	// Delete all processed bitmaps

	ErrorCleanup();

	// Complete with cancel

	iImageState = EInactive;

	RequestComplete( KErrCancel );

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::RunL

// -----------------------------------------------------------------------------

void CIHLFileImage::RunL()

	{

	__ASSERT_DEBUG( iDestination, Panic( KErrGeneral ) );

	User::LeaveIfError( iStatus.Int() );

	switch( iImageState )

		{

		case EStartLoad:

			{

			// start loading the bitmaps

			StartLoadL();

			break;

			}

		case ECompleteLoad:

			{

			// complete loading the bitmaps

			CompleteLoadL();

			break;

			}

		default:

			{

			Panic( KErrTotalLossOfPrecision );

			}

		}

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::RunError

// -----------------------------------------------------------------------------

TInt CIHLFileImage::RunError( TInt aError )

	{

    IHL_DEBUG2( KIHLDebug, "IHL - CIHLFileImage - Loading error: %d", aError );

	// Delete all processed bitmaps

	ErrorCleanup();

	// Complete with error

	iImageState = EInactive;

	RequestComplete( aError );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::LoadRequest

// -----------------------------------------------------------------------------

TInt CIHLFileImage::LoadRequest( TRequestStatus& aStatus,

                                 MIHLBitmap& aDestination,

                                 TInt aFrameIndex )

	{

	if( IsBusy() )

		{

		return KErrNotReady;

		}

	if( aFrameIndex < 0 || aFrameIndex >= iDecoder->FrameCount() )

		{

		return KErrArgument;

		}

	const CFbsBitmap& dstBitmap = aDestination.Bitmap();

	if( !dstBitmap.Handle() )

		{

		return KErrArgument;

		}

	TSize dstSize( dstBitmap.SizeInPixels() );

	if( dstSize != Size() &&

		!iFullyScaleable )

		{

		TBool sizeFound( EFalse );

		const TInt count( iLoadSizeArray.Count() );

		for( TInt i( 0 ); i < count; ++i )

			{

			if( dstSize == iLoadSizeArray[ i ] )

				{

				sizeFound = ETrue;

				}

			}

		if( !sizeFound )

			{

			return KErrArgument;

			}

		}

    IHL_DEBUG1( KIHLDebug, "IHL - CIHLFileImage - Frame loading requested" );

	iImageStatus = &aStatus;

	*iImageStatus = KRequestPending;

	iDestination = static_cast<CIHLBitmap*>( &aDestination ); //lint !e826

	iFrameIndex = aFrameIndex;

	// Start the active object

	iImageState = EStartLoad;

	SelfComplete();

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::StartLoadL

// -----------------------------------------------------------------------------

void CIHLFileImage::StartLoadL()

	{

	__ASSERT_DEBUG( !iSubFrameBitmap, Panic( KErrGeneral ) );

    IHL_DEBUG1( KIHLDebug, "IHL - CIHLFileImage - Start ICL convert" );

	if( iAnimation )

		{

		// Start animation from first frame by default

		iSubFrameIndex = 0;

		// Check is animation can be continued on top of destination bitmap

		if( iDestination->IsCreated() &&

			iDestination->EditorPtr() == this &&

			iDestination->EditorValue() < iFrameIndex )

			{

			// Editor value means frame index

			iSubFrameIndex = iDestination->EditorValue() + 1;

			}

		StartLoadSubFrameL( iSubFrameIndex, ETrue );

		}

    else if( iGif )

        {

		StartLoadSubFrameL( iFrameIndex, EFalse );

        }

	else

		{

        // Frame fills the whole image -> normal load

	    StartLoadNormalFrame( iFrameIndex );

		}

	iImageState = ECompleteLoad;

	SetActive();

	}

// -----------------------------------------------------------------------------

// CIHLFileImage::StartLoadNormalFrame

// -----------------------------------------------------------------------------

void CIHLFileImage::StartLoadNormalFrame( TInt aFrameIndex )