// Copyright (c) 2002-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 "BitmapTransformsPlugin.h"

#include "BitmapConverter.h"

#include <bitmtrans/bitmtranspanic.h>

#include <e32math.h>

const TInt KFixedPointBits = 4;

const TInt KFixedPointScale = (1 << KFixedPointBits);

const TInt KLinesPerCall = 10;

const TInt KBitsPerByte = 8;

/*

*The function NewL constructs a CBitmapScalerPlugin

*

*@return CBitmapScalerPlugin* 

*/

MBitmapScalerPlugin* CBitmapScalerPlugin::NewL()

	{

	CBitmapScalerPlugin* self = new(ELeave) CBitmapScalerPlugin();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/*

*

*CBitmapScalerPlugin()

*Constructor for this class. Adds itself to CActiveScheduler.

*/

CBitmapScalerPlugin::CBitmapScalerPlugin()

	: CActive(CActive::EPriorityIdle), iOrigDes(NULL, 0), iDestDes(NULL, 0),

	iQualityLevel(CBitmapScaler::EMaximumQuality)

	{

	CActiveScheduler::Add(this);

	}

/*

*

*ConstructL()

*Performs second phase of construction.

*/

void CBitmapScalerPlugin::ConstructL()

	{

	iScanlineBitmap = new(ELeave) CFbsBitmap;

	SetPostProcessingEnabled(ETrue);	

	ASSERT( GetCurrentState() == EInactiveState );

	}

/*

*

*~CBitmapScalerPlugin

*This is the destructor for the CBitmapScalerPlugin 

*and is resposible for deallocating all resources 

*allocated by the CBitmapScalerPlugin.

*/

CBitmapScalerPlugin::~CBitmapScalerPlugin()

	{

	Cancel();

	Cleanup();

	delete iScanlineBitmap;

	// should have been deleted by cleanup

	ASSERT(iScaleBitmap==NULL || !(iFlags & EScaleBitmapIsOwned));

	ASSERT(iFilterIndexTable==NULL);

	ASSERT(iFilterCoeffsTable==NULL);

	ASSERT(iDevice==NULL);

	ASSERT(iGc==NULL);

	ASSERT(iPostProcessBitmap == NULL );

	ASSERT(iBitmapConverter == NULL );

	ASSERT( GetCurrentState() == EInactiveState );

	}

/*

*This function performs deallocation of memory allocated by the class

*which is allocated on each scale as opposed to the entire liftime

*of the scaler object.

*/

void CBitmapScalerPlugin::Cleanup()

	{

	delete[] iFilterIndexTable; 

	iFilterIndexTable = NULL;

	delete[] iFilterCoeffsTable; 

	iFilterCoeffsTable = NULL;

	if (iOrigDes.Length() != 0)	// Test is required to avoid PANIC 45

		{

		User::Free( reinterpret_cast<TAny*>( const_cast<TUint8*>( iOrigDes.Ptr() ) ) );

		iOrigDes.SetLength(0);

		}

	if (iDestDes.Length() != 0)	// Test is required to avoid PANIC 45

		{

		User::Free( reinterpret_cast<TAny*>( const_cast<TUint8*>( iDestDes.Ptr() ) ) );

		iDestDes.SetLength(0);

		}

	if (iFlags & ECreatedTempBitmap)

		{

		delete iTempBitmap; 

		iTempBitmap = NULL;

		iFlags &= ~ECreatedTempBitmap;

		}

	// Reset the EIsSourceBitmapResized flag here

	if (iFlags & EIsSourceBitmapResized)

		{

		iFlags &= ~EIsSourceBitmapResized;

		ASSERT((iFlags & EIsSourceBitmapResized) == 0);

		}

	// Only delete the scale bitmap if we created it.

	if (iFlags & EScaleBitmapIsOwned)

		{

		delete iScaleBitmap;

		iFlags &= ~EScaleBitmapIsOwned;

		}

	iScaleBitmap = NULL;

	delete iGc; 

	iGc = NULL;

	delete iDevice; 

	iDevice = NULL;

	iDestBmpPtr = NULL; // we don't own it

	delete iPostProcessBitmap; 

	iPostProcessBitmap = NULL;

	delete iBitmapConverter;

	iBitmapConverter = NULL;

	SetCurrentState( EInactiveState );

	}

/*

* Allocates some memory and assigns a pointer to it.

* @param aPtr Pointer to the allocated memory

* @param aAllocSize The size in bytes of the memory to allocate

* @pre aAllocSize >= 0

* @pre InVariant

*/

TInt CBitmapScalerPlugin::AllocPtr( TPtr8& aPtr, TInt aAllocSize )

	{

	//[ preconditions ]

	ASSERT(aAllocSize >= 0 );

	ASSERT(InVariant());

	TInt rc = KErrNone;

	// User::Alloc() returns NULL if no memory

	TUint8* addr = static_cast<TUint8*>(User::Alloc(aAllocSize + sizeof(TUint32) ));

	if (addr)

		{

		// coverity [memory_leak]

		addr = reinterpret_cast<TUint8*>( _ALIGN_UP(TLinAddr(addr), sizeof(TUint32)) );

		aPtr.Set(addr, aAllocSize, aAllocSize);

		}

	else

		{

		rc = KErrNoMemory;

		}

	return rc;

	}

// MBitmapScalerPlugin::Cancel() calls CActive::Cancel()

void CBitmapScalerPlugin::Cancel()

	{

	CActive::Cancel();

	}

/*

*

* ScaleRequestPostcondition

* @return 'ETrue' when post conditions for scale request are 

* correct

*

*/

TBool CBitmapScalerPlugin::ScaleRequestPostcondition() const 

	{

	TBool result = ETrue;

	if (QualityAlgorithm() != CBitmapScaler::EMaximumQuality )

		{

		if(	( iFinalOffset != iDestSize.iHeight ) ||

			( iFilterIndexTable != NULL ) ||

			( iFilterCoeffsTable != 0 ) )

			{

			result = EFalse;

			}

		}

	else

		{

		// Using the original (maximum quality) algorithm

		if(	( iFlags & EVerticalScan) ||

			( iFilterIndexTable == NULL ) ||

			( iFinalOffset != iOrigSize.iHeight ) ||

			( iFilterCoeffsTable == 0 ) )

			{

			result = EFalse;

			}

	if (( iDevice == NULL ) ||

		( iScanlineBitmap->Handle() == 0 ) ||

		( iCurOffset != 0 ))

		{

		result = EFalse;

			}			

		}

	return result;

	}

/**

 *

 * Begins the bitmap re-scaling operation.

 *

 * The scaling factor is based on the relative value of the source bitmap

 * size and the explicitly supplied size. The operation is asynchronous.

 * When it is complete, successfully or otherwise, the

 * <code>TRequestStatus</code>& is set, passing the state of the operation.

 *

 * @param     "TRequestStatus* aRequestStatus"

 *

 * @param     "CFbsBitmap& aBitmap"

 *            The bitmap to be re-scaled. This reference is also the

 *            target location for the re-scaled bitmap.

 * @param     "const TSize& aDestinationSize"

 *            The requested target size for the re-scaled bitmap.

 * @param     "TBool aMaintainAspectRatio = ETrue"

 *            <code>ETrue</code> - the aspect ratio is retained;

 *            this is the default. The same scaling factor is

 *            applied in both the horizontal and vertical

 *            directions. This is the smaller of the horizontal

 *            scaling factor and the vertical scaling factor.

 *            <code>EFalse</code> - the aspect ratio need not be

 *            retained.

 *

 */

void CBitmapScalerPlugin::Scale(TRequestStatus* aRequestStatus,

									 CFbsBitmap& aBitmap,

									 const TSize& aDestinationSize,

									 TBool aMaintainAspectRatio)

	{

	//[ assert preconditions ]

	// [ panic if aRequestStatus is NULL ]

	__ASSERT_ALWAYS( (aRequestStatus != NULL), Panic( EBadArgumentScale ) );

	//[ panic if the src has not been created]

	__ASSERT_ALWAYS( (aBitmap.Handle() != 0), Panic( ENoSourceBitmap ) );

	iScaleStatus = aRequestStatus;

	*iScaleStatus = KRequestPending;

	if(aBitmap.ExtendedBitmapType()!=KNullUid)

        {

        RequestComplete(KErrNotSupported);

        return;

        }

	// Set up the sizes before they're lost

	iOrigSize = aBitmap.SizeInPixels();

	iDestSize = aDestinationSize;

	// Dithering is not required if the tgt's display mode

	// is none of EGray256, EColor16M, EColor16MU, EColor16MA

	TBool dither = ETrue;

	iTgtDisplayMode = aBitmap.DisplayMode();

	if ((iTgtDisplayMode == EGray256) ||

		(iTgtDisplayMode == EColor16M) ||

		(iTgtDisplayMode == EColor16MA)||

		(iTgtDisplayMode == EColor16MU) )

		{

		dither = EFalse;

		}

	// Create a temporary bitmap if we're not using the low memory algorithm

	// OR if we're using the low memory algorithm AND dithering

	TInt leaveErr = KErrNone;

	if (!UseLowMemoryAlgorithm() || 

		(UseLowMemoryAlgorithm() && dither) )

		{

		if (iFlags & ECreatedTempBitmap)

			{

			delete iTempBitmap;

			iTempBitmap = NULL;

			iFlags &= ~ECreatedTempBitmap;

			}

		iTempBitmap = new CFbsBitmap;

		if (iTempBitmap != NULL)

			{

			// iTempBitmap has been created so flag that it needs to be deleted

			iFlags |= ECreatedTempBitmap;

			leaveErr = iTempBitmap->Create(aDestinationSize, iTgtDisplayMode);

			}

		else

			{

			// No memory to new the temp bitmap

			leaveErr = KErrNoMemory;

			}

		}

	if (leaveErr == KErrNoMemory ||

		(UseLowMemoryAlgorithm() && !dither) )

		{

		// Either failed to create the tempbitmap OR

		// we explicitly want to use the low-memory algorithm.

		// Either way use the source directly in the manner of the low-memory algorithm.

		// Check if we need to delete the tempbitmap 

		if (iFlags & ECreatedTempBitmap)

			{

			delete iTempBitmap;

			iTempBitmap = NULL;

			iFlags &= ~ECreatedTempBitmap;

			}

		iTempBitmap = &aBitmap;

		iFlags |= EIsSourceBitmapResized;

		}

	else if (leaveErr != KErrNone)

		{

		iScaleStatus = aRequestStatus;

		*iScaleStatus = KRequestPending;

		ProcessError(leaveErr);

		return;

		}

	Scale(aRequestStatus, aBitmap, *iTempBitmap, aMaintainAspectRatio);

	}

/*

 *

 * Begins the bitmap re-scaling operation.

 *

 * The scaling factor is based on the relative sizes of the source

 * and target bitmaps. The operation is asynchronous. When it is

 * complete, successfully or otherwise, the TRequestStatus &

 * aStatus is set, passing the state of the operation.

 *

 * @param     TRequestStatus* aRequestStatus

 *

 * @param     "CFbsBitmap& aSrcBitmap"

 *            The bitmap to be re-scaled.

 * @param     "CFbsBitmap& aTgtBitmap"

 *            The target location for the re-scaled bitmap.

 * @param     "TBool aMaintainAspectRatio = ETrue"

 *            ETrue  - the aspect ratio is retained;

 *            this is the default. The same scaling factor is

 *            applied in both the horizontal and vertical

 *            directions. This is the smaller of the horizontal

 *            scaling factor and the vertical scaling factor.

 *             EFalse  - the aspect ratio need not be

 *            retained.

 *

 *

 */

void CBitmapScalerPlugin::Scale(TRequestStatus* aRequestStatus,

							  CFbsBitmap& aSrcBitmap,

							  CFbsBitmap& aTgtBitmap,

							  TBool aMaintainAspectRatio)

	{

	// [ precondition checking on arguments ]

	// [ panic if aRequestStatus is NULL ]

	__ASSERT_ALWAYS( (aRequestStatus != NULL), Panic( EBadArgumentScale ) );

	//[ panic if the src has not been created]

	__ASSERT_ALWAYS( (aSrcBitmap.Handle() != 0), Panic( ENoSourceBitmap ) );

	//[ panic if the tgt has not been created]

	__ASSERT_ALWAYS( (aTgtBitmap.Handle() != 0), Panic( ENoDestinationBitmap ) );

	iScaleStatus = aRequestStatus;

	*iScaleStatus = KRequestPending;

	//[ current state must be inactive ]

	if( GetCurrentState() != EInactiveState )

		{

		ProcessError( KErrGeneral );

		return;

		}

	ASSERT(iDevice==NULL);

	if(aSrcBitmap.ExtendedBitmapType()!=KNullUid || aTgtBitmap.ExtendedBitmapType()!=KNullUid)

        {

        RequestComplete(KErrNotSupported);

        return;

        }

	iSrcBitmap = &aSrcBitmap;

	iTgtBitmap = &aTgtBitmap;

	if (!(iFlags & EIsSourceBitmapResized))

		{

		// As we're not scaling directly to the source bitmap

		// we can determine the scaling sizes here (otherwise

		// we'd overwrite the values that we got prior to setting

		// the tgtBitmap to the srcBitmap!!)

		iOrigSize = iSrcBitmap->SizeInPixels();

		iDestSize = iTgtBitmap->SizeInPixels();

		}

	TInt err = KErrNone;

	// Target's colour depth

	iTgtDisplayMode = iTgtBitmap->DisplayMode();

	// Check the aspect ratio and adjust the resolution if needed

	if (aMaintainAspectRatio)

		{

		//[ update destination height to preserve aspect ratio ]

	    HeightAndWidthPreservingAspectRatio( iDestSize, iOrigSize );

		}

	iIntermediateSize.iWidth = iDestSize.iWidth;

	if ( QualityAlgorithm() != CBitmapScaler::EMaximumQuality )

		{

		// Using one of the lower quality algorithms so use the destination size

		// that we are scaling to.

		iIntermediateSize.iHeight = iDestSize.iHeight;

		}

	else

		{

		// Using the original algorithm (which firstly scales horizontally to

		// an intermediate bitmap), so the intermediate size requires the original

		// height unchanged.

		iIntermediateSize.iHeight = iOrigSize.iHeight;

		}

	// if either of the destination dimension is zero then 

	// complete with KErrNone

	if ((iDestSize.iWidth == 0) ||

		(iDestSize.iHeight == 0))

		{

		ProcessError(KErrNone);

		return;

		}

	// if either of the source dimension is zero then send back an error 

	if ((iOrigSize.iWidth == 0) || 

		(iOrigSize.iHeight == 0)) 

		{

		ProcessError( KErrArgument );

		return;

		}

	// Scale to bitmap of display mode EColor16M except for 

	// target bitmaps of EGray256, EColor16MU and EColor16MA

	if ( (iTgtDisplayMode == EGray256) || (iTgtDisplayMode == EColor16MU) 

			|| (iTgtDisplayMode == EColor16MA))

		{

		iLocalDisplayMode = iTgtDisplayMode;

		}

	else

		{

		iLocalDisplayMode = EColor16M;

		}

	if (iTgtDisplayMode != EColor16M && iTgtDisplayMode != EColor16MA && iTgtDisplayMode != EColor16MU)

		{

		// Create an intermediate bitmap to scale to for cases other than EColor16M

		if (iScaleBitmap == NULL)

			{

			// Only want one instance of iScaleBitmap

			iScaleBitmap = new CFbsBitmap;

			iFlags |= EScaleBitmapIsOwned;	// flag that we're the owner of the scale bitmap

			if (iScaleBitmap == NULL)

				{

				err = KErrNoMemory;

				}

			}

		if( err != KErrNone )

			{

			ProcessError( err );

			return;

			}

		err = iScaleBitmap->Create(iIntermediateSize, iLocalDisplayMode);

		if( err != KErrNone )

			{

			ProcessError( err );

			return;

			}

		iDestBmpPtr = iScaleBitmap;

		}

	else

		{

		// For EColor16M scale directly to TgtBitmap

		iScaleBitmap = iTgtBitmap;

		// Downscaling one bitmap to another requires 

		// the scale bitmap to be resized to ensure that

		// the correct amount of data is read from the source.

		if (!(iFlags & EIsSourceBitmapResized))

			{

			err = iScaleBitmap->Resize(iIntermediateSize);

			if (err != KErrNone)

				{

				ProcessError(err);

				return;

				}

			}

		}

	iComponentsPerPixel = TDisplayModeUtils::NumDisplayModeBitsPerPixel(iLocalDisplayMode) / KBitsPerByte;

	if (iComponentsPerPixel == 0)

		{

		iComponentsPerPixel = 1;

		}