// 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:
// TSU_MMF_CodecTests.cpp
// 
//

// EPOC includes
#include <e32base.h>
#include <e32math.h>
#include <f32file.h>
#include <s32file.h>

// Test system includes
#include "TSU_MMF_DeviceSuite.h"
#include "TSU_MMF_SignConversionCodecs.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"


//[ 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 TSignConversionTestParams
	{	
public:
	const TText* iTestName;       // name of the test
	};

// constant table of parameters for tests
const TSignConversionTestParams KSignConversionParameters[] =
	{	
		{_S("MM-MMF-SWCODECDEVICES-U-0017-HP")},
		{_S("MM-MMF-SWCODECDEVICES-U-0018-HP")},
		{_S("MM-MMF-SWCODECDEVICES-U-0019-HP")},
		{_S("MM-MMF-SWCODECDEVICES-U-0020-HP")}, 
		{_S("MM-MMF-SWCODECDEVICES-U-0021-HP")}
	};

/**
*
* PrintComparisonDataL
* @param aCodedData the coded data buffer
* @param aRefCodedData the reference coded data buffer
* 
*/
void CMMFDataGenerator::PrintComparisonDataL( CMMFDataBuffer& aCodedData, CMMFDataBuffer& aRefCodedData )
	{
	//[precondition reference coded data is equal in size or longer than coded data ]
	if( aRefCodedData.Data().Length() < aCodedData.Data().Length() )
		{
         //[coded data is longer than reference data]
	//	RDebug::Print(_L("Coded Data is longer than refernce data")); Commented under DEF105143
		User::Leave( KErrCorrupt );	 
		}

	TUint8* ptr1 = CONST_CAST(TUint8*, aCodedData.Data().Ptr());
	TUint8* ptr2 = CONST_CAST(TUint8*, aRefCodedData.Data().Ptr());
    TInt length = aCodedData.Data().Length();
	//[ now print the results for comparison ]
	for( TInt i = 0; i < length; i++ )
		{
        RDebug::Print( _L("difference: %d, coded: %d, RefCoded: %d"), (*ptr1-*ptr2), *ptr1++, *ptr2++ );
		} 
	}

/**
*
* AssembleValue
* @param aData src data buffer 
* @param aValue resultant value
* @param aBigEndian whether the value is in BigEndian format
* @precondition aData is not null and has length >= 2
*
*/
void CMMFDataGenerator::AssembleValue( TUint8* aData, TInt16& aValue, TBool aBigEndian )
	{
	__ASSERT_DEBUG( aData, Panic(EBadArgument));
    if( aBigEndian )
		{
		aValue  = static_cast<TInt16>( aData[1] &KAndMask8bit );  
		aValue |=  static_cast<TInt16>((aData[0] << 8 ));
		}
	else
		{
		aValue  = static_cast<TInt16>( aData[0] &KAndMask8bit);  
		aValue |=  static_cast<TInt16>((aData[1] << 8 ));
		}
	}

/**
*
* AssembleValue
* @param aData src data buffer 
* @param aValue resultant value
* @param aBigEndian whether the value is in BigEndian format
* @precondition aData is not null and has length >= 2
*
*/
void CMMFDataGenerator::AssembleValue( TUint8* aData, TUint16& aValue, TBool aBigEndian )
	{
	__ASSERT_DEBUG( aData, Panic(EBadArgument));
	if( aBigEndian )
		{
		aValue     = aData[1] ; //[ big endian format]
		aValue    |= (aData[0] << 8 ); 
		}
	else
		{
		aValue     = aData[0] ; 
		aValue    |= (aData[1] << 8 ); 
		}
	}
/**
*
* CMMFPcmU16toPcmU16BGenerator
*
**/
CMMFPcmU16toPcmU16BGenerator::CMMFPcmU16toPcmU16BGenerator()
	{
	}

/**
*
* ~CMMFPcmU16toPcmU16BGenerator
*
**/
CMMFPcmU16toPcmU16BGenerator::~CMMFPcmU16toPcmU16BGenerator()
	{
	}

