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

// TS_MM_ICL_FRM_CP.cpp

// This file contains the test steps ICL testing

// 

//

// EPOC includes

#include <e32base.h>

#include <caf/caf.h>

// Test system includes

#include <testframework.h>

// Specific includes for this test suite

#include "TestSuite_TSI_ICL_FRM_00.h"

// Specific includes for these test steps

#include "TestStepConversion.h"

#include "ICLFbsSessionTest.h"

// use classes in the CAF namespace directly

using namespace ContentAccess;

const TUid KImageTypeTestUid = {0x101f7bf7};

const TUid KImageSubTypeTestUid = {0x101f7bf8};

const TInt	KDefaultQualityFactor = 50;		//JPEG

const TInt	KDefaultSampling		= 3;	//JPEG

/* 

 *

 * Open and decoder image from file, then compare

 * with reference bitmap

 *

 * @param		"const TDesC& aFilename"

 *				destination file

 *				

 * @return		"TInt"

 *				Error	

 */

TInt	CTestStepConversion::OpenImageForDecodeFromFileL(const TDesC& aFilename, 

														 TUid aCodecUid)

	{

	TInt theRes = KErrNone; 

	TFileName theSourceFilename;

	Directory(EInput, theSourceFilename);

	theSourceFilename.Append(aFilename);

	User::LeaveIfError(iFs.Connect());

	INFO_PRINTF2(_L("Openning the file : %S"), &theSourceFilename);

	CImageDecoder *theImageDecoder = NULL;

	if(aCodecUid.iUid == 0)

		{

		TRAP(theRes, theImageDecoder=CImageDecoder::FileNewL(iFs, theSourceFilename));

		}

	else

		{

		TRAP(theRes, theImageDecoder=CImageDecoder::FileNewL(iFs, theSourceFilename, CImageDecoder::EOptionNone, aCodecUid));

		}

	if(theRes != KErrNone)

		{

		iFs.Close();

		INFO_PRINTF2(_L("Cannot open file %S"), &theSourceFilename);

		return theRes;

		}

	if(theImageDecoder == NULL)

			return KErrUnknown;

	CleanupStack::PushL(theImageDecoder);

	INFO_PRINTF2(_L("The file : %S had been opened"), &theSourceFilename);

		//[ Create an active Listener and push it on the cleanup stack]

	CActiveListener* activeListener = new(ELeave)CActiveListener;

	CleanupStack::PushL( activeListener );

	CFbsBitmap* theDestination = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(theDestination);

	const TFrameInfo*	theFrameInfo = &theImageDecoder -> FrameInfo();

	// >>>>>>>>>  WMF ONLY  <<<<<<<<<<<<<<<<

	// Instead of using the Frame info width and height (in pixels) we use fixed values

	// that we know are the correct values for the reference raster bitmap

	// which is used for comparison.

	// This is because the WMF is a vector image and its exact pixel size depends

	// on the screen device characteristics, i.e. the Twips to Pixel ratio.

	// In other words, different Dots Per Inch (DPI) screens will produce different

	// pixel size image from the same WMF file.

	// known target bitmap size in pixels. Size of the reference bitmap used for comparison.

	// this is the pixel frame size in wins platform, and it's different to the arm4 equivalent.

	// if iImageTypeUid == KImageTypeWMFUid and the particular test

	if (iTestStepName.Compare(_L("MM-ICL-FRM-I-0009-CP")) == 0)

		{

		TSize fixedPixelSize(465, 454);

		User::LeaveIfError(theDestination->Create(fixedPixelSize,

							theFrameInfo->iFrameDisplayMode ));//EColor256));//

		}

	else

		{

		User::LeaveIfError(theDestination->Create(theFrameInfo->iOverallSizeInPixels,

							theFrameInfo->iFrameDisplayMode ));//EColor256));//

		}

	activeListener ->InitialiseActiveListener();

	theImageDecoder->Convert(& activeListener -> iStatus, *theDestination, 0);

	CActiveScheduler::Start();

	theRes = activeListener -> iStatus.Int();

	if(theRes == KErrNone)

		INFO_PRINTF2(_L("Conversion of file %S was successfull"), &theSourceFilename);

	else

		INFO_PRINTF2(_L("Fail during conversion the file : %S"), &theSourceFilename);

	TFileName				theReferenceFilename;

	TBuf<KLenBufferExtension>		theExtension;

	Directory(EReference, theReferenceFilename);

	TInt theSeparatorPos = aFilename.LocateReverse('.') + 1;

	theReferenceFilename.Append(aFilename.Left(theSeparatorPos));

	GetImageExtension(KImageTypeMBMUid, theExtension);

	theReferenceFilename.Append(theExtension);

	if(theRes == KErrNone)

		theRes = CheckBitmapL(*theDestination, theReferenceFilename);

	iFs.Close();

	theDestination->Reset();	  

	CleanupStack::PopAndDestroy(3,theImageDecoder);  // theDestination,CActiveListener, CImageDecoder

	return theRes;

	}

