/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Ixonos Plc

*

* Description: 

*

*/

//----IMAAMI----

//*************************************************************************

//

//Version 1.00

//

//Contains:

//	CDisplayChain 

//		Image processing class implementing

//		display specific image processing:

//			- Scaling to display size with pan support

//			- IETD - display specific color contrast enhancement

//			- Sharpening 

//			- Display feature compensation by simple color management

//			- Dithering 

//			

//History:

//	30.10.2003 version 1.00 created using existing IMAAMI algorithms	

//*************************************************************************

#include <fbs.h>

#include "DisplayChain.h"

/*

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

  Constructor

  Default constructor, initializes member variables to initial values

  Return Values:  none

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

*/

CDisplayChain::CDisplayChain()

{

	// This function is intentionally left blank.

}

/*

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

  NewLC

  Factory function to instantiate the class.

  This function leaves the class pointer to the cleanup stack

  May leave with KErrNoMemory if no memory available

  Return Values:  CDisplayChain* self:  pointer to the class instance

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

*/

CDisplayChain* CDisplayChain::NewLC()

{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

/*

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

  CDCIetd

  NewL

  Factory function to instantiate the class.

  May leave with KErrNoMemory if no memory available

  Return Values:  CDisplayChain* self:  pointer to the class instance

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

*/

CDisplayChain* CDisplayChain::NewL()

{

	CDisplayChain* self = CDisplayChain::NewLC();

	CleanupStack::Pop();

	return self;

}

/*

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

  CDCIetd

  ConstructL

  Second phase constructor. Does nothing at the moment

  Return Values:  none

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

*/

void CDisplayChain::ConstructL()

{

	// Create objects for ImaamiImageChain

	DigitalZoomPtr = CDCDigitalZoom::NewL();

	CleanupStack::PushL(DigitalZoomPtr);

	SharpeningPtr = DCSharpening::NewL();

	CleanupStack::PushL(SharpeningPtr);

	DitheringPtr = CDCDithering::NewL();

	CleanupStack::PushL(DitheringPtr);

	IetdPtr = CDCIetd::NewL();

	CleanupStack::PushL(IetdPtr);

	ColorManagementPtr = CDCColorManagement::NewL();

	CleanupStack::PushL(ColorManagementPtr);

	TInt i; //Index

	//As default image is just opened to be processed

	Parameters.FirstOpening = ETrue;

	//Get current processing parameters from processing objects

	DigitalZoomPtr->GetParameters(&Parameters.DZParameters);

	IetdPtr->GetParams(&Parameters.IETDParameters);

	SharpeningPtr->GetParameters(&Parameters.SharpeningParameters);

	ColorManagementPtr->GetParameters(&Parameters.ColorManagementParameters);

	//Here the parameters can be read for example from a text file or from the registers, etc.

	//if (!ReadFileL())

	{			

		//Set default parameter values

		//(Defined in DCInit.h)

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

		//Set each processing ON/OFF

		Parameters.DigitalZoomON = DZ;

		Parameters.DitheringON = DITHER;

		Parameters.ColorManagementON = ETrue; //CM;

		Parameters.IetdON = IETD;

		Parameters.SharpeningON = SHARP;

		//DigitalZoom

		DigitalZoomPtr->GetParameters(&Parameters.DZParameters);

		Parameters.DZParameters.sizeX = DZsizeX;

		Parameters.DZParameters.sizeY = DZsizeY;

		Parameters.DZParameters.scaleX = DZscaleX;

		Parameters.DZParameters.scaleY = DZscaleY;

		Parameters.DZParameters.allShiftX = DZallX;

		Parameters.DZParameters.allShiftY = DZallY;

		Parameters.DZParameters.newShiftX = DZnewX;

		Parameters.DZParameters.newShiftY = DZnewY;

		//IETD

		Parameters.IETDParameters.aStretchLimit = StretchLimit;

		Parameters.IETDParameters.aBlackPixels = BlackPixels;

		Parameters.IETDParameters.aWhitePixels = WhitePixels;

		Parameters.IETDParameters.aSaturationGain = SaturationGain;

		Parameters.IETDParameters.aBitLimit = BitLimit;

		Parameters.IETDParameters.aWBC = WBC;

		Parameters.IETDParameters.aDBC = DBC;

		//Sharpening

		Parameters.SharpeningParameters.SHARP_GAIN = SharpGain;

		Parameters.SharpeningParameters.SHARP_DZONE = SharpDZone;

		Parameters.SharpeningParameters.SHARP_OVER = SharpOver;

		//Color Management (fill LUTs and matrix)

		for(i=0;i<256;i++)

		{

			Parameters.ColorManagementParameters.GammaR[i] = CMGammaR[i];

		}

		for(i=0;i<256;i++)

		{

			Parameters.ColorManagementParameters.GammaG[i] = CMGammaG[i];

		}

		for(i=0;i<256;i++)

		{

			Parameters.ColorManagementParameters.GammaB[i] = CMGammaB[i];

		}

		for(i=0;i<256;i++)

		{

			Parameters.ColorManagementParameters.TRCR[i] = CMTRCR[i];

		}

		for(i=0;i<256;i++)

		{

			Parameters.ColorManagementParameters.TRCG[i] = CMTRCG[i];

		}

		for(i=0;i<256;i++)

		{

			Parameters.ColorManagementParameters.TRCB[i] = CMTRCB[i];

		}

		for(i=0;i<9;i++)

		{

			Parameters.ColorManagementParameters.Matrix[i] = CMMatrix[i];

		}

	}

	//Set the default parameters

	IetdPtr->SetParams(&Parameters.IETDParameters);

	SharpeningPtr->SetParameters(&Parameters.SharpeningParameters);

	ColorManagementPtr->SetParameters(&Parameters.ColorManagementParameters);

	CleanupStack::Pop(5); //Processing objects

}

/*

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

  CDCIetd

  Destructor

  Deletes the allocated memory

  Return Values:  none

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

*/

CDisplayChain::~CDisplayChain()

{

	//Delete processing objects

	delete DigitalZoomPtr;

	delete SharpeningPtr;

	delete DitheringPtr;

	delete IetdPtr;

	delete ColorManagementPtr;

}

/*

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

  ProcessL

  Process image referenced by InBitmap (modify aTargetBitmap).

  If scaling is not used aTargetBitmap is processed directly.

  May leave with KErrNoMemory if no memory available

  Return Values:  none

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

*/

void CDisplayChain::ProcessL(const CFbsBitmap* InBitmap, CFbsBitmap* aTargetBitmap)

{

	//CHECK! pan check needed only when DZ is ON

	//Scaling

	if (Parameters.DigitalZoomON)

	{

		// refine the zooming parameters based on input data

		TSize inSize = InBitmap->SizeInPixels();

		TSize outSize = aTargetBitmap->SizeInPixels();

		Parameters.DZParameters.sizeX = outSize.iWidth;

		Parameters.DZParameters.sizeY = outSize.iHeight;

		Parameters.DZParameters.scaleX = (TReal)outSize.iWidth/(TReal)inSize.iWidth;

		Parameters.DZParameters.scaleY = (TReal)outSize.iHeight/(TReal)inSize.iHeight;

		//If the image is tried to pan over the image borders, bound to the borders

		if (Parameters.DZParameters.allShiftX < (-InBitmap->SizeInPixels().iWidth/2 * Parameters.DZParameters.scaleX + aTargetBitmap->SizeInPixels().iWidth/2))

		{

			Parameters.DZParameters.allShiftX = (TInt)((-InBitmap->SizeInPixels().iWidth/2)*Parameters.DZParameters.scaleX + aTargetBitmap->SizeInPixels().iWidth/2);

		}

		if (Parameters.DZParameters.allShiftX > (InBitmap->SizeInPixels().iWidth/2 * Parameters.DZParameters.scaleX - aTargetBitmap->SizeInPixels().iWidth/2))

		{

			Parameters.DZParameters.allShiftX = (TInt)((InBitmap->SizeInPixels().iWidth/2)*Parameters.DZParameters.scaleX - aTargetBitmap->SizeInPixels().iWidth/2);

		}

		if (Parameters.DZParameters.allShiftY < (-InBitmap->SizeInPixels().iHeight/2 * Parameters.DZParameters.scaleY + aTargetBitmap->SizeInPixels().iHeight/2))

		{

			Parameters.DZParameters.allShiftY = (TInt)((-InBitmap->SizeInPixels().iHeight/2)*Parameters.DZParameters.scaleY + aTargetBitmap->SizeInPixels().iHeight/2);

		}

		if (Parameters.DZParameters.allShiftY > (InBitmap->SizeInPixels().iHeight/2 * Parameters.DZParameters.scaleY - aTargetBitmap->SizeInPixels().iHeight/2))

		{

			Parameters.DZParameters.allShiftY = (TInt)((InBitmap->SizeInPixels().iHeight/2)*Parameters.DZParameters.scaleY - aTargetBitmap->SizeInPixels().iHeight/2);

		}

		DigitalZoomPtr->SetParameters(&Parameters.DZParameters);

		DigitalZoomPtr->ProcessL(InBitmap, aTargetBitmap);

	}

	//IETD 

	if (Parameters.IetdON)

	{

 		if (Parameters.FirstOpening)

		{

			IetdPtr->Analyze(*aTargetBitmap);

			Parameters.FirstOpening = EFalse;

		}

		//Set parameters is needed if default values can change (read from file etc.)

		//IetdPtr->SetParams(&Parameters.IETDParameters);

		IetdPtr->ProcessL(*aTargetBitmap);

	}

	//Sharpening

	if (Parameters.SharpeningON)

	{

		//Set parameters is needed if default values can change (read from file etc.)

		//SharpeningPtr->SetParameters(&Parameters.SharpeningParameters);

		SharpeningPtr->ProcessL(aTargetBitmap);

	}

	//ColorManagement

	if (Parameters.ColorManagementON)

	{

		//Set parameters is needed if default values can change (read from file etc.)

		//ColorManagementPtr->SetParameters(&Parameters.ColorManagementParameters);

		ColorManagementPtr->ProcessL(aTargetBitmap);

	}

	//Dithering

	if (Parameters.DitheringON)

	{

		DitheringPtr->ProcessL(*aTargetBitmap);

	}

}

/*

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

  SetParams

  Set processing parameters

  Return Values:  none

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

*/

void CDisplayChain::SetParameters(DisplayChainParams* params)

{

	//Copy parameter struct

	Parameters = *params;

}

/*

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

  GetParams

  Get current processing parameters

  Return Values:  none

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

*/

void CDisplayChain::GetParameters(DisplayChainParams* params)

{

	//Copy parameter struct

	*params = Parameters;

}

/*

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

  ReadFileL

  Example function for reading processing parameters from file

  Return Values:  none

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

TBool CDisplayChain::ReadFileL()

{

	FILE *fp;

	TInt i,j,data;

	TUint8 data_uchar;

	TReal data_real;

	// Open for read (will fail if file does not exist) 

	if((fp = fopen("e:\\DisplayChain.txt","r"))==NULL )

	{

		if((fp = fopen("c:\\DisplayChain.txt","r"))==NULL )

		{

			//AfxMessageBox("CMData.txt was not opened");

			return EFalse;

		}

	}

	//Digital Zoom

	fscanf(fp,"%d",&data);

	Parameters.DigitalZoomON = data;

	//Ietd

	fscanf(fp,"%d",&data);

	Parameters.IetdON = data;

	fscanf(fp,"%d",&data_uchar);

	Parameters.IETDParameters.aWhitePixels = data_uchar;

	fscanf(fp,"%d",&data_uchar);

	Parameters.IETDParameters.aBlackPixels = data_uchar;

	fscanf(fp,"%d",&data_uchar);

	Parameters.IETDParameters.aStretchLimit = data_uchar;

	fscanf(fp,"%d",&data_uchar);

	Parameters.IETDParameters.aSaturationGain = data_uchar;

	fscanf(fp,"%d",&data_uchar);

	Parameters.IETDParameters.aBitLimit = data_uchar;

	fscanf(fp,"%d",&data_uchar);

	Parameters.IETDParameters.aWBC = data_uchar;

	fscanf(fp,"%d",&data_uchar);

	Parameters.IETDParameters.aDBC = data_uchar;

	//Sharpening

	fscanf(fp,"%d",&data);

	Parameters.SharpeningON = data;

	fscanf(fp,"%d",&data);

	Parameters.SharpeningParameters.SHARP_OVER = data;

	fscanf(fp,"%d",&data);

	Parameters.SharpeningParameters.SHARP_DZONE = data;

	//fscanf(fp,"%f",&data_real);

	fscanf(fp,"%d",&data);

	data_real = ((TReal)data)/65536;

	Parameters.SharpeningParameters.SHARP_GAIN = data_real;

	//Dithering

	fscanf(fp,"%d",&data);

	Parameters.DitheringON = data;

	//ColorManagement

	fscanf(fp,"%d",&data);

	Parameters.ColorManagementON = data;

	for(i=0;i<256;i++)

	{

		fscanf(fp,"%d",&data);

		Parameters.ColorManagementParameters.GammaR[i]=data;

	}

	for(i=0;i<256;i++)

	{

		fscanf(fp,"%d",&data);

		Parameters.ColorManagementParameters.GammaG[i]=data;

	}

	for(i=0;i<256;i++)

	{

		fscanf(fp,"%d",&data);

		Parameters.ColorManagementParameters.GammaB[i]=data;

	}

	for(i=0;i<256;i++)

	{

		fscanf(fp,"%d",&data);

		Parameters.ColorManagementParameters.TRCR[i]=data;

	}

	for(i=0;i<256;i++)

	{

		fscanf(fp,"%d",&data);

		Parameters.ColorManagementParameters.TRCG[i]=data;

	}

	for(i=0;i<256;i++)

	{

		fscanf(fp,"%d",&data);

		Parameters.ColorManagementParameters.TRCB[i]=data;

	}

	for(i=0;i<3;i++)

	{

		for(j=0;j<3;j++)

		{

			fscanf(fp,"%d",&data);

			Parameters.ColorManagementParameters.Matrix [3*i+j]=data;

		}

	}

	// Close stream 

	fclose(fp);

	return ETrue;	

}

*/