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

const TInt KLinesPerCall = 10;

/**

The function NewL constructs a CBitmapRotatorPlugin

@returns CBitmapRotatorPlugin* 

*/

MBitmapRotatorPlugin* CBitmapRotatorPlugin::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Constructor for this class. Adds itself to <code>CActiveScheduler</code>.

The priority of this active object is CActive::EPriorityIdle

*/

CBitmapRotatorPlugin::CBitmapRotatorPlugin()

	: CActive(CActive::EPriorityIdle), iScanlineDes(NULL,0)

	{

	CActiveScheduler::Add(this);

	}

/**

Performs second phase of contruction

*

*/

void CBitmapRotatorPlugin::ConstructL()

	{

	}

/**

*

* Default destructor for this class.

*

*/

CBitmapRotatorPlugin::~CBitmapRotatorPlugin()

	{

	Cancel();

	Cleanup();

	// should have been deleted by cleanup

	ASSERT(iScanlineBuffer==NULL);

	ASSERT(iTempBitmap==NULL);

	ASSERT(iDevice==NULL);

	ASSERT(iGc==NULL);

	}

/**

This function performs deallocation of memory allocated by the class

*/

void CBitmapRotatorPlugin::Cleanup()

	{

	delete [] iScanlineBuffer; iScanlineBuffer = NULL;

	delete iTempBitmap; iTempBitmap = NULL;

	delete iGc; iGc = NULL;

	delete iDevice; iDevice = NULL;

	delete iScanlineBitmap; iScanlineBitmap = NULL;

#if defined(ROTATION_PROFILING)

	TUint fcTaken=User::FastCounter() - iStartedAtFc;

	RDebug::Print(_L("BmpRotator: FC time taken %d"),fcTaken);

#endif // 	

	}

// MBitmapRotatorPlugin::Cancel() calls CActive::Cancel()

void CBitmapRotatorPlugin::Cancel()

	{

	CActive::Cancel();

	}

/**

The function Rotate schedules a rotate/mirror operation on a bitmap supplied in the 

aSrcBitmap whose output overwrites aSrcBitmap.

Preconditions:

aRequestStatus is not a NULL pointer

aSrcBitmap     is a fully constructed bitmap of unknown size including zero dimension

aAngle         is a member of the enumeration TRotationAngle

@param "aRequestStatus" 

       is a pointer to the completion status of the asynchronous operation.

@param "CFbsBitmap& aBitmap" 

       is a reference to a CFbsBitmap. This bitmap should have been created

       and is also an output

@param "TRotationAngle aAngle"

       aAngle is a member of the enumeration TRotationAngle and specifies the rotation mirror operation   

@panic  This function panics with TBitmapTransformsMain::ENoSourceBitmap when the aSrcBitmap has not been constructed

ie its handle is 0

Sucess Guarantee

aSrcBitmap      contains the rotated bitmap

aRequestStatus  points to the value KErrorNone

*/