/* 

 *

 * Open and decode image from file

 *

 * @param		"const TDesC& aFilename"

 *				destination file

 *				

 * @return		"TInt"

 *				Error	

 */

TInt	CTestStepConversion::OpenPpmImageForDecodeFromFileL(const TDesC& aFilename, 

														 TUid aCodecUid,

														 const TUid aPpmDecodeUid)

	{

	TInt theRes = KErrNone; 

	TFileName theSourceFilename;

	Directory(EInput, theSourceFilename);

	theSourceFilename.Append(aFilename);

	User::LeaveIfError(iFs.Connect());

	INFO_PRINTF2(_L("Openning the file : %S"), &theSourceFilename);

	CImageDecoder *theImageDecoder = NULL;

	if((aCodecUid.iUid == 0)&&(aPpmDecodeUid.iUid == 0))

		{

		TRAP(theRes, theImageDecoder=CImageDecoder::FileNewL(iFs, theSourceFilename));

		}

	else

		{

		TRAP(theRes, theImageDecoder=CImageDecoder::FileNewL(iFs, theSourceFilename, CImageDecoder::EOptionNone, aCodecUid, KNullUid, aPpmDecodeUid));

		}

	if(theRes != KErrNone)

		{

		iFs.Close();

		INFO_PRINTF2(_L("Cannot open file %S"), &theSourceFilename);

		return theRes;

		}

	if(theImageDecoder == NULL)

			return KErrUnknown;

	CleanupStack::PushL(theImageDecoder);

	INFO_PRINTF2(_L("The file : %S had been opened"), &theSourceFilename);

		//[ Create an active Listener and push it on the cleanup stack]

	CActiveListener* activeListener = new(ELeave)CActiveListener;

	CleanupStack::PushL( activeListener );

	CFbsBitmap* theDestination = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(theDestination);

	const TFrameInfo*	theFrameInfo = &theImageDecoder -> FrameInfo();

	User::LeaveIfError(theDestination->Create(theFrameInfo->iOverallSizeInPixels,

							theFrameInfo->iFrameDisplayMode ));//EColor256));//

	activeListener ->InitialiseActiveListener();

	theImageDecoder->Convert(& activeListener -> iStatus, *theDestination, 0);

	CActiveScheduler::Start();

	theRes = activeListener -> iStatus.Int();

	if(theRes == KErrNone)

		{

		INFO_PRINTF2(_L("Conversion of file %S was successfull"), &theSourceFilename);

		}

	else

		{

		INFO_PRINTF2(_L("Fail during conversion the file : %S"), &theSourceFilename);

		}

	iFs.Close();

	theDestination->Reset();	  

	CleanupStack::PopAndDestroy(3,theImageDecoder);  // theDestination,CActiveListener, CImageDecoder

	return theRes;

	}

void CTestStepConversion::OpenImageForDecodeFromFileWithIntentL(const TDesC& aFilename, 

																	TIntent aIntent, 

																	const TDesC8& aMimeType)

	{

	TInt err = KErrNone; 

	TFileName theSourceFilename;

	Directory(EInput, theSourceFilename);

	theSourceFilename.Append(aFilename);

	User::LeaveIfError(iFs.Connect());

	INFO_PRINTF2(_L("Openning the file : %S"), &theSourceFilename);

	CImageDecoder *theImageDecoder = NULL;

	if(aMimeType != KNullDesC8)

		{

		TRAP(err, theImageDecoder=CImageDecoder::FileNewL(iFs, theSourceFilename, aMimeType, aIntent));

		}

	else

		{

		TRAP(err, theImageDecoder=CImageDecoder::FileNewL(iFs, theSourceFilename, aIntent));

		}

	if(err != KErrNone)

		{

		iFs.Close();

		INFO_PRINTF2(_L("Cannot open file %S"), &theSourceFilename);

		User::Leave(err);

		}

	if(theImageDecoder == NULL)

		User::Leave(KErrUnknown);

	CleanupStack::PushL(theImageDecoder);

	INFO_PRINTF2(_L("The file : %S had been opened"), &theSourceFilename);

		//[ Create an active Listener and push it on the cleanup stack]

	CActiveListener* activeListener = new(ELeave)CActiveListener;

	CleanupStack::PushL( activeListener );

	CFbsBitmap* theDestination = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(theDestination);

	const TFrameInfo*	theFrameInfo = &theImageDecoder -> FrameInfo();

	User::LeaveIfError(theDestination->Create(theFrameInfo->iOverallSizeInPixels,

						theFrameInfo->iFrameDisplayMode ));

	activeListener ->InitialiseActiveListener();

	theImageDecoder->Convert(& activeListener -> iStatus, *theDestination, 0);

	CActiveScheduler::Start();

	err = activeListener -> iStatus.Int();

	if(err == KErrNone)

		INFO_PRINTF2(_L("Conversion of file %S was successfull"), &theSourceFilename);

	else

		INFO_PRINTF2(_L("Fail during conversion the file : %S"), &theSourceFilename);

	TFileName theReferenceFilename;

	TBuf<KLenBufferExtension> theExtension;

	Directory(EReference, theReferenceFilename);

	TInt theSeparatorPos = aFilename.LocateReverse('.') + 1;

	theReferenceFilename.Append(aFilename.Left(theSeparatorPos));

	GetImageExtension(KImageTypeMBMUid, theExtension);

	theReferenceFilename.Append(theExtension);

	if(err == KErrNone)

		err = CheckBitmapL(*theDestination, theReferenceFilename);

	iFs.Close();

	theDestination->Reset();

	CleanupStack::PopAndDestroy(3,theImageDecoder);  // theDestination,CActiveListener, CImageDecoder

	User::LeaveIfError(err);

	}

