--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/devsound/devsoundrefplugin/tsrc/SwCodecDevices/TSU_MMF_SignConversionCodecs.cpp Fri Oct 08 19:40:43 2010 +0100
@@ -0,0 +1,984 @@
+// 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>;
+