// Copyright (c) 2002-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 program is designed the test of the MMF_ACLNT.

// 

//

/**

 @file TestConverter.cpp

*/

#include "TestConverter.h"

#include "mmfwavformat.h"

#include <mmfformatimplementationuids.hrh>

#include <mdaaudiosampleplayer.h>	

#include "WavDecodeUtility.h"		

// from "mmfauformat.h" :

const TUint KAuFileUncompressedDataHeaderSize = 24 ; // 6 times 4 byte quantities

_LIT(KAclntConConfigKeyName, "configAudio");

_LIT(KAclntConDurationKeyName, "configAudio2");

_LIT(KAclntConPositionKeyName, "configAudio3");

_LIT(KAclntConQueryKeyName, "configAudio4");

_LIT(KAclntConDestBitRateKeyName, "configAudio5");

_LIT(KAclntConDestSampleRateKeyName, "configAudio6");

_LIT(KAclntConDestNumberChannelsKeyName, "configAudio7");

_LIT(KAclntConDestDataTypeKeyName, "configAudio8");

_LIT(KAclntConDestFormatKeyName, "configAudio9");

_LIT(KAclntConSourceInfoKeyName, "configAudio10");

/**

 * Constructor

 */

CTestMmfAclntDoConv::CTestMmfAclntDoConv(const TDesC& aTestName, const TDesC& aSectName, 

										 const TDesC& aKeyName, 

										 const TDesC& aSectName2, const TDesC& aKeyName2,

										 TInt	aBits,

										 FormatSpec aFormat)

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = aTestName;

	iSectName = aSectName;

	iKeyName = aKeyName;

	iSectName2 = aSectName2;

	iKeyName2 = aKeyName2;

	iBits = aBits;

	iFormat = aFormat;

	}

CTestMmfAclntDoConv* CTestMmfAclntDoConv::NewL(const TDesC& aTestName, const TDesC& aSectName, 

											   const TDesC& aKeyName, const TDesC& aSectName2, 

											   const TDesC& aKeyName2,

											   TInt	aBits,

											   FormatSpec aFormat)

	{

	CTestMmfAclntDoConv* self = new (ELeave) CTestMmfAclntDoConv(aTestName, aSectName, aKeyName, aSectName2, aKeyName2, aBits, aFormat);

	return self;

	}

void CTestMmfAclntDoConv::MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

	{

	iError = aErrorCode;

	iObject = aObject;

	iPreviousState = aPreviousState;

	iCurrentState = aCurrentState;

	INFO_PRINTF1( _L("CTestMmfAclntDoConv : MMdaObjectStateChangeObserver Callback for CMdaAudioConvertUtility complete"));

	INFO_PRINTF4( _L("iError %d iPreviousState %d iCurrentState %d"), iError, iPreviousState, iCurrentState);

	CActiveScheduler::Stop();

	}

TVerdict CTestMmfAclntDoConv::DoTestStepL()

	{

	INFO_PRINTF1( _L("TestConverter : Do Convert"));

	TVerdict ret = EFail;

	TBuf<KSizeBuf>	filename1;

	TPtrC filename11, filename2;

	if ((!GetStringFromConfig(iSectName, iKeyName, filename11)) || 

		(!GetStringFromConfig( iSectName2, iKeyName2, filename2)))

		return EInconclusive;

	GetDriveName(filename1);

	filename1.Append(filename11);

	//delete previos output file

	RFs	theFs;

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

	theFs.Delete(filename2);	

	theFs.MkDirAll(filename2);

	theFs.Close();

	TMdaUL16RawAudioCodec	theCodecUnsupported;

	TMdaPcmWavCodec			theCodecWav8Bit(TMdaPcmWavCodec::E8BitPcm);

	TMdaPcmWavCodec			theCodecWav16Bit(TMdaPcmWavCodec::E16BitPcm);

	TMdaPackage*			theCodec = NULL;

	switch(iBits)

		{

		case 0:	theCodec = &theCodecWav8Bit; break;

		case 1:	theCodec = &theCodecWav16Bit; break;

		case -1:	theCodec = &theCodecUnsupported; break;

		default: break;

		}

	if(theCodec == NULL)

		return EInconclusive;

	iError = KErrTimedOut;

	CMdaAudioConvertUtility* converter = CMdaAudioConvertUtility::NewL(*this);

	CleanupStack::PushL(converter);

	TMdaFileClipLocation	theLocation(filename2);

	TMdaWavClipFormat		theMdaFormat;

	TMmfAclntWavEncodeClipFormat theMmfFormat;

	TMdaClipFormat* useFormat;

	if(iFormat == MdaFormatSpec)

		useFormat = &theMdaFormat;

	else

		useFormat = &theMmfFormat;

		converter->OpenL(filename1,

						&theLocation,	// Normally file or descriptor

						useFormat,

						theCodec);

	INFO_PRINTF1( _L("Initialise CMdaAudioConvertUtility"));

	CActiveScheduler::Start();

	if(iError == KErrNone)

		ret = DoTestL(converter);

	else if(iError != KErrNone && iBits == -1)

		ret = EPass;

	if (iError != KErrNone)

		ERR_PRINTF2( _L("CMdaAudioConvertUtility failed with error %d"),iError );

	CleanupStack::PopAndDestroy(converter);

	User::After(KOneSecond);

	return ret;	

	}

TVerdict CTestMmfAclntDoConv::DoTestL(CMdaAudioConvertUtility* aConverter)

	{

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	// Convert 44100 -> 8000 sample rate

	const TUint KAclntDestSampleRate = 8000;

	aConverter->SetDestinationSampleRateL(KAclntDestSampleRate);

	// Output as AU file

	aConverter->SetDestinationFormatL(TUid::Uid(KMmfUidFormatAUWrite));

	aConverter->ConvertL();

	INFO_PRINTF1( _L("Convert CMdaAudioConvertUtility"));

	CActiveScheduler::Start();

	// XXX Improve test. e.g. check that a valid AU file is written

	if(iError == KErrNone)

		{

		ret = EPass;

		}

	else

		{

		INFO_PRINTF2(_L("Error returned in MoscoStateChangeEvent callback: %d"), iError);

		ret = EFail;

		}

	if (ret == EPass)

		{

		CActiveScheduler::Start();

		// XXX Improve test. e.g. check that a valid AU file is written

		if(iError == KErrNone)

			{

			ret = EPass;

			}

		else

			{

			INFO_PRINTF2(_L("Error returned in MoscoStateChangeEvent callback: %d"), iError);

			ret = EFail;

			}

		}

	return ret;

	}

//------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntConCloseOpen::CTestMmfAclntConCloseOpen(const TDesC& aTestName)

	:CTestMmfAclntConConfig(aTestName, EPcm16Wav, EFalse)

	{}

CTestMmfAclntConCloseOpen* CTestMmfAclntConCloseOpen::NewL(const TDesC& aTestName)

	{

	CTestMmfAclntConCloseOpen* self = new (ELeave) CTestMmfAclntConCloseOpen(aTestName);

	return self;

	}

/**

 * Open source and destination audio. Close them and open a new source and destination.

 */

TVerdict CTestMmfAclntConCloseOpen::DoTestL(CMdaAudioConvertUtility* aConverter)

	{

	INFO_PRINTF1( _L("TestConverter : Close/Open"));

	TVerdict ret = EFail;

	SetupFormatL(iTestFormat);

	TPtrC toFilename, fromFilename;

	if ((!GetStringFromConfig(_L("SectionOne"), _L("playerAudioFile"), fromFilename)) || (!GetStringFromConfig(_L("SectionFour"), _L("configAudio"), toFilename)))

		return EInconclusive;

	TMdaFileClipLocation location(toFilename);

	iError = KErrTimedOut;

	aConverter->Close(); 

	iError = KErrTimedOut;

	aConverter->OpenL(fromFilename, &location, iFormat, iCodec, NULL);

	// wait for open

	INFO_PRINTF1( _L("Initialise CMdaAudioConvertUtility"));

	CActiveScheduler::Start();

	if(iError == KErrNone)

		ret = EPass;

	return ret;

	}

//------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntConWindow::CTestMmfAclntConWindow(const TDesC& aTestName)

	:CTestMmfAclntConConfig(aTestName, EPcm16Wav, EFalse)

	{}

CTestMmfAclntConWindow* CTestMmfAclntConWindow::NewL(const TDesC& aTestName)

	{

	CTestMmfAclntConWindow* self = new (ELeave) CTestMmfAclntConWindow(aTestName);

	return self;

	}

/**

 * Set convert window. Enquire window. Delete window

 */

TVerdict CTestMmfAclntConWindow::DoTestL(CMdaAudioConvertUtility* aConverter)

	{

	INFO_PRINTF1( _L("*** Converter set window test\n"));

	TVerdict ret = EFail;

	TInt64 temp1, temp2;

	temp1 = aConverter->Duration().Int64()/4;	// set start at first quarter of clip

	temp2 = TInt64(3) * (aConverter->Duration().Int64()/4);	// set end at 3rd quarter of clip

	ASSERT(temp2 > temp1);	// temp1 = start, temp2 = end

	TInt windowDuration = (I64INT(temp2) - I64INT(temp1));

	TTimeIntervalMicroSeconds endTime(temp2); 

	TTimeIntervalMicroSeconds startTime(temp1);

	INFO_PRINTF4(_L("StartTime = %d EndTime = %d WindowDuration = %d"),

		I64INT(startTime.Int64()), I64INT(endTime.Int64()), windowDuration);

	aConverter->SetPlayWindow(startTime,endTime);

	TRAP(iError,aConverter->SetDestinationNumberOfChannelsL(1));

	if (iError != KErrNone)

		return ret ;

	iError = KErrTimedOut;

	INFO_PRINTF1( _L("CMdaAudioConvertUtility::ConvertL"));

	aConverter->ConvertL();

	CActiveScheduler::Start();	// initial MoscoStateChangeEvent callback

	if (iError == KErrNone)

		{

		CActiveScheduler::Start();	// conversion starts here

		if (iError == KErrNone)

			{

			// Check file size is as expected

			TPtrC filename;

			if (!GetStringFromConfig(_L("SectionFour"), _L("configAudio"), filename))

				{

				INFO_PRINTF1(_L("Error getting filename from ini file"));

				ret = EInconclusive;

				}

			else

				{

				ret = CheckFileSize(filename, KConverterWindowFileSize);

				}

			}

		}

	else

		{

		INFO_PRINTF2(_L("iError = %d"), iError);

		ret = EFail;

		}

	// Test clear window

	if (ret == EPass)

		{

		INFO_PRINTF1(_L("*** Converter clear window test\n"));

		iError = KErrTimedOut;

		aConverter->ClearPlayWindow();

		aConverter->ConvertL();

		CActiveScheduler::Start();	// initial MoscoStateChangeEvent callback

		if (iError == KErrNone)

			{

			CActiveScheduler::Start();	// conversion starts here

			if (iError == KErrNone)

				{

				TPtrC filename;

				if (!GetStringFromConfig(_L("SectionFour"), _L("configAudio"), filename))

					{

					INFO_PRINTF1(_L("Error getting filename from ini file"));

					ret = EInconclusive;

					}

				else

					{

					// Second convert will be appended to the first

					ret = CheckFileSize(filename, KConverterWindowPlusNormalFileSize);

					}

				}

			}

		else

			{

			INFO_PRINTF2(_L("iError = %d"), iError);

			ret = EFail;

			}

		}

	return ret;

	}

TVerdict CTestMmfAclntConWindow::CheckFileSize(const TDesC& aFilename, const TInt aExpectedSize)

	{

	TVerdict verdict = EFail;

	RFile file;

	RFs fs;

	TInt ret = fs.Connect();

	if (ret != KErrNone)

		{

		INFO_PRINTF1(_L("Error opening file system!"));

		return EInconclusive;

		}

	// Check file size matches expected size

	TInt err = file.Open(fs, aFilename, EFileRead);

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("Error opening converted file (%d)"), err);

		verdict = EInconclusive;

		}

	else

		{

		TInt size = 0;

		err = file.Size(size);

		if (err != KErrNone || size != aExpectedSize)

			{

			if (err != KErrNone)

				INFO_PRINTF2(_L("Error getting file size (%d)"), err);

			else

				INFO_PRINTF3(_L("Converted file size incorrect (expected %d, got %d)"), aExpectedSize, size);

			verdict = EFail;

			}

		else

			{

			INFO_PRINTF1(_L("Converted file size as expected (test passed)"));

			verdict = EPass;

			}

		file.Close();

		}

	fs.Close();

	return verdict;

	}

//------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntConDuration::CTestMmfAclntConDuration(const TDesC& aTestName)

	:CTestMmfAclntConConfig(aTestName,EPcm16Wav, EFalse)

	{}

CTestMmfAclntConDuration* CTestMmfAclntConDuration::NewL(const TDesC& aTestName)

	{

	CTestMmfAclntConDuration* self = new (ELeave) CTestMmfAclntConDuration(aTestName);

	return self;

	}

void CTestMmfAclntConDuration::GetKeyName(TDes& aDes)

	{

	aDes = KAclntConDurationKeyName;

	}

/** Enquire duration

 */

TVerdict CTestMmfAclntConDuration::DoTestL(CMdaAudioConvertUtility* aConverter)

	{

	INFO_PRINTF1( _L("TestConverter : Duration"));

	TVerdict ret = EFail;

	TTimeIntervalMicroSeconds duration(KSoundFileLength); // 8 second sound file!

	//since format+codec have wrrong default values

	TRAP(iError,aConverter->SetDestinationSampleRateL(8000));

	TRAP(iError,aConverter->SetDestinationNumberOfChannelsL(1));

	//TRAP(iError,aConverter->ConvertL());

	if(KErrNone == iError && (aConverter->Duration() == duration))

		{

		INFO_PRINTF3(_L("Duration  = %f mkS Record time  =  %f mkS"),

				I64REAL(duration.Int64()), 

				I64REAL(aConverter->RecordTimeAvailable().Int64()));

		ret = EPass;

		}

	else

		{

		TInt64		durationExpected = duration.Int64();

		TInt64		durationReceived = aConverter->Duration().Int64();	

		INFO_PRINTF3( _L("Expected duration: %f, received duration: %f"), I64REAL(durationExpected), I64REAL(durationReceived));

		}

	return ret;

	}

void CTestMmfAclntConDuration::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt /*aCurrentState*/, TInt aErrorCode)

	{

	iError = aErrorCode;

	INFO_PRINTF1( _L("CTestMmfAclntDelete : MMdaObjectStateChangeObserver Callback for CMdaAudioConvertUtility complete"));

	INFO_PRINTF2( _L("iError %d"), iError);

	CActiveScheduler::Stop();

	}

//------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntConPosition::CTestMmfAclntConPosition(const TDesC& aTestName,const	TTimeIntervalMicroSeconds aPosition)

	:CTestMmfAclntConConfig(aTestName,EPcm16Wav, EFalse)

	{

	iPosition = aPosition;

	}

CTestMmfAclntConPosition* CTestMmfAclntConPosition::NewL(const TDesC& aTestName,const TTimeIntervalMicroSeconds aPosition)

	{

	CTestMmfAclntConPosition* self = new (ELeave) CTestMmfAclntConPosition(aTestName, aPosition);

	return self;

	}

void CTestMmfAclntConPosition::GetKeyName(TDes& aDes)

	{

	aDes = KAclntConPositionKeyName;

	}

/**

 * Set position and enquire position. Sound is always set to minus one

 * frame, becuase DevSound has to play something. (Even if set to the end of the clip).

 *

 */

TVerdict CTestMmfAclntConPosition::DoTestL(CMdaAudioConvertUtility* aConverter)

	{

	INFO_PRINTF1( _L("TestConverter : Position"));

	TVerdict ret = EFail; 

	//  Set position: middle of clip.

	if (I64INT(iPosition.Int64()) == 0)

		iPosition = I64INT(aConverter->Duration().Int64())/2;

	// Set position: end of clip.

	if (I64INT(iPosition.Int64()) == -1)

		iPosition = aConverter->Duration();

	// Position is beyond the end of the clips duration.

	// so check that the value is clipped.

	if(aConverter->Duration() < iPosition)

		{

		TInt64 temp = (aConverter->Duration().Int64() / KPcm16FrameInterval) - 1; // -1 for DevSound

		aConverter->SetPosition(iPosition);

		TInt64 theReceived = aConverter->Position().Int64();

		TInt64 theExpected = temp * KPcm16FrameInterval;

		TBool theRes = TimeComparison(I64INT(theReceived), I64INT(theExpected), KExpectedDeviation);

		if(theRes == (TBool) ETrue)

			ret = EPass;

		INFO_PRINTF3( _L("Expected position : %d, Received position : %d"), theExpected, theReceived);

		}

	// Position is before the beginning of the clip

	// so check that the value is zero

	else if(iPosition < TTimeIntervalMicroSeconds(0))

		{

		TInt	theExpected = 0;

		aConverter->SetPosition(iPosition);

		TInt	theReceived = I64INT(aConverter->Position().Int64());

		TBool theRes = TimeComparison(theReceived, theExpected, 0);

		if(theRes)

			ret = EPass;

		INFO_PRINTF3( _L("Expected position : %d, Received position : %d"), theExpected, theReceived);

		}

	else

		{

		//Original

		/*

		aConverter->SetPosition(iPosition);

		aConverter->ConvertL();

		CActiveScheduler::Start();

		TInt64 temp = (iPosition.Int64() / KPcm16FrameInterval) - 1; // -1 for DevSound

		TInt	theReceived = I64INT(aConverter->Position().Int64());

		TInt	theExpected = I64INT(temp) * KPcm16FrameInterval;

		TBool theRes = TimeComparison(theReceived, theExpected, KExpectedDeviation);

		if(theRes == (TBool) ETrue)

			{

			ret = EPass;

			}

		INFO_PRINTF3( _L("Expected position : %d, Received position : %d"), theExpected, theReceived);

		*/

		//Amendment

		TInt	theDurationa = I64INT(aConverter->Duration().Int64());

		aConverter->SetPosition(iPosition);

		TInt	theExpected = I64INT(aConverter->Position().Int64());

			//ConvertL requires two CActiveScheduler::Start()

		aConverter->ConvertL();

		CActiveScheduler::Start();

		CActiveScheduler::Start();

		TPtrC toFilename, fromFilename;

		GetStringFromConfig(_L("SectionFour"), _L("configAudio"), fromFilename); 

		GetStringFromConfig(_L("SectionFour"), _L("configAudio12"), toFilename);

		TMdaFileClipLocation location2(toFilename);

		aConverter->OpenL(fromFilename, &location2, iFormat, iCodec);

		CActiveScheduler::Start();

		TInt	theDurationb = I64INT(aConverter->Duration().Int64());

		TInt	theReceived = theDurationa - theDurationb;

		TBool theRes = TimeComparison(theReceived, theExpected, KDeviation);

		if(theRes == (TBool) ETrue)

			{

			ret = EPass;

			}

		INFO_PRINTF3( _L("Expected position : %d, Received position : %d"), theExpected, theReceived);

		}

	return ret;

	}

//------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntConConfig::CTestMmfAclntConConfig(const TDesC& aTestName, const TTestFormat aFormat, const TBool aNegative)

	{

	iTestStepName = aTestName;

	iThisIsNegativeTest = aNegative;

	iTestFormat = aFormat;

	}

CTestMmfAclntConConfig* CTestMmfAclntConConfig::NewL(const TDesC& aTestName, const TTestFormat aFormat, const TBool aNegative)

	{

	CTestMmfAclntConConfig* self = new (ELeave) CTestMmfAclntConConfig(aTestName, aFormat, aNegative);

	return self;

	}

void CTestMmfAclntConConfig::MoscoStateChangeEvent(CBase* /*aObject*/, 

												   TInt /*aPreviousState*/, 

												   TInt /*aCurrentState*/, 

												   TInt aErrorCode)

	{

	iError = aErrorCode;

	INFO_PRINTF1( _L("CTestMmfAclntConConfig : MMdaObjectStateChangeObserver Callback for CMdaAudioConvertUtility complete"));

	INFO_PRINTF2( _L("iError %d"), iError);

	CActiveScheduler::Stop();

	}

void CTestMmfAclntConConfig::GetKeyName(TDes& aDes)

	{

	aDes = KAclntConConfigKeyName;

	}

TVerdict CTestMmfAclntConConfig::DoTestStepPreambleL()

	{

	TVerdict ret = EPass;

	SetupFormatL(iTestFormat);

	TBuf<64> keyName;

	GetKeyName(keyName);

	// Make sure file doesn't exist (maybe from a previous test)

	TParse fullFileName;

	TPtrC filename;

	if(!GetStringFromConfig(_L("SectionFour"), keyName, filename))

		return EInconclusive;

	// parse the filenames

		if(!fullFileName.Set(filename, &KDefault, NULL))

		{

		RFs fs;

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

		TInt error = fs.Delete(fullFileName.FullName());

		if(error == KErrPathNotFound)

			{

				error = fs.MkDirAll(fullFileName.DriveAndPath());

				INFO_PRINTF2(_L("Path for file %S was been created"), &fullFileName.FullName());	

			}

		else if(error == KErrNotFound)

			INFO_PRINTF2(_L("No need to delete %S"), &fullFileName.FullName());	

		else if(error==KErrNone)

			INFO_PRINTF2(_L("Deleted %S"), &fullFileName.FullName());	

		else

			ret = EInconclusive;

		fs.Close();

		}

	if((ret == EInconclusive) || (ret == EFail))

		{

		return ret;	

		}

	return CTestMmfAclntStep::DoTestStepPreambleL();

	}

/**

 * Set config destination clip

 */

TVerdict CTestMmfAclntConConfig::DoTestStepL()

	{

	INFO_PRINTF1( _L("TestConverter : Config"));

	TVerdict ret = EFail;

	TPtrC toFilename, fromFilename;

	if ((!GetStringFromConfig(_L("SectionOne"), _L("playerAudioFile"), fromFilename)) 

		|| (!GetStringFromConfig(_L("SectionFour"), _L("configAudio"), toFilename)))

		return EInconclusive;

	// Delete the old file if it exists

	RFs fs;

	TInt err = fs.Connect();

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("Error doing fs.Connect (%d)"), err);

		return EInconclusive;

		}

	err = fs.Delete(toFilename);

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

		{

		INFO_PRINTF3(_L("Error deleting 'toFilename' (%S) %d"), &toFilename, err);

		return EInconclusive;

		}

	fs.Close();

	TMdaFileClipLocation location(toFilename);

	iError = KErrTimedOut;

	CMdaAudioConvertUtility* converter = CMdaAudioConvertUtility::NewL(*this);

	CleanupStack::PushL(converter);

	if (iThisIsNegativeTest)

		{

		iAudioSettings.iSampleRate = KInvalidNumber;

		iAudioSettings.iChannels = KInvalidNumber;

		converter->OpenL(fromFilename, &location, iFormat, iCodec, &iAudioSettings);

		}

	else

		{

		  converter->OpenL(fromFilename, &location, iFormat, iCodec);

		}

	INFO_PRINTF1( _L("Initialise CMdaAudioConvertUtility"));

	CActiveScheduler::Start();

	//TRAP(iError, converter->SetDestinationNumberOfChannelsL(1));

	if (iError == KErrNone)

		ret = DoTestL(converter);

	if (ret == EFail)

		INFO_PRINTF2( _L("CMdaAudioConvertUtility failed with error %d"),iError );

	if(iThisIsNegativeTest && iError == KErrNotSupported)

		{

			ret = EPass;	

		}

	CleanupStack::PopAndDestroy(converter);

	User::After(KOneSecond);

	return ret;	

	}

TVerdict CTestMmfAclntConConfig::DoTestL(CMdaAudioConvertUtility* aConverter)

	{

	TVerdict ret = EFail;

	iError = KErrTimedOut;

	aConverter->ConvertL(); 

	INFO_PRINTF1( _L("Convert CMdaAudioConvertUtility"));

	CActiveScheduler::Start();

	// a negative test will fail succesfully at this point

	if (!iThisIsNegativeTest)

		ret = EPass;

	else if (iError == KErrNotSupported)

		ret = EPass;

	return ret;

	}

//------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntConQuery::CTestMmfAclntConQuery(const TDesC& aTestName)

	:CTestMmfAclntConConfig(aTestName, EPcm16Wav, EFalse)

	{}

CTestMmfAclntConQuery* CTestMmfAclntConQuery::NewL(const TDesC& aTestName)

	{

	CTestMmfAclntConQuery* self = new (ELeave) CTestMmfAclntConQuery(aTestName);

	return self;

	}

void CTestMmfAclntConQuery::GetKeyName(TDes& aDes)

	{

	aDes = KAclntConQueryKeyName;

	}

TVerdict CTestMmfAclntConQuery::DoTestStepL()

	{

	INFO_PRINTF1( _L("TestConverter : ConQuery"));

	TVerdict ret = EFail;

	TPtrC toFilename, fromFilename;

	if ((!GetStringFromConfig(_L("SectionOne"), _L("playerAudioFile"), fromFilename)) 

	//if ((!GetStringFromConfig(_L("SectionSeven"), _L("auFile"), fromFilename)) 

	//if ((!GetStringFromConfig(_L("SectionSeven"), _L("rawFile"), fromFilename)) 

	|| (!GetStringFromConfig(_L("SectionFour"), _L("configAudio4"), toFilename)))

		return EInconclusive;

	TMdaFileClipLocation location(toFilename);

	iError = KErrTimedOut;

	CMdaAudioConvertUtility* converter = CMdaAudioConvertUtility::NewL(*this);

	CleanupStack::PushL(converter);

	converter->OpenL(fromFilename, &location, iFormat, iCodec);

	INFO_PRINTF1( _L("Initialise CMdaAudioConvertUtility"));

	CActiveScheduler::Start();

	if (iError == KErrNone)

		ret = DoTestL(converter);

	if (ret == EFail)

		INFO_PRINTF2( _L("CMdaAudioConvertUtility failed with error %d"),iError );

	CleanupStack::PopAndDestroy(converter);

	User::After(KOneSecond);

	return ret;	

	}

/**

 * query transformations available.

 */

TVerdict CTestMmfAclntConQuery::DoTestL(CMdaAudioConvertUtility* aConverter)

	{

	INFO_PRINTF1( _L("TestConverter : Query Transactions"));

	RArray<TFourCC>		theSupportedDataTypes;

	TInt err ; 

	TRAP(err,aConverter->GetSupportedDestinationDataTypesL(theSupportedDataTypes));

	if(err!=KErrNone)

		{

		INFO_PRINTF2(_L("CMdaAudioConvertUtility::GetSupportedDataTypesL left with error %d"),err);

		return EFail;

		}

	TUint8		theBuffer8[KSizeBuf];

	INFO_PRINTF1( _L("The supported available transformation"));

	for(TInt	index = 0; index < theSupportedDataTypes.Count() ; index++)

		{

		 TFourCC&	four = 	theSupportedDataTypes[index];

		 TPtr8		ptrFour(theBuffer8, KSizeBuf);

		 four.FourCC(&ptrFour);

		 TBuf<KSizeBuf>	theBuf;

		 theBuf.Copy(ptrFour);

		 INFO_PRINTF3( _L("%d  %S"), index, &theBuf);

		}

	return EPass;	

	}

//-------------------------------------------------------------------

// Negative tests

//-------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntDelete::CTestMmfAclntDelete()

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = _L("MM-MMF-ACLNT-I-1051-CP");

	}

void CTestMmfAclntDelete::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt /*aCurrentState*/, TInt aErrorCode)

	{

	iError = aErrorCode;

	INFO_PRINTF1( _L("CTestMmfAclntDelete : MMdaObjectStateChangeObserver Callback for CMdaAudioConvertUtility complete"));

	INFO_PRINTF2( _L("iError %d"), iError);

	CActiveScheduler::Stop();

	}

/**

 * Conversion utility - Delete object before conversion operation has completed.

 */

TVerdict CTestMmfAclntDelete::DoTestStepL( void )

	{

	INFO_PRINTF1( _L("TestConverter : Delete"));

	TPtrC sourceFileName, targetFileName;

	if((!GetStringFromConfig(_L("SectionOne"), _L("playerAudioFile"), sourceFileName)) || 

		(!GetStringFromConfig(_L("SectionFour"), _L("configAudio"), targetFileName)))

		return EInconclusive;

	RFs		theFs;

	theFs.Connect();

	theFs.Delete(targetFileName);

	theFs.Close();

	iError = KErrTimedOut;

	TMdaFileClipLocation location(targetFileName);

	TMdaWavClipFormat	format;

	TMdaPcmWavCodec		codec;

	__MM_HEAP_MARK;

	CMdaAudioConvertUtility* converter = CMdaAudioConvertUtility::NewL(*this);

	CleanupStack::PushL(converter);

	converter->OpenL(sourceFileName,&location, &format, &codec);

	INFO_PRINTF1( _L("Initialise CMdaAudioConvertUtility"));

	CActiveScheduler::Start();

	if(iError == KErrNone)

		{

		converter->ConvertL(); 

		INFO_PRINTF1( _L("Convert CMdaAudioConvertUtility"));

		//User::After(3 * KOneSecond);		

		CleanupStack::PopAndDestroy(converter);

		User::After(KOneSecond);

		INFO_PRINTF1( _L("Destroy CMdaAudioConvertUtility"));

		__MM_HEAP_MARKEND;

		User::Heap().Check();

		return	EPass;

		}

	ERR_PRINTF2( _L("CMdaAudioConvertUtility failed with error %d"),iError );

	CleanupStack::PopAndDestroy(converter);

	User::After(KOneSecond);

	return EFail;

	}

//------------------------------------------------------------------

/**

 * Constructor

 */

CTestMmfAclntOpenWhileConvert::CTestMmfAclntOpenWhileConvert(const TDesC& aTestName)

	:CTestMmfAclntConConfig(aTestName, EPcm16Wav,EFalse)

	{

	}

CTestMmfAclntOpenWhileConvert* CTestMmfAclntOpenWhileConvert::NewL(const TDesC& aTestName)

	{

	CTestMmfAclntOpenWhileConvert* self = new (ELeave) CTestMmfAclntOpenWhileConvert(aTestName);

	return self;

	}

/**

 * Open new file while audio converter is converting. Open a new audio file.

 */

TVerdict CTestMmfAclntOpenWhileConvert::DoTestL(CMdaAudioConvertUtility* aConverter)

	{

	INFO_PRINTF1( _L("TestConverter : Open/Convert"));

	TPtrC auFilename, wavFilename;

	//if((!GetStringFromConfig(_L("SectionFour"), _L("auAudioFile"), auFilename)) || 

	//	(!GetStringFromConfig(_L("SectionFour"), _L("wavAudioFile"), wavFilename)))

	if((!GetStringFromConfig(_L("SectionOne"), _L("PCM8"), auFilename)) || 

		(!GetStringFromConfig(_L("SectionFour"), _L("PCM16_out"), wavFilename)))

		return EInconclusive;

	RFs	theFs;

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

	theFs.Delete(wavFilename);

	theFs.MkDirAll(wavFilename);

	theFs.Close();

	iError = KErrTimedOut;

	TMdaFileClipLocation location(wavFilename);

	TMdaWavClipFormat format;

	TMdaPcmWavCodec		codec(TMdaPcmWavCodec::E16BitPcm);

	aConverter->ConvertL(); 

	INFO_PRINTF1( _L("Convert CMdaAudioConvertUtility"));

	User::After(KOneSecond);		

	aConverter->OpenL(auFilename,&location, &format, &codec);

	INFO_PRINTF1( _L("Initialise CMdaAudioConvertUtility"));

	// wait for open

	CActiveScheduler::Start();

	if(iError == KErrInUse || iError == KErrNone)

		return	EPass;

	return EFail;

	}

//------------------------------------------------------------------

CTestMmfAclntConvertDestBitRate::CTestMmfAclntConvertDestBitRate(const TDesC& aTestName, TBool aNegative)

	: CTestMmfAclntConConfig(aTestName, EPcm16Wav, aNegative)