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

//

// EPOC includes

#include <e32base.h>

#include <imagedisplay.h>

#include <icl/imagedisplayplugin.h>

#include "TestHelperIface.h"

// Test system includes

#include <testframework.h>

#include <imageconversion.h>

#include "TestStepImageDisplay.h"

#include "TestSuiteImageDisplay.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <iclrecognizerutil.h>

#endif

// Heap size for these tests.

const TInt KHeapSize = 0x100000;

_LIT(KIclPanicCategory, "TS_ImageDisplay");

GLDEF_C void Panic(TS_ImageTransformPanic aError)

	{

	User::Panic(KIclPanicCategory, aError);

	}

/**

*

* CTestStepImageDisplay constructor 

*

* 

*/

CTestStepImageDisplay::CTestStepImageDisplay() 

:  iFs(), iImageDisplaySuite(NULL), iSourceFilename(), iScheduler(NULL)

	{

	}

/**

*

* CTestStepImageDisplay destructor

*

* 

*/

CTestStepImageDisplay::~CTestStepImageDisplay()

	{

	}

/**

* SetSuite is a set function

* @param  aPtr is a ptr to a CTestSuiteImageDisplay

*/

void CTestStepImageDisplay::SetSuite(CTestSuiteImageDisplay* aPtr)

	{

	iImageDisplaySuite = aPtr;

	}

/**

DoTestStepPreambleL is the preamble function for test steps

It creates an active scheduler and installs it. This is necessary

since we are multithreading and each test step runs in a separate thread.

@returns TVerdict which is either EPass or Efail

The function can leave if there is insufficient memeory

*/

TVerdict CTestStepImageDisplay::DoTestStepPreambleL()

	{

	//[ mark the heap and unmark at the end of postamble ]

	__MM_HEAP_MARK;

    User::LeaveIfError(FbsStartup());

    User::LeaveIfError( RFbsSession::Connect() );

	iScheduler = new(ELeave)CActiveScheduler;

    //[ push the scheduler on the stack ]

	CleanupStack::PushL( iScheduler );

	//[install the active scheduler ]

	CActiveScheduler::Install( iScheduler );

	// [Pop iScheduler ] 

	CleanupStack::Pop( iScheduler);

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

	return EPass;

	}

/**

The post amble step cleans up the allocated memory in the preamble

@returns TVerdict EPass or EFail

@leaves can leave due to insufficient memory

*/

TVerdict CTestStepImageDisplay::DoTestStepPostambleL()

	{

	Cleanup();

	iFs.Close();

	//[ Destroy the scheduler ]

	delete iScheduler ;

	iScheduler = NULL;

    // [ umark the heap which was marked in preamble ]

	__MM_HEAP_MARKEND;

	return EPass;

	}

/**

*

* CTestStepImageDisplay Suite accessor function

* @returns CTestSuiteImageDisplay*  

*/

CTestSuiteImageDisplay* CTestStepImageDisplay::Suite()

	{

	return iImageDisplaySuite;

	}

/**

*

* CTestStepImageDisplay SetTestFilename

* This method adds the filename to include the default path

* @param aPathNameAndExtn const TDesC&  afull file and path name

* @returns void

*/

void CTestStepImageDisplay::DefaultPath(TFileName& aName)

	{

	Suite()->DefaultPath(aName);

	}

void CTestStepImageDisplay::SetSourceFilename(const TDesC& aPathNameAndExtn)

	{

	//[ append the filename relative to the default path ]

	TFileName fileName;

	DefaultPath( fileName );

	fileName.Append(aPathNameAndExtn);

	iSourceFilename = fileName ;

	}

void CTestStepImageDisplay::SetDestFilenameL(const TDesC& aPathNameAndExtn)

	{

	//[ append the filename relative to the default path ]

	TFileName fileName;

	DefaultPath( fileName );

	_LIT(KOutputFolder, "output\\");

	fileName.Append(KOutputFolder);

	//create the output subfolder

	TInt err = iFs.MkDirAll(fileName);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		INFO_PRINTF2(_L("Unable to create output folder, err = %d"), err);

		User::Leave(err);

		}

	fileName.Append(aPathNameAndExtn);

	iDestFilename = fileName;

	}

// delete the destination file

void CTestStepImageDisplay::DeleteDestFilenameL()

	{

	TInt err = iFs.Delete(DestFilename());

	if (err != KErrNone && err != KErrNotFound)

		{

		INFO_PRINTF2(_L("Unable to delete output file, err = %d"), err);

		User::Leave(err);

		}

	}

void CTestStepImageDisplay::SetRefFilenameL(const TDesC& aPathNameAndExtn)

	{

	//[ append the filename relative to the default path ]

	TFileName fileName;

	DefaultPath( fileName );

	_LIT(KRefFolder, "ref\\");

	fileName.Append(KRefFolder);

	fileName.Append(aPathNameAndExtn);

	iRefFilename = fileName ;

	}

/**

*

* CTestStepImageDisplay SourceFilename

*

* 

* 

*/

TFileName& CTestStepImageDisplay::SourceFilename() 

	{

	return  iSourceFilename;

	}

/**

*

* CTestStepImageDisplay DestFilename

*

* 

* 

*/

TFileName& CTestStepImageDisplay::DestFilename() 

	{

	return  iDestFilename;

	}

/**

*

* CTestStepImageDisplay RefFilename

*

* 

* 

*/

TFileName& CTestStepImageDisplay::RefFilename() 

	{

	return  iRefFilename;

	}

/**

 *

 * Compare two bitmap files

 *

 * @param "const TDesC& aFile1"

 *		  The first file to compare

 * @param "const TDesC& aFile2"

 *		  The second file to compare

 * @leave "" 

 *		  Will leave with appropriate system codes if a problem is encountered reading either file 	

 * @return "TVerdict"

 *		  EPass if the files are identical

 *		  EFail otherwise

 * @xxxx

 *

 */

TVerdict CTestStepImageDisplay::CompareFilesL(const TDesC& aFile1,const TDesC& aFile2) 

	{

	CFbsBitmap* refBitmap=new (ELeave) CFbsBitmap();

   	CleanupStack::PushL(refBitmap);

   	User::LeaveIfError( refBitmap->Load(aFile1, 0) );

   	TVerdict result=CompareBitmapWithFileL(*refBitmap, aFile2);

	if (result != EPass)

		{

		INFO_PRINTF3(_L("Files do not match %S %S"), &aFile1, &aFile2);

		}

	CleanupStack::PopAndDestroy(refBitmap);

	return result;

	}

TVerdict CTestStepImageDisplay::CompareBitmapWithFileL(const CFbsBitmap& aBitmap,const TDesC& aFile) const

   {

   CFbsBitmap* refBitmap=new (ELeave) CFbsBitmap();

   CleanupStack::PushL(refBitmap);

   User::LeaveIfError( refBitmap->Load(aFile, 0) );

   if (aBitmap.DisplayMode() != refBitmap->DisplayMode() || aBitmap.SizeInPixels() != refBitmap->SizeInPixels())

		{

		CleanupStack::PopAndDestroy(refBitmap);

		return EFail;

		}

	const TInt srcScanlineLen=CFbsBitmap::ScanLineLength(refBitmap->SizeInPixels().iWidth, refBitmap->DisplayMode());

	HBufC8* srcScanline = HBufC8::NewMaxLC(srcScanlineLen);

	TPtr8 src(srcScanline->Des());

	HBufC8* refScanline = HBufC8::NewMaxLC(srcScanlineLen);

	TPtr8 ref(refScanline->Des());   

	const TUint8* pSrc=src.Ptr();

	const TUint8* pRef=ref.Ptr();

	TVerdict result = EPass;

	for (TInt y=aBitmap.SizeInPixels().iHeight; y; --y)

		{

		const TPoint pnt(0,y-1);

		aBitmap.GetScanLine(src,pnt,srcScanlineLen, aBitmap.DisplayMode());

		refBitmap->GetScanLine(ref,pnt,srcScanlineLen, aBitmap.DisplayMode());   

		if (Mem::Compare(pSrc,src.Length(), pRef, src.Length()) !=0)

		 	{

		 	result = EFail;

		 	break;

		 	}

		}

   CleanupStack::PopAndDestroy(3,refBitmap); 

   return result;

   }

/**

*

* Test step constructor.

* Each test step initialises its own name.

*

*/

CTestStepImgDisplayGeneric::CTestStepImgDisplayGeneric(const TImageDisplayUnitTestParams& aTestParams) :

	iTestParams(&aTestParams),

	iCurrentUId(aTestParams.iUniqueId)

	{

	// Store the name of this test case

	iTestStepName = iTestParams->iTestName;

	// Increase the heap size for this test

	iHeapSize = KHeapSize;

	}

/**

*

* Test step destructor.

* 

*/

CTestStepImgDisplayGeneric::~CTestStepImgDisplayGeneric()

	{

	}

void CTestStepImgDisplayGeneric::Cleanup()

	{

	delete iImageDisplay; iImageDisplay= NULL;

	iFileHandle.Close();

	delete iSourceBuf; iSourceBuf = NULL;

	if (iFbsConnection)

		RFbsSession::Disconnect();

	iFbsConnection = EFalse;

	}

/**

 *

 * Do the test step.

 * transform from file to file

 * @return	"TVerdict" the status of the test

 *			 The result of the test step 

 */

TVerdict CTestStepImgDisplayGeneric::DoTestStepL()

	{

	INFO_PRINTF2(_L("%S"), &iTestStepName);

	INFO_PRINTF2(_L("%s"), iTestParams->iTestDescription);

	TVerdict verdict = EFail;

	if (iTestParams->iTestType == TImageDisplayUnitTestParams::EAlloc)

		{

		INFO_PRINTF1(_L("Alloc test"));

		TInt i;

		TInt err;

		for (i = 1 ; ; i++)

			{

			__MM_HEAP_MARK;

			if (i % 5 == 0)

				INFO_PRINTF2(_L("Fail count = %d"), i);

			__UHEAP_SETFAIL(RHeap::EFailNext, i);

			TRAP(err, verdict = DoTestStepFbsL());

			TAny* testAlloc = User::Alloc(1);

			TBool heapTestingComplete = (testAlloc == NULL);

			User::Free(testAlloc);

			Cleanup();

			__UHEAP_RESET;

			__MM_HEAP_MARKEND;

			if ((err != KErrNoMemory) || heapTestingComplete)

				{

				INFO_PRINTF4(_L("err = %d, verdict = %d, Fail count = %d"), err, verdict, i);

				INFO_PRINTF1(_L("Alloc testing completed successfully"));

				break;

				}

			}

		}

	else

		{

		verdict = DoTestStepFbsL();

		}

	return verdict;

	}

TVerdict CTestStepImgDisplayGeneric::DoTestStepFbsL()

	{

	// [ connect to the bitmap server and check the error code]

    User::LeaveIfError(FbsStartup());

	User::LeaveIfError(RFbsSession::Connect());

	iFbsConnection = ETrue;

	TVerdict verdict = TestL();

	return verdict;

	}

void CTestStepImgDisplayGeneric::SetImageSourceL()

	{

	ASSERT(iImageDisplay);

	SetSourceFilename(TPtrC(iTestParams->iInputFilename));

	TPtrC uniqueId(ContentAccess::KDefaultContentObject);

	if (iCurrentUId && *iCurrentUId)

		{

		uniqueId.Set(TPtrC(*iCurrentUId));

		}      

	switch (iTestParams->iSourceType)

		{

		case TImageDisplayUnitTestParams::ETypeFileName:

			{

			if (iTestParams->iUniqueId==NULL && iTestParams->iIntent==TImageDisplayUnitTestParams::KNoIntent)

				{

				iImageDisplay->SetImageSource(TMMFileSource(SourceFilename()));

				}

			else if (iTestParams->iIntent==TImageDisplayUnitTestParams::KNoIntent)

				{

				iImageDisplay->SetImageSource(TMMFileSource(SourceFilename(), uniqueId));

				}

			else

				{

				iImageDisplay->SetImageSource(TMMFileSource(SourceFilename(), uniqueId, iTestParams->iIntent));

				}      			

			}

			break;

		case TImageDisplayUnitTestParams::ETypeFileHandle:

			{

			iFileHandle.Close();

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

			User::LeaveIfError( iFileHandle.Open(iFs, SourceFilename(), EFileRead | EFileShareExclusive) );

			if (iTestParams->iUniqueId==NULL && iTestParams->iIntent==TImageDisplayUnitTestParams::KNoIntent)

				{

				iImageDisplay->SetImageSource(TMMFileHandleSource(iFileHandle));

				}

			else if (iTestParams->iIntent==TImageDisplayUnitTestParams::KNoIntent)

				{

				iImageDisplay->SetImageSource(TMMFileHandleSource(iFileHandle, uniqueId));

				}

			else

				{

				iImageDisplay->SetImageSource(TMMFileHandleSource(iFileHandle, uniqueId, iTestParams->iIntent));

				}      			

			}

			break;

		case TImageDisplayUnitTestParams::ETypeData:

			{

			User::LeaveIfError( iFileHandle.Open(iFs, SourceFilename(), EFileRead | EFileShareReadersOnly) );

			TInt length;

			User::LeaveIfError( iFileHandle.Size(length) );

			delete iSourceBuf; iSourceBuf = NULL;

			iSourceBuf = HBufC8::NewL(length);

			TPtr8 buf(iSourceBuf->Des());

			User::LeaveIfError( iFileHandle.Read(buf) );

			iFileHandle.Close();

			iImageDisplay->SetImageSource(TDescriptorDataSource(*iSourceBuf));

			}

			break;

		default:

			ASSERT(FALSE);

		}

	}

TBool CTestStepImgDisplayGeneric::ConsumeFrame(const CFbsBitmap* /*aBitmap*/)

	{

	++iFrameNumber;

	return ETrue;

	}

void CTestStepImgDisplayGeneric::MiidoImageReady(const CFbsBitmap* aBitmap, TUint aStatus, const TRect& /*aUpdatedArea*/, TInt aError)

	{

	INFO_PRINTF3(_L("ImgReadCb Status=%d Error=%d"), aStatus, aError);

	iLastError 			= aError;

	iLatestPlugintStatus= aStatus;

	if (KErrNone != iLastError || (aStatus & CImageDisplayPlugin::EStatusNoMoreToDecode))

		{

		CActiveScheduler::Stop();

		}

	else if (aStatus & CImageDisplayPlugin::EStatusFrameReady)

		{

		TBool ContinueDecoding=ConsumeFrame(aBitmap);

		if (ContinueDecoding && iLastError == KErrNone)

			{

			iImageDisplay->Play();

			}

		else

			{

			CActiveScheduler::Stop();	

			}

		}

	}

/**

 *

 * Do the test step.

 * transform from file to file

 * @return	"TVerdict" the status of the test

 *			 The result of the test step 

 */