/*

* 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:  

*

*/

//	INCLUDES

#include <bautils.h>

#include <eikenv.h>

#include <aknutils.h>

#include <e32math.h>

//#include "ImageEditorPluginBase.hrh"

#include "platform_security_literals.hrh"

#include "ImageEditorEngineWrapper.h"

#include "CFilterStack.h"

#include "MImageFilter.h"

#include "SystemParameters.h"

#include "ImageEditorError.h"

#include "ImageEditorUtils.h"

#include "EditorVersion.h"

#include "CExifParser.h"

#include "TBitmapHandle.h"

#include "MJpegSave.h"

#include "JpegSaveFactory.h"

//  Debug logger definitions

#include "imageeditordebugutils.h"

_LIT( KEngineWrapperLogFile,"EngineWrapper.log" );

// CONSTANTS

// 	Minimum source image x-y value that the engine is able to render

const TInt KObMinSourceDimension    		= 16; 

//	EXIF thumbnail quality

const TInt KThumbnailJpegQuality    		= 60; 		// [0,100]

const TInt KThumbnailMaxDimension			= 160;

//  Used fixed point resolution for scales

const TInt KScaleBits						= 12;

const TReal KZoomScaleFactor                 = 0.5; 

// Comment tag to be written to the EXIF data of JPEG file.

_LIT8( KImageEditorExifComment, "Edited with Nokia Image Editor %d.%d.%d" );

// 	Filter paths

_LIT(KFilterJpegSource, "FilterJpegSource.dll");

_LIT(KFilterIclSource, "FilterIclSource.dll");

_LIT(KFilterTarget, "FilterJpegTarget.dll");

_LIT(KFilterBuffer, "FilterBuffer.dll");

_LIT(KFilterScale, 	"FilterScale.dll");

_LIT(KFilterRotate, "FilterRotate.dll");

//=============================================================================

EXPORT_C CEngineWrapper * CEngineWrapper::NewL ()

