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