// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 // EPOC includes

 #include <e32base.h>

 #include <e32math.h>

 #include <f32file.h>

 #include <s32file.h>

 // Test system includes

 #include "tsu_mmf_CodecTests.h"

 #include "TSU_MMF_DeviceSuite.h"

 //[codec includes ]

 #include <mmf/plugin/mmfhwdeviceimplementationuids.hrh>

 #include "MmfPcm16toAlawhwDevice.h"

 #include "MmfALawToPcm16HwDevice.h"

 #include "mmfpcm16toMulawhwdevice.h"

 #include "MmfMuLawToPcm16hwDevice.h"

 #include "mmfpcmS8ToPcmS16HwDevice.h"

 #include "mmfpcmS16PcmS8HwDevice.h"

 #include "mmfpcm16topcmU16BEHwDevice.h"

 #include "mmfpcm16SwapEndianhwdevice.h"

 #include "mmfpcm16ToImaAdpcm.h"

 #include "MmfImaAdpcmtopcm16hwdevice.h"

 #include "MMFpcm16ToPcm16HwDevice.h"

 #include "MMFpcm16ToPcmU8HwDevice.h"

 #include "MMFpcmU8ToPcm16HwDevice.h"

 #include "mmfpcmS16PcmS8HwDevice.h"

 const TInt KFmtChunkSize = 16;

 const TInt KAuMagic = 0x2e736e64;

 //[ Codec Unit tests  structure 

 // The unit tests shall use text files

 // for small portions of test data 

 // which should be stored are stored in a simple format

 // containing the relevant parameters for the test

 //]

 class TCodecUnitTestParams

 	{	

 public:

 	const TText* iTestName;       // name of the test

 	const TText* iInputFilename;  // input wav file

 	const TText* iComparisonFileName;  // output wav file

 	TInt		 iExpectedResult; // expected result

 	};

 // constant table of parameters for tests

 const TCodecUnitTestParams KTestParameters[] =

 {	

 	{ 

 	_S("MM-MMF-SWCODECDEVICES-U-0010-HP"),   

 	_S("Pcm16Mono8khz400hzTone.wav"),

 	_S("Pcm16BMono8Khz400hzTone.Au"),

 	KErrNone 

 	},

 	{ 

 	_S("MM-MMF-SWCODECDEVICES-U-0011-HP"),   

 	_S("Pcm16Mono8khz400hzTone.wav"),

 	_S("Imaad4BitMono8Khz400hzTone.wav"),

 	KErrNone 

 	},

 	{ 

 	_S("MM-MMF-SWCODECDEVICES-U-0012-HP"),   

 	_S("Imaad4BitMono8Khz400hzTone.wav"),

 	_S("Pcm16Mono8khz400hzTone.wav"),

 	KErrNone 

 	},

 	{ 

 	_S("MM-MMF-SWCODECDEVICES-U-0014-HP"),

 	_S("Pcm16Mono8khz400hzTone.wav"),

 	_S("PcmU8Mono8khz400hzTone.wav"),

 	KErrNone 

 	},

 	{ 

 	_S("MM-MMF-SWCODECDEVICES-U-0015-HP"),

 	_S("PcmU8Mono8khz400hzTone.wav"),

 	_S("Pcm16Mono8khz400hzTone.wav"),

 	KErrNone 

 	},

 	{ 

 	_S("MM-MMF-SWCODECDEVICES-U-0016-HP"),

 	_S("Pcm16Stereo8khz400hzTone.wav"),

 	_S("PcmU8Stereo8khz400hzTone.wav"),

 	KErrNone 

 	},

 };

 /**

 *

 * Print8BitResults

 * @param aRefCodedData

 * @param aCodedData

 * @param aDataLength

 *

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 void CTestStepCodecUnitTest<T,Comparator, A, B, C>::Print8BitResults( TUint8* aRefCodedData, TUint8* aCodedData, TInt aDataLength )

 	{

      __ASSERT_DEBUG(aRefCodedData,Panic(EBadArgument));

 	 __ASSERT_DEBUG(aCodedData,Panic(EBadArgument));

 	for( TInt i = 0; i < aDataLength; i++ )

 		{

         INFO_PRINTF6( _L("delta %u p1 %u p2 %u p1 %x p2 %x"), (*aRefCodedData-*aCodedData),*aRefCodedData, *aCodedData, *aRefCodedData, *aCodedData );

 		aRefCodedData++;

 		aCodedData++;

 		}

 	}

 /**

 *

 * Print16BitResults

 * @param aRefCodedData

 * @param aCodedData

 * @param aDataLength

 *

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 void CTestStepCodecUnitTest<T,Comparator, A, B, C>::Print16BitResults( TUint8* aRefCodedData, TUint8* aCodedData, TInt aDataLength )

 	{

 	//[precondition pointers are aok]

      __ASSERT_DEBUG(aRefCodedData,Panic(EBadArgument));

 	 __ASSERT_DEBUG(aCodedData,Panic(EBadArgument));

 	 //[precondition data is of even length ]

 	 __ASSERT_DEBUG( (aDataLength % 2 == 0),Panic(EBadArgument));

 	TInt length = aDataLength /2;

 	TInt16 refCodedValue = 0;

 	TInt16 codedValue = 0;

 	for( TInt i = 0; i < length; i++ )

 		{

 		refCodedValue  = static_cast<TInt16>( aRefCodedData[0] );  

 		refCodedValue |=  static_cast<TInt16>((aRefCodedData[1] << 8 ));

 		codedValue  = static_cast<TInt16>( aCodedData[0] &KAndMask8bit);  

 		codedValue |=  static_cast<TInt16>((aCodedData[1] << 8 ));

         INFO_PRINTF6( _L("delta %d p1 %d p2 %d p1 %x p2 %x"), (refCodedValue-codedValue),refCodedValue, codedValue, refCodedValue, codedValue );

 		aRefCodedData+=2;

 		aCodedData+=2;

 		}

 	}

 /**

 *

 * CTestStepCodecUnitTest

 *

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 CTestStepCodecUnitTest<T,Comparator, A, B, C>::CTestStepCodecUnitTest( TUint aTestIndex )

 	{

 	//[precondition valid index ]

 //	__ASSERT_DEBUG( (aTestIndex >= 0),Panic(EBadArgument));	// EABI warning removal

 	__ASSERT_DEBUG( (aTestIndex < (sizeof(KTestParameters)/sizeof(TCodecUnitTestParams))),Panic(EBadArgument));

 	// store a pointer to the test parameters

 	iTestParameters = &(KTestParameters[aTestIndex]);

 	// store the name of this test case

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

 	iTestStepName = iTestParameters->iTestName;

 	}

 /**

 *

 * ~CTestStepCodecUnitTest

 *

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 CTestStepCodecUnitTest<T,Comparator, A, B, C>::~CTestStepCodecUnitTest()

 	{

 	}

 /**

 *

 * DoTestStepL

 *

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 TVerdict CTestStepCodecUnitTest<T,Comparator, A, B, C>::DoTestStepL()

 	{

 	__MM_HEAP_MARK;

 	TVerdict result = EPass;

 	// code and decode the input file

     TInt numBuffersToProcess = ComputeBuffersToProcess();

 	TInt codedBufferSize = numBuffersToProcess*iCodecUnderTest->SinkBufferSize();

 	iCodedData = CMMFDescriptorBuffer::NewL( codedBufferSize);

 	// Compare the results and return test status

 	TUint8* ptrSrc  = CONST_CAST(TUint8*,iSourceData->Data().Ptr());

 	TUint8* ptrDest = CONST_CAST(TUint8*,iCodedData->Data().Ptr());

     CMMFDataBuffer* srcBuffer = CMMFDescriptorBuffer::NewL(iCodecUnderTest->SourceBufferSize());

 	CleanupStack::PushL(srcBuffer);

 	CMMFDataBuffer* destBuffer = CMMFDescriptorBuffer::NewL(iCodecUnderTest->SinkBufferSize());

 	TUint8* pInBuffer  = CONST_CAST(TUint8*,srcBuffer->Data().Ptr());

     TUint8* pOutBuffer = CONST_CAST(TUint8*,destBuffer->Data().Ptr());

 	CleanupStack::PushL(destBuffer);

 	for( TInt i = 0; i < numBuffersToProcess;  i++)

 		{

          //[ copy data & increment input pointer]

 		Mem::Copy( pInBuffer, ptrSrc, iCodecUnderTest->SourceBufferSize() );

 		srcBuffer->Data().SetLength( iCodecUnderTest->SourceBufferSize() );

 		ptrSrc+= iCodecUnderTest->SourceBufferSize();

 		 //[ code the data ]

 		iCodecUnderTest->ProcessL( *srcBuffer, *destBuffer);

 		 //[ copy out the data & increment pointer ]

 		Mem::Copy( ptrDest, pOutBuffer, iCodecUnderTest->SinkBufferSize() );

         iCodedData->Data().SetLength( (i+1)*iCodecUnderTest->SinkBufferSize() );

 		destBuffer->Data().SetLength(0); // reset buffer length

 		ptrDest+=iCodecUnderTest->SinkBufferSize();

 		}

 	//[ compare the coded data against the reference data]

 	//[ compare the processed number of bytes in the 

 	// coded buffer to the reference data]

 	__ASSERT_DEBUG( iRefCodedData->Data().Length() >= iCodedData->Data().Length(),Panic(EBadInvariant));

 	TUint8* ptr1 = CONST_CAST(TUint8*,iRefCodedData->Data().Ptr());

 	TUint8* ptr2 = CONST_CAST(TUint8*,iCodedData->Data().Ptr());

 	if(!iComparator.CompareL( ptr1,ptr2, iCodedData->Data().Length())!=0)

 		{

 		 INFO_PRINTF1( _L("Comparison has failed"));

 		//(this->*iPrintFormats[ C ])( ptr1, ptr2, iCodedData->Data().Length() );

 		result = EFail ;

 		}

 	//[ pop buffers ]

 	CleanupStack::PopAndDestroy(2,srcBuffer); //srcBuffer, destBuffer

 	delete iCodedData;

 	iCodedData = NULL;

 	__MM_HEAP_MARKEND;

 	return result;

 	}

 /**

 *

 * DoTestStepPreambleL

 *

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 TVerdict CTestStepCodecUnitTest<T,Comparator,A,B, C>::DoTestStepPreambleL()

 	{

 	//[ assert preconditions on a and b ]

 	__ASSERT_DEBUG( A >= 0, Panic(EBadInvariant)); //sanity check on data

 	__ASSERT_DEBUG( B >= 0, Panic(EBadInvariant)); //sanity check on data

 	__ASSERT_DEBUG( C >= 0, Panic(EBadInvariant)); //sanity check on data

 	__ASSERT_DEBUG( A < 2, Panic(EBadInvariant)); //sanity check on data

 	__ASSERT_DEBUG( B < 2, Panic(EBadInvariant)); //sanity check on data

 	__ASSERT_DEBUG( C < 2, Panic(EBadInvariant)); //sanity check on data

 	//[ initialise file reader callbacks ]

 	iReaders[ 0 ] = &CTestStepCodecUnitTest<T,Comparator,A,B,C>::ReadWavFileL;

     iReaders[ 1 ] = &CTestStepCodecUnitTest<T,Comparator,A,B,C>::ReadAuFileL;

 	//[ initialise print format callbacks ]

 	iPrintFormats[ 0 ] = &CTestStepCodecUnitTest<T,Comparator,A,B,C>::Print8BitResults;

     iPrintFormats[ 1 ] = &CTestStepCodecUnitTest<T,Comparator,A,B,C>::Print16BitResults;

     // make codec

 	iCodecUnderTest = new(ELeave) T; // a cmmfcodec 

 	// [ Parse files into buffers, input & comparison

 	//   using the configured file readers ]

 	TBuf<40> testFileName = iTestParameters->iInputFilename;

 	(this->*iReaders[ A ])(iSourceData, testFileName );

 	testFileName = iTestParameters->iComparisonFileName;

     (this->*iReaders[ B ])(iRefCodedData,testFileName );

 	return EPass;

 	}

 /**

 *

 * DoTestStepPostambleL

 *

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 TVerdict CTestStepCodecUnitTest<T,Comparator, A, B, C>::DoTestStepPostambleL(void)

 	{

     //Destroy Codec

     delete iCodecUnderTest;

 	delete iSourceData;  

 	delete iCodedData;   

 	delete iRefCodedData;

 	return EPass;

 	}

 /**

 * Reads wav file data into the supplied buffer

 * ReadFileL

 * @param

 * @param

 * This function reads the data portion of a wav file

 * into a data buffer

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 void CTestStepCodecUnitTest<T,Comparator, A, B, C>::ReadWavFileL( CMMFDataBuffer* &aBuffer, const TDesC& aFile )

 	{

 	// connect to the file server

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

 	// [open the file and read its data contents into the buffer ]

 	// [the assumption will be the data is stored in wav format only]

 	TFileName fileName = GetSuite()->DefaultPath();

 	fileName.Append(aFile);

 	RFile file1;

 	User::LeaveIfError(file1.Open(iFs, fileName, EFileShareAny | EFileStream | EFileRead));

 	CleanupClosePushL(file1);

     //[ get the size and position of the data from the wav file ]

 	TInt pos  = KFmtChunkSize;

 	User::LeaveIfError(file1.Seek( ESeekStart, pos ));

 	TInt fmtChunkSize = 0;

 	User::LeaveIfError(ReadInt(file1, fmtChunkSize));

 	//[ seek to data chunk size ]

     pos = KFmtChunkSize+fmtChunkSize+8;

 	User::LeaveIfError(file1.Seek(ESeekStart, pos ));    

 	//read data chunk size

 	TInt dataChunkSize = 0;

 	User::LeaveIfError(ReadInt(file1, dataChunkSize));

     //create buffer large eneough to deal with data size

 	TInt fileSize = 0;

 	User::LeaveIfError(file1.Size(fileSize));

 	__ASSERT_DEBUG( fileSize > dataChunkSize, Panic(EBadInvariant)); //sanity check on data

 	aBuffer = CMMFDescriptorBuffer::NewL(dataChunkSize);

 	User::LeaveIfError(file1.Read( aBuffer->Data(),dataChunkSize));

 	aBuffer->Data().SetLength(dataChunkSize);

 	file1.Close();

 	CleanupStack::PopAndDestroy(1); //file1

 	}

 /**

 * Reads Au file data into the supplied buffer

 * ReadFileL

 * @param

 * @param

 * This function reads the data portion of a wav file

 * into a data buffer

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 void CTestStepCodecUnitTest<T,Comparator, A, B, C>::ReadAuFileL( CMMFDataBuffer* &aBuffer, const TDesC& aFile )

 	{

 	// connect to the file server

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

 	// [open the file and read its data contents into the buffer ]

 	TFileName fileName = GetSuite()->DefaultPath();

 	fileName.Append(aFile);

 	RFile file1;

 	User::LeaveIfError(file1.Open(iFs, fileName, EFileShareAny | EFileStream | EFileRead));

 	CleanupClosePushL(file1);

   	TInt magicNumber = 0;

 	User::LeaveIfError(ReadIntB(file1, magicNumber));

     if( magicNumber != KAuMagic )

 		{

          // have not detected the appropriate header

 		 INFO_PRINTF1(_L("Have not detected Au Header ie magic number 0x2e736e64"));

 		 User::Leave( KErrCorrupt );

 		}

 	//[ header size ]

     TInt headerSize = 0;

 	User::LeaveIfError(ReadIntB(file1, headerSize));

 	TInt fileSize = 0;

 	User::LeaveIfError(file1.Size(fileSize));

     //[ filesize - headersize = datasize ]

     TInt dataSize = fileSize - headerSize;

     // [ assert that the datasize >= 0 ]

 	__ASSERT_DEBUG( dataSize >= 0, Panic(EBadInvariant)); //sanity check on data

 	//[Seek to the correct position and read data into Buffer]

 	User::LeaveIfError(file1.Seek(ESeekStart, headerSize )); 

 	__ASSERT_DEBUG( fileSize > dataSize, Panic(EBadInvariant)); //sanity check on data

 	//[ read the data into a Buffer ]

 	aBuffer = CMMFDescriptorBuffer::NewL(dataSize);

 	User::LeaveIfError(file1.Read( aBuffer->Data(),dataSize));

 	aBuffer->Data().SetLength(dataSize);

 	file1.Close();

 	CleanupStack::PopAndDestroy(1); //file1

 	}

 /**

 * Reads file into buffer

 * ReadFileL

 * @param aFile the file from which to read the data

 * @param aValue the returned value

 * This function reads a 32bit value in a rather inefficient way

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 TInt CTestStepCodecUnitTest<T,Comparator, A, B, C>::ReadInt( RFile& aFile, TInt& aValue )

 	{

 	 TUint8 data[4];

      TPtr8 theDes( data, 4 ); 

  	 User::LeaveIfError(aFile.Read( theDes, 4));

      // now assemble the data from the buffer

      aValue  = data[0];

 	 aValue |= data[1] << 8;

 	 aValue |= data[2] << 16;

 	 aValue |= data[3] << 24;

 	 return KErrNone;

 	}

 /**

 * Reads file into buffer

 * ReadFileL

 * @param aFile the file from which to read the data

 * @param aValue the returned value

 * This function reads a 32bit value in BigEndian forma

 and coverts it to Little Endian in a rather inefficient way

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 TInt CTestStepCodecUnitTest<T,Comparator, A, B, C>::ReadIntB( RFile& aFile, TInt& aValue )

 	{

 	 TUint8 data[4];

      TPtr8 theDes( data, 4 ); 

  	 User::LeaveIfError(aFile.Read( theDes, 4));

      // now assemble the data from the buffer

      aValue  = data[3];

 	 aValue |= data[2] << 8;

 	 aValue |= data[1] << 16;

 	 aValue |= data[0] << 24;

 	 return KErrNone;

 	}

 /**

 *

 * ComputeBuffersToProcess

 * @precondition InputBuffer has been setup

 * @precondition Codec has been instantiated

 *

 **/

 template <class T, class Comparator, TInt A, TInt B, TInt C>

 TInt CTestStepCodecUnitTest<T,Comparator, A, B, C>::ComputeBuffersToProcess()

 	{

    	TInt numWholeBuffers = (iSourceData->Data().MaxLength()/iCodecUnderTest->SourceBufferSize() );

 	return numWholeBuffers;

     }

 /**

 *

 * This is used for template instantiation.

 *

 **/

 template class CTestStepCodecUnitTest<CMMFPcm16SwapEndianCodec,TComparator,0,1,1>;

 template class CTestStepCodecUnitTest<CMMFPcm16ToImaAdpcmCodec,TComparator>;

 template class CTestStepCodecUnitTest<CMMFImaAdpcmToPcm16Codec,TDbComparator<>,0,0,1>;

 template class CTestStepCodecUnitTest<CMMFPcm16ToPcmU8Codec,TComparator>;

 template class CTestStepCodecUnitTest<CMMFPcmU8ToPcm16Codec,TDbComparator<>,0,0,1>;

 /**

 *

 * Compare

 * @param aData

 * @param aData2

 * @param aNoSamples

 * @return TBool

 *

 **/

 TBool TComparator::CompareL( TUint8* aData, TUint8* aData2, TInt aLength )

 	{

 	TBool result = ETrue;

     if( !aData )

 		User::Leave(KErrArgument);

 	if( !aData2 )

 		User::Leave(KErrArgument);

 	if( Mem::Compare( aData,aLength, aData2, aLength )!=0)

 		{

 		result = EFalse;

 		}

 	return result;

 	}

 /**

 *

 * Compare

 * @param aData

 * @param aData2

 * @param aNoSamples

 * @result TBool

 *

 **/

 template <TInt T>

 TBool TDbComparator<T>::CompareL( TUint8* aData, TUint8* aData2, TInt aLength )

 	{

 	TBool result = ETrue;

     if( !aData )

 		User::Leave(KErrArgument);

 	if( !aData2 )

 		User::Leave(KErrArgument);

     //[ lets compute the signal to noise ratio ]

     TReal sumSigSquared   = 0.0;

 	TReal sumErrorSquared = 0.0;

 	TUint8* pData = aData;

 	TUint8* pData2 = aData2;

 	TInt numSamples = aLength/2;

 	// compute the sum of sig and error squared

 	for( TInt count = 0; count < numSamples; count++ )

 		{

 		TInt16 sample1  = static_cast<TInt16>( pData[0] &KAndMask8bit);  

 		       sample1 |=  static_cast<TInt16>((pData[1] << 8 ));

 		TInt16 sample2  = static_cast<TInt16>( pData2[0] &KAndMask8bit);  

 		       sample2 |=  static_cast<TInt16>((pData2[1] << 8 ));

 			   pData +=1;

 			   pData2+=2;

 		sumSigSquared   += sample1*sample1;

 		sumErrorSquared += (sample1-sample2)*(sample1-sample2);

 		}

 	TReal sn = 0.0;

 	const TReal tolerance = 0.001;

 	//[precondition error is >= tolerance ]

 	if( sumErrorSquared < tolerance )

 		User::Leave( KErrArgument );

 	//[claculate ratio safely ]

 	Math::Log( sn, (sumSigSquared/sumErrorSquared));

 	sn*= 10;

 	TReal threshold = T; // integer used as real with 100ths db accuracy

 	      threshold /= 100.0;

 	if( sn < threshold )

 		result = EFalse;

 	return result;

 	}