{

    LOG_INIT ( KEngineWrapperLogFile );

	CEngineWrapper * self = new (ELeave) CEngineWrapper;

	CleanupStack::PushL (self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

}

//=============================================================================

EXPORT_C CEngineWrapper::~CEngineWrapper ()

{

    LOG( KEngineWrapperLogFile, "CEngineWrapper::~CEngineWrapper");

    Cleanup();

	delete iExifParser;

	iExifParser = NULL;

}

//=============================================================================

EXPORT_C void CEngineWrapper::CreateJpegSourceL (const TDesC & aFileName)

{

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL" );

#ifdef VERBOSE

    LOGFMT( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL\taFileName: %S", &aFileName );

#endif // VERBOSE

    //  SANITY CHECKS

    if ( !iMainEngine )

    {

        LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL: iMainEngine not created!" );

        User::Panic (KEnginePanic, KEnginePanicAllocation);

    }

	//	Add JPEG source to engine

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL --- Add jpeg source" );

	if ( iMainEngine->NumFilters() == 0 )

	{

		iMainEngine->AddFilterL ( KFilterJpegSource );

	}

	else if  ( IsSameString ( (TUint8*)iMainEngine->Filter(0)->Type(), (TUint8*)"iclsource" ) )

	{

		iMainEngine->RemoveFilter (0);

		iMainEngine->AddFilterL (KFilterJpegSource, 0);

	}

	else if  ( !IsSameString ( (TUint8*)iMainEngine->Filter(0)->Type(), (TUint8*)"jpegsource" ) )

	{

		iMainEngine->AddFilterL (KFilterJpegSource, 0);

	}

	iCmd.Copy ( _L("file \""));

	iCmd.Append ( aFileName );

	iCmd.Append ( _L("\""));

	LOGFMT ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL: Cmd: %S", &aFileName );

	iMainEngine->FunctionL ( 0, iCmd );

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL --- Jpeg source added" );

	iMainEngine->FunctionL ( 0, _L("loadimage"));

	//	Get source image size

	TRect rect = iMainEngine->Filter (0)->Rect(); 

	iSourceSize = iMainEngine->Filter (0)->ViewPortSize(); 

	LOGFMT ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL: source width: %d", iSourceSize.iWidth);

	LOGFMT ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL: source height: %d", iSourceSize.iHeight);

    //  Check that the source image is of minimum size

    if (iSourceSize.iWidth < KObMinSourceDimension || iSourceSize.iHeight < KObMinSourceDimension)

    {

        User::Leave (KSIEEOpenFile);

    }

	//	Initialize crop parameters

	iBoundingRect.iTl.iX = 0;    

	iBoundingRect.iTl.iY = 0;    

	iBoundingRect.iBr.iX = iSourceSize.iWidth;    

	iBoundingRect.iBr.iY = iSourceSize.iHeight;    

    iScale = 1.0;

    iMaxScale = 1.0;

    iMinScale = (TReal)iScreenSize.iWidth / iSourceSize.iWidth; 

    iPanX = iSourceSize.iWidth * 0.5;

    iPanY = iSourceSize.iHeight * 0.5;

    iPanStep = 128.0;

    iZoomMode = EZoomNormal;

	//	Initialize system parameters

    iSysPars->SourceSize() = iSourceSize;

    iSysPars->Scale() = 1.0;

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL ---  Read EXIF data" );

	//	Read EXIF data pointer

	iCmd.Copy ( _L("exifdata"));

	TUint8 * exifptr = (TUint8 *)iMainEngine->FunctionL ( 0, iCmd );

	//	Read EXIF data length

	iCmd.Copy ( _L("exiflength"));

	TInt exiflen = (TInt)iMainEngine->FunctionL ( 0, iCmd );

	//	Create and initialize EXIF parser

	TPtrC8 exifdata (exifptr, exiflen);

	if (iExifParser)

	{

		delete iExifParser;

		iExifParser = NULL;		

	}

	iExifParser = CExifParser::NewL ();

	TRAPD( err, iExifParser->ParseL (exifdata) );

	if (KErrNone == err)

	{

		LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL --- EXIF data read." );

	}

	else

	{

		LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL --- FAILED to parse EXIF data. Ignored." );

	}

}

//=============================================================================

EXPORT_C void CEngineWrapper::CreateJpegTargetL (

	const TDesC & aFileName,

    const TInt      aQuality,

    const TSize *   aSize 

    )

{

    LOG( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL" );

#ifdef VERBOSE

    LOGFMT( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL\taFileName: %S", &aFileName );

    LOGFMT( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL\taQuality: %d", aQuality );

    if (aSize)

    {

        LOGFMT( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL\taSize->iWidth: %d", aSize->iWidth);

        LOGFMT( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL\taSize->iHeight: %d", aSize->iHeight);

    }

    else

    {

		LOG( KEngineWrapperLogFile, "aSize == NULL" );

    }

#endif // VERBOSE

    //  SANITY CHECKS

    if ( !iMainEngine )

    {

        LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL: iMainEngine not created!" );

        User::Panic (KEnginePanic, KEnginePanicAllocation);

    }

    if ( aQuality < 0 || aQuality > 100)

    {

        LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL: Invalid parameter aQuality!" );

        User::Panic (KEnginePanic, KEnginePanicParameter);

    }

    if ( aSize && ( (aSize->iWidth < 0 || aSize->iHeight < 0) ) )

    {

        LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL: Invalid parameter aSize!" );

        User::Panic (KEnginePanic, KEnginePanicParameter);

    }

	//	Remove source buffer

	iMainEngine->FunctionL (0, _L("fileoutput"));

	//	Remove screen buffer

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL --- Remove screen buffer" );

	if ( IsSameString ( (TUint8*)iMainEngine->Filter(iMainEngine->NumFilters() - 1)->Type(), (TUint8*)"buffer" ) )

	{

		iMainEngine->RemoveFilter(iMainEngine->NumFilters() - 1);	

	}

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL --- Screen buffer removed" );

	//	Remove jpeg target buffer

	if ( IsSameString ( (TUint8*)iMainEngine->Filter(iMainEngine->NumFilters() - 1)->Type(), (TUint8*)"jpegtarget" ) )

	{

		iMainEngine->RemoveFilter(iMainEngine->NumFilters() - 1);	

	}

	//	Remove scale buffer, if image is not scaled

	if ( iSysPars->Scale() == 1.0 )

	{

		LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL --- Remove screen scale filter." );

		if ( IsSameString ( (TUint8*)iMainEngine->Filter(iMainEngine->NumFilters() - 1)->Type(), (TUint8*)"scale" ) )

		{

			iMainEngine->RemoveFilter(iMainEngine->NumFilters() - 1);	

		}

		LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL --- Screen scale filter removed." );

	}

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL --- Add jpeg target filter." );

	iMainEngine->AddFilterL ( KFilterTarget );

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegTargetL --- Jpeg target filter added." );

	//	If external target size is given, set it to target.

	if ( aSize )

	{

		iCmd.Format( _L("width %d height %d"), aSize->iWidth, aSize->iHeight );

		iMainEngine->FunctionL ( iMainEngine->NumFilters() - 1, iCmd );

	}

	//	Set the scaled source size to target

	if ( iSysPars->Scale() != 1.0 )

	{

		TReal scale = iSysPars->Scale();

		TSize tgtsize = iMainEngine->Filter ( iMainEngine->NumFilters() - 3 )->ViewPortSize();

		tgtsize.iWidth = (TInt)(tgtsize.iWidth * scale + 0.5);

		tgtsize.iHeight = (TInt)(tgtsize.iHeight * scale + 0.5);

		iCmd.Format( _L("width %d height %d"), tgtsize.iWidth, tgtsize.iHeight);

		iMainEngine->FunctionL ( iMainEngine->NumFilters() - 1, iCmd );

		iMainEngine->FunctionL ( iMainEngine->NumFilters() - 2, _L("nop"));

	}

	//	Store save file name

	iTargetFile.Copy ( aFileName );

    LOG ( KEngineWrapperLogFile, "CreateJpegTargetL: Sink created" );

}

//=============================================================================

EXPORT_C void CEngineWrapper::CreateIclSourceL (const TDesC & aFileName)

{

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateIclSourceL" );

#ifdef VERBOSE

    LOGFMT( KEngineWrapperLogFile, "CEngineWrapper::CreateIclSourceL\taFileName: %S", &aFileName );

#endif // VERBOSE

    //  SANITY CHECKS

    if ( !iMainEngine )

    {

        LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateIclSourceL: iMainEngine not created!" );

        User::Panic (KEnginePanic, KEnginePanicAllocation);

    }

	//	Add JPEG source to engine

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateIclSourceL --- Add icl source" );

	if ( iMainEngine->NumFilters() == 0 )

	{

		iMainEngine->AddFilterL ( KFilterIclSource );

	}

	else if  ( IsSameString ( (TUint8*)iMainEngine->Filter(0)->Type(), (TUint8*)"jpegsource" ) )

	{

		iMainEngine->RemoveFilter(0);

		iMainEngine->AddFilterL ( KFilterIclSource, 0);

	}

	else if  ( !IsSameString ( (TUint8*)iMainEngine->Filter(0)->Type(), (TUint8*)"iclsource" ) )

	{

		iMainEngine->AddFilterL ( KFilterIclSource, 0);

	}

	iCmd.Copy (_L("file \""));

	iCmd.Append ( aFileName );

	iCmd.Append (_L("\""));

	LOGFMT ( KEngineWrapperLogFile, "CEngineWrapper::CreateIclSourceL: Cmd: %S", &iCmd );

	iMainEngine->FunctionL ( 0, iCmd );

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateIclSourceL --- Icl source added" );

	iMainEngine->FunctionL ( 0, _L("loadimage"));

	//	Get source image size

	TRect rect = iMainEngine->Filter (0)->Rect(); 

	iSourceSize = iMainEngine->Filter (0)->ViewPortSize(); 

	LOGFMT ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL: source width: %d", iSourceSize.iWidth);

	LOGFMT ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL: source height: %d", iSourceSize.iHeight);

    //  Check that the source image is of minimum size

    if (iSourceSize.iWidth < KObMinSourceDimension || iSourceSize.iHeight < KObMinSourceDimension)

    {

        User::Leave (KSIEEOpenFile);

    }

	//	Initialize crop parameters

    iScale = 1.0;

    iMaxScale = 1.0;

    iMinScale = (TReal)iScreenSize.iWidth / iSourceSize.iWidth; 

    iPanX = iSourceSize.iWidth * 0.5;

    iPanY = iSourceSize.iHeight * 0.5;

    iPanStep = 128.0;

    iZoomMode = EZoomNormal;

	//	Initialize system parameters

    iSysPars->SourceSize() = iSourceSize;

    iSysPars->Scale() = 1.0;

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateIclSourceL ---  Create EXIF parser" );

	if (iExifParser)

	{

		delete iExifParser;

		iExifParser = NULL;		

	}

	iExifParser = CExifParser::NewL ();

	LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateJpegSourceL --- EXIF parser created." );

}

//=============================================================================

EXPORT_C void CEngineWrapper::CreateRGB888TargetL ()

{

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateRGB888TargetL " );

    //  SANITY CHECKS

    if ( !iMainEngine )

    {

        LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateRGB888TargetL: iMainEngine not created!" );

        User::Panic (KEnginePanic, KEnginePanicAllocation);

    }

#ifdef VERBOSE

    LOGFMT( KEngineWrapperLogFile, "\tiScreenSize.w: %d", iScreenSize.iWidth);

    LOGFMT( KEngineWrapperLogFile, "\tiScreenSize.h: %d", iScreenSize.iHeight);

#endif

	//	Create source buffer

	iMainEngine->FunctionL (0, _L("bufferoutput"));

	//	Remove target filter and add screen buffer

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateRGB888TargetL --- Add buffer target." );

    TInt n = iMainEngine->NumFilters();

	if ( IsSameString ( (TUint8*)iMainEngine->Filter(n - 1)->Type(), (TUint8*)"jpegtarget") ) 

	{

		iMainEngine->RemoveFilter(n - 1);	

		iMainEngine->AddFilterL ( KFilterBuffer );

	}

	else if ( !IsSameString ( (TUint8*)iMainEngine->Filter(n - 1)->Type(), (TUint8*)"buffer" ) )

	{

		iMainEngine->AddFilterL ( KFilterBuffer );

	}

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateRGB888TargetL --- Buffer target added." );

	//	Set buffer size

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateRGB888TargetL --- Set buffer size ");

	iCmd.Format( _L("width %d height %d"), iScreenSize.iWidth, iScreenSize.iHeight );

	LOGDES (KEngineWrapperLogFile, iCmd);

	iMainEngine->FunctionL ( iMainEngine->NumFilters() - 1, iCmd );

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateRGB888TargetL --- Buffer size set." );

	//	Set scale buffer before screen buffer

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateRGB888TargetL --- Add screen buffer scale filter");

	if ( !IsSameString ( (TUint8*)iMainEngine->Filter(iMainEngine->NumFilters() - 2)->Type(), (TUint8*)"scale") ) 

	{

		iMainEngine->AddFilterL ( KFilterScale, iMainEngine->NumFilters() - 1);

	}

	iMainEngine->FunctionL ( iMainEngine->NumFilters() - 2, iCmd );

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateRGB888TargetL --- Screen buffer scale filter added.");

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::CreateRGB888TargetL: Sink created" );

}

//=============================================================================

EXPORT_C void CEngineWrapper::SetScreenSizeL (const TSize & aSize)

{

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::SetScreenSizeL" );

#ifdef VERBOSE

    LOGFMT( KEngineWrapperLogFile, "CEngineWrapper::SetScreenSizeL\taSize.iWidth: %d", aSize.iWidth );

    LOGFMT( KEngineWrapperLogFile, "CEngineWrapper::SetScreenSizeL\taSize.iHeight: %d", aSize.iHeight );

#endif // VERBOSE

    //  SANITY CHECKS

    if ( aSize.iWidth < 0 || aSize.iHeight < 0)

    {

        LOG ( KEngineWrapperLogFile, "CEngineWrapper::SetScreenSizeL: Invalid parameter aSize!" );

        User::Panic (KEnginePanic, KEnginePanicParameter);

    }

	if ( aSize != iScreenSize )

	{

		iScreenSize = aSize;

		//	Set buffer size

		TInt n = iMainEngine->NumFilters();

		if (n > 2)

		{

			if ( IsSameString ((TUint8*)iMainEngine->Filter(n - 1)->Type(), (TUint8*) "buffer" ) )

			{

				iCmd.Format( _L("width %d height %d"), iScreenSize.iWidth, iScreenSize.iHeight);

				iMainEngine->FunctionL ( n - 1, iCmd );

				iMainEngine->FunctionL ( n - 2, _L("nop"));

				UpdateCropRectL();

			}

		}

	}

}

//=============================================================================

EXPORT_C void CEngineWrapper::AddFilterL (const TDesC & aFilterName) 

{

    LOGFMT( KEngineWrapperLogFile, "CEngineWrapper::AddFilterL (TDes & aFilterName: %S)", &aFilterName );

    //  SANITY CHECKS

    if ( !iMainEngine )

    {

        LOG ( KEngineWrapperLogFile, "CEngineWrapper::AddFilterL: iMainEngine not created!" );

        User::Panic (KEnginePanic, KEnginePanicAllocation);

    }

	//  Check whether the filter is found

	TFileName filtername;

	filtername.Copy (aFilterName);

    /*

    // no need for this as AddFilterL will leave if there is an error

    if (FileExists (filtername) )

    {

           TParse parse;

           User::LeaveIfError( parse.Set( aFilterName ,NULL, NULL ) );

           filtername = parse.NameAndExt();

    };

    */

	TInt n = iMainEngine->NumFilters();

	if (n >= 2)

	{

		iMainEngine->AddFilterL ( filtername, n - 2 );

	}

    LOG ( KEngineWrapperLogFile, "CEngineWrapper::AddFilterL: Filter added" );

}

//=============================================================================

EXPORT_C void CEngineWrapper::SetParamsL (const TDesC & aParam)

{

    LOG( KEngineWrapperLogFile, "CEngineWrapper::SetParamsL " );

    //  SANITY CHECKS

    if ( !iMainEngine )

    {

        LOG ( KEngineWrapperLogFile, "CEngineWrapper::SetParamsL: iMainEngine not created!" );

        User::Panic (KEnginePanic, KEnginePanicAllocation);

    }

    //  Initialize error value

	TInt n = iMainEngine->NumFilters();

	if ( n > 2 )

	{

    	LOGDES( KEngineWrapperLogFile, aParam );

		iMainEngine->FunctionL ( n - 3, aParam );

	}

	if ( IsSameString ( (TUint8*)iMainEngine->Filter(n - 3)->Type(), (TUint8*) "rotate" ) )

	{

		if (iScale == 1.0)

		{

			ComputeBoundingRectL();	

		}

		UpdateCropRectL();

	}