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

// This file contains the test steps ICL YUV testing  for Bravo - PREQ 747.

// 

//

// EPOC includes

#include <testframework.h>

#include <icl/icl_uids.hrh>

#include "TestStepYUVConversion.h"

#include "ICLFbsSessionTest.h"

#include <iclexifimageframe.h>

#define INFO_PRINTF1_IF_LOGS_ENABLED( a ) if(iEnableLogs) 		\

											{					\

											INFO_PRINTF1( a );	\

											}											

#define INFO_PRINTF2_IF_LOGS_ENABLED( a, b ) if(iEnableLogs)					\

												{								\

												INFO_PRINTF2( ( a ), ( b ) );	\

												}

#define INFO_PRINTF3_IF_LOGS_ENABLED( a, b, c ) if(iEnableLogs)								\

													{										\

													INFO_PRINTF3( ( a ), ( b ), ( c ) );	\

													}

#define ERR_PRINTF1_IF_LOGS_ENABLED( a ) if(iEnableLogs)		\

											{					\

											ERR_PRINTF1( a );	\

											}											

#define ERR_PRINTF2_IF_LOGS_ENABLED( a, b ) if(iEnableLogs)						\

												{								\

												ERR_PRINTF2( ( a ), ( b ) );	\

												}

#define ERR_PRINTF3_IF_LOGS_ENABLED( a, b, c ) if(iEnableLogs)							\

													{									\

													ERR_PRINTF3( ( a ), ( b ), ( c ) );	\

													}											

const TUid KImageFramePluginUid  = {0x101F7C60};

const TUid KTestImageFramePluginUid = {0x101f7c61};

const TInt KRChunkSize  = 0;

//

// POSITIVE TESTS

//

//

// CTestConvertYuvRchunk

//

 CTestStepYUVConversion::CTestStepYUVConversion(const TDesC& aTestName) : CTestStepConversion(aTestName)

 {

 	iHeapSize = 500000;

 	iEnableLogs = ETrue;//By deafult log the messages    

 }

/*

*

* OpenImageAndYUVDecodeToDesc

* MM-ICL-FRM-I-1001-CP,  MM-ICL-FRM-I-1008-HP

*

*/