void CTestStepConversion::OpenImageForDecodeFromFileWithIntentL(const TDesC& aFilename, 

																	TIntent aIntent, 

																TUid aImageTypeUid,

																TUid aDecoderUid)

	{

	TInt err = KErrNone; 

	TFileName theSourceFilename;

	Directory(EInput, theSourceFilename);

	theSourceFilename.Append(aFilename);

	User::LeaveIfError(iFs.Connect());

	INFO_PRINTF2(_L("Openning the file : %S"), &theSourceFilename);

	CImageDecoder *theImageDecoder = NULL;

	TRAP(err, theImageDecoder=CImageDecoder::FileNewL(iFs, theSourceFilename, aIntent, CImageDecoder::EOptionNone, aImageTypeUid, KNullUid, aDecoderUid));

	if(err != KErrNone)

		{

		iFs.Close();

		INFO_PRINTF2(_L("Cannot open file %S"), &theSourceFilename);

		User::Leave(err);

		}

	if(theImageDecoder == NULL)

		User::Leave(KErrUnknown);

	CleanupStack::PushL(theImageDecoder);

	INFO_PRINTF2(_L("The file : %S had been opened"), &theSourceFilename);

		//[ Create an active Listener and push it on the cleanup stack]

	CActiveListener* activeListener = new(ELeave)CActiveListener;

	CleanupStack::PushL( activeListener );

	CFbsBitmap* theDestination = new(ELeave) CFbsBitmap;

	CleanupStack::PushL(theDestination);

	const TFrameInfo*	theFrameInfo = &theImageDecoder -> FrameInfo();

	User::LeaveIfError(theDestination->Create(theFrameInfo->iOverallSizeInPixels,

						theFrameInfo->iFrameDisplayMode ));

	activeListener ->InitialiseActiveListener();

	theImageDecoder->Convert(& activeListener -> iStatus, *theDestination, 0);

	CActiveScheduler::Start();

	err = activeListener -> iStatus.Int();

	if(err == KErrNone)

		INFO_PRINTF2(_L("Conversion of file %S was successfull"), &theSourceFilename);

	else

		INFO_PRINTF2(_L("Fail during conversion the file : %S"), &theSourceFilename);

	TFileName theReferenceFilename;

	TBuf<KLenBufferExtension> theExtension;

	Directory(EReference, theReferenceFilename);

	TInt theSeparatorPos = aFilename.LocateReverse('.') + 1;

	theReferenceFilename.Append(aFilename.Left(theSeparatorPos));

	GetImageExtension(KImageTypeMBMUid, theExtension);

	theReferenceFilename.Append(theExtension);

	if(err == KErrNone)

		err = CheckBitmapL(*theDestination, theReferenceFilename);

	iFs.Close();

	theDestination->Reset();

		  //Active Listiner

	CleanupStack::PopAndDestroy(3,theImageDecoder);  // theDestination,CActiveListener, CImageDecoder

	User::LeaveIfError(err);

	}

/* 

 *

 * get size of step to increment

 *

 * @param		"TInt aValue"

 *				wanted buffer size

 *				

 * @return		"TInt"

 *				step	

 */

inline TInt CTestStepConversion::StreamIncrement(TInt aValue)

	{

	return (aValue<KStreamBreakpoint)?KStreamInitialIncrement:KStreamSecondaryIncrement;

	}

/* 

 *

 * Read and decode an image incrementally then compare with reference

 *

 * @param		"const TDesC& aFileName"

 *				"TInt aStepBeforeCancel"

 *				request cancel of load/decode from the client app before completion

 *				(only if aStepBeforeCancel > 0 )

 *

 * @return		"TInt"

 *				error	

 */

TInt CTestStepConversion::ReadAndDecodeIncrementallyL(const TDesC& aFileName, TInt aStepBeforeCancel)

	{

	TInt aFrameNo = 0;

	TInt	theRes;

	User::LeaveIfError(iFs.Connect());

	TFileName		sourceFileName;

	Directory(EInput, sourceFileName);

	sourceFileName.Append(aFileName);

	theRes = iFile.Open(iFs, sourceFileName, EFileShareReadersOnly|EFileStream|EFileRead);

	if(theRes != KErrNone)

		{

		iFs.Close();

		INFO_PRINTF2(_L("Cannot open file : %S"), &sourceFileName);

		return theRes;

		}

	else

		{

		INFO_PRINTF2(_L("File %S was opened successfully"), &sourceFileName);

		}

	CleanupClosePushL(iFile);

	TInt fileSize = 0;

	User::LeaveIfError(iFile.Size(fileSize));

	TPtr8 buffer(STATIC_CAST(TUint8*, User::AllocLC(1024)), 0, 1024);

	RFile destFile;

	TFileName		destFileName;

	Directory(EOutput, destFileName);

	destFileName.Append(aFileName);

	TInt  destFileLength = 0;

	theRes = destFile.Create(iFs, destFileName, EFileShareAny|EFileStream|EFileWrite);

	//theRes = destFile.Create(iFs, destFileName, EFileShareAny);

	if(theRes == KErrAlreadyExists)

		User::LeaveIfError(theRes = destFile.Replace(iFs, destFileName, EFileShareAny|EFileStream|EFileWrite));

	else if(theRes)

		{

		INFO_PRINTF2(_L("Cannot create destination file %S"), &destFileName);

		User::LeaveIfError(theRes);

		}

	CleanupClosePushL(destFile);

	INFO_PRINTF2(_L("Destination file %S was created successfully"), &destFileName);

	TInt wantedBufferSize=1;

	User::LeaveIfError(iFile.Read(buffer, wantedBufferSize));

	ASSERT(buffer.Length()==wantedBufferSize); // should always work on emulator

	User::LeaveIfError(destFile.Write(buffer));

	destFileLength += wantedBufferSize;

	CImageDecoder *theImageDecoder = NULL;

	// gradually increment buffer size until we can open the decoder

	for (;;)

		{

		TRAPD(error, theImageDecoder = CImageDecoder::FileNewL(iFs, destFileName, 

								CImageDecoder::EOptionNone));//, 

		if (error==KErrNone)

			break;

		if (error!=KErrUnderflow || wantedBufferSize>=fileSize)

			{

			INFO_PRINTF2(_L("Cannot create image decoder for file %S"), &destFileName);

			if(KErrAccessDenied == error)

				INFO_PRINTF1(_L("Access denied"));

			User::Leave(error);

			}

		TInt increment = StreamIncrement(wantedBufferSize); 

		wantedBufferSize = Min(fileSize, wantedBufferSize+increment);

		TInt extra = wantedBufferSize - destFileLength;

		ASSERT(extra>0);

		User::LeaveIfError(iFile.Read(buffer, extra));

		ASSERT(buffer.Length()==extra); // should always work on emulator

		User::LeaveIfError(destFile.Write(buffer));

		destFileLength += extra;

		}

	CleanupStack::PushL(theImageDecoder);

	// gradually increment buffer size until we get info about the given frame

	while (theImageDecoder->IsImageHeaderProcessingComplete() == (TBool)EFalse && 

		wantedBufferSize<fileSize)

		{

		TInt increment = StreamIncrement(wantedBufferSize); 

		wantedBufferSize = Min(fileSize, wantedBufferSize+increment);

		TInt extra = wantedBufferSize - destFileLength;

		ASSERT(extra>0);

		User::LeaveIfError(iFile.Read(buffer, extra));

		ASSERT(buffer.Length()==extra); // should always work on emulator

		User::LeaveIfError(destFile.Write(buffer));

		destFileLength += extra;

		theImageDecoder->ContinueProcessingHeaderL();

		}

	// resize the bitmap - since we now know the size

	TFrameInfo frameInfo(theImageDecoder->FrameInfo());