/**
*
* GenerateSourceDataL
*
**/
void CMMFPcmU16toPcmU16BGenerator::GenerateSourceDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	{
	const TUint16 KScale2 = 32000;

	 //[ create a buffer large enough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);

	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());

	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
	 TUint16 srcValue = 0;
	 TReal val   = 0.0;
	 TReal theta = 0.0; 

	 TInt noSamples = aSize/sizeof(TInt16);
	 for(TInt i=0; i< noSamples; i++)
		 {
		 //[ assign data and place in buffer]
		  theta = (KPi*i)/10; // fundamental of 400hz sampled @8khz has 20 db or
		                      // better reproduction through gsm codec
		  User::LeaveIfError(Math::Sin(val,theta));
          srcValue = static_cast<TUint16>( (KScale2 * val ) + KScale2+0.5);
          *pDst++ = static_cast<TUint8>( srcValue &KAndMask8bit);
		  *pDst++ = static_cast<TUint8>( (srcValue >>8) &KAndMask8bit);
		 }
    
	 aBuffer->Data().SetLength(aSize); 
	}

/**
*
* GenerateComparisonDataL
*
**/
void CMMFPcmU16toPcmU16BGenerator::GenerateComparisonDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	{
	const TUint16 KScale2 = 32000;

	 //[ create a buffer large eneough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);

	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());

	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
	 TUint16 srcValue = 0;
	 TReal val   = 0.0;
	 TReal theta = 0.0; 

	 TInt noSamples = aSize/sizeof(TInt16);
	 for(TInt i=0; i< noSamples; i++)
		 {
		 //[ assign data and place in buffer]
		  theta = (KPi*i)/10; // fundamental of 400hz sampled @8khz has 20 db or
		                      // better reproduction through gsm codec
		  User::LeaveIfError(Math::Sin(val,theta));
          srcValue = static_cast<TUint16>( (KScale2 * val)+KScale2 +0.5);
          //[endian swap here ]
		  *pDst++ = static_cast<TUint8>( (srcValue >>8) &KAndMask8bit);
		  *pDst++ = static_cast<TUint8>( srcValue &KAndMask8bit);
		 }
    
	 aBuffer->Data().SetLength(aSize); 
	}

/**
*
* PrintComparisonDataL
* Prints out coded results for comparison with the 
* Reference values and is used when the results differ
*
**/
void CMMFPcmU16toPcmU16BGenerator::PrintComparisonDataL( CMMFDataBuffer& aCodedData, CMMFDataBuffer& aRefCodedData )
	{
	//[precondition reference coded data is equal in size or longer than coded data ]
	if( aRefCodedData.Data().Length() < aCodedData.Data().Length() )
		{
         //[coded data is longer than reference data]
	//	RDebug::Print( _L("Coded Data is longer than refernce data"));Commented under DEF105143
		User::Leave( KErrCorrupt );	 
		}

	//[ now print the results for comparison ]
    TUint8* ptr1 = CONST_CAST(TUint8*, aCodedData.Data().Ptr());
	TUint8* ptr2 = CONST_CAST(TUint8*, aRefCodedData.Data().Ptr());
    TInt length = aCodedData.Data().Length();
	length /= 2; // [for 16bit words length is half]
	//[ assert invariant length is even ]
	__ASSERT_DEBUG( (length % 2 == 0 ), Panic(EBadInvariant));

	TUint16 codedValue = 0;
	TUint16 refCodedValue = 0;
	//[ now print the results for comparison ]
	for( TInt i = 0; i < length; i++ )
		{
		//[ assemble 16bit values from buffer values ]    
		AssembleValue( ptr1, codedValue, ETrue );
		AssembleValue( ptr2, refCodedValue, ETrue );       
		RDebug::Print( _L("difference: %u, coded: %u, RefCoded: %u"), (refCodedValue-codedValue), codedValue, refCodedValue );
		if( i % 100 == 0 ) //deal with debug printf deficiencies
			{
			User::After(100 );
			}
		ptr1+=2;
		ptr2+=2;
		} 
 	}

/**
*
* CMMFPcmU16BtoPcmU16Generator
*
**/
CMMFPcmU16BtoPcmU16Generator::CMMFPcmU16BtoPcmU16Generator()
	{
	}

/**
*
* ~CMMFPcmU16BtoPcmU16Generator
*
**/
CMMFPcmU16BtoPcmU16Generator::~CMMFPcmU16BtoPcmU16Generator()
	{
	}

/**
*
* GenerateSourceDataL
*
**/
void CMMFPcmU16BtoPcmU16Generator::GenerateSourceDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	{
	const TUint8 KScale2 = 127;

	 //[ create a buffer large eneough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);

	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());

	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
	 TInt8 srcValue = 0;
	 TReal val   = 0.0;
	 TReal theta = 0.0; 

	 TInt noSamples = aSize/sizeof(TInt16);
	 for(TInt i=0; i< noSamples; i++)
		 {
		 //[ assign data and place in buffer]
		  theta = (KPi*i)/10; // fundamental of 400hz sampled @8khz has 20 db or
		                      // better reproduction through gsm codec
		  User::LeaveIfError(Math::Sin(val,theta));
          srcValue = static_cast<TUint8>( (KScale2 * val) );
          //[endian swap here ]
		  *pDst++ = static_cast<TUint8>( (srcValue >>8) &KAndMask8bit);
		  *pDst++ = static_cast<TUint8>( srcValue &KAndMask8bit);
		 }
    
	 aBuffer->Data().SetLength(aSize); 
	}

/**
*
* GenerateComparisonDataL
*
**/
void CMMFPcmU16BtoPcmU16Generator::GenerateComparisonDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	{
	const TUint8 KScale2 = 127;

	 //[ create a buffer large eneough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);

	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());

	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
	 TUint16 srcValue = 0;
	 TReal val   = 0.0;
	 TReal theta = 0.0; 
	 TInt noSamples = aSize/sizeof(TInt16);
	 for(TInt i=0; i< noSamples; i++)
		 {
		 //[ assign data and place in buffer]
		  theta = (KPi*i)/10; // fundamental of 400hz sampled @8khz has 20 db or
		                      // better reproduction through gsm codec
		  User::LeaveIfError(Math::Sin(val,theta));
          srcValue = static_cast<TUint16>( KScale2 * val );
		  *pDst++ = static_cast<TUint8>( srcValue &KAndMask8bit);
		  *pDst++ = static_cast<TUint8>( (srcValue >>8) &KAndMask8bit);
		 }
    
	 aBuffer->Data().SetLength(aSize); 
	}

/**
*
* PrintComparisonDataL
* Prints out coded results for comparison with the 
* Reference values and is used when the results differ
*
**/
void CMMFPcmU16BtoPcmU16Generator::PrintComparisonDataL( CMMFDataBuffer& aCodedData, CMMFDataBuffer& aRefCodedData )
	{
	//[precondition reference coded data is equal in size or longer than coded data ]
	if( aRefCodedData.Data().Length() < aCodedData.Data().Length() )
		{
		//[coded data is longer than reference data]
	//	RDebug::Print( _L("Coded Data is longer than refernce data"));Commented under DEF105143
		User::Leave( KErrCorrupt );	 
		}
	
	//[ now print the results for comparison ]
    TUint8* ptr1 = CONST_CAST(TUint8*, aCodedData.Data().Ptr());
	TUint8* ptr2 = CONST_CAST(TUint8*, aRefCodedData.Data().Ptr());
    TInt length = aCodedData.Data().Length();
	length /= 2; //[ for 16bit words ]
	TUint16 codedValue = 0;
	TUint16 refCodedValue = 0;
	//[ now print the results for comparison ]
	for( TInt i = 0; i < length; i++ )
		{
		// assemble 16bit values
		AssembleValue( ptr1, codedValue, EFalse);
		AssembleValue( ptr2, refCodedValue, EFalse );        
		RDebug::Print( _L("difference: %u, coded: %u, RefCoded: %u"), (refCodedValue-codedValue), codedValue, refCodedValue );
		if( i % 100 == 0 ) //deal with debug printf deficiencies
			{
			User::After( 100 );
			}
		ptr1+=2;
		ptr2+=2;
		} 	
	}

/**
*
* CMMFPcm8ToPcm16Generator
*
**/
CMMFPcm8ToPcm16Generator::CMMFPcm8ToPcm16Generator()
	{
	}

/**
*
* CMMFPcm8ToPcm16Generator
*
**/
CMMFPcm8ToPcm16Generator::~CMMFPcm8ToPcm16Generator()
	{
	}

/**
*
* GenerateSourceDataL
*
**/
void CMMFPcm8ToPcm16Generator::GenerateSourceDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	{
	const TInt8 KScale2 = 127;

	 //[ create a buffer large eneough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);

	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());

	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
	 TInt8 srcValue = 0;
	 TReal val   = 0.0;
	 TReal theta = 0.0; 
     TInt noSamples = aSize/sizeof(TInt8);
	 for(TInt i=0; i< noSamples; i++)
		 {
		 //[ assign data and place in buffer]
		  theta = (KPi*i)/10; // fundamental of 400hz sampled @8khz has 20 db or
		                      // better reproduction through gsm codec
		  User::LeaveIfError(Math::Sin(val,theta));
          srcValue = static_cast<TInt8>( (KScale2 * val) );
          *pDst++ = srcValue;
		 }
    
	 aBuffer->Data().SetLength(aSize); 
	}

/**
*
* GenerateSourceDataL
*
**/
void CMMFPcm8ToPcm16Generator::GenerateComparisonDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	{
	const TInt8 KScale2 = 127;

	 //[ create a buffer large eneough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);

	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());

	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
	 TInt16 srcValue = 0;
	 TReal val   = 0.0;
	 TReal theta = 0.0; 
	 TInt noSamples = aSize/sizeof(TInt16);
	 for(TInt i=0; i< noSamples; i++)
		 {
		 //[ assign data and place in buffer]
		  theta = (KPi*i)/10; // fundamental of 400hz sampled @8khz has 20 db or
		                      // better reproduction through gsm codec
		  User::LeaveIfError(Math::Sin(val,theta));
		  TInt8 temp = static_cast<TInt8>((KScale2 * val));
          srcValue =  static_cast<TInt16>( temp << 8); 
		  *pDst++ = static_cast<TInt8>( srcValue&KAndMask8bit);
		  *pDst++ = static_cast<TInt8>((srcValue>>8)&KAndMask8bit);
		 }
    
	 aBuffer->Data().SetLength(aSize); 
	}

/**
*
* PrintComparisonDataL
* Prints out coded results for comparison with the 
* Reference values and is used when the results differ
*
**/
void CMMFPcm8ToPcm16Generator::PrintComparisonDataL( CMMFDataBuffer& aCodedData, CMMFDataBuffer& aRefCodedData )
	{
	//[precondition reference coded data is equal in size or longer than coded data ]
	if( aRefCodedData.Data().Length() < aCodedData.Data().Length() )
		{
		//[coded data is longer than reference data]
	//	RDebug::Print( _L("Coded Data is longer than refernce data"));Commented under DEF105143
		User::Leave( KErrCorrupt );	 
		}
	
	//[ now print the results for comparison ]
    TUint8* ptr1 = CONST_CAST(TUint8*, aCodedData.Data().Ptr());
	TUint8* ptr2 = CONST_CAST(TUint8*, aRefCodedData.Data().Ptr());
    TInt length = aCodedData.Data().Length();
	length /= 2; //[ for 16bit words ]
	TInt16 codedValue = 0;
	TInt16 refCodedValue = 0;
	//[ now print the results for comparison ]
	for( TInt i = 0; i < length; i++ )
		{
		// assemble 16bit values
  		AssembleValue( ptr1, codedValue, EFalse );
		AssembleValue( ptr2, refCodedValue, EFalse );        
		RDebug::Print( _L("difference: %d, coded: %d, RefCoded: %d"), (refCodedValue-codedValue), codedValue, refCodedValue );
		if( i % 100 == 0 ) //deal with debug printf deficiencies
			{
			User::After(100 );
			}
		ptr1+=2;
		ptr2+=2;
		} 	
	}

/**
*
* CMMFPcmU8ToPcm16Generator
*
**/
CMMFPcmU8ToPcm16Generator::CMMFPcmU8ToPcm16Generator()
	 {
	 }

/**
*
* ~CMMFPcmU8ToPcm16Generator
*
**/
CMMFPcmU8ToPcm16Generator::~CMMFPcmU8ToPcm16Generator()
	 {
	 }

/**
*
* GenerateSourceDataL
* @param aBuffer
* @param aSize in bytes
*
**/
void CMMFPcmU8ToPcm16Generator::GenerateSourceDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	 {
	 const TUint8 KScale2 = 127;

	 //[ create a buffer large eneough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);

	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());

	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
	 TUint8 srcValue = 0;
	 TReal val   = 0.0;
	 TReal theta = 0.0; 
	 TInt noSamples = aSize/sizeof(TUint8);
	 for(TInt i=0; i< noSamples; i++)
		 {
		 //[ assign data and place in buffer]
		  theta = KPi*i/10; // fundamental of 400hz sampled @8khz has 20 db or
		                      // better reproduction through gsm codec
		  User::LeaveIfError(Math::Sin(val,theta));

          srcValue = static_cast<TUint8>((KScale2 * val+KScale2+0.5));
          *pDst++ = srcValue;
		   //RDebug::Print( _L("U8 = %u"), srcValue );  Statement commented under DEf105143
		 }
    
	 aBuffer->Data().SetLength(aSize); 
	 }

/**
*
* GenerateComparisonDataL
* @param aBuffer
* @param aSize
*
**/
void CMMFPcmU8ToPcm16Generator::GenerateComparisonDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	{
	const TInt8 KScale2 = 127;
	
	//[ create a buffer large eneough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);
	
	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());
	
	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
//	RDebug::Print( _L("Generation"));Commented under DEF105143
	TUint8 theValue = 0;
	TReal val   = 0.0;
	TReal theta = 0.0; 
	TUint8 rrr  = 0;
	TInt length = aSize/sizeof(TInt16);
	for(TInt i=0; i< length; i++)
		{
		//[ assign data and place in buffer]
		theta = KPi*i/10; // fundamental of 400hz sampled @8khz has 20 db or
		// better reproduction through gsm codec
		User::LeaveIfError(Math::Sin(val,theta));
		theValue = static_cast<TUint8>(KScale2 *val + KScale2 + 0.5); 
		//[ apply the same transformation as the codec ]
		rrr = static_cast<TUint8>( theValue^KMaskSign8bit );
		//RDebug::Print( _L("U8 = %u"), theValue ); Statement commented under DEf105143
		*pDst++ = rrr;
		*pDst++ = rrr;
		}
    
	aBuffer->Data().SetLength(aSize); 
	}

/**
*
* PrintComparisonDataL
* Prints out coded results for comparison with the 
* Reference values and is used when the results differ
*
**/
void CMMFPcmU8ToPcm16Generator::PrintComparisonDataL( CMMFDataBuffer& aCodedData, CMMFDataBuffer& aRefCodedData )
	{
	//[precondition reference coded data is equal in size or longer than coded data ]
	if( aRefCodedData.Data().Length() < aCodedData.Data().Length() )
		{
		//[coded data is longer than reference data]
	//	RDebug::Print( _L("Coded Data is longer than reference data"));Commented under DEF105143
		User::Leave( KErrCorrupt );	 
		}
	
	//[ now print the results for comparison ]
    TUint8* ptr1 = CONST_CAST(TUint8*, aCodedData.Data().Ptr());
	TUint8* ptr2 = CONST_CAST(TUint8*, aRefCodedData.Data().Ptr());
    TInt length = aCodedData.Data().Length();
	length /= 2; //[ for 16bit words ]
	TInt16 codedValue = 0;
	TInt16 refCodedValue = 0;
	//[ now print the results for comparison ]
	for( TInt i = 0; i < length; i++ )
		{
		// assemble 16bit values
  		AssembleValue( ptr1, codedValue, EFalse );
		AssembleValue( ptr2, refCodedValue, EFalse );        
		RDebug::Print( _L("delta %d c %d, rf %d"), (refCodedValue-codedValue), codedValue, refCodedValue );
		if( i % 100 == 0 ) //deal with debug printf deficiencies
			{
			User::After(100 );
			}
		ptr1+=2;
		ptr2+=2;
		} 

	}

/**
*
* CMMFPcm16ToPcmU8Generator
*
**/
CMMFPcm16ToPcmU8Generator::CMMFPcm16ToPcmU8Generator()
	{
     //Nothing doing
	}

/**
*
* CMMFPcm16ToPcmU8Generator
*
**/
CMMFPcm16ToPcmU8Generator::~CMMFPcm16ToPcmU8Generator()
	{
     //Nothing doing
	}

/**
*
* GenerateSourceDataL
* @param aBuffer
* @param aSize in bytes
* This function generates a 400hz sine wav
* under the assumption the sampling frequency is 8khz
*
*/
void CMMFPcm16ToPcmU8Generator::GenerateSourceDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	{
	const TInt KScale = 320;

	 //[ create a buffer large eneough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);

	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());

	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
	 TInt16 srcValue = 0;
	 TReal val   = 0.0;
	 TReal theta = 0.0; 
	 TInt noSamples = aSize/sizeof(TInt16);
	 for(TInt i=0; i< noSamples; i++)
		 {
		 //[ assign data and place in buffer]
		  theta = (KPi*i)/10; // fundamental of 400hz sampled @8khz has 20 db or
		                      // better reproduction through gsm codec
		  User::LeaveIfError(Math::Sin(val,theta));
          srcValue = static_cast<TInt16>( KScale * val );
          *pDst++ = static_cast<TUint8>( srcValue & KAndMask8bit);
		  *pDst++ = static_cast<TUint8>((srcValue >> 8) & KAndMask8bit );
		 }
    
	 aBuffer->Data().SetLength(aSize); 
	}

/**
*
* GenerateComparisonDataL
* @param aBuffer
* @param aSize in bytes
* This function generates a 400hz sine wav
* under the assumption the sampling frequency is 8khz
*/
//[ use partial sopecialization to provide copncrete implmentation]
void CMMFPcm16ToPcmU8Generator::GenerateComparisonDataL( CMMFDataBuffer* &aBuffer, TInt aSize )
	{
	const TInt KScale2 = 320; //low value chosen to emphasize the distortion of this codec!

	 //[ create a buffer large eneough to fill with the data ]
	aBuffer = CMMFDescriptorBuffer::NewL(aSize);

	TUint8* pDst = CONST_CAST(TUint8*,aBuffer->Data().Ptr());

	//[ lets fill it with a 400hz signal at approx -3db ]
	//[encode the data]
	 TInt16 srcValue = 0;
	 TReal val   = 0.0;
	 TReal theta = 0.0; 
	 TInt noSamples = aSize/sizeof(TUint8);
	 for(TInt i=0; i< noSamples; i++)
		 {
		 //[ assign data and place in buffer]
		  theta = (KPi*i)/10; // fundamental of 400hz sampled @8khz has 20 db or
		                      // better reproduction through gsm codec
		  User::LeaveIfError(Math::Sin(val,theta));
          srcValue = static_cast<TInt16>( KScale2 * val );
          *pDst++ = static_cast<TUint8>( (srcValue >> 8) - KMaskSign8bit);
		 }
    
	 aBuffer->Data().SetLength(aSize); 
	}

/**
*
* PrintComparisonDataL
* Prints out coded results for comparison with the 
* Reference values and is used when the results differ
*
**/
void CMMFPcm16ToPcmU8Generator::PrintComparisonDataL( CMMFDataBuffer& aCodedData, CMMFDataBuffer& aRefCodedData )
	{
	//[precondition reference coded data is equal in size or longer than coded data ]
	if( aRefCodedData.Data().Length() < aCodedData.Data().Length() )
		{
         //[coded data is longer than reference data]
	//	RDebug::Print( _L("Coded Data is longer than refernce data"));Commented under DEF105143
		User::Leave( KErrCorrupt );	 
		}

	//[ now print the results for comparison ]
    TUint8* ptr1 = CONST_CAST(TUint8*, aCodedData.Data().Ptr());
	TUint8* ptr2 = CONST_CAST(TUint8*, aRefCodedData.Data().Ptr());
    TInt length = aCodedData.Data().Length();
	//[ now print the results for comparison ]
	for( TInt i = 0; i < length; i++ )
		{
		RDebug::Print( _L("difference: %u, coded: %u, RefCoded: %u"), (*ptr1-*ptr2), *ptr1, *ptr2 );
		if( i % 100 == 0 ) //deal with debug printf deficiencies
			{
			User::After(100 );
			}
		ptr1++;
		ptr2++;
		} 
	}

/**
*
* CompareData
* @param aData1 first data buffer for comparison
* @param aData2 second data buffer for comparison
* result TBool data is the same
* @precondition aData1 has the same amount of data as aData2
*
*/
template <class T, class Generator, TInt index>
TBool CTestStepSignConversionTest<T, Generator, index>::CompareData( CMMFDataBuffer* aData1, CMMFDataBuffer* aData2)
	{
	TBool result = ETrue;

	//[ precondition aData1 != NULL ]
	if( !aData1 )
		{
		User::Leave( KErrArgument );
		}

    //[ precondition aData2 != NULL ]
	if( !aData2 )
		{
		User::Leave( KErrArgument );
		}

    //[precondition aData1 length == aData2 length ]
	if( aData1->Data().Length() != aData2->Data().Length() )
		{
		User::Leave( KErrArgument );
		}

	//[Now Compare the data]
	TUint8* ptr1 = CONST_CAST(TUint8*, aData1->Data().Ptr());
	TUint8* ptr2 = CONST_CAST(TUint8*, aData2->Data().Ptr());
	TInt dataLength = aData2->Data().Length();
   	if( Mem::Compare( ptr1, dataLength, ptr2, dataLength )!=0)
		{
		TUint8* p1 = ptr1; 
        TUint8* p2 = ptr2;
		TInt16 s1  = 0;
		TInt16 s2  = 0;
		INFO_PRINTF1(_L("------------------------------"));
		for( TInt i = 0; i < dataLength/2; i++ )
			{
		    s1  = static_cast<TInt16>( p1[0] &KAndMask8bit);  
		    s1 |=  static_cast<TInt16>((p1[1] << 8 ));
		    s2  = static_cast<TInt16>( p2[0] &KAndMask8bit);  
		    s2 |=  static_cast<TInt16>((p2[1] << 8 ));
			INFO_PRINTF3(_L("%d  %d"), s1, s2);
			p1+=2;
			p2+=2;
			}
		INFO_PRINTF1(_L("------------------------------"));
	//	RDebug::Print( _L("Comparison has failed")); Commented under DEF105143
		iGenerator->PrintComparisonDataL( *aData1, *aData2 );
		result = EFalse ;
		}
	return result;
	}

/**
*
* DoTestStepL
* @result TVerdict
*
*/
template <class T, class Generator, TInt index>
TVerdict CTestStepSignConversionTest<T, Generator, index>::DoTestStepL()
	{
	__MM_HEAP_MARK;	
	TVerdict result = EPass;

	//[pre condition iSourceData ]
	if( !iSourceData )
		{
		INFO_PRINTF1(_L("Source Data Failure"));
		User::Leave( KErrCorrupt);
		}
	//[precondition iCodedData  ]
	if( !iCodedData )
		{
		INFO_PRINTF1(_L("Coded Data Failure"));
		User::Leave( KErrCorrupt);
		}
	//[precondition iRefData ]
	if( !iRefCodedData )
		{
		INFO_PRINTF1(_L("RefCodedData Argument Failure"));
		User::Leave( KErrCorrupt);
		}

	//[ lets code the data and compare it to the reference data ]
    iCodecUnderTest->ProcessL(*iSourceData, *iCodedData);
    if(!CompareData(iCodedData, iRefCodedData))
		{
		INFO_PRINTF1(_L("Coded Results do not match reference coded results"));

		result = EFail;
		}
	
	__MM_HEAP_MARKEND;
	return result;
	}

/**
*
* DoTestStepPostambleL
* @result TVerdict
*
*/
template <class T, class Generator, TInt index>
TVerdict CTestStepSignConversionTest<T, Generator, index>::DoTestStepPostambleL()
	{
	TVerdict result = EPass;	
	//[delete the buffers & Codec]
	delete iCodecUnderTest;
	delete iGenerator;
	delete iSourceData;
	delete iCodedData;
	delete iRefCodedData;
	return result;
	}

/**
*
* DoTestStepPreambleL
* @result TVerdict
*
*/
template <class T, class Generator, TInt index>
TVerdict CTestStepSignConversionTest<T, Generator, index>::DoTestStepPreambleL()
	{
	TVerdict result = EPass;

	iCodecUnderTest =  new(ELeave) T;   // a cmmfcodec ;
	iGenerator = new(ELeave) Generator; // src generator

  	//[ensure the number of samples is >= srcbuffers]
	const TInt KNumBuffers = 2;
	const TInt dataSrcSize = KNumBuffers *  iCodecUnderTest->SourceBufferSize();

	//[generate src data]
	iGenerator->GenerateSourceDataL( iSourceData, dataSrcSize);
	
	const TInt dataSinkSize = KNumBuffers *  iCodecUnderTest->SinkBufferSize();

	//[generate comparison data]
	iGenerator->GenerateComparisonDataL( iRefCodedData, dataSinkSize);

	//[reserve space for coded data ]
    iCodedData = CMMFDescriptorBuffer::NewL(dataSinkSize);

	return result;
	}

/**
*
* CTestStepCodecUnitTest
*
*/
template <class T, class Generator, TInt index>
CTestStepSignConversionTest<T, Generator, index>::CTestStepSignConversionTest()
	{
	// store the name of this test case
	// this is the name that is used by the script file
	iTestStepName = (&KSignConversionParameters[index])->iTestName;
	}

/**
*
* CTestStepCodecUnitTest
*
*/
template <class T, class Generator, TInt index>
CTestStepSignConversionTest<T, Generator, index>::~CTestStepSignConversionTest()
	{
	}

/**
*
* This is used for template instantiation.
*
**/

template class CTestStepSignConversionTest<CMMFPcm16ToPcmU8Codec,CMMFPcm16ToPcmU8Generator,0>;
template class CTestStepSignConversionTest<CMMFPcm8ToPcm16Codec,CMMFPcm8ToPcm16Generator,1>;
template class CTestStepSignConversionTest<CMMFPcm16SwapEndianCodec,CMMFPcmU16toPcmU16BGenerator,2>;
template class CTestStepSignConversionTest<CMMFPcm16SwapEndianCodec,CMMFPcmU16BtoPcmU16Generator,3>;
template class CTestStepSignConversionTest<CMMFPcmU8ToPcm16Codec,CMMFPcmU8ToPcm16Generator,4>;