void CBitmapRotatorPlugin::Rotate(TRequestStatus* aRequestStatus, CFbsBitmap& aBitmap, TRotationAngle aAngle)

	{

	// [ 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 ) );

	//[ assert the angle is ok ]

	__ASSERT_ALWAYS( ( aAngle >= CBitmapRotator::ERotation90DegreesClockwise ) &&

					 ( aAngle <= CBitmapRotator::EMirrorVerticalAxis ), Panic(EBadArgumentRotate) );

	ASSERT(iTempBitmap==NULL);

	iRotateStatus = aRequestStatus;

	*iRotateStatus = KRequestPending;

	if(aBitmap.ExtendedBitmapType()!=KNullUid)

        {

        RequestComplete(KErrNotSupported);

        return;

        }

	iTempBitmap = new CFbsBitmap;

	if (!iTempBitmap)

		{

		RequestComplete(KErrNoMemory);

		return;

		}

	Rotate(aRequestStatus, aBitmap, *iTempBitmap, aAngle);

	}

	/**

The Rotate function schedules a rotate/mirror operation on a bitmap supplied in the srcBitmap and 

produces the output in the tgtBitmap.

The CBitmapRotatorPlugin is an active object and as such provides asynchronous operations

Preconditions:

aRequestStatus is not a NULL pointer

aSrcBitmap     is a fully constructed bitmap of unknown size including zero dimension and 

of type EColor16M

aTgtBitmap     is a fully constructed bitmap of unknown size including zero dimension

and is of type EColor16M

aAngle         is a member of the enumeration TRotationAngle 

Sucess Guarantee:

aTgtBitmap      contains the rotated bitmap

aRequestStatus  points to the value KErrNone

Minimal Guarantee:

The bitmap supplied in aSrcBitmap is unaltered

@param "TRequestStatus* aRequestStatus"

       a pointer to the completion status of the asynchronous operation.

@param "CFbsBitmap& aSrcBitmap"

       This bitmap should have been created and be of type EColor16M

@param "CFbsBitmap& aTgtBitmap"

       This bitmap should have been created and be of type EColor16M

@param "TRotationAngle aAngle" 

       is a member of the enumeration TRotationAngle and specifies the rotation mirror operation

@panic This function panics with TBitmapTransformsMain::ENoSourceBitmap when the aSrcBitmap has not been constructed

       i.e. its handle is zero

*/

void CBitmapRotatorPlugin::Rotate(TRequestStatus* aRequestStatus, CFbsBitmap& aSrcBitmap, CFbsBitmap& aTgtBitmap, TRotationAngle aAngle)

	{

	// [ 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 ) );

	//[ assert the angle is ok ]

	__ASSERT_ALWAYS( ( aAngle >= CBitmapRotator::ERotation90DegreesClockwise ) && 

					 ( aAngle <= CBitmapRotator::EMirrorVerticalAxis ), Panic(EBadArgumentRotate) );

	//[ we do not need to ensure a tgt has been created]

#if defined(ROTATION_PROFILING)

	iStartedAtFc = User::FastCounter();

#endif // ROTATION_PROFILING	

	// Initialize member variables

	iSrcBitmap = &aSrcBitmap;

	iTgtBitmap = &aTgtBitmap;

	iAngle = aAngle;

	iCurOffset = 0;

	iBitmapSize = iSrcBitmap->SizeInPixels();

	iDisplayMode = iSrcBitmap->DisplayMode();

	iRotateStatus = aRequestStatus;

	*iRotateStatus = KRequestPending;

	if(aSrcBitmap.ExtendedBitmapType()!=KNullUid)

        {

        RequestComplete(KErrNotSupported);

        return;

        }

	if(aTgtBitmap.Handle()!=0 && aTgtBitmap.ExtendedBitmapType()!=KNullUid)

        {

        RequestComplete(KErrNotSupported);

        return;

        }

	TSize newSize;

	if ((aAngle == CBitmapRotator::ERotation90DegreesClockwise) || (aAngle == CBitmapRotator::ERotation270DegreesClockwise))

		{

		newSize.SetSize(iBitmapSize.iHeight, iBitmapSize.iWidth); // Swap width and height

		}

	else

		{

		newSize.SetSize(iBitmapSize.iWidth, iBitmapSize.iHeight);

		}

	TInt err = iTgtBitmap->Create(newSize, iDisplayMode);

	TBool bmpDeviceNeeded=EFalse;

	if (iSrcBitmap->DisplayMode()==EColor16M || iSrcBitmap->DisplayMode()==EColor16MU ||

		iSrcBitmap->DisplayMode()==EColor16MA ||

		iSrcBitmap->DisplayMode()==EColor256 || iSrcBitmap->DisplayMode()==EGray256 || 

		iSrcBitmap->DisplayMode()==EColor64K )

		{

		iScanlineDisplayMode = iSrcBitmap->DisplayMode();

		}

	else

		{

		// we can't cope with that color mode, then use the highest one for intermediate buffer

		bmpDeviceNeeded		= ETrue;

		iScanlineDisplayMode= EColor16MA;

		}

	iPixelSizeInBytes = TDisplayModeUtils::NumDisplayModeBitsPerPixel(iScanlineDisplayMode) / 8;

	TInt scanlineLength=iSrcBitmap->ScanLineLength(newSize.iWidth, iScanlineDisplayMode);

	scanlineLength=Align4(scanlineLength);

	if (err == KErrNone)

		{

		ASSERT(iScanlineBuffer==NULL);

		iScanlineBuffer = new TUint32 [ scanlineLength ];

		if(!iScanlineBuffer)

			{

			err = KErrNoMemory;

			}

		}

	if (err != KErrNone)

		{

		Cleanup();

		RequestComplete(err);

		return;

		}

	iRows = newSize.iHeight;

	TPtr8 scanlineDes(reinterpret_cast<TText8*>(iScanlineBuffer),scanlineLength,scanlineLength); // Use a temporary to avoid compiler warnings

	iScanlineDes.Set(scanlineDes);

	ASSERT(iDevice==NULL);

	if (bmpDeviceNeeded)

		{

		iScanlineBitmap = new CFbsBitmap();

		err= (iScanlineBitmap? 	  iScanlineBitmap->Create(TSize(iTgtBitmap->SizeInPixels().iWidth, 1), iScanlineDisplayMode)

								: KErrNoMemory);

		if (err==KErrNone)

			{

			TRAP(err, iDevice = CFbsBitmapDevice::NewL(iTgtBitmap));

			}

		if (err == KErrNone)

			{

			err = iDevice->CreateContext(iGc);

			}

		}

	if (err != KErrNone)

		{

		Cleanup();

		RequestComplete(err);

		return;

		}

	// Start the active object

	SelfComplete(KErrNone);

	}

/**

This function is called by the Active Scheduler

to perform the rotate operation

*/

void CBitmapRotatorPlugin::DoRotate()

	{

	TInt linesLeftPerCall = KLinesPerCall;

	while ((linesLeftPerCall > 0) && (iCurOffset < iRows))

		{

		switch (iAngle)

			{

			// Rotation of 90 degrees

			case CBitmapRotator::ERotation90DegreesClockwise:

				{

				iSrcBitmap->GetVerticalScanLine(iScanlineDes, iCurOffset, iScanlineDisplayMode);

				FlipScanLine(iScanlineDes, iTgtBitmap->SizeInPixels().iWidth);

				PutScanline(iCurOffset);

				break;

				}

			// Rotation of 180 degrees

			case CBitmapRotator::ERotation180DegreesClockwise:

				{

				iSrcBitmap->GetScanLine(iScanlineDes,TPoint(0, iCurOffset), iBitmapSize.iWidth, iScanlineDisplayMode);

				FlipScanLine(iScanlineDes, iBitmapSize.iWidth);

				PutScanline(iBitmapSize.iHeight - 1 - iCurOffset);

				break;

				}

			// Rotation of 270 degrees

			case CBitmapRotator::ERotation270DegreesClockwise:

				{

				iSrcBitmap->GetVerticalScanLine(iScanlineDes, iCurOffset, iScanlineDisplayMode);

				PutScanline(iBitmapSize.iWidth - 1 - iCurOffset);

				break;

				}

			// Flip about the vertical Axis

			case CBitmapRotator::EMirrorVerticalAxis:    

				{

				iSrcBitmap->GetScanLine(iScanlineDes,TPoint(0,iCurOffset),iBitmapSize.iWidth,iScanlineDisplayMode);

				FlipScanLine(iScanlineDes, iBitmapSize.iWidth);

				PutScanline(iCurOffset);

				break;

				}

			// Flip about the horizontal axis

			case  CBitmapRotator::EMirrorHorizontalAxis:

				{

				iSrcBitmap->GetScanLine(iScanlineDes,TPoint(0,iCurOffset),iBitmapSize.iWidth,iScanlineDisplayMode);

				PutScanline(iBitmapSize.iHeight-1-iCurOffset);

				break;

				}

			default:

				{

				ASSERT( EFalse );

				}

			}

		iCurOffset++;

		linesLeftPerCall--;

		}

	if (iCurOffset == iRows)

		{

		TInt duplicateErr = KErrNone;

		if (iTempBitmap)

			{

			duplicateErr = iSrcBitmap->Duplicate(iTgtBitmap->Handle());

			}

		Cleanup();

		RequestComplete(duplicateErr);

		}

	else

		{

		// Start the active object

		SelfComplete(KErrNone);

		}

	}

/**

Handles an active object’s request completion event.

The function is called by the active scheduler

when a request completion event occurs,

*/

void CBitmapRotatorPlugin::RunL()

	{

	DoRotate();

	}

/**

Implements cancellation of an outstanding request. 

This function is called as part of the active object’s Cancel().

It must call the appropriate cancel function offered by the active object’s asynchronous service provider.

The asynchronous service provider’s cancel is expected to act immediately.

*/

void CBitmapRotatorPlugin::DoCancel()

	{

	Cleanup();

	RequestComplete(KErrCancel);

	}

/**

Signals to the current thread that the asynchronous request 

associated with the request status is complete.

@param aReason is a TInt and is the completion code of this request.

*/

void CBitmapRotatorPlugin::RequestComplete(TInt aReason)

	{

	ASSERT(iRotateStatus);

	TRequestStatus* status = iRotateStatus;

	User::RequestComplete(status, aReason);

	}

/**

This function activates the active object and 

signals completion of the current asynchronous operation

*/

void CBitmapRotatorPlugin::SelfComplete(TInt aReason)

	{

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, aReason);

	}

/**

  template function that can be used for swapping of memory locations 

  of particular pointer type

  @param ptr1 - pointer to value1

  @param ptr2 - pointer to value2

*/

template <class T>

inline void SwapPixels(T* ptr1, T* ptr2)

	{

	T temp 	= *ptr1;

	*ptr1	= *ptr2;

	*ptr2  	= temp;

	}

/**

  template function that can be used for mirroring of linear

  memory location of a particular scalar type

  @param aScanLinePtr location address

  @param aWidth width of location in elements, not bytes

*/	

template <class T>

inline void FlipLine(TUint8* aScanLinePtr, TInt aWidth)

	{

	T* startPixelPtr 	= reinterpret_cast<T*>(aScanLinePtr);

	T* endPixelPtr 		= startPixelPtr + aWidth - 1;

	if (aWidth&1)

		{

		SwapPixels(startPixelPtr++, endPixelPtr--);

		}

	if(aWidth&3)

		{

		while (startPixelPtr < endPixelPtr)

			{

			SwapPixels(startPixelPtr++, endPixelPtr--);

			}

		}

	else

		{

		while (startPixelPtr < endPixelPtr)

			{

			SwapPixels(startPixelPtr++, endPixelPtr--);

			SwapPixels(startPixelPtr++, endPixelPtr--);

			}			

		}

	}

/**

This function flips a scan line buffer of width aWidth

PreConditions:

aWidth >= 0 && aWidth is the length of the buffer

aDes is a reference to a buffer of rgb pixels

Postcondition:

The contents of the buffer have flipped about the buffers centre

@param TDes8 aDes

       reference to a buffer of rgb pixels of lenth aWidth

@param Tint aWidth

       is the width of the buffer

*/

void CBitmapRotatorPlugin::FlipScanLine(TDes8& aDes, TInt aWidth)

	{

	//[ assert consistency between descriptor length and width ]

	ASSERT( (aDes.Length() == (iPixelSizeInBytes * aWidth) ));

	TUint8* const scanLinePtr=const_cast<TUint8*>(aDes.Ptr());

	switch (iPixelSizeInBytes)

		{

		case 4:

			{

			FlipLine<TUint32>(scanLinePtr, aWidth);

			}

			break;

		case 3:

			{

			TUint8* startPixelPtr = scanLinePtr;

			TUint8* endPixelPtr = startPixelPtr + (aWidth - 1)*iPixelSizeInBytes;

	while (startPixelPtr < endPixelPtr)

		{

		TUint8 temp0 = startPixelPtr[0];

		TUint8 temp1 = startPixelPtr[1];