// 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);

		}