--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imaging/imaginginttest/src/TestStepConversion.cpp	Wed Aug 25 12:29:52 2010 +0300
@@ -0,0 +1,2315 @@
+// 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());
+	TSize frameSize(frameInfo.iFrameCoordsInPixels.Width(),
+			frameInfo.iFrameCoordsInPixels.Height());
+	
+	CFbsBitmap*	theBitmap = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL( theBitmap );
+	User::LeaveIfError(theBitmap->Create(frameSize, frameInfo.iFrameDisplayMode)); 
+
+	// the conversion itself
+	TBool first = ETrue;
+	CActiveListener* activeListener = new(ELeave)CActiveListener;
+	CleanupStack::PushL( activeListener );
+	if(aStepBeforeCancel > 0)
+		iActiveScheduler->SetDecoder(theImageDecoder, activeListener, aStepBeforeCancel);
+	for(;;)
+		{
+		activeListener->InitialiseActiveListener();
+		if (first)
+			theImageDecoder->Convert(&activeListener->iStatus,*theBitmap,aFrameNo);
+		else
+			theImageDecoder->ContinueConvert(&activeListener->iStatus);
+
+		first = EFalse;
+
+		CActiveScheduler::Start();
+		TInt error = activeListener->iStatus.Int();
+		if (error==KErrNone)
+			break;
+		
+		if(error == KErrCancel)
+			{
+			//The incremental load was canceled at the client before completion
+			theRes = KErrCancel;
+			break;
+			}
+		if (error!=KErrUnderflow || wantedBufferSize>=fileSize)
+			User::Leave(error);
+		TInt increment = StreamIncrement(wantedBufferSize); 
+		wantedBufferSize = Min(fileSize, wantedBufferSize+increment);
+		TInt extra = wantedBufferSize - destFileLength;
+		
+		ASSERT(extra>0);
+		
+		if(iFile.SubSessionHandle())
+			User::LeaveIfError(iFile.Read(buffer, extra));
+		
+		ASSERT(buffer.Length()==extra); // should always work on emulator
+		
+		if(destFile.SubSessionHandle())
+			{
+			User::LeaveIfError(destFile.Write(buffer));
+			destFileLength += extra;
+			}
+		}
+	
+	TFileName	refFileName;
+	TBuf<KLenBufferExtension>		imageExtension;
+	Directory(EReference, refFileName);
+	refFileName.Append(aFileName.Left(aFileName.Length()-3));
+	GetImageExtension(KImageTypeMBMUid, imageExtension);
+	refFileName.Append(imageExtension);
+	
+	if(theRes == KErrNone && aStepBeforeCancel == 0)
+		theRes = CheckBitmapL(*theBitmap, refFileName);
+	
+	theBitmap->Reset();
+	CleanupStack::PopAndDestroy(6); // theImageDecoder, destFile, buffer, file, theBitmap, activeListener
+
+	iFs.Close();
+	
+	return theRes;
+	}
+
+
+/* 
+ *
+ * Read and decode image from buffer
+ *
+ * @param		"const TDesC& aFileName"
+ *				"TUid aUid"
+ *				using for negative test
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::OpenImageForDecodeFromBufferL(const TDesC& aFilename, TUid aUid)
+	{
+
+	TInt theRes = KErrNone;
+
+	TFileName theSourceFilename;
+	Directory(EInput, theSourceFilename);
+	theSourceFilename.Append(aFilename);
+
+	User::LeaveIfError(iFs.Connect());
+	
+	TInt fileSize = 0;
+
+	theRes = iFile.Open(iFs, theSourceFilename, EFileRead);
+
+	if(theRes == KErrNone)
+		iFile.Size(fileSize);
+	// if aFilename.Length() == 0 - we try negative test "Request data where no frame is loaded
+	else if(aFilename.Length() != 0)
+		{
+		INFO_PRINTF2(_L("Cannot open source file %S"), &theSourceFilename);
+		return theRes;
+		}
+
+	HBufC8 *theImageFromFile = HBufC8::NewMaxLC(fileSize);
+	
+	TPtr8 imageFromFilePtr = theImageFromFile->Des();
+	if(iFile.SubSessionHandle())
+		iFile.Read(imageFromFilePtr);
+	iFile.Close();
+	
+	CImageDecoder* theImageDecoder = NULL;
+	
+	if(aUid.iUid == 0)
+		{
+		TRAP(theRes, theImageDecoder = CImageDecoder::DataNewL(iFs, imageFromFilePtr));
+		}
+	else
+		{//for negative testing
+		TRAP(theRes, theImageDecoder = CImageDecoder::DataNewL(iFs, imageFromFilePtr, CImageDecoder::EOptionNone, KImageTypeWMFUid));
+		}
+	
+	iFs.Close();
+	
+	if(theRes != KErrNone)
+		{
+		CleanupStack::PopAndDestroy(theImageFromFile);
+		
+		INFO_PRINTF1(_L("Cannot create image decoder from file's pointer"));
+		return theRes;
+		}
+		
+	if(theImageDecoder == NULL)
+		{
+		CleanupStack::PopAndDestroy(theImageFromFile);
+		return KErrUnknown;
+		}
+		
+	CleanupStack::PushL(theImageDecoder);	
+
+	CFbsBitmap* theDestination = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(theDestination);
+		
+	const TFrameInfo*	theFrameInfo = &theImageDecoder-> FrameInfo();
+	User::LeaveIfError(theDestination->Create(theFrameInfo->iOverallSizeInPixels, 
+							theFrameInfo->iFrameDisplayMode ));
+		// Create an active Listener and push it on the cleanup stack
+	CActiveListener* activeListener = new(ELeave)CActiveListener;
+	CleanupStack::PushL( activeListener );
+	activeListener->InitialiseActiveListener();
+
+	theImageDecoder->Convert(& activeListener -> iStatus, *theDestination);
+	CActiveScheduler::Start();
+	theRes = activeListener -> iStatus.Int();
+	if(theRes == KErrNone)
+		{
+		INFO_PRINTF2(_L("File %S was converted successfully"), &theSourceFilename);
+		}
+	else
+		{
+		INFO_PRINTF2(_L("Fail during conversion file %S"), &theSourceFilename);
+		}
+
+	TFileName				theReferenceFilename;
+	TBuf<KLenBufferExtension>		theExtension;
+
+	Directory(EReference, theReferenceFilename);
+	theReferenceFilename.Append(aFilename.Left(aFilename.Length()-3));
+	GetImageExtension(KImageTypeMBMUid, theExtension);
+	theReferenceFilename.Append(theExtension);
+
+	if(theRes == KErrNone)
+		theRes = CheckBitmapL(*theDestination, theReferenceFilename);
+				
+	theDestination->Reset();	  
+	CleanupStack::PopAndDestroy(4,theImageFromFile); // CActiveListener, theDestination, theImageDecoder, theImageFromFile
+	return theRes;
+	}
+
+/* 
+	Read and decode a given frame from an image buffer with a specific codec (Uid) and decode options
+	@param const TDesC&	aFileName	The file to be read into a data buffer (for use in CImageDecoder::DataNewL())
+	@param TInt	aFrameNumber		The frame to be decoded (0 is the first frame).
+	@param TUid	aUid				The Uid of the codec to be used for the decode.
+	@param CImageDecoder::TOptions aOptions	Any decoder options (EOptionNone is the default).
+ */
+void CTestStepConversion::OpenBufferedImageL(const TDesC& aFilename, TInt aFrameNumber, TUid aUid, const CImageDecoder::TOptions aOptions)
+	{
+	TInt err = KErrNone;
+
+	TFileName theSourceFilename;
+	Directory(EInput, theSourceFilename);
+	theSourceFilename.Append(aFilename);
+
+	User::LeaveIfError(iFs.Connect());
+	
+	TInt fileSize = 0;
+
+	err = iFile.Open(iFs, theSourceFilename, EFileRead);
+
+	if(err == KErrNone)
+		{
+		iFile.Size(fileSize);
+		}
+	else
+		{
+		INFO_PRINTF2(_L("Cannot open source file %S"), &theSourceFilename);
+		User::Leave(err);
+		}
+
+	HBufC8* theImageFromFile = HBufC8::NewMaxLC(fileSize);
+		
+	TPtr8 imageFromFilePtr = theImageFromFile->Des();
+	if(iFile.SubSessionHandle())
+		{
+		iFile.Read(imageFromFilePtr);
+		}
+	iFile.Close();
+	
+	CImageDecoder* theImageDecoder = NULL;
+	
+	TRAP(err, theImageDecoder = CImageDecoder::DataNewL(iFs, imageFromFilePtr, aOptions, KNullUid, KNullUid, aUid));
+	
+	iFs.Close();
+	
+	if(err != KErrNone)
+		{
+		INFO_PRINTF1(_L("Cannot create image decoder from file's pointer"));
+		User::Leave(err);
+		}
+	
+	CleanupStack::PushL(theImageDecoder);
+	
+	if(aFrameNumber >= theImageDecoder->FrameCount())
+		{
+		INFO_PRINTF1(_L("Requested to decode unavailable image frame."));
+		User::Leave(KErrArgument);
+		}
+
+	CFbsBitmap* theDestination = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(theDestination);
+
+	const TFrameInfo* theFrameInfo = &theImageDecoder->FrameInfo(aFrameNumber);
+	User::LeaveIfError(theDestination->Create(theFrameInfo->iOverallSizeInPixels,
+						theFrameInfo->iFrameDisplayMode));
+	
+	// Create an active Listener and push it on the cleanup stack
+	CActiveListener* activeListener = new(ELeave)CActiveListener;
+	CleanupStack::PushL(activeListener);
+	activeListener->InitialiseActiveListener();
+	theImageDecoder->Convert(&activeListener->iStatus, *theDestination, aFrameNumber);
+	
+	CActiveScheduler::Start();
+	
+	err = activeListener->iStatus.Int();
+	if(err == KErrNone)
+		{
+		INFO_PRINTF3(_L("Frame %d of file %S was converted successfully"), aFrameNumber, &theSourceFilename);
+		}
+	else
+		{
+		INFO_PRINTF3(_L("Fail during conversion of frame %d of file %S"), aFrameNumber, &theSourceFilename);
+		User::Leave(err);
+		}
+
+	TFileName theReferenceFilename;
+	TBuf<KLenBufferExtension> theExtension;
+
+	Directory(EReference, theReferenceFilename);
+	TInt theSeparatorPos = aFilename.LocateReverse('.') + 1;
+	theReferenceFilename.Append(aFilename.Left(theSeparatorPos));
+	GetImageExtension(KImageTypeMBMUid, theExtension);
+	theReferenceFilename.Append(theExtension);
+
+//  Uncomment to save the decoded bitmap	
+//	User::LeaveIfError(theDestination->Save(theReferenceFilename));
+	
+	if(err == KErrNone)
+		{
+		TInt err1 = KErrNone;
+		TRAP(err, err1 = CheckBitmapL(*theDestination, theReferenceFilename));
+		if(err != KErrNone || err1 != KErrNone)
+			{
+			INFO_PRINTF1(_L("Bitmap check failed"));
+			User::Leave(KErrGeneral);
+			}
+		}
+	
+	theDestination->Reset();	  
+	CleanupStack::PopAndDestroy(4, theImageFromFile); // CActiveListener, theDestination, theImageDecoder, theImageFromFile
+	}
+
+
+/* 
+ *
+ * Read and encode image from file to memory
+ *
+ * @param		"const TDesC& aFileName"
+ *				"TUid		aTypeImage"
+ *				codec Uid 
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::EncodeImageToMemoryL(const TDesC& aFilename, 
+												   TUid		aTypeImage)
+	{
+	TInt	theRes = KErrNone;
+	CICLFbsSessionTest* fbsSession = CICLFbsSessionTest::NewLC();
+
+	TFileName	theSourceFileName;
+	Directory( EReference, theSourceFileName);
+	theSourceFileName.Append(aFilename);
+
+	CFbsBitmap	*theBitmap = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(theBitmap);
+	theRes = theBitmap->Load(theSourceFileName);
+	
+	if(theRes == KErrNone)
+		theRes = EncodeImageFromBitmapToMemoryL(aFilename, 
+												    theBitmap,
+													aTypeImage);
+	else
+		INFO_PRINTF2(_L("File : %S not found"), &theSourceFileName);
+
+	CleanupStack::PopAndDestroy(2, fbsSession);
+
+	return theRes;
+	}
+
+
+/* 
+ *
+ * Read and encode image from bitmap to memory
+ *
+ * @param		"const TDesC& aFileName"
+ *				"CFbsBitmap	*theBitmap"
+ *				"TUid		aTypeImage"
+ *				codec Uid 
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::EncodeImageFromBitmapToMemoryL(const TDesC& aFilename, 
+												    CFbsBitmap	*theBitmap,
+													TUid		aImageTypeId)
+	{
+
+	TInt	theRes = KErrNone;
+	
+	TFileName	theSourceFileName;
+	Directory( EReference, theSourceFileName);
+	theSourceFileName.Append(aFilename);
+
+	HBufC8 *theDestinationImage = NULL;
+	CImageEncoder *theImageEncoder = NULL;
+	
+	// creating encoder
+	TBuf<KLenBufferExtension>	theExtension;
+	GetImageExtension(aImageTypeId, theExtension);
+	ERR_PRINTF3(_L("Creating encoder %S, Uid = %d"), &theExtension, aImageTypeId); 
+	
+	TRAP(theRes, theImageEncoder = CImageEncoder::DataNewL( theDestinationImage, 
+		CImageEncoder::EOptionNone, aImageTypeId ));
+	if(theRes != KErrNone)
+		{
+		ERR_PRINTF2(_L("Cannot create image encoder buffer for Uid = %d"), 
+			aImageTypeId.iUid);
+		return theRes;
+		
+		}
+	CleanupStack::PushL(theImageEncoder);
+	
+	ERR_PRINTF1(_L("Image buffer was created successfully")); 
+
+	//prepare encode data
+	TConvertInfo	theConvInfo;
+	theConvInfo.iImageTypeId = iImageTypeUid;
+	theConvInfo.iDisplayMode = theBitmap->DisplayMode();
+	
+	TImageDataBlock*	imageData = NULL;
+	TFrameDataBlock*	frameData = NULL;
+	
+	CFrameImageData* theFrameImageData = CFrameImageData::NewL();
+	CleanupStack::PushL(theFrameImageData);
+		
+	theRes	 = PrepareEncodeDataL(theConvInfo, &imageData, &frameData);
+	//
+	if(imageData)
+		{
+		CleanupStack::PushL(imageData);
+		User::LeaveIfError(theFrameImageData->AppendImageData(imageData));
+		CleanupStack::Pop(imageData);
+		}
+	if(frameData)
+		{
+		CleanupStack::PushL(frameData);	
+		User::LeaveIfError(theFrameImageData->AppendFrameData(frameData));
+		CleanupStack::Pop(frameData);
+		}
+	// do conversion
+	CActiveListener* activeListener = new(ELeave)CActiveListener;
+	CleanupStack::PushL( activeListener );
+	
+	activeListener->InitialiseActiveListener();
+	theImageEncoder->Convert(&activeListener->iStatus,*theBitmap, theFrameImageData);
+	CActiveScheduler::Start();
+
+	theRes = activeListener->iStatus.Int();
+
+	if(theRes == KErrNone)
+		ERR_PRINTF1(_L("Conversion was successful")); 
+	else
+		ERR_PRINTF1(_L("Fail during conversion")); 
+
+	if(theRes == KErrNone)
+		theRes = CompareFileL(aFilename, theDestinationImage, 
+									aImageTypeId, 
+									EInput); 
+	//
+	delete theDestinationImage;
+	theDestinationImage = NULL;
+
+	CleanupStack::PopAndDestroy(3, theImageEncoder);
+	
+	return theRes; 
+	}
+
+
+/* 
+ *
+ * Read and encode image from bitmap to file
+ * After encoding load file into a flat buffer and do bitwise compare
+ *
+ * @param		"const TDesC& aFileName"
+ *				"TUid		aTypeImage"
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::EncodeImageFromBitmapToFileL(const TDesC& aFilename, 
+												   TUid		aImageTypeId)
+	{
+	TFileName	theSourceFile;
+	Directory(EReference, theSourceFile);
+	theSourceFile.Append(aFilename);
+
+	CFbsBitmap	*theBitmap = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(theBitmap);
+	TInt theRes = theBitmap->Load(theSourceFile);
+	
+	if(theRes != KErrNone)
+		{
+		CleanupStack::PopAndDestroy(theBitmap);
+
+		ERR_PRINTF2(_L("File %S cannot be louded" ), &theSourceFile); 
+		return theRes;
+		}
+	
+	User::LeaveIfError(iFs.Connect());
+
+	// call for a convertor
+	//
+	TFileName	theDestinationFileName; 
+	TBuf<KLenBuffer>		theExtinsion;
+
+	Directory(EOutput, theDestinationFileName);
+	theDestinationFileName.Append(aFilename.Left(aFilename.Length()-3));
+
+	GetImageExtension(aImageTypeId, theExtinsion);
+	theDestinationFileName.Append(theExtinsion);
+	
+	CImageEncoder* theImageEncoder = NULL;
+	TRAP(theRes, theImageEncoder = 
+		CImageEncoder::FileNewL(iFs, theDestinationFileName, 
+		CImageEncoder::EOptionNone, aImageTypeId));
+
+	if(theRes != KErrNone)
+		{
+		CleanupStack::PopAndDestroy(theBitmap);
+
+		iFs.Close();
+		ERR_PRINTF3(_L("Error during creating Image Encoder UId %d to file %S" ), aImageTypeId, &theDestinationFileName); 
+		if(KErrPathNotFound == theRes)
+			ERR_PRINTF2(_L("Path %S not found" ), &theDestinationFileName); 
+		
+		if(theRes == KErrAccessDenied)
+			ERR_PRINTF1(_L("Access denied" )); 
+
+		return theRes;	
+		}
+	CleanupStack::PushL(theImageEncoder);
+	//-----------
+	//prepare encode data
+	TConvertInfo	theConvInfo;
+	theConvInfo.iImageTypeId = iImageTypeUid;
+	theConvInfo.iDisplayMode = theBitmap->DisplayMode();
+	
+	//TJpegImageData::TColorSampling iSampling;
+	//TInt iQualityFactor; // 0 to 100 inclusive
+	TImageDataBlock*	imageData = NULL;
+	TFrameDataBlock*	frameData = NULL;
+
+	CFrameImageData* theFrameImageData = CFrameImageData::NewL();
+	CleanupStack::PushL(theFrameImageData);
+		
+	theRes	 = PrepareEncodeDataL(theConvInfo, &imageData, &frameData);
+	//
+	if(imageData)
+		{
+		CleanupStack::PushL(imageData);
+		User::LeaveIfError(theFrameImageData->AppendImageData(imageData));
+		CleanupStack::Pop(imageData);
+		}
+	if(frameData)
+		{
+		CleanupStack::PushL(frameData);	
+		User::LeaveIfError(theFrameImageData->AppendFrameData(frameData));
+		CleanupStack::Pop(frameData);
+		}
+	//--------------
+	// do conversion
+	CActiveListener* activeListener = new(ELeave)CActiveListener;
+	CleanupStack::PushL( activeListener );
+
+	iActiveScheduler->SetEncoder(theImageEncoder, activeListener, 0);
+	iActiveScheduler->SetStep(this);
+
+	activeListener->InitialiseActiveListener();
+	theImageEncoder->Convert(&activeListener->iStatus, *theBitmap, theFrameImageData);
+	CActiveScheduler::Start();
+	
+
+	theRes = activeListener->iStatus.Int();
+	iActiveScheduler->SetStep(NULL);
+
+	//  ! this function will be removed from API
+	//TInt nSize = iImageEncoder->CurrentImageSizeL();
+	//
+
+	CleanupStack::PopAndDestroy(4, theBitmap); //active sheduler
+
+	if(theRes != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error during conversion" )); 
+		return theRes;
+		}
+	else
+		{
+		ERR_PRINTF1(_L("Conversion was successful" )); 
+		}
+	//
+	//compare two file into a flat buffer
+	
+	TInt fileSize;
+	
+	iFile.Open(iFs, theDestinationFileName, EFileRead);
+	iFile.Size(fileSize);
+	HBufC8 *theCreatedImage = HBufC8::NewMaxLC(fileSize);
+
+	TPtr8 imageFromFilePtr = theCreatedImage->Des();
+	iFile.Read(imageFromFilePtr);
+	iFile.Close();
+
+	theRes = CompareFileL(aFilename, theCreatedImage, aImageTypeId, EInput); 
+
+	CleanupStack::PopAndDestroy(theCreatedImage);
+	//
+	iFs.Close();
+
+	return theRes; 
+	}
+
+ 
+
+/* 
+ *
+ * Prepare encode data
+ *
+ * @param		"TConvertInfo &aConvInfo"
+ *				input information
+ *				"TImageDataBlock**	imageData"
+ *				"TFrameDataBlock**	frameData"
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::PrepareEncodeDataL(TConvertInfo &aConvInfo, 
+											   TImageDataBlock** aImageData, 
+											   TFrameDataBlock** aFrameData)
+	{
+	TBuf<KLenBuffer>	nameSection;
+	TInt theRes = KErrNone;
+	TBool theColor = ETrue;
+	if(aConvInfo.iDisplayMode == EGray2)
+		theColor = EFalse;
+	
+	if(aConvInfo.iImageTypeId == KImageTypeMBMUid)
+		{
+		*aFrameData = new (ELeave) TMbmEncodeData;
+		TMbmEncodeData*	data = STATIC_CAST(TMbmEncodeData*, *aFrameData);
+		TInt	displaymode;
+		data->iDisplayMode = aConvInfo.iDisplayMode;
+			//
+		if(GetIntFromConfig(nameSection, _L("displaymode"), displaymode) == (TBool)ETrue)
+			{
+				switch(displaymode)
+					{
+					case 1: data->iDisplayMode = EGray2; break;
+					case 2: data->iDisplayMode = EGray4; break;
+					case 3: data->iDisplayMode = EGray16;break;
+					case 4: data->iDisplayMode = EGray256;break;
+					case 5: data->iDisplayMode = EColor16;break;
+					case 6: data->iDisplayMode = EColor256;break;
+					case 7: data->iDisplayMode = EColor64K;break;
+					case 8: data->iDisplayMode = EColor16M;break;
+					default: break;
+					}
+			}
+		}
+	else if(aConvInfo.iImageTypeId == KImageTypeGIFUid)
+		{
+		//the encoder is not configurable	
+		}
+	else if(aConvInfo.iImageTypeId == KImageTypeBMPUid)
+		{
+		*aImageData= new(ELeave) TBmpImageData;
+		TBmpImageData*	data = STATIC_CAST(TBmpImageData*, *aImageData);
+
+		TPtrC ptr = iTestStepName;
+		nameSection = ptr.Right(KLenNameInSection);
+		TInt nBitsPerPixel = 0;
+		if(GetIntFromConfig(nameSection, _L("BitsPerPixel"), nBitsPerPixel) == EFalse)
+			{
+		
+			switch(aConvInfo.iDisplayMode)
+				{
+				case EGray2: data->iBitsPerPixel = 1; break;
+				case EGray4: data->iBitsPerPixel = 2; break;
+				case EGray16: data->iBitsPerPixel = 4; break;
+				case EGray256: data->iBitsPerPixel = 8;break;
+				case EColor16: data->iBitsPerPixel = 4; break;
+				case EColor256: data->iBitsPerPixel = 8; break;
+				case EColor64K: data->iBitsPerPixel = 16;break;
+				case EColor16M: data-> iBitsPerPixel = 24;break;
+				default: data->iBitsPerPixel = 0; break;
+				}
+			}
+			else 
+				data->iBitsPerPixel = nBitsPerPixel;
+		}
+	else if(aConvInfo.iImageTypeId == KImageTypeJPGUid)
+		{
+			// read config file
+			TInt		theQualityFactor = KDefaultQualityFactor;
+			TInt		theSampling = KDefaultSampling;
+
+			TPtrC ptr = iTestStepName;
+			nameSection = ptr.Right(KLenNameInSection);
+			GetIntFromConfig(nameSection, _L("QualityFactor"), theQualityFactor);
+			GetIntFromConfig(nameSection, _L("Sampling"), theSampling);
+			//
+
+			*aImageData = new (ELeave) TJpegImageData;
+			TJpegImageData* data = STATIC_CAST(TJpegImageData*, *aImageData);
+
+			if(!theColor)
+				data->iSampleScheme = TJpegImageData::EMonochrome;
+			else 
+				data->iSampleScheme=TJpegImageData::TColorSampling(theSampling);
+			data->iQualityFactor=theQualityFactor; 
+		}
+
+	return theRes;
+	}
+/* 
+ *
+ * List all available decoders MIME types
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::ListAvailableMIMEDecoders()
+	{
+	TInt	theRes;
+	RFileExtensionMIMETypeArray		theFileExtensionArray;
+	
+	TRAP(theRes, CImageDecoder::GetFileTypesL(theFileExtensionArray));	
+	
+	if(theRes != KErrNone)
+		{
+		theFileExtensionArray.ResetAndDestroy();
+		return theRes;
+		}
+
+	
+	INFO_PRINTF1(_L("A List of decoder file extensions and MIME types"));
+	
+	for (TInt index=0; index<theFileExtensionArray.Count(); index++)
+		{
+		CFileExtensionMIMEType& fileExtAndMIMEType = *theFileExtensionArray[index];
+		
+		const TDesC& extension = fileExtAndMIMEType.FileExtension();
+		const TDesC8& mimeType = fileExtAndMIMEType.MIMEType();
+		TBuf<KLenBuffer>	mimeType16;
+
+		mimeType16.Copy(mimeType);
+		
+		INFO_PRINTF3(_L("Extension : %S, MIME Type : %S"), &extension, &mimeType16);
+		
+		}
+	
+	theFileExtensionArray.ResetAndDestroy();
+	
+	return theRes;
+	}
+
+
+/* 
+ *
+ * List all available encoders MIME types
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::ListAvailableMIMEEncoders()
+	{
+	TInt	theRes = KErrNone;
+	
+	RFileExtensionMIMETypeArray		theFileExtensionArray;
+
+	TRAP(theRes, CImageEncoder::GetFileTypesL(theFileExtensionArray));	
+	
+	if(theRes != KErrNone)
+		{
+		theFileExtensionArray.ResetAndDestroy();
+		return theRes;
+		}
+	INFO_PRINTF1(_L("\n"));
+	INFO_PRINTF1(_L("A List of encoder file extensions and MIME types"));
+	
+	for (TInt index=0; index<theFileExtensionArray.Count(); index++)
+		{
+		CFileExtensionMIMEType& fileExtAndMIMEType = *theFileExtensionArray[index];
+		
+		const TDesC& extension = fileExtAndMIMEType.FileExtension();
+		const TDesC8& mimeType = fileExtAndMIMEType.MIMEType();
+		TBuf<KLenBuffer> mimeType16;
+
+		mimeType16.Copy(mimeType);
+		
+		INFO_PRINTF3(_L("Extension: %S, MIME Type : %S") , &extension, &mimeType16);
+		
+		}
+	theFileExtensionArray.ResetAndDestroy();
+	
+	return theRes; 
+	}
+
+/* 
+ *
+ * List all available decoders 
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::ListAllAvailableDecoders()
+	{
+	TInt theRes = KErrNone;
+
+
+	// find out UID and then name of the codec
+	RImageTypeDescriptionArray imageDecTypeArray;
+	TRAP(theRes, CImageDecoder::GetImageTypesL(imageDecTypeArray));
+	// find a description with the same image type and, if subtype given, subtype too
+	
+	if(theRes != KErrNone)
+		{
+		return theRes;
+		}
+	
+	TInt index;
+	
+	if(imageDecTypeArray.Count() > 0)
+		INFO_PRINTF1(_L("A List of available Decoder plugins!"));
+
+	for (index=0; index<imageDecTypeArray.Count(); index++)
+		{
+		CImageTypeDescription& description = *imageDecTypeArray[index];
+		
+		const TDesC& theBufDes = description.Description();
+ 
+		INFO_PRINTF1(theBufDes);
+		//
+		TUid theUid = description.ImageType();
+		RImageTypeDescriptionArray	theSubTypeArray;
+		
+		TInt theRes1;
+		TRAP(theRes1, CImageDecoder::GetImageSubTypesL(theUid, theSubTypeArray));
+		
+		if(theRes1 == KErrNone)
+			{
+			if(theSubTypeArray.Count() > 0)
+				INFO_PRINTF1(_L("A List of available Sub Types:"));
+			TInt index1;
+			for (index1=0; index1<theSubTypeArray.Count(); index1++)
+				{
+				CImageTypeDescription& description1 = *theSubTypeArray[index1];
+				const TDesC& theBufDes1 = description1.Description();
+ 
+				INFO_PRINTF2(_L("   %S"), &theBufDes1);
+				
+				}	
+			theSubTypeArray.ResetAndDestroy();
+			}
+		//
+		INFO_PRINTF1(_L("\n"));
+		}
+	imageDecTypeArray.ResetAndDestroy();
+
+	return theRes; //
+	}
+
+/* 
+ *
+ * List all available encoders 
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::ListAllAvailableEncoders()
+	{
+	TInt theRes = KErrNone;
+
+	// find out UID and then name of the codec
+	RImageTypeDescriptionArray imageEncTypeArray;
+	
+	TRAP(theRes, CImageEncoder::GetImageTypesL(imageEncTypeArray));
+
+	if(theRes != KErrNone)
+		return theRes;
+	// find a description with the same image type and, if subtype given, subtype too
+	TInt index;
+	
+	if(imageEncTypeArray.Count() > 0)
+		INFO_PRINTF1(_L("A List of available Encoder plugins!"));
+
+	for (index=0; index<imageEncTypeArray.Count(); index++)
+		{
+		CImageTypeDescription& description = *imageEncTypeArray[index];
+		
+		const TDesC&	theBufDes = description.Description();
+		
+		INFO_PRINTF1(theBufDes);
+
+		//
+		TUid theUid = description.ImageType();
+		RImageTypeDescriptionArray	theSubTypeArray;
+		
+		TInt theRes1;
+		TRAP(theRes1, CImageEncoder::GetImageSubTypesL(theUid, theSubTypeArray));
+		
+		if(theRes1 == KErrNone)
+			{
+			if(theSubTypeArray.Count() > 0)
+				INFO_PRINTF1(_L("A List of available Sub Types:"));
+			TInt index1;
+			for (index1=0; index1<theSubTypeArray.Count(); index1++)
+				{
+				CImageTypeDescription& description1 = *theSubTypeArray[index1];
+				const TDesC& theBufDes1 = description1.Description();
+ 
+				INFO_PRINTF2(_L("   %S"), &theBufDes1);
+				
+				}	
+			theSubTypeArray.ResetAndDestroy();
+			}
+		//
+
+		}
+	imageEncTypeArray.ResetAndDestroy();
+
+	return theRes; 
+	}
+
+/* 
+ *
+ * Enquire MIME type of an unopened image  
+ *
+ * @param		"const TDesC& aFileName"
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::FindMimeTypeL(const TDesC& aFileName)
+	{
+	TInt theRes = KErrNone;
+
+	TBuf8<KLenBuffer>	theMimeType;
+
+	INFO_PRINTF1(_L("Enquire MIME type of an unopened images"));
+	
+	User::LeaveIfError(iFs.Connect());
+
+	TFileName	theSourceFilename;
+	Directory(EInput, theSourceFilename);
+	theSourceFilename.Append(aFileName);
+
+	CImageDecoder::GetMimeTypeFileL(iFs, theSourceFilename, theMimeType);
+	TBuf<KLenBuffer>	mimeType;
+	mimeType.Copy(theMimeType);
+	INFO_PRINTF3(_L("File : %S, MimeType %S"), &theSourceFilename, &mimeType);
+	//-------------
+	TInt fileSize;
+
+	iFile.Open(iFs, theSourceFilename, EFileRead);
+	iFile.Size(fileSize);
+	HBufC8 *theImageFromFile = HBufC8::NewMaxLC(fileSize);
+
+	TPtr8 imageFromFilePtr = theImageFromFile->Des();
+	iFile.Read(imageFromFilePtr);
+	iFile.Close();
+
+	iFs.Close();
+
+	TBuf8<KLenBuffer>	theMimeType1;
+
+	CImageDecoder::GetMimeTypeDataL(imageFromFilePtr, theMimeType1);
+	
+	mimeType.Copy(theMimeType1);
+	INFO_PRINTF3(_L("Reading from buffer, File : %S, MimeType %S\n"), 
+		&theSourceFilename, &mimeType);
+	
+	CleanupStack::PopAndDestroy();
+
+	return theRes; 
+	}
+
+
+/* 
+ *
+ * Enquire UID of a loaded decoder & Implementation Info
+ *
+ * @param		"const TDesC& aFileName"
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::EnquireDecoderUIDAndImplementationInfoL(const TDesC& aFileName)
+	{
+	TInt theRes = KErrNone;
+
+	User::LeaveIfError(iFs.Connect());
+
+	TFileName	theSourceFilename;
+	Directory(EInput, theSourceFilename);
+	theSourceFilename.Append(aFileName);
+
+	CImageDecoder *theImageDecoder = CImageDecoder::FileNewL(iFs, theSourceFilename);
+	if(theImageDecoder == NULL)
+			return KErrUnknown;
+
+	TUid uid = theImageDecoder->ImplementationUid();
+	INFO_PRINTF3(_L("UID of a loaded decoder during reading file %S = %x\n"), 
+		&theSourceFilename, uid);
+
+	delete theImageDecoder;
+	theImageDecoder = NULL;
+	//------------------------
+	TInt fileSize;
+
+	iFile.Open(iFs, theSourceFilename, EFileRead);
+	iFile.Size(fileSize);
+	HBufC8 *theImageFromFile = HBufC8::NewMaxLC(fileSize);
+
+	TPtr8 imageFromFilePtr = theImageFromFile->Des();
+	iFile.Read(imageFromFilePtr);
+	iFile.Close();
+	iFs.Close();
+
+	
+	theImageDecoder = CImageDecoder::DataNewL(iFs, imageFromFilePtr);
+	if(theImageDecoder == NULL)
+			return KErrUnknown;
+	CleanupStack::PushL(theImageDecoder);
+	TUid uid1 = theImageDecoder->ImplementationUid();
+	
+	INFO_PRINTF2(_L("UID of a loaded decoder from buffer = 0x%08x\n"), 
+		uid1);
+//------
+	//Request ImplementationInformation
+	CImplementationInformationType* theImplementationInfo = 
+		CImageDecoder::GetImplementationInformationL(uid1);
+	CleanupStack::PushL(theImplementationInfo);
+	TInt theVersion = theImplementationInfo->Version();
+	const TDesC& dispName = theImplementationInfo->DisplayName();
+	const TDesC8&  dataType8 = theImplementationInfo->DataType();
+	const TDesC8&  opaqueData8 = theImplementationInfo->OpaqueData();
+	
+	TBuf<KLenBuffer>	dataType;
+	TBuf<KLenBuffer>	opaqueData;
+
+	dataType.Copy(dataType8);
+	opaqueData.Copy(opaqueData8);
+	//------------------
+	TUid	theUid;
+	TUid	theUidSubType;
+
+	theImageDecoder->ImageType(0, theUid, theUidSubType);
+
+	TInt versionNo = 0;
+	TBuf<KLenBuffer>	bufDisplayName;
+	const TUint8*		defaultDataPtr = NULL;		
+	const TUint8*		opaqueDataPtr = NULL;
+	TInt		lenDefaultData = 0;
+	TInt		lenOpaqueData = 0;
+
+	TInt versionNoJPEG = 1;
+	const TUint8 defaultDataJPEG[] = {0xFF, 0xD8};
+	static const TUint8 opaqueDataJPEG[] = {0, 0x10, 0x1F, 0x45, 0xD8, 0, 0, 0, 0, 1, 0x2E, 0x6A, 0x70, 0x67, 0x0D, 1, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2F, 0x6A, 0x70, 0x65, 0x67, 0x0D};
+	
+	TInt versionNoGIF = 1;
+	const TUint8 defaultDataGIF[] = {0x47, 0x49, 0x46, 0x38, 0x3F, 0x61};
+	static const TUint8 opaqueDataGIF[] = {0, 0x10, 0x1F, 0x45, 0xB3, 0, 0, 0, 0, 1, 0x2E, 0x67, 0x69, 0x66, 0x0D, 1, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2F, 0x67, 0x69, 0x66, 0x0D};
+
+	TInt versionNoBMP = 1;
+	const TUint8 defaultDataBMP[] = {0x42, 0x4D};
+	static const TUint8 opaqueDataBMP[] = {0, 0x10, 0x1F, 0x45, 0xB0, 0, 0, 0, 0, 1, 0x2E, 0x62, 0x6D, 0x70, 0x0D, 2, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2F, 0x78, 0x2D, 0x62, 0x6D, 0x70, 0x0D, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x2F, 0x62, 0x6D, 0x70, 0x0D};
+
+	if(theUid == KImageTypeJPGUid)
+		{
+			versionNo = versionNoJPEG;
+			bufDisplayName = _L("JPEG");
+			defaultDataPtr = defaultDataJPEG;
+			opaqueDataPtr  = opaqueDataJPEG;	
+			lenDefaultData = sizeof(defaultDataJPEG) / sizeof(defaultDataJPEG[0]);
+			lenOpaqueData = sizeof(opaqueDataJPEG) / sizeof(opaqueDataJPEG[0]);
+		}
+	else if(theUid == KImageTypeGIFUid)
+		{
+			versionNo = versionNoGIF;
+			bufDisplayName = _L("GIF");
+			defaultDataPtr = defaultDataGIF;
+			opaqueDataPtr  = opaqueDataGIF;	
+			lenDefaultData = sizeof(defaultDataGIF) / sizeof(defaultDataGIF[0]);
+			lenOpaqueData = sizeof(opaqueDataGIF) / sizeof(opaqueDataGIF[0]);
+		}
+	else if(theUid == KImageTypeBMPUid)
+		{
+			versionNo = versionNoBMP;
+			bufDisplayName = _L("BMP");
+			defaultDataPtr = defaultDataBMP;
+			opaqueDataPtr  = opaqueDataBMP;	
+			lenDefaultData = sizeof(defaultDataBMP) / sizeof(defaultDataBMP[0]);
+			lenOpaqueData = sizeof(opaqueDataBMP) / sizeof(opaqueDataBMP[0]);
+		}
+	
+	if(versionNo != theVersion)
+		theRes = KErrNotIdentical;
+
+	if(theRes == KErrNone)
+		theRes = Mem::Compare(defaultDataPtr, lenDefaultData, 
+			dataType8.Ptr(), dataType8.Length());
+
+
+
+	if(theRes == KErrNone)
+		{
+		theRes = Mem::Compare(opaqueDataPtr, lenOpaqueData, 
+			opaqueData8.Ptr(), opaqueData8.Length());
+		if (theUid == KImageTypeJPGUid && theRes!=KErrNone)
+			{
+			INFO_PRINTF1(_L("Known issue: EXIF plug-in has got different data, ignoring diffs."));
+			theRes=KErrNone;
+			}			
+		}
+	//------------
+	INFO_PRINTF1(_L("Implementation information"));
+	INFO_PRINTF2(_L("Display name : %S"), &dispName);
+	INFO_PRINTF2(_L("Version : %d"), theVersion);
+	//INFO_PRINTF2(_L("Data type : %S"), &dataType);
+	//INFO_PRINTF2(_L("Opaque data : %S"), &opaqueData);
+
+//-------
+	CleanupStack::PopAndDestroy(3, theImageFromFile); //theImageDecoder, theImageFromFile, theImplementationInfo
+	
+	return theRes; //
+	}
+
+/* 
+ *
+ * Enquire UID of a loaded encoder 
+ *
+ * @param		"const TDesC& aFileName"
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::EnquireEncoderUIDL(const TDesC& aFileName, 
+											   TUid		aTypeImageUid)
+	{
+	TInt theRes = KErrNotSupported;
+
+
+	User::LeaveIfError(iFs.Connect());
+
+	TFileName	theDestinationFilename;
+	Directory(EOutput, theDestinationFilename);
+	theDestinationFilename.Append(aFileName);
+	
+	CImageEncoder *theImageEncoder = NULL;
+	TRAP(theRes, theImageEncoder = CImageEncoder::FileNewL(iFs, theDestinationFilename, 
+		CImageEncoder::EOptionNone, aTypeImageUid));
+	if(theRes != KErrNone)
+		{
+		iFs.Close();
+		INFO_PRINTF2(_L("Cannot create file with Uid  = %d\n"), 
+				aTypeImageUid);
+		
+		if(KErrPathNotFound == theRes)
+			INFO_PRINTF2(_L("Path %S not found"), &theDestinationFilename);
+		return theRes;
+		}
+	CleanupStack::PushL(theImageEncoder);	
+	TUid uid1 = theImageEncoder->ImplementationUid();
+	INFO_PRINTF3(_L("UID of a loaded decoder during openning file %S = %d\n"), 
+		&theDestinationFilename, uid1);
+
+	CleanupStack::PopAndDestroy(theImageEncoder);
+
+	return theRes; 
+	}
+
+/* 
+ *
+ * Request number frames in image 
+ *
+ * @param		"const TDesC& aFileName"
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::RequestNumberFramesL(const TDesC& aFileName)
+	{
+	TInt	theRes 	= KErrNone;
+
+	User::LeaveIfError(iFs.Connect());
+
+	TFileName	theSourceFilename;
+	Directory(EInput, theSourceFilename);
+	theSourceFilename.Append(aFileName);
+
+	CImageDecoder *theImageDecoder = CImageDecoder::FileNewL(iFs, theSourceFilename);
+	CleanupStack::PushL(theImageDecoder);
+	if(theImageDecoder == NULL)
+			return KErrUnknown;
+
+	TInt	theFrameCount = theImageDecoder->FrameCount();
+
+	CleanupStack::PopAndDestroy(theImageDecoder);
+
+	iFs.Close();
+
+	INFO_PRINTF3(_L("Number of frames from a file %S = %d\n"), 
+		&theSourceFilename, theFrameCount);
+
+	return theRes;
+	}
+
+
+/* 
+ *
+ * Print frame information 
+ *
+ * @param		"const TFrameInfo& aFrameInfo"
+ *
+ */
+TAny	CTestStepConversion::PrintFrameInfo(const TFrameInfo& aFrameInfo)
+	{
+	TBuf<KLenBuffer>	theBuf;
+	//TRect iFrameCoordsInPixels;
+	//TSize iFrameSizeInTwips;
+	//TInt iBitsPerPixel;
+	//TTimeIntervalMicroSeconds iDelay;
+	//TUint32 iFlags;
+	//TSize iOverallSizeInPixels;
+	//TDisplayMode iFrameDisplayMode;
+	//TRgb iBackgroundColor;
+
+	INFO_PRINTF5(_L("Frame's coordinates (left, top, right, bottom)  = %d, %d, %d, %d\n"), 
+			aFrameInfo.iFrameCoordsInPixels.iTl.iX, aFrameInfo.iFrameCoordsInPixels.iTl.iY,
+			aFrameInfo.iFrameCoordsInPixels.iBr.iX, aFrameInfo.iFrameCoordsInPixels.iBr.iY);
+
+	INFO_PRINTF3(_L("Frame's size in twips  = %d, %d\n"), 
+			aFrameInfo.iFrameSizeInTwips.iWidth, aFrameInfo.iFrameSizeInTwips.iHeight);
+
+	INFO_PRINTF2(_L("Bits per pixel  = %d\n"), 
+				aFrameInfo.iBitsPerPixel);
+
+	TInt64	int64 = aFrameInfo.iDelay.Int64();
+	TInt	delay = I64INT(int64);
+
+	INFO_PRINTF2(_L("Delay in microseconds = %d\n"), 
+				delay);
+	
+	INFO_PRINTF3(_L("Overall size in pixel = %d, %d\n"),  
+		aFrameInfo.iOverallSizeInPixels.iWidth, aFrameInfo.iOverallSizeInPixels.iHeight);
+	
+	FrameDisplayMode(aFrameInfo.iFrameDisplayMode, theBuf);
+		INFO_PRINTF2(_L("Frame display mode  = %S\n"), 
+				&theBuf);
+
+	INFO_PRINTF4(_L("Background color Red, Green, Blue = %d, %d, %d \n"), 
+				aFrameInfo.iBackgroundColor.Red(), 
+				aFrameInfo.iBackgroundColor.Green(),
+				aFrameInfo.iBackgroundColor.Blue());
+
+	}
+
+/* 
+ *
+ * Request decode information & options for frames in a loaded image
+ *	and print it
+ *
+ * @param		"const TDesC& aFileName"
+ *				"TInt	aParam"
+ *				KShowFrameInformation - show Frame Information
+ *				KShowFrameOption - show frame option 
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::RequestDecodeDataL(const TDesC& aFileName, TInt aParam)
+	{
+	TInt	theErr = KErrNone;
+
+	User::LeaveIfError(iFs.Connect());
+
+	TFileName	theSourceFilename;
+	Directory(EInput, theSourceFilename);
+	theSourceFilename.Append(aFileName);
+	
+	CImageDecoder *theImageDecoder = NULL;
+	TRAP(theErr, theImageDecoder = CImageDecoder::FileNewL(iFs, theSourceFilename));
+	CleanupStack::PushL(theImageDecoder);
+	if(theErr != KErrNone)
+		{
+		INFO_PRINTF2(_L("Cannot open decoder for file %S\n"), &theSourceFilename);
+		
+
+		return theErr;
+		}
+	INFO_PRINTF2(_L("The file %S had been loaded successfully\n"), &theSourceFilename);
+
+	//frames loop
+	TInt	theFrameCount = theImageDecoder->FrameCount();
+	for(TInt theCurFrame = 0; theCurFrame < theFrameCount;theCurFrame++ )
+		{
+		const TFrameInfo& theFrameInfo = theImageDecoder->FrameInfo(theCurFrame);
+			
+		INFO_PRINTF1(_L("------------\n"));
+		INFO_PRINTF2(_L("The frame number %d\n"), 
+				theCurFrame);
+		if(aParam & KShowFrameInformation)
+			{	
+			PrintFrameInfo(theFrameInfo);
+
+		//---------------------
+			const CFrameImageData&	theFrameData = theImageDecoder->FrameData(theCurFrame);
+			TInt theImageDataCount = theFrameData.ImageDataCount();
+			TInt theFrameCount = theFrameData.FrameDataCount();
+			INFO_PRINTF2(_L("Number frame data entries %d"), theFrameCount);
+			TInt	index;
+			for(index = 0; index < theFrameCount; index++)
+				{
+				const TFrameDataBlock* theFrameDataBlock = theFrameData.GetFrameData(index);
+				INFO_PRINTF3(_L("Frame Data Block # %d, UId %d"),
+					index, theFrameDataBlock->DataType());
+
+				}
+
+			INFO_PRINTF2(_L("Number image data entries %d"), theImageDataCount);
+			for(index = 0; index < theImageDataCount; index++)
+				{
+				const TImageDataBlock* theImageDataBlock = theFrameData.GetImageData(index);
+				INFO_PRINTF3(_L("Image Data Block # %d, UId %d"),
+					index, theImageDataBlock->DataType());
+
+				}
+			}
+		//--------------
+
+		if(aParam & KShowFrameOption)
+			PrintFrameOptions(theFrameInfo);
+		}
+	  
+	CleanupStack::PopAndDestroy(theImageDecoder);
+	iFs.Close();
+
+	return theErr;
+	}
+
+
+/* 
+ *
+ * Print frame options 
+ *
+ * @param		"const TFrameInfo& aFrameInfo"
+ *
+ */
+TAny CTestStepConversion::PrintFrameOptions(const TFrameInfo& aFrameInfo)
+	{
+	_LIT(theBufYes, "Yes");
+	_LIT(theBufNo, "No");
+	
+	// iFlags;
+			
+			//EColor					= 0x00000001 Grayscale if not set
+			//ETransparencyPossible	= 0x00000002 Fully opaque if not set
+			//EFullyScaleable			= 0x00000004 Will only scale to 1/2,1/4 & 1/8th if not set
+			//EConstantAspectRatio	= 0x00000008 Scaling need not maintain aspect ratio if not set
+			//ECanDither				= 0x00000010 Will not use error diffusion if not set
+			//EAlphaChannel			= 0x00000020 Set if the image contains alpha-blending information
+			//ELeaveInPlace			= 0x00000040
+			//ERestoreToBackground	= 0x00000080 Mutually exclusive image disposal methods
+			//ERestoreToPrevious		= 0x00000100
+			//EPartialDecodeInvalid   = 0x00000200   Where CImageDecoder::Convert fails on KErrUnderflow, image not suitable for display
+
+	if(TFrameInfo::EColor & aFrameInfo.iFlags)
+		INFO_PRINTF2(_L("Color = %S \n"),
+								&theBufYes);
+	else
+		INFO_PRINTF2(_L("Color = %S \n"),
+								&theBufNo);
+				
+	if(TFrameInfo::ETransparencyPossible & aFrameInfo.iFlags)
+		INFO_PRINTF2(_L("Transparency = %S \n"),
+								&theBufYes);
+	else
+		INFO_PRINTF2(_L("Transparency = %S \n"),
+								&theBufNo);
+
+	if(TFrameInfo::EFullyScaleable & aFrameInfo.iFlags)
+		INFO_PRINTF2(_L("Fully scaleable = %S \n"),
+								&theBufYes);
+	else
+		INFO_PRINTF2(_L("Fully scaleable = %S \n"),
+								&theBufNo);
+
+	if(TFrameInfo::EConstantAspectRatio & aFrameInfo.iFlags)
+		INFO_PRINTF2(_L("Aspect ratio = %S \n"),
+								&theBufYes);
+	else
+		INFO_PRINTF2(_L("Aspect ratio = %S \n"),
+								&theBufNo);
+
+	if(TFrameInfo::ECanDither & aFrameInfo.iFlags)
+		INFO_PRINTF2(_L("Can dither = %S \n"),
+						&theBufYes);
+	else
+		INFO_PRINTF2(_L("Can dither = %S \n"),
+						&theBufNo);
+
+	if(TFrameInfo::EAlphaChannel & aFrameInfo.iFlags)
+		INFO_PRINTF2(_L("Alpha channel = %S \n"),
+						&theBufYes);
+	else
+		INFO_PRINTF2(_L("Alpha channel = %S \n"),
+						&theBufNo);
+
+	if(TFrameInfo::ELeaveInPlace & aFrameInfo.iFlags)
+		INFO_PRINTF2(_L("Leave in place = %S \n"),
+								&theBufYes);
+	else
+		INFO_PRINTF2(_L("Leave in place = %S \n"),
+						&theBufNo);
+
+	if(TFrameInfo::ERestoreToBackground & aFrameInfo.iFlags)
+			INFO_PRINTF2(_L("Restore to background = %S \n"),
+								&theBufYes);
+	else
+		INFO_PRINTF2(_L("Restore to background = %S \n"),
+							&theBufNo);
+
+	if(TFrameInfo::ERestoreToPrevious & aFrameInfo.iFlags)
+		INFO_PRINTF2(_L("Restore to previos = %S \n"),
+								&theBufYes);
+	else
+		INFO_PRINTF2(_L("Restore to previos = %S \n"),
+								&theBufNo);
+
+	if(TFrameInfo::EPartialDecodeInvalid & aFrameInfo.iFlags)
+		INFO_PRINTF2(_L("Partial decode invalid = %S \n"),
+								&theBufYes);
+	else
+		INFO_PRINTF2(_L("Partial decode invalid = %S \n"),
+								&theBufNo);
+
+	}
+
+/* 
+ *
+ *	Open image and retrieve embedded image comments
+ *
+ * @param		"TUid aImageTypeId"
+ *				Uid encoder
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::RetrieveEmbeddedCommentsL(const TDesC& aFilename)
+	{
+
+	TInt theRes = KErrNone; 
+		
+	TFileName theSourceFilename;
+	Directory(EInput, theSourceFilename);
+	theSourceFilename.Append(aFilename);
+
+	User::LeaveIfError(iFs.Connect());
+
+		//
+	CImageDecoder *theImageDecoder = NULL;	
+	TRAP(theRes, (theImageDecoder = CImageDecoder::FileNewL(iFs, theSourceFilename)));//,
+
+	if(theRes != KErrNone)
+		{
+		INFO_PRINTF2(_L("Cannot open file %S"),
+						&theSourceFilename);
+		return theRes;
+		
+		}
+	if(theImageDecoder == NULL)
+			return KErrUnknown;
+	CleanupStack::PushL(theImageDecoder);
+	TInt	theNumComment=theImageDecoder->NumberOfImageComments();
+	
+	INFO_PRINTF3(_L("Number of image comments in the file %S  = %d\n"),
+						&theSourceFilename,
+						theNumComment);		
+	for(TInt theCurComment = 0; theCurComment < theNumComment ;theCurComment++)
+		{
+		HBufC* commentBuf = theImageDecoder->ImageCommentL(theCurComment);
+		if(commentBuf)
+			{
+
+			TPtr imageCommentPtr = commentBuf->Des();
+
+			INFO_PRINTF3(_L("Frame %d, comment - %S \n"),
+						theCurComment,		
+						&imageCommentPtr);
+					
+			delete commentBuf;
+			}
+		}
+	
+	CleanupStack::PopAndDestroy(theImageDecoder);
+	
+	iFs.Close();
+		
+	return theRes;
+	}
+
+/* 
+ *
+ *	Open image and retrieve frame info
+ *
+ * @param		"const TDesC& aFilename"
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt	CTestStepConversion::RetrieveFrameInfoL(const TDesC& aFilename)
+	{
+	TInt theRes = KErrNone; 
+
+	TFileName theSourceFilename;
+	Directory(EInput, theSourceFilename);
+	theSourceFilename.Append(aFilename);
+
+	User::LeaveIfError(iFs.Connect());
+		//
+	CImageDecoder* theImageDecoder = NULL;
+	TRAP(theRes, (theImageDecoder = CImageDecoder::FileNewL(iFs, theSourceFilename, 
+		CImageDecoder::EOptionNone)));
+	CleanupStack::PushL(theImageDecoder);
+	if(theRes != KErrNone)
+		{
+		INFO_PRINTF2(_L("Cannot open file %S"),
+						&theSourceFilename);
+		return theRes;
+		
+		}
+	if(theImageDecoder == NULL)
+			return KErrUnknown;
+
+	TInt theNumOfFrameComments = theImageDecoder->NumberOfFrameComments(0);
+	INFO_PRINTF2(_L("Number of frame comments : %d"), theNumOfFrameComments);
+
+// GIF doesn't support frame comments
+//	HBufC*  theBuf = iImageDecoder->FrameCommentL(0, 0);
+//	TPtr	theBufPtr = theBuf->Des();
+//	INFO_PRINTF2(_L("Frame comments : %S\n"), &theBufPtr);
+//
+//	delete theBuf;
+//	theBuf = NULL;
+
+	TInt imageComments = theImageDecoder->NumberOfImageComments();
+	INFO_PRINTF2(_L("Number of image comments : %d"), imageComments);
+
+	HBufC*  theBuf = theImageDecoder->ImageCommentL(0);
+	TPtr	theBufPtr = theBuf->Des();
+	INFO_PRINTF2(_L("Image comments : %S\n"), &theBufPtr);
+
+	delete theBuf;
+	theBuf = NULL;
+	
+
+	INFO_PRINTF1(_L("Call function FrameInfoStringsL\n"));
+	CFrameInfoStrings*	theStr = theImageDecoder->FrameInfoStringsL(0);
+
+	TInt index;
+	for(index = 0; index < theStr->Count(); index++)
+		{
+			const TPtrC str = theStr->String(index);
+			INFO_PRINTF3(_L("String # %d : %S"),
+						index, &str);
+		}
+	delete 	theStr;
+	theStr = NULL;
+	
+	INFO_PRINTF1(_L("Call function FrameInfoStringsLC"));
+	CFrameInfoStrings*	theStr1 = theImageDecoder->FrameInfoStringsLC(0);
+	for(index = 0; index < theStr1->Count(); index++)
+		{
+			const TPtrC str = theStr1->String(index);
+			INFO_PRINTF3(_L("String # %d : %S"),
+						index, &str);
+		}
+	
+	CleanupStack::Pop();
+	delete 	theStr1;
+	
+	TInt theFrameNumber = 0;
+	TUid theImageType;
+	TUid theImageSubType;
+
+	theImageDecoder->ImageType(theFrameNumber, theImageType, theImageSubType);
+	INFO_PRINTF5(_L("Image type Uid: %d (expected %d), Image sub type Uid %d (expected %d)"),
+						theImageType, KImageTypeTestUid, theImageSubType, 
+						KImageSubTypeTestUid);
+	
+	CleanupStack::PopAndDestroy(theImageDecoder);
+	iFs.Close();
+
+	return theRes;
+	}
+
+// dummy Hal call for heap balance on target
+// Need to do this BEFORE doing any allocation testing !
+TInt CTestStepConversion::DummyHalCall()
+	{
+    TInt err1 = FbsStartup();
+    if (err1 != KErrNone)
+        {
+        INFO_PRINTF2(_L("FbsStartup failed, err = %d"), err1);
+        return EInconclusive;
+        }
+
+    err1 = RFbsSession::Connect();
+    if (err1 != KErrNone)
+        {
+        INFO_PRINTF2(_L("RFbsSession::Connect() failed, err = %d"), err1);
+        return EInconclusive;
+        }
+		
+	TInt displayMode = EColor256;
+	CFbsScreenDevice* screenDevice = NULL;	
+	TInt err;
+	while(displayMode < EColorLast) 
+		{
+		TRAP(err, screenDevice = CFbsScreenDevice::NewL(_L("NotUsed"),(TDisplayMode)displayMode));
+		delete screenDevice;
+		screenDevice = NULL;	
+		if(err == KErrNone)
+			{
+			break;
+			}
+		displayMode++;
+		}			
+	
+	RFbsSession::Disconnect();
+	if (err != KErrNone)
+		{
+		INFO_PRINTF2(_L("Unable to create CFbsScreenDevice, err = %d"), err);
+		}
+	return err;
+  	}
+
+//MS3.4 File Handles//
+/* 
+ *
+ * Decode a Bitmap, supplied a Decoder Object
+ * After encoding load file into a flat buffer and do bitwise compare
+ *
+ * @param		"CImageDecoder& aImageDecoder"
+ *				"TDesC& aFileName"
+ *
+ * @return		"TInt"
+ *				error	
+ */
+TInt CTestStepConversion::DecodeUsingDecoderL(const TDesC& aFileName)
+	{
+	TInt theRes = KErrNone;
+
+	if(iImageDecoder == NULL)
+		{
+		return KErrUnknown;
+		}
+
+	//[ Create an active Listener and push it on the cleanup stack ]
+	CActiveListener* activeListener = new(ELeave)CActiveListener;
+	CleanupStack::PushL( activeListener );
+
+	//[ Create a destination Bitmap ]
+	CFbsBitmap* theDestination = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(theDestination);
+	
+	const TFrameInfo* theFrameInfo = &iImageDecoder->FrameInfo();
+	User::LeaveIfError(theDestination->Create(theFrameInfo->iOverallSizeInPixels, theFrameInfo->iFrameDisplayMode));//EColor256));// 
+	
+	//[ Convert Method of the Decoder ]
+	activeListener->InitialiseActiveListener();
+	iImageDecoder->Convert(&activeListener->iStatus, *theDestination, 0);
+		
+	CActiveScheduler::Start();
+	theRes = activeListener->iStatus.Int();
+
+	if(theRes == KErrNone)
+		{
+		INFO_PRINTF2(_L("Decoding of file %S was successful"), &aFileName);
+		}
+	else
+		{
+		INFO_PRINTF2(_L("Failed to Decode the file : %S"), &aFileName);
+		}
+
+	//[ Checking with Reference Bitmaps at the end ]
+	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);
+		}
+	theDestination->Reset();	
+	CleanupStack::PopAndDestroy(2,activeListener);  // theDestination,CActiveListener
+	
+	return theRes;
+	}
+
+/* 
+ *
+ * Read and encode image from bitmap to file
+ * After encoding load file into a flat buffer and do bitwise compare
+ *
+ * @param		"const TDesC& aFileName"
+ *				"TUid		aTypeImage"
+ *
+ */
+void CTestStepConversion::EncodeUsingEncoderL(const TDesC& aFileNameSrc)
+	{
+	TInt theRes = KErrNone; 
+
+	if(iImageEncoder == NULL)
+		{
+		User::Leave(KErrUnknown);
+		}
+
+	//[ Open the Source Bitmap ]
+	TFileName theSourceFile;
+	Directory(EReference, theSourceFile);
+	theSourceFile.Append(aFileNameSrc);
+
+	CFbsBitmap *theBitmap = new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(theBitmap);
+	
+	theRes = theBitmap->Load(theSourceFile);
+	
+	if(theRes != KErrNone)
+		{
+		ERR_PRINTF2(_L("File %S cannot be loaded." ), &theSourceFile); 
+		User::Leave(theRes);
+		}
+	
+	//[ Prepare Encode Data ]
+	TConvertInfo theConvInfo;
+	theConvInfo.iImageTypeId = iImageTypeUid;
+	theConvInfo.iDisplayMode = theBitmap->DisplayMode();
+	
+	TImageDataBlock* imageData = NULL;
+	TFrameDataBlock* frameData = NULL;
+	
+	CFrameImageData* theFrameImageData = CFrameImageData::NewL();
+	CleanupStack::PushL(theFrameImageData);
+
+	theRes	 = PrepareEncodeDataL(theConvInfo, &imageData, &frameData);
+	//
+	if(imageData)
+		{
+		CleanupStack::PushL(imageData);
+		User::LeaveIfError(theFrameImageData->AppendImageData(imageData));
+		CleanupStack::Pop(imageData);
+		}
+	if(frameData)
+		{
+		CleanupStack::PushL(frameData);	
+		User::LeaveIfError(theFrameImageData->AppendFrameData(frameData));
+		CleanupStack::Pop(frameData);
+		}
+		
+	//[ Create an active Listener and push it on the cleanup stack ]
+	CActiveListener* activeListener = new(ELeave)CActiveListener;
+	CleanupStack::PushL( activeListener );
+
+	iActiveScheduler->SetEncoder(iImageEncoder, activeListener, 0);
+	iActiveScheduler->SetStep(this);
+	
+	//[ Convert Method of the Encoder ]
+	activeListener->InitialiseActiveListener();
+	iImageEncoder->Convert(&activeListener->iStatus, *theBitmap, theFrameImageData);
+	CActiveScheduler::Start();
+	theRes = activeListener->iStatus.Int();
+	iActiveScheduler->SetStep(NULL);
+
+	if(theRes == KErrNone)
+		{
+		INFO_PRINTF2(_L("Encoding of file %S was successful"), &aFileNameSrc);
+		}
+	else
+		{
+		INFO_PRINTF2(_L("Failed to Encode the file : %S"), &aFileNameSrc);
+		User::Leave(theRes);
+		}
+
+	//[ Compare two files into a flat buffer ]
+	TFileName theDestinationFileName; 
+	TBuf<KLenBuffer> theExtension;
+
+	Directory(EOutput, theDestinationFileName);
+	theDestinationFileName.Append(aFileNameSrc.Left(aFileNameSrc.Length()-3));
+	GetImageExtension(iImageTypeUid, theExtension);
+	theDestinationFileName.Append(theExtension);
+	
+	iFile.Close(); //- As a precaution.
+	
+	TInt fileSize;
+	theRes = iFile.Open(iFs, theDestinationFileName, EFileWrite);
+	if(theRes != KErrNone)
+		{
+		INFO_PRINTF2(_L("Cannot open file: %S to Compare"), &theDestinationFileName);
+		User::Leave(theRes);
+		}
+	iFile.Size(fileSize);
+	HBufC8 *theCreatedImage = HBufC8::NewMaxLC(fileSize);
+
+	TPtr8 imageFromFilePtr = theCreatedImage->Des();
+	iFile.Read(imageFromFilePtr);
+	
+	iFile.Close();
+	
+	//[ Call the CompareFileL Function ]
+	theRes = CompareFileL(aFileNameSrc, theCreatedImage, iImageTypeUid, EInput);
+	User::LeaveIfError(theRes);
+	//[ Delete the Local Objects ]
+	CleanupStack::PopAndDestroy(4,theBitmap); //CActiveListener
+	}
+