TInt CTestStepYUVConversion::DecodeToRChunkAndEncodeToDescL(const TDesC& aFileName)

    {

    // Get the path

    TFileName theSourceFilename;

    Directory(EInput, theSourceFilename);

    theSourceFilename.Append(aFileName);

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

    CleanupClosePushL(iFs);

    INFO_PRINTF2_IF_LOGS_ENABLED(_L("Opening the file %S for "), &theSourceFilename);

    // Open the image and create an image imageDecoder

    CJPEGImageFrameDecoder* imageDecoder = NULL;

	TRAPD(err,imageDecoder = static_cast<CJPEGImageFrameDecoder*>( CImageDecoder::FileNewL(iFs, theSourceFilename, CImageDecoder::EOptionNone, KNullUid, KNullUid, KImageFramePluginUid)));

    if (err != KErrNone)

        {

        INFO_PRINTF3_IF_LOGS_ENABLED(_L("Cannot open file: %S. Unexpected Error: %d"), &theSourceFilename, err);

        User::Leave(err);

        }

    if (imageDecoder == NULL)

        {

        INFO_PRINTF1_IF_LOGS_ENABLED(_L("ImageDecoder is NULL!"));

        User::Leave(err);

        }

    CleanupStack::PushL(imageDecoder);

	INFO_PRINTF2_IF_LOGS_ENABLED(_L("The file %S had been opened."), &theSourceFilename);

    // create destination RChunk

	RChunk chunk;

	TInt imageSizeInBytes;

	TBool supported = imageDecoder->RecommendedBufferSize(imageSizeInBytes);

	if (supported == EFalse)

		{

		INFO_PRINTF1_IF_LOGS_ENABLED(_L("Codec does not support this image format"));

		User::Leave(KErrNotSupported);

		}

	TInt res = chunk.CreateGlobal(_L("aRchunkICL"), imageSizeInBytes, imageSizeInBytes, EOwnerProcess);	

	User::LeaveIfError(res);

	CleanupClosePushL(chunk);

  	// create an empty imageframe   

  	CImageFrame* theImageFrame = NULL;

	TRAP(err, theImageFrame = CImageFrame::NewL(&chunk, imageSizeInBytes, KRChunkSize));

	if (err != KErrNone)

		{

		INFO_PRINTF2_IF_LOGS_ENABLED(_L("Could not do Create imageFrame"),err);

		if (theImageFrame)

			{

			delete theImageFrame;

			}

		User::Leave(err);

		}

		CleanupStack::PushL(theImageFrame);

	// Create an active listener and push it on the cleanup stack

    CActiveListener* activeListener = new (ELeave) CActiveListener;

    CleanupStack::PushL(activeListener);

    activeListener->InitialiseActiveListener();

    // Decode the image

    imageDecoder->ConvertFrame(&activeListener->iStatus, *theImageFrame);

    CActiveScheduler::Start();

    err = activeListener->iStatus.Int();

    if (err != KErrNone)

        {

        ERR_PRINTF2_IF_LOGS_ENABLED(_L("Error during Decoding of the file: %S"), &theSourceFilename);

        User::Leave(err);

        }

    // Encode //

	// Create the destination buffer

	HBufC8 *theDestinationImage = NULL;

	//CleanupStack::PushL(theDestinationImage);

	// Create an object of CJPEGImageFrameEncoder

    CJPEGImageFrameEncoder* imageEncoder = NULL;

	TRAP(err, imageEncoder = static_cast<CJPEGImageFrameEncoder*>( CImageEncoder::DataNewL(theDestinationImage, CImageEncoder::EOptionNone, KNullUid, KNullUid, KImageFramePluginUid)));

	if (err != KErrNone)

		{

		delete theDestinationImage;

		theDestinationImage = NULL;

		ERR_PRINTF3_IF_LOGS_ENABLED(_L("Error during creating Image Encoder UId %d to file %S" ), iImageTypeUid, &iFileNameDest);			 		

		if (err == KErrPathNotFound)

    		{

    		ERR_PRINTF2_IF_LOGS_ENABLED(_L("Path %S not found" ), &iFileNameDest);

    		}

		if (err == KErrAccessDenied)

    		{

    		ERR_PRINTF1_IF_LOGS_ENABLED(_L("Access denied" ));

    		}

		User::Leave(err);

		}

	CleanupStack::PushL(imageEncoder);

    // Create CActiveListener

	CActiveListener* activeEncodeListener = new(ELeave)CActiveListener;

	CleanupStack::PushL( activeEncodeListener );

	iActiveScheduler->SetEncoder(imageEncoder, activeEncodeListener, 0);

	iActiveScheduler->SetStep(this);

	activeEncodeListener->InitialiseActiveListener();

	// Do the Encode from YUV to JPEG

	imageEncoder->ConvertFrame(&activeEncodeListener->iStatus, *theImageFrame);

	CActiveScheduler::Start();

	err = activeEncodeListener->iStatus.Int();

	iActiveScheduler->ResetValues();

    if (err != KErrNone)

		{

		ERR_PRINTF1_IF_LOGS_ENABLED(_L("Error during conversion"));

		User::Leave(err);

		}

	// Cleanup

	CleanupStack::PopAndDestroy(6); //active scheduler

    //compare two file into a flat buffer

	err = CompareFileL(aFileName, theDestinationImage, iImageTypeUid, EReference); 

	User::LeaveIfError(err);

    delete theDestinationImage;

	theDestinationImage = NULL;

	CleanupStack::PopAndDestroy(1);

	return err;

    }

/*

*

* OpenImageAndYUVDecodeToRChunkL

* MM-ICL-FRM-I-1002-CP, MM-ICL-FRM-I-1009-HP 

*

*/

TInt CTestStepYUVConversion::DecodeToRChunkAndEncodeToFileL(const TDesC& aFileName)

    {

    // Get the path

    TFileName theSourceFilename;

    Directory(EInput, theSourceFilename);

    theSourceFilename.Append(aFileName);

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

	CleanupClosePushL(iFs);

	INFO_PRINTF2_IF_LOGS_ENABLED(_L("Opening the file %S for "), &theSourceFilename);

    // Open the image and create an image imageDecoder

    CJPEGImageFrameDecoder* imageDecoder = NULL;

	TRAPD(err,imageDecoder = static_cast<CJPEGImageFrameDecoder*>( CImageDecoder::FileNewL(iFs, theSourceFilename, CImageDecoder::EOptionNone, KNullUid, KNullUid, KImageFramePluginUid)));

    if (err != KErrNone)

        {

        INFO_PRINTF3_IF_LOGS_ENABLED(_L("Cannot open file: %S. Unexpected Error: %d"), &theSourceFilename, err);

        User::Leave(err);

        }

    if (imageDecoder == NULL)

        {

        INFO_PRINTF1_IF_LOGS_ENABLED(_L("ImageDecoder is NULL!"));

        User::Leave(err);

        }

    CleanupStack::PushL(imageDecoder);

	INFO_PRINTF2_IF_LOGS_ENABLED(_L("The file %S had been opened."), &theSourceFilename);

	// create destination RChunk

	RChunk chunk;

	TInt imageSizeInBytes;

	TBool supported = imageDecoder->RecommendedBufferSize(imageSizeInBytes);

	if (supported == EFalse)

		{

		INFO_PRINTF1_IF_LOGS_ENABLED(_L("Codec does not support this image format"));

		User::Leave(KErrNotSupported);

		}

	TInt res = chunk.CreateGlobal(_L("aRchunkICL"), imageSizeInBytes, imageSizeInBytes, EOwnerProcess);	

	User::LeaveIfError(res);

	CleanupClosePushL(chunk);

	// create an empty imageframe   

  	CImageFrame* theImageFrame = NULL;

	TRAP(err, theImageFrame = CImageFrame::NewL(&chunk, imageSizeInBytes,KRChunkSize));

	if (err != KErrNone)

		{

		INFO_PRINTF2_IF_LOGS_ENABLED(_L("Could not do Create imageFrame"),err);

		if (theImageFrame)

			{

			delete theImageFrame;

			}

		User::Leave(err);

		}

		CleanupStack::PushL(theImageFrame);

	// Create an active listener and push it on the cleanup stack

    CActiveListener* activeListener = new (ELeave) CActiveListener;

    CleanupStack::PushL(activeListener);

    activeListener->InitialiseActiveListener();

    // Decode the image

    imageDecoder->ConvertFrame(&activeListener->iStatus, *theImageFrame);

    CActiveScheduler::Start();

    err = activeListener->iStatus.Int();

    if (err != KErrNone)

        {

        ERR_PRINTF2_IF_LOGS_ENABLED(_L("Error during Decoding of the file: %S"), &theSourceFilename);

        User::Leave(err);

        }

    // Encode //

	// Create the destination filename from the source filename

	TBuf<KLenBuffer> theExtension;

	Directory(EOutput, iFileNameDest);

	iFileNameDest.Append(aFileName.Left(aFileName.Length() - 4));

	iFileNameDest.Append(_L("_OUT."));

	GetImageExtension(iImageTypeUid, theExtension);

	iFileNameDest.Append(theExtension);

	// Create an object of CJPEGImageFrameEncoder

    CJPEGImageFrameEncoder* imageEncoder = NULL;

	TRAP(err, imageEncoder = static_cast<CJPEGImageFrameEncoder*>( CImageEncoder::FileNewL(iFs, iFileNameDest, CImageEncoder::EOptionNone, KNullUid, KNullUid, KImageFramePluginUid)));

	if (err != KErrNone)

		{

		ERR_PRINTF3_IF_LOGS_ENABLED(_L("Error during creating Image Encoder UId %d to file %S" ), iImageTypeUid, &iFileNameDest);

		if (err == KErrPathNotFound)

    		{

    		ERR_PRINTF2_IF_LOGS_ENABLED(_L("Path %S not found" ), &iFileNameDest);

    		}

		if (err == KErrAccessDenied)

    		{

    		ERR_PRINTF1_IF_LOGS_ENABLED(_L("Access denied" ));

    		}

		User::Leave(err);

		}

	CleanupStack::PushL(imageEncoder);

    // Create CActiveListener

	CActiveListener* activeEncodeListener = new(ELeave)CActiveListener;

	CleanupStack::PushL(activeEncodeListener);

	iActiveScheduler->SetEncoder(imageEncoder, activeEncodeListener, 0);

	iActiveScheduler->SetStep(this);

	activeEncodeListener->InitialiseActiveListener();

	// Do the Encode from YUV to JPEG

	imageEncoder->ConvertFrame(&activeEncodeListener->iStatus, *theImageFrame);

	CActiveScheduler::Start();

	err = activeEncodeListener->iStatus.Int();

	iActiveScheduler->ResetValues();

    if (err != KErrNone)

		{

		ERR_PRINTF2_IF_LOGS_ENABLED(_L("Error during conversion"),err);

		User::Leave(err);

		}

	// Cleanup

	CleanupStack::PopAndDestroy(6); //active scheduler

	//compare two file into a flat buffer

	TInt fileSize;

	iFile.Open(iFs, iFileNameDest, EFileRead);

	CleanupClosePushL(iFile);

	iFile.Size(fileSize);

	INFO_PRINTF2_IF_LOGS_ENABLED(_L("File Size: %d"),fileSize);

	HBufC8 *theCreatedImage = HBufC8::NewMaxLC(fileSize);

	TPtr8 imageFromFilePtr = theCreatedImage->Des();

	iFile.Read(imageFromFilePtr);

	iFile.Close();

	err = CompareFileL(aFileName, theCreatedImage, iImageTypeUid, EReference); 

    User::LeaveIfError(err);

	// Cleanup

	CleanupStack::PopAndDestroy(3); //theCreatedImage

    return err;

    }

/**

*

* DecodeToDescAndEncodeToDescL

* MM-ICL-FRM-I-1003-CP,  MM-ICL-FRM-I-1010-HP

*

*/

TInt CTestStepYUVConversion::DecodeToDescAndEncodeToDescL(const TDesC& aFileName)

    {

    // Get the path

    TFileName theSourceFilename;

    Directory(EInput, theSourceFilename);

    theSourceFilename.Append(aFileName);

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

    CleanupClosePushL(iFs);

	INFO_PRINTF2_IF_LOGS_ENABLED(_L("Opening the file %S for "), &theSourceFilename);

    // Open the image and create an image imageDecoder

    CJPEGImageFrameDecoder* imageDecoder = NULL;

	TRAPD(err, imageDecoder = static_cast<CJPEGImageFrameDecoder*>( CImageDecoder::FileNewL(iFs, theSourceFilename, CImageDecoder::EOptionNone, KNullUid, KNullUid, KImageFramePluginUid)));

    if (err != KErrNone)

        {

        INFO_PRINTF3_IF_LOGS_ENABLED(_L("Cannot open file: %S. Unexpected Error: %d"), &theSourceFilename, err);

        User::Leave(err);

        }

    if (imageDecoder == NULL)

        {

        INFO_PRINTF1_IF_LOGS_ENABLED(_L("ImageDecoder is NULL!"));

        User::Leave(err);

        }

    CleanupStack::PushL(imageDecoder);

	INFO_PRINTF2_IF_LOGS_ENABLED(_L("The file %S had been opened for Decode."), &theSourceFilename);

	// create destination Desc

	TInt imageSizeInBytes;

	TBool supported = imageDecoder->RecommendedBufferSize(imageSizeInBytes);

	if (supported == EFalse)

	{

		INFO_PRINTF1_IF_LOGS_ENABLED(_L("Codec does not support this image format"));

		User::Leave(KErrNotSupported);

	}

	HBufC8* buffer = HBufC8::NewMaxL(imageSizeInBytes);

	CleanupStack::PushL(buffer);

	TPtr8 ptr = buffer->Des();

	// create an empty imageframe   

	CImageFrame* theImageFrame = NULL;

	TRAP(err, theImageFrame =	CImageFrame::NewL(ptr, imageSizeInBytes));

	if (err != KErrNone)

		{

		INFO_PRINTF2_IF_LOGS_ENABLED(_L("Could not do Create imageFrame"),err);

		if (theImageFrame)

			{

			delete theImageFrame;

			}

		User::Leave(err);

		}

	CleanupStack::PushL(theImageFrame);

	// Create an active listener and push it on the cleanup stack

    CActiveListener* activeListener = new (ELeave) CActiveListener;

    CleanupStack::PushL(activeListener);

    activeListener->InitialiseActiveListener();

    // Decode the image

    imageDecoder->ConvertFrame(&activeListener->iStatus, *theImageFrame);

    CActiveScheduler::Start();

    err = activeListener->iStatus.Int();

    if (err != KErrNone)

        {

        ERR_PRINTF2_IF_LOGS_ENABLED(_L("Error during conversion of the file: %S"), &theSourceFilename);

        User::Leave(err);

        }

    // Encode //

	// Create the destination buffer

	HBufC8 *theDestinationImage = NULL;

	// Create an object of CJPEGImageFrameEncoder

    CJPEGImageFrameEncoder* imageEncoder = NULL;

	TRAP(err, imageEncoder = static_cast<CJPEGImageFrameEncoder*>( CImageEncoder::DataNewL(theDestinationImage, CImageEncoder::EOptionNone, KNullUid, KNullUid, KImageFramePluginUid)));

	if (err != KErrNone)

		{

		ERR_PRINTF3_IF_LOGS_ENABLED(_L("Error during creating Image Encoder UId %d to file %S" ), iImageTypeUid, &iFileNameDest);

		if (err == KErrPathNotFound)

    		{

    		ERR_PRINTF2_IF_LOGS_ENABLED(_L("Path %S not found" ), &iFileNameDest);

    		}

		if (err == KErrAccessDenied)

    		{

    		ERR_PRINTF1_IF_LOGS_ENABLED(_L("Access denied" ));

    		}

		User::Leave(err);

		}

	CleanupStack::PushL(imageEncoder);

    // Create CActiveListener

	CActiveListener* activeEncodeListener = new(ELeave)CActiveListener;

	CleanupStack::PushL( activeEncodeListener );

	iActiveScheduler->SetEncoder(imageEncoder, activeEncodeListener, 0);

	iActiveScheduler->SetStep(this);

	activeEncodeListener->InitialiseActiveListener();

	// Do the Encode from YUV to JPEG

	imageEncoder->ConvertFrame(&activeEncodeListener->iStatus, *theImageFrame);

	CActiveScheduler::Start();

	err = activeEncodeListener->iStatus.Int();

	iActiveScheduler->ResetValues();

    if (err != KErrNone)

		{

		ERR_PRINTF1_IF_LOGS_ENABLED(_L("Error during conversion"));

		delete theDestinationImage;

		theDestinationImage = NULL;

		User::Leave(err);

		}

	// Cleanup

	CleanupStack::PopAndDestroy(6); //active sheduler

    //compare two file into a flat buffer

	err = CompareFileL(aFileName, theDestinationImage , iImageTypeUid, EReference); 

    User::LeaveIfError(err);

    delete theDestinationImage;

	theDestinationImage = NULL;

	CleanupStack::PopAndDestroy(1);

	return err;

    }

/**

*

* DecodeToDescAndEncodeToFileL