/*

* Copyright (c) 2006 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:   

*	CDCDCDigitalZoom 

*		Scaling of image to display size & zooming.

*		Includes support for different scaling and crop sizes with pan&scan.

*		Pan can use previously computed scaled data when changing.

*		Based on IMAAMI scaling algorithm.

*

*/

#include <fbs.h>

#include "DCDigitalZoom.h"

/*

-----------------------------------------------------------------------------

    CDCDigitalZoom::CDCDigitalZoom

	C++ constructor.

	Initialises set of member parameters.

-----------------------------------------------------------------------------

*/

CDCDigitalZoom::CDCDigitalZoom()

{

	iParams.sizeX      = 176; //640;	// Size of VGA image for X

	iParams.sizeY      = 144; //480;	// Size of VGA image for Y

	iParams.scaleX     = 1.0f;	// No Scaling for X

	iParams.scaleY     = 1.0f;	// No scaling for Y

	iParams.allShiftX  = 0;		// No pan

	iParams.allShiftY  = 0;		// 

	iParams.newShiftX  = 0;		// No pan

	iParams.newShiftY  = 0;		//

}

/*

-----------------------------------------------------------------------------

    CDCDigitalZoom::ConstructL

	Second phase constructor.

	Construct the object. (not used, may leave)

-----------------------------------------------------------------------------

*/

void CDCDigitalZoom::ConstructL()

{

	// This function is intentionally left blank.

}

/*

-----------------------------------------------------------------------------

    CDCDigitalZoom::NewLC

	Allocate the memory and construct the object.

	Pushs pointer to a new instance to Cleanupstack.

    Return value:

		CDCDigitalZoom* self		Pointer to a new instance

-----------------------------------------------------------------------------

*/

CDCDigitalZoom* CDCDigitalZoom::NewLC()

{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

/*

-----------------------------------------------------------------------------

    CDCDigitalZoom::NewL

	Allocate the memory and construct the object.

    Return value:

		CDCDigitalZoom* self		Pointer to a new instance

-----------------------------------------------------------------------------

*/

CDCDigitalZoom* CDCDigitalZoom::NewL()

{

	CDCDigitalZoom* self = CDCDigitalZoom::NewLC();

	CleanupStack::Pop();

	return self;

}

/*

-----------------------------------------------------------------------------

    CDCDigitalZoom::~CDCDigitalZoom

	C++ destructor.

-----------------------------------------------------------------------------

*/

CDCDigitalZoom::~CDCDigitalZoom()

{

	// This function is intentionally left blank.

}

/*

-----------------------------------------------------------------------------

    CDCDigitalZoom::ProcessL

	Main function of digital zoom. (public)

	Calls processing function (zoomImage).

	NOTE:

		ImageZoomParams iParams have to be set before calling

		this function, so that the wanted processing is done.

    Parameters in:

		CFbsBitmap* aOriPtr		Pointer to source image bitmap

	Parameters out:

		CFbsBitmap* aOutPtr		Pointer to destination image bitmap

    Return value: None

-----------------------------------------------------------------------------

*/

void CDCDigitalZoom::ProcessL(const CFbsBitmap *aOriPtr, CFbsBitmap *aOutPtr)

{

	//EColor16M image is needed

	if(aOutPtr->DisplayMode() != EColor16M)

	{

		return;

	}

	if(aOriPtr->DisplayMode() != EColor16M)

	{

		return;

	}

	// Find size of original image

	TInt oriSizeX = aOriPtr->SizeInPixels().iWidth;

	TInt oriSizeY = aOriPtr->SizeInPixels().iHeight;

	//Do scaling

	DecimateL(aOriPtr, aOutPtr,

			iParams.sizeX, iParams.sizeY,

			oriSizeX, oriSizeY,

			iParams.scaleX, iParams.scaleY,

			iParams.allShiftX, iParams.allShiftY,

			iParams.newShiftX, iParams.newShiftY);

}

/*

-----------------------------------------------------------------------------

  DecimateL

  IMAAMI scaling core function

-----------------------------------------------------------------------------

*/

void CDCDigitalZoom::DecimateL(const CFbsBitmap* aOriPtr, CFbsBitmap* aOutPtr,

									 TInt aOutSizeX, TInt aOutSizeY,

									 TInt aOriSizeX, TInt aOriSizeY,

									 TReal aZoomX, TReal aZoomY,

									 TInt allShiftX, TInt allShiftY,

									 TInt newShiftX, TInt newShiftY)

{

	TInt32

		divider,

		xPos, yPos, tmpline,

		xAver, yAver,

		xStep, yStep,

		tmpEnd, tmpSta,

		sumB, sumG, sumR,

		tmpB, tmpG, tmpR;

	TInt32

		x, y,

		i, j,

		LastLine,

		xInt, yInt,

		xStaInt, yStaInt,

		xEndInt, yEndInt,

		xFirstInt, yFirstInt;

	TUint32

		LineNum,

		outFlag,

		xRem, yRem,

		xStaRem, yStaRem,

		xEndRem, yEndRem,

		xStaWei, yStaWei,

		xEndWei, yEndWei,

		xAllWei, yAllWei,

		xMaxWei, yMaxWei,

		xLoopSta, yLoopSta,

		xLoopEnd, yLoopEnd,

		xFirstRem, yFirstRem;

	TUint32

		PIX_BITS	= 13,						// 13

		PIXEL		= (TUint32)(1 << PIX_BITS),

		HALF_PIX	= (TUint32)(1 << (PIX_BITS - 1)),

		REMAINDER	= (TUint32)(PIXEL - 1),

		WEI_BITS	= 4,						// 4

		HALF_WEI	= (TUint32)(1 << (WEI_BITS - 1)),

		DIF1_BITS	= (TUint32)(PIX_BITS - WEI_BITS),

		HALF_DIF1	= (TUint32)(1 << (DIF1_BITS - 1)),

		REM_HDIF1	= (TUint32)(HALF_DIF1 - 1),

		RED_BITS	= 4,						// 4

		HALF_RED	= (TUint32)(1 << (RED_BITS - 1));

	if(aZoomX < 0.20 || aZoomY < 0.20)

	{

		RED_BITS = 5;

		HALF_RED = (TUint32)(1 << (RED_BITS - 1));

	}

	// Allocate local temporal input0 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine0 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine0);

	// Allocate local temporal input1 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine1 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine1);

	// Allocate local temporal input2 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine2 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine2);

	// Allocate local temporal input3 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine3 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine3);

	// Allocate local temporal input4 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine4 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine4);

	// Allocate local temporal input5 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine5 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine5);

	// Allocate local temporal input6 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine6 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine6);

	// Allocate local temporal input7 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine7 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine7);

	// Allocate local temporal input8 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine8 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine8);

	// Allocate local temporal input9 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine9 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine9);

	// Allocate local temporal input10 line buffer and push its pointer to CleanupStack

	HBufC8* oriLine10 = HBufC8::NewMaxL(3 * aOriSizeX);	// BGRBGR...

	CleanupStack::PushL(oriLine10);

	// Set pointers of input lines

	TUint8* line0Ptr = (TUint8*)oriLine0->Des().Ptr();

	TUint8* line1Ptr = (TUint8*)oriLine1->Des().Ptr();

	TUint8* line2Ptr = (TUint8*)oriLine2->Des().Ptr();

	TUint8* line3Ptr = (TUint8*)oriLine3->Des().Ptr();

	TUint8* line4Ptr = (TUint8*)oriLine4->Des().Ptr();

	TUint8* line5Ptr = (TUint8*)oriLine5->Des().Ptr();

	TUint8* line6Ptr = (TUint8*)oriLine6->Des().Ptr();

	TUint8* line7Ptr = (TUint8*)oriLine7->Des().Ptr();

	TUint8* line8Ptr = (TUint8*)oriLine8->Des().Ptr();

	TUint8* line9Ptr = (TUint8*)oriLine9->Des().Ptr();

	TUint8* line10Ptr = (TUint8*)oriLine10->Des().Ptr();

	TUint8* linePtrs[11] = {line0Ptr, line1Ptr, line2Ptr, line3Ptr, line4Ptr,

							line5Ptr, line6Ptr, line7Ptr, line8Ptr, line9Ptr, line10Ptr};

	TUint8* tmpPtr;

	TUint8* tempPtr;

	// Set TPtr8s of input lines

	TPtr8 Ptr0(line0Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr1(line1Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr2(line2Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr3(line3Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr4(line4Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr5(line5Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr6(line6Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr7(line7Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr8(line8Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr9(line9Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptr10(line10Ptr, 3 * aOriSizeX, 3 * aOriSizeX);

	TPtr8 Ptrs[11] = {Ptr0, Ptr1, Ptr2, Ptr3, Ptr4, Ptr5, Ptr6, Ptr7, Ptr8, Ptr9, Ptr10};

	// Set indicator for order of input lines

	TInt lines[11] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

	// Allocate local temporal output line buffer and push its pointer to CleanupStack

	HBufC8* scanLine = HBufC8::NewMaxL(3 * aOutSizeX);

	CleanupStack::PushL(scanLine);

	// Set pointer of output line

	TUint8* DataPtr = (TUint8*)scanLine->Des().Ptr();

	// Set TPtr8 of output line

	TPtr8 linePtr(DataPtr, 3 * aOutSizeX, 3 * aOutSizeX);

	// Calculate step between output pixels in original image

	xStep = (TInt)(PIXEL / aZoomX + 0.5);

	yStep = (TInt)(PIXEL / aZoomY + 0.5);

	// Calculate First output pixel position in original image

	xPos = ((aOriSizeX - 1) << (PIX_BITS - 1)) - (((aOutSizeX - 1 - (allShiftX << 1)) * xStep) >> 1);

	yPos = ((aOriSizeY - 1) << (PIX_BITS - 1)) - (((aOutSizeY - 1 - (allShiftY << 1)) * yStep) >> 1);

	xFirstInt = (TInt32)(xPos >> PIX_BITS);

	if(xPos < 0) xFirstRem = (TUint32)((xPos + ((-xFirstInt) << PIX_BITS)) & REMAINDER);

	else		 xFirstRem = (TUint32)(xPos & REMAINDER);

	yFirstInt = (TInt32)(yPos >> PIX_BITS);

	if(yPos < 0) yFirstRem = (TUint32)((yPos + ((-yFirstInt) << PIX_BITS)) & REMAINDER);

	else		 yFirstRem = (TUint32)(yPos & REMAINDER);

	// Calculate averaging area around the original pixel position

	xAver = (TInt)(xStep >> 1);

	yAver = (TInt)(yStep >> 1);

	// For bilinear interpolation at least 1 pixel have to be used

	if(aZoomX > 1 && xAver < (TInt32)(HALF_PIX)) xAver = HALF_PIX;

	if(aZoomY > 1 && yAver < (TInt32)(HALF_PIX)) yAver = HALF_PIX;

	// Calculate maximum weight sum

	yMaxWei = (TUint32)(((yAver << 1) + HALF_DIF1) >> DIF1_BITS);

	xMaxWei = (TUint32)(((xAver << 1) + HALF_DIF1) >> DIF1_BITS);

	// Calculate filter divider for filter window

	divider = (TInt)((xMaxWei * yMaxWei + HALF_RED) >> RED_BITS);

	while(divider <= 256 && WEI_BITS < PIX_BITS)

	{

		WEI_BITS++;

		HALF_WEI  = (TUint32)(1 << (WEI_BITS - 1));

		DIF1_BITS = (TUint32)(PIX_BITS - WEI_BITS);

		HALF_DIF1 = (TUint32)(1 << (DIF1_BITS - 1));

		REM_HDIF1 = (TUint32)(HALF_DIF1 - 1);

		// Calculate maximum weight sum

		yMaxWei = (TUint32)(((yAver << 1) + HALF_DIF1) >> DIF1_BITS);

		xMaxWei = (TUint32)(((xAver << 1) + HALF_DIF1) >> DIF1_BITS);

		// Calculate filter divider for filter window

		divider = (TInt)((xMaxWei * yMaxWei + HALF_RED) >> RED_BITS);

	}

	if(divider > 1024)

	{

		WEI_BITS--;

		HALF_WEI  = (TUint32)(1 << (WEI_BITS - 1));

		DIF1_BITS = (TUint32)(PIX_BITS - WEI_BITS);

		HALF_DIF1 = (TUint32)(1 << (DIF1_BITS - 1));

		REM_HDIF1 = (TUint32)(HALF_DIF1 - 1);

		// Calculate maximum weight sum

		yMaxWei = (TUint32)(((yAver << 1) + HALF_DIF1) >> DIF1_BITS);

		xMaxWei = (TUint32)(((xAver << 1) + HALF_DIF1) >> DIF1_BITS);

		// Calculate filter divider for filter window

		divider = (TInt)((xMaxWei * yMaxWei + HALF_RED) >> RED_BITS);

	}

	while(divider <= 512 && RED_BITS > 0)

	{

		RED_BITS--;

		HALF_RED = (TUint32)(1 << (RED_BITS - 1));

		divider = (TInt)((xMaxWei * yMaxWei + HALF_RED) >> RED_BITS);

	}

	if(divider > 1024)

	{

		RED_BITS++;

		HALF_RED = (TUint32)(1 << (RED_BITS - 1));

	}

	// Initialise y loop limiters

	yLoopSta = 0;

	yLoopEnd = (TUint32)(aOutSizeY);

	// Initialise x loop limiters

	xLoopSta = 0;

	xLoopEnd = (TUint32)(aOutSizeX);

	// Calculate only the panned image

		if(newShiftY > 0)

		{

			// Update y loop start

			yLoopSta = (TUint32)(aOutSizeY - newShiftY);

			// Initialise y position

			yInt = yFirstInt;

			yRem = yFirstRem;

			// Copy available image and change y position

			for(y = 0; y < (TInt32)yLoopSta; y++)

			{

				// Read output line from source image

				aOriPtr->GetScanLine(Ptrs[lines[0]], TPoint(0, y+newShiftY), aOriSizeX, aOriPtr->DisplayMode());

				//Set the line to destination image

				aOutPtr->SetScanLine(linePtr, y);

				// Update y position

				tmpEnd = (TInt)(yRem + yStep);

				yInt = (TInt32)(yInt + (tmpEnd >> PIX_BITS));

				yRem = (TUint32)(tmpEnd & REMAINDER);

			}

			// Update y position of first pixel

			yFirstInt = yInt;

			yFirstRem = yRem;

		}

		else if(newShiftY < 0)

		{

			// Update y loop end

			yLoopEnd = (TUint32)(-newShiftY);

			// Copy available image

			for(y = (TInt32)(aOutSizeY - 1); y >= (TInt32)yLoopEnd; y--)

			{

				// Read output line from source image

				aOriPtr->GetScanLine(Ptrs[lines[0]], TPoint(0, y+newShiftY), aOriSizeX, aOriPtr->DisplayMode());

				//Set the line to destination image

				aOutPtr->SetScanLine(linePtr, y);

			}

		}

		// Calculate only the panned image

		if(newShiftX > 0)

		{

			// Update x loop start

			xLoopSta = (TUint32)(aOutSizeX - newShiftX);

			// Initialise x position

			xInt = xFirstInt;

			xRem = xFirstRem;

			// Change x position

			for(x = 0; x < (TInt32)xLoopSta; x++)

			{

				// Update x position

				tmpSta = (TInt)(xRem + xStep);

				xInt = (TInt32)(xInt + (tmpSta >> PIX_BITS));

				xRem = (TUint32)(tmpSta & REMAINDER);

			}

			// Update x position of first pixel

			xFirstInt = xInt;

			xFirstRem = xRem;

		}

		else if(newShiftX < 0)

		{

			// Update loop end

			xLoopEnd = (TUint32)(-newShiftX);

		}

		// Initialise y position

		yInt = yFirstInt;

		yRem = yFirstRem;

		tmpEnd = (TInt)(yRem + yAver + HALF_PIX + HALF_WEI);

		yEndInt = (TInt32)((tmpEnd >> PIX_BITS) + yInt);

		yEndRem = (TUint32)(tmpEnd & REMAINDER);