diff -r 000000000000 -r bde4ae8d615e os/mm/mmlibs/mmfw/tsrc/mmfunittest/Actrl/TestStepActrlPlay.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmlibs/mmfw/tsrc/mmfunittest/Actrl/TestStepActrlPlay.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1071 @@ +// 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: +// TestStepActrlPlay +// + +#include +#include +#include +#include +#include +#include +#include + +#include "ActrlTestUids.h" + +// Test system includes +#include + +// Specific includes for this test suite +#include "TS_MMF_ACTRL_TestStep.h" +#include "TS_MMF_ACTRL_TestSuite.h" + +// Specific includes for these test steps +#include "TestStepActrlPlay.h" + +// CONSTANTS +//const TInt KPlayDelayNewMail = 100000000; //arbitrary delay // EABI warning removal + +const TUint KSampleRate8000Hz = 8000; +const TUint KSampleRate11025Hz = 11025; +const TUint KSampleRate22050Hz = 22050; +const TUint KSampleRate44100Hz = 44100; + +const TUint KNone = 0; +const TUint KMono = 1; +const TUint KStereo = 2; + +//const TUint KFormatWAV = 0; +//const TUint KFormatAU = 1; +//const TUint KFormatRAW = 2; + +// parameter structure for conversion tests +class TConvParameters + { +public: + const TText* iTestName; + TUid iSrcFormat; + TUid iDestFormat; + TUint32 iSrcEncoding; + TUint32 iDestEncoding; + TUint iSrcSampleRate; + TUint iDestSampleRate; + TUint iSrcChannels; + TUint iDestChannels; + const TText* iFromFilename; + const TText* iRefFilename; + TInt iExpectedResult; + }; + + +// constant table of parameters for tests +const TConvParameters KTestParameters[] = +{ + // straight encode test + { _S("MM-MMF-ACTRL-U-0040-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatAUWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodePCM16B, KSampleRate44100Hz, KSampleRate8000Hz, KStereo, KMono, _S("44KHzPCM16Stereo1KHzTone.wav"), _S("44KHzPCM16StereoWAVTo8KHzPCM16Mono.au"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0041-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodePCMU8, KMMFFourCCCodePCM16, KSampleRate22050Hz, KSampleRate11025Hz, KMono, KStereo, _S("22KHzPCM8Mono1KHzTone.wav"), _S("22KHzPCM8MonoWAVTo11KHzPCM16Stereo.wav"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0042-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatRAWWrite}, KMMFFourCCCodeIMAD, KMMFFourCCCodePCM16, KSampleRate11025Hz, KSampleRate8000Hz, KMono, KMono, _S("11KHzADPCMMono1KHzTone.wav"), _S("11KHzADPCMMonoWAVTo8KHzPCM16Mono.raw"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0043-HP"), {KMmfUidFormatAURead}, {KMmfUidFormatAUWrite}, KMMFFourCCCodePCM16B, KMMFFourCCCodePCM16B, KSampleRate8000Hz, KSampleRate8000Hz, KMono, KMono, _S("8KHzPCM16Mono1KHzTone.au"), _S("8KHzPCM16MonoAUTo8KHzPCM16Mono.au"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0044-HP"), {KMmfUidFormatAURead}, {KMmfUidFormatRAWWrite}, KMMFFourCCCodePCM16B, KMMFFourCCCodePCM16, KSampleRate44100Hz, KSampleRate22050Hz, KStereo, KMono, _S("44KHzPCM16Stereo1KHzTone.au"), _S("44KHzPCM16StereoAUTo22KHzPCM16Mono.raw"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0045-HP"), {KMmfUidFormatAURead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodePCM16B, KMMFFourCCCodePCM16, KSampleRate22050Hz, KSampleRate8000Hz, KMono, KMono, _S("22KHzPCM16Mono1KHzTone.au"), _S("22KHzPCM16MonoAUTo8KhzPCM16Mono.wav"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0046-HP"), {KMmfUidFormatRAWRead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodeGSM610, KMMFFourCCCodePCM16, KSampleRate8000Hz, KSampleRate8000Hz, KMono, KMono, _S("8KHzGSM610Mono1KHzTone.raw"), _S("8KHzGSM610MonoRAWTo8KHzPCM16Mono.wav"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0047-HP"), {KMmfUidFormatRAWRead}, {KMmfUidFormatRAWWrite}, KMMFFourCCCodeALAW, KMMFFourCCCodePCM16, KSampleRate22050Hz, KSampleRate11025Hz, KStereo, KMono, _S("22KHzALAWStereo1KHzTone.raw"), _S("22KHzALAWStereoRAWTo11KHzPCM16Mono.raw"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0048-HP"), {KMmfUidFormatRAWRead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodeGSM610, KSampleRate11025Hz, KSampleRate8000Hz, KMono, KMono, _S("11KHzPCM16Mono1KHzTone.raw"), _S("11KHzPCM16MonoRAWTo8KHzGSM610Mono.wav"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0049-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodeALAW, KMMFFourCCCodePCM16, KSampleRate22050Hz, KSampleRate8000Hz, KMono, KMono, _S("22KHzALAWMono1KHzTone.wav"), _S("22KHzALAWMonoWAVTo8KHzPCM16Mono.wav"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0050-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodeMuLAW, KSampleRate11025Hz, KSampleRate8000Hz, KStereo, KMono, _S("11KHzPCM16Stereo1KHzTone.wav"), _S("11KHzPCM16StereoWAVTo8KHzMuLAWMono.wav"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0051-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodeGSM610, KSampleRate8000Hz, KSampleRate8000Hz, KStereo, KMono, _S("8KHzPCM16Stereo1KHzTone.wav"), _S("8KHzPCM16StereoWAVTo8KHzGSM610Mono.wav"), KErrNone }, + + // test 52 not currently supported - should return -5 + { _S("MM-MMF-ACTRL-U-0052-HP"), {KMmfUidFormatAURead}, {KMmfUidFormatAUWrite}, KMMFFourCCCodePCM16B, KMMFFourCCCodeIMAD, KSampleRate22050Hz, KSampleRate8000Hz, KMono, KMono, _S("22KHzPCM16Mono1KHzTone.au"), _S("NoReferenceFile"), KErrNotSupported }, + + { _S("MM-MMF-ACTRL-U-0053-HP"), {KMmfUidFormatRAWRead}, {KMmfUidFormatAUWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodePCM16B, KSampleRate44100Hz, KSampleRate8000Hz, KStereo, KStereo, _S("44KHzPCM16Stereo1KHzTone.raw"), _S("44KHzPCM16StereoRAWTo8KHzPCM16Stereo.au"), KErrNone }, + + // test below will return -5 + { _S("MM-MMF-ACTRL-U-0054-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodePCM16, KSampleRate11025Hz, KSampleRate44100Hz, KStereo, KStereo, _S("11KHzPCM16Stereo1KHzTone.wav"), _S("NoReferenceFile"), KErrNotSupported }, + { _S("MM-MMF-ACTRL-U-0055-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatAUWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodeIMAD, KSampleRate22050Hz, KSampleRate22050Hz, KStereo, KStereo, _S("22KHzPCM16Stereo1KHzTone.wav"), _S("NoReferenceFile"), KErrNotSupported }, + + // replacement for test 039 - see DEF017344 + { _S("MM-MMF-ACTRL-U-0039-HP"), {KMmfUidFormatAURead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodePCM8, KMMFFourCCCodePCM16, KSampleRate11025Hz, KSampleRate8000Hz, KMono, KMono, _S("NewMail.au"), _S("11KHzPCMU8MonoAUTo8KHzPCM16Mono.wav"), KErrNone }, + + //DEF025783 - Convert Stereo PCM16 to IMA ADPCM + //Sink channels are not configured, we are testing if negotiation will do this + { _S("MM-MMF-ACTRL-U-0056-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodeIMAD, KSampleRate11025Hz, KSampleRate11025Hz, KStereo, KNone, _S("11KHzPCM16Stereo1KHzTone.wav"), _S("11KHzPCM16StereoWAVTo11KHzADPCMMono.wav"), KErrNone }, + { _S("MM-MMF-ACTRL-U-0057-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatRAWWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodeIMAD, KSampleRate11025Hz, KSampleRate11025Hz, KStereo, KNone, _S("11KHzPCM16Stereo1KHzTone.wav"), _S("11KHzPCM16StereoWAVTo11KHzADPCMMono.raw"), KErrNone }, + //Configure sink channels to stereo expect KErrNotSupported + { _S("MM-MMF-ACTRL-U-0058-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatWAVWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodeIMAD, KSampleRate11025Hz, KSampleRate11025Hz, KStereo, KStereo, _S("11KHzPCM16Stereo1KHzTone.wav"), _S("11KHzPCM16StereoWAVTo11KHzADPCMMono.wav"), KErrNotSupported }, + { _S("MM-MMF-ACTRL-U-0059-HP"), {KMmfUidFormatWAVRead}, {KMmfUidFormatRAWWrite}, KMMFFourCCCodePCM16, KMMFFourCCCodeIMAD, KSampleRate11025Hz, KSampleRate11025Hz, KStereo, KStereo, _S("11KHzPCM16Stereo1KHzTone.wav"), _S("11KHzPCM16StereoWAVTo11KHzADPCMMono.raw"), KErrNotSupported } + +}; + + +/** +* +* Test step constructor. +* Each test step initialises its own name. +* +*/ +CTestStepActrlPlay::CTestStepActrlPlay() + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACTRL-U-0018-HP"); + } + +/** +* +* Test step destructor. +* +*/ +CTestStepActrlPlay::~CTestStepActrlPlay() + { + } + + +/** +* @xxxx +* Do the test step. +* @return "TVerdict" the status of the test +* The result of the test step +*/ +TVerdict CTestStepActrlPlay::DoTestStepL( void ) + { + TVerdict result = EPass; + + _LIT( KTestPlay, "Play Test"); + Log( KTestPlay ); + + _LIT( KTestStepPlay, "This test checks playing an audio clip"); + Log( KTestStepPlay ); + + // [ audio file to play ] + _LIT(KTestWavFile, "newmail.wav"); + //[ configure the filename ] + SetReadFileNameL( KTestWavFile ); + + TInt errorCode = iController.Open(KUidCustomTestAudioPlugin, iPriority); + User::LeaveIfError( errorCode ); + + //[ add data source and sink and prime the controller ] + errorCode = iController.AddDataSource(KUidMmfFileSource, ReadFileConfig()); + User::LeaveIfError( errorCode ); + + errorCode = iController.AddDataSink(KUidMmfAudioOutput, KNullDesC8); + User::LeaveIfError( errorCode ); + + errorCode = iController.Prime(); + User::LeaveIfError( errorCode ); + + // [ wait for and process the return event from the audio output ] + + TMMFEvent primeEvent( KPrimeTestId, KErrNone); + result = SearchForEvent( primeEvent ); + if( result == EFail ) + { + return result; + } + + User::LeaveIfError( iController.Play() ); + + // note this test does not wait around + // to detect that the audio has been played + // [ now process the confirmation event that play has reached audio output + // this is the raison detre of the test ] + TMMFEvent playEvent( KPlayTestId, KErrNone ); + + result = SearchForEvent( playEvent ); + + //[ ensure the controller is unloaded so that it does + // not interfere with the following test ] + // There is error in this code and the stop followed by reset + // ensure the controller resources are released. + iController.Stop(); + iController.Reset(); + iController.Close(); + + // test steps return a result + return result; + } + +/** +* +* CTestStepPlayT +* @param aTimesToPlay +* +*/ +CTestStepPlayT::CTestStepPlayT( TInt aTimesToPlay ) +: iTimesToPlay( aTimesToPlay ) + { + // store the name of this test case + // this is the name that is used by the script file + iTestStepName = _L("MM-MMF-ACTRL-U-0004-HP"); + } + +/** +* +* ~CTestStepPlayT +*/ +CTestStepPlayT::~CTestStepPlayT() + { + } + +/** +* Do the test step. +* Each test step must supply an implementation for DoTestStepL. +* This Test step will play an audio clip n +* times +* @return "TVerdict" the status of the test +* The result of the test step +*/ +TVerdict CTestStepPlayT::DoTestStepL() + { + __MM_HEAP_MARK; + TVerdict result = EPass; + + _LIT( KTestPlay, "Play Test"); + Log( KTestPlay ); + + _LIT( KTestStepPlay, "This test checks playing an audio clip n times"); + Log( KTestStepPlay ); + + // [ audio file to play ] + _LIT(KTestWavFile, "newmail.wav"); + SetReadFileNameL( KTestWavFile ); + + TInt errorCode = iController.Open(KUidCustomTestAudioPlugin, iPriority); + User::LeaveIfError( errorCode ); + + //[ add data source and sink and prime the controller ] + errorCode = iController.AddDataSource(KUidMmfFileSource, ReadFileConfig()); + User::LeaveIfError( errorCode ); + + errorCode = iController.AddDataSink(KUidMmfAudioOutput, KNullDesC8); + User::LeaveIfError( errorCode ); + + + for( TInt iTimes = 0; iTimes < iTimesToPlay; iTimes++) + { + errorCode = iController.Prime(); + User::LeaveIfError( errorCode ); + + // [ wait for and process the return event from the audio output ] + + TMMFEvent primeEvent( KPrimeTestId, KErrNone); + TVerdict primeResult = SearchForEvent( primeEvent ); + if( primeResult == EFail ) + { + return primeResult; + } + + User::LeaveIfError( iController.Play() ); + + // note this test does not wait around + // to detect that the audio has been played + // [ now process the confirmation event that play has reached audio output + // this is the raison detre of the test ] + TMMFEvent playEvent( KPlayTestId, KErrNone ); + + TVerdict playResult = SearchForEvent( playEvent ); + if( playResult == EFail ) + { + return playResult ; + } + + // [ lets ensure we are stopped ] + User::LeaveIfError( iController.Stop() ); + } + + //[ ensure the controller is unloaded so that it does + // not interfere with the following test ] + // There is error in this code and the stop followed by reset + // ensure the controller resources are released. + iController.Stop(); + iController.Reset(); + iController.Close(); + + __MM_HEAP_MARKEND; + // test steps return a result + return result; + } + +/* +* +* CTestStepPause +* +*/ +CTestStepPause::CTestStepPause() + { + iTestStepName = _L("MM-MMF-ACTRL-U-0011-HP"); + } + +/* +* +* ~CTestStepPause +* +*/ +CTestStepPause::~CTestStepPause() + { + } + +/* +* +* DoTestStepL +* This test checks the pause function +* +*/ +TVerdict CTestStepPause::DoTestStepL() + { + __MM_HEAP_MARK; + + TVerdict result = EFail; + + _LIT( KTestPlay, "Pause Test"); + Log( KTestPlay ); + + _LIT( KTestStepPlay, "This test checks the pause function"); + Log( KTestStepPlay ); + + // [ audio file to play ] + _LIT(KTestWavFile, "newmail.wav"); + SetReadFileNameL( KTestWavFile ); + + TInt errorCode = iController.Open(KUidCustomTestAudioPlugin, iPriority); + User::LeaveIfError( errorCode ); + + //[ add data source and sink and prime the controller ] + errorCode = iController.AddDataSource(KUidMmfFileSource, ReadFileConfig()); + User::LeaveIfError( errorCode ); + + errorCode = iController.AddDataSink(KUidMmfAudioOutput, KNullDesC8); + User::LeaveIfError( errorCode ); + + // [ The controller is in the stopped state + // and should return an error if pause is called ] + + TInt pauseError = iController.Pause(); + if( pauseError == KErrNone ) + { + // [ we should not be able to call pause while stopped ] + result = EFail; + return result ; + } + + TMMFEvent pauseFailEvent( KPauseTestId, pauseError ); + result = SearchForEvent( pauseFailEvent ); + if( result == EFail ) + { + return result; + } + + // [ move the contoller to the primed state ] + errorCode = iController.Prime(); + User::LeaveIfError( errorCode ); + + //[ call pause in the paused state + // should return no error ] + pauseError = iController.Pause(); + if( pauseError == KErrNone ) + { + //[calling paused while paused returns an error] + result = EFail; + return result ; + } + + // [ wait for and process the return event from the audio output ] + TMMFEvent primeEvent( KPrimeTestId, KErrNone ); + result = SearchForEvent( primeEvent ); + if( result == EFail ) + { + return result; + } + + result = SearchForEvent( pauseFailEvent ); + if( result == EFail ) + { + return result; + } + + User::LeaveIfError( iController.Play() ); + + // [ process the play event ] + TMMFEvent playEvent( KPlayTestId, KErrNone ); + result = SearchForEvent( playEvent ); + if( result == EFail ) + { + return result; + } + + // [ now call pause when playing ] + TMMFEvent pausePassEvent( KPauseTestId, KErrNone ); + pauseError = iController.Pause(); + if( pauseError != KErrNone ) + { + //[calling paused while paused returns an error] + result = EFail; + return result ; + } + + // note this test does not wait around + // to detect that the audio has been played + // [ now process the confirmation event that play has reached audio output + // this is the raison detre of the test ] + result = SearchForEvent( pausePassEvent ); + if( result == EFail ) + { + return result; + } + + // [ we should now be in the paused state + // try playing ] + User::LeaveIfError( iController.Play() ); + result = SearchForEvent( playEvent ); + if( result == EFail ) + { + return result; + } + + //[ ensure the controller is unloaded so that it does + // not interfere with the following test ] + // There is error in this code and the stop followed by reset + // ensure the controller resources are released. + iController.Stop(); + iController.Reset(); + iController.Close(); + + __MM_HEAP_MARKEND; + + return result; + } + +/** +* +* CTestStepStop +* +*/ +CTestStepStop::CTestStepStop() + { + iTestStepName = _L("MM-MMF-ACTRL-U-0012-HP"); + } + +/** +* +* ~CTestStepStop +* +*/ +CTestStepStop::~CTestStepStop() + { + } + +/* +* +* DoTestStepL +* This test checks the stop function on the controller +* +*/ +TVerdict CTestStepStop::DoTestStepL() + { + __MM_HEAP_MARK; + + TVerdict result = EFail; + + _LIT( KTestPlay, "Stop Test"); + Log( KTestPlay ); + + _LIT( KTestStepPlay, "This test checks the stop function"); + Log( KTestStepPlay ); + + // [ audio file to play ] + _LIT(KTestWavFile, "newmail.wav"); + SetReadFileNameL( KTestWavFile ); + + TInt errorCode = iController.Open(KUidCustomTestAudioPlugin, iPriority); + User::LeaveIfError( errorCode ); + + //[ add data source and sink and prime the controller ] + errorCode = iController.AddDataSource(KUidMmfFileSource, ReadFileConfig()); + User::LeaveIfError( errorCode ); + + errorCode = iController.AddDataSink(KUidMmfAudioOutput, KNullDesC8); + User::LeaveIfError( errorCode ); + + //[ call stop while stopped ] + User::LeaveIfError( iController.Stop() ); + + + // [ go to primed and call stop ] + errorCode = iController.Prime(); + User::LeaveIfError( errorCode ); + + // [ wait for and process the return event from the audio output ] + + TMMFEvent primeEvent( KPrimeTestId, KErrNone); + result = SearchForEvent( primeEvent ); + if( result == EFail ) + { + return result; + } + + User::LeaveIfError( iController.Stop() ); + + // [ go to play and call stop ] + errorCode = iController.Prime(); + User::LeaveIfError( errorCode ); + + // [ wait for and process the return event from the audio output ] + + result = SearchForEvent( primeEvent ); + if( result == EFail ) + { + return result; + } + + User::LeaveIfError( iController.Play() ); + + // note this test does not wait around + // to detect that the audio has been played + // [ now process the confirmation event that play has reached audio output + // this is the raison detre of the test ] + TMMFEvent playEvent( KPlayTestId, KErrNone ); + result = SearchForEvent( playEvent ); + if( result == EFail ) + { + return result; + } + + User::LeaveIfError( iController.Stop() ); + + + // [ go to prime from stopped via playing ] + // [ stopped ] + // [ prime ] + // [ play ] + // [ pause ] + // [ stop ] + + errorCode = iController.Prime(); + User::LeaveIfError( errorCode ); + + // [ wait for and process the return event from the audio output ] + + result = SearchForEvent( primeEvent ); + if( result == EFail ) + { + return result; + } + + User::LeaveIfError( iController.Play() ); + + // note this test does not wait around + // to detect that the audio has been played + // [ now process the confirmation event that play has reached audio output + // this is the raison detre of the test ] + result = SearchForEvent( playEvent ); + if( result == EFail ) + { + return result; + } + + // [ now call pause when playing ] + TMMFEvent pausePassEvent( KPauseTestId, KErrNone ); + TInt pauseError = iController.Pause(); + if( pauseError != KErrNone ) + { + //[calling paused while paused returns an error] + result = EFail; + return result ; + } + + // note this test does not wait around + // to detect that the audio has been played + // [ now process the confirmation event that play has reached audio output + // this is the raison detre of the test ] + result = SearchForEvent( pausePassEvent ); + if( result == EFail ) + { + return result; + } + + // [ now stop from paused ] + User::LeaveIfError( iController.Stop() ); + + //[ ensure the controller is unloaded so that it does + // not interfere with the following test ] + // There is error in this code and the stop followed by reset + // ensure the controller resources are released. + iController.Stop(); + iController.Reset(); + iController.Close(); + + return result; + } + + +/* +* +* CTestStepConvertFormat +* +*/ +CTestStepConvertFormat::CTestStepConvertFormat( TUint aTestIndex ) + { + // 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; + } + +/* +* +* ~CTestStepConvertFormat +* +*/ +CTestStepConvertFormat::~CTestStepConvertFormat() + { + + + } + + +// test preamble +TVerdict CTestStepConvertFormat::DoTestStepPreambleL(void) + { + // connect to the file server + User::LeaveIfError(iFs.Connect()); + + // call the superclass + return CTestStepActrl::DoTestStepPreambleL(); + } + +//test postamble +TVerdict CTestStepConvertFormat::DoTestStepPostambleL(void) + { + // close connection with the file server + iFs.Close(); + + // call the superclass + return CTestStepActrl::DoTestStepPostambleL(); + } +/** + * + * Compare two binary files + * + * @param "const TDesC& aFile1" + * The first file to compare + * @param "const TDesC& aFile2" + * The second file to compare + * @leave "" + * Will leave with appropriate system codes if a problem is encountered reading either file + * @return "TVerdict" + * EPass if the files are identical + * EFail otherwise + * @xxxx + * + */ +TVerdict CTestStepConvertFormat::CompareFilesL(const TDesC& aFile1,const TDesC& aFile2) + { + RFile file1, file2; + + User::LeaveIfError(file1.Open(iFs, aFile1, EFileShareAny | EFileStream | EFileRead)); + CleanupClosePushL(file1); + + User::LeaveIfError(file2.Open(iFs, aFile2, EFileShareAny | EFileStream | EFileRead)); + CleanupClosePushL(file2); + + TInt fileSize1, fileSize2; + + TVerdict result = EPass; + TInt blockSize = 1024; + + User::LeaveIfError(file1.Size(fileSize1)); + User::LeaveIfError(file2.Size(fileSize2)); + + if (fileSize1 == fileSize2) + { + HBufC8* buf1 = HBufC8::NewMaxLC(blockSize); + TPtr8 buf1Ptr(buf1->Des()); + HBufC8* buf2 = HBufC8::NewMaxLC(blockSize); + TPtr8 buf2Ptr(buf2->Des()); + + TInt length = 0; + + while (length blockSize) + copySize = blockSize; + else + copySize = fileSize1 - length; + User::LeaveIfError(file1.Read(buf1Ptr,copySize)); + User::LeaveIfError(file2.Read(buf2Ptr,copySize)); + + TInt comp_res = Mem::Compare(buf1Ptr.Ptr(),copySize,buf2Ptr.Ptr(),copySize); + + if (comp_res!=0) + { + INFO_PRINTF5(_L("Comparison Failed, comparison failed (%S, %S), result=%d at offset %d"), + &aFile1, &aFile2, comp_res, length); + result = EFail; + break; + } + + length += copySize; + } + CleanupStack::PopAndDestroy(2); // buf1, buf2 + } + else + { + INFO_PRINTF5(_L("Comparison Failed, files are different sizes (%S, %S), (%d,%d)"), + &aFile1, &aFile2, fileSize1, fileSize2); + result = EFail; + } + + file1.Close(); + file2.Close(); + + CleanupStack::PopAndDestroy(2); //file1, file2 + + return result; + } +/* +* +* DoTestStepL +* This test checks the stop function on the controller +* +*/ +TVerdict CTestStepConvertFormat::DoTestStepL( void ) + { + TVerdict result = EPass; + TInt error; + + // do the conversion step + TRAP(error, result = DoConvertStepL( )); + + if (error != iTestParameters->iExpectedResult ) + { + INFO_PRINTF2(_L("Error - Test step returned %d"), error); + result = EFail; + } + + //[ delete output file after comparison] + //[ here because DoTestStepL() can leave ] + TInt ret = iFs.Delete( WriteFileConfig()().iPath ); + if (ret != KErrNone && ret != KErrNotFound) + { + INFO_PRINTF2(_L("Error deleting file - Delete returned %d"), ret); + } + + //[ ensure the controller is unloaded so that it does + // not interfere with the following test ] + // There is error in this code and the stop followed by reset + // ensure the controller resources are released. + iController.Stop(); + iController.Reset(); + iController.Close(); + + return result; + } + +/* +* DoConvertL( void ) +* Do the conversion of the files +* @return "TVerdict" the result of the convert operation +*/ +TVerdict CTestStepConvertFormat::DoConvertStepL( void ) + { + TVerdict result = EPass; + + _LIT( KTestConvertFormat, "Convert Formats Test"); + Log( KTestConvertFormat ); + + _LIT( KTestStepPlay, "This test checks converting an audio clip"); + Log( KTestStepPlay ); + + // get filename of input file + TInt strLen = User::StringLength(iTestParameters->iFromFilename); + TPtrC ptr( iTestParameters->iFromFilename, strLen ); + + //[ configure the filename ] + SetReadFileNameL( ptr ); + + //[ configure reference filename ] + strLen = User::StringLength(iTestParameters->iRefFilename); + ptr.Set( iTestParameters->iRefFilename, strLen ); + + SetRefFileNameL( ptr ); + + // [ converted audio file name ] + //_LIT(KTestOutFile, "ConvertedOutput"); + TBuf<32> testFileName = _L("ConvertedOutput"); + + switch ( iTestParameters->iDestFormat.iUid ) + { + case KMmfUidFormatRAWWrite: + testFileName.Append( _L(".raw") ); + break; + + case KMmfUidFormatWAVWrite: + testFileName.Append( _L(".wav") ); + break; + + case KMmfUidFormatAUWrite: + testFileName.Append( _L(".au") ); + break; + + default: + // not a recognised output format - use .tmp + testFileName.Append( _L(".tmp") ); + break; + } + + //[ configure the filename ] + SetWriteFileNameL( testFileName ); + + // open the audio controller + TInt errorCode = iController.Open(KUidCustomTestAudioPlugin, iPriority); + User::LeaveIfError( errorCode ); + + //[ add data source and sink and prime the controller ] + errorCode = iController.AddDataSource(KUidMmfFileSource, ReadFileConfig()); + User::LeaveIfError( errorCode ); + + errorCode = iController.AddDataSink(KUidMmfFileSink, WriteFileConfig()); + User::LeaveIfError( errorCode ); + + //[ attempt to get the sink num channels ] + RMMFAudioControllerCustomCommands theCommander( iController ); + + // if source data is RAW then need to complete the source format + if ( iTestParameters->iSrcFormat.iUid == KMmfUidFormatRAWRead ) + { + + errorCode = theCommander.SetSourceFormat( iTestParameters->iSrcFormat ); + User::LeaveIfError( errorCode ); + + errorCode = theCommander.SetSourceDataType( iTestParameters->iSrcEncoding ); + User::LeaveIfError( errorCode ); + + errorCode = theCommander.SetSourceSampleRate( iTestParameters->iSrcSampleRate ); + User::LeaveIfError( errorCode ); + + errorCode = theCommander.SetSourceNumChannels( iTestParameters->iSrcChannels ); + User::LeaveIfError( errorCode ); + } + + // set sink sample rate + errorCode = theCommander.SetSinkSampleRate( iTestParameters->iDestSampleRate ); + User::LeaveIfError( errorCode ); + + // set sink number of channels + if(iTestParameters->iDestChannels != KNone) + { + errorCode = theCommander.SetSinkNumChannels( iTestParameters->iDestChannels ); + User::LeaveIfError( errorCode ); + } + + //[ ok lets try to set the sink format ] + errorCode = theCommander.SetSinkFormat( iTestParameters->iDestFormat ); + User::LeaveIfError( errorCode ); + + //[ set the sink data type ] + errorCode = theCommander.SetSinkDataType( iTestParameters->iDestEncoding ); + User::LeaveIfError( errorCode ); + + errorCode = iController.Prime(); + User::LeaveIfError( errorCode ); + + // [ wait for and process the return event from the audio output ] + TMMFEvent primeEvent( KPrimeTestId, KErrNone); + result = SearchForEvent( primeEvent ); + if( result == EFail ) + { + return result; + } + + errorCode = iController.Play(); + User::LeaveIfError( errorCode ); + + // note this test does not wait around + // to detect that the audio has been played + // [ now process the confirmation event that play has reached audio output + // this is the raison detre of the test ] + TMMFEvent playEvent( KPlayTestId, KErrNone ); + + result = SearchForEvent( playEvent ); + if( result == EFail ) + { + return result; + } + + //[ now wait for play complete event] + TMMFEvent playCompleteEvent( KPlayCompleteTestId, KErrNone); + result = SearchForEvent( playCompleteEvent ); + if( result == EFail ) + { + return result; + } + + //[ now compare the file produced with a reference file ] + INFO_PRINTF1(_L("Comparing file to reference...")); + result = CompareFilesL( RefFileName()().iPath, WriteFileConfig()().iPath); + + if (result == EFail) + { + INFO_PRINTF1(_L("Comparison Failed - Files are not identical !")); + } + + + return result; + } + +/* +* +* SetRefFileNameL +* +*/ +void CTestStepConvertFormat::SetRefFileNameL( const TDesC& aPathNameAndExtn ) + { + //[ append the filename relative to the default path ] + TFileName fileName = GetSuite()->DefaultPath(); + fileName.Append(aPathNameAndExtn); + iFileConfigRef().iPath = fileName ; + } +/* +* +* RefFileName +* +*/ +TMMFFileConfig& CTestStepConvertFormat::RefFileName() + { + return iFileConfigRef; + } + +/* +* +* CTestStepRampVolume +*/ +CTestStepRampVolume::CTestStepRampVolume() + { + iTestStepName = _L("MM-MMF-ACTRL-U-0064-HP"); + } + +/* +* +* ~CTestStepRampVolume +*/ +CTestStepRampVolume::~CTestStepRampVolume() + { + } + +/* +* +* CTestStepRampVolume +*/ +TVerdict CTestStepRampVolume::DoTestStepL() + { + TVerdict result = EPass; + + _LIT( KTestVolumeRamp, "Volume Ramp Test"); + Log( KTestVolumeRamp ); + + _LIT( KTestStepPlay, "This test checks volume ramp"); + Log( KTestStepPlay ); + + // [ audio file to play ] + _LIT(KTestWavFile, "RampVolume.wav"); + //[ configure the filename ] + SetReadFileNameL( KTestWavFile ); + + TInt errorCode = iController.Open(KUidCustomTestAudioPlugin, iPriority); + User::LeaveIfError( errorCode ); + + //[ add data source and sink and prime the controller ] + errorCode = iController.AddDataSource(KUidMmfFileSource, ReadFileConfig()); + User::LeaveIfError( errorCode ); + + errorCode = iController.AddDataSink(KUidMmfAudioOutput, KNullDesC8); + User::LeaveIfError( errorCode ); + + errorCode = iController.Prime(); + User::LeaveIfError( errorCode ); + + // [ wait for and process the return event from the audio output ] + //[ attempt to get the sink num channels ] + RMMFAudioPlayDeviceCustomCommands theCommander( iController ); + //[lets say 2 seconds for now ] + TTimeIntervalMicroSeconds aRampDuration( 2000000); + errorCode = theCommander.SetVolumeRamp( aRampDuration); + User::LeaveIfError( errorCode ); + + TMMFEvent primeEvent( KPrimeTestId, KErrNone); + result = SearchForEvent( primeEvent ); + if( result == EFail ) + { + return result; + } + + //[ lets set the volume ramp before we play ] + + + User::LeaveIfError( iController.Play() ); + + // note this test does not wait around + // to detect that the audio has been played + // [ now process the confirmation event that play has reached audio output + // this is the raison detre of the test ] + TMMFEvent playEvent( KPlayTestId, KErrNone ); + result = SearchForEvent( playEvent ); + if( result == EFail ) + { + return EFail; + } + + //[ now wait for play complete event] + TMMFEvent playCompleteEvent( KPlayCompleteTestId, KErrNone); + result = SearchForEvent( playCompleteEvent ); + if( result == EFail ) + { + return EFail; + } + + //[ ensure the controller is unloaded so that it does + // not interfere with the following test ] + // There is error in this code and the stop followed by reset + // ensure the controller resources are released. + iController.Stop(); + iController.Reset(); + iController.Close(); + + // test steps return a result + return result; + } + +/* +* +* CTestStepRampVolume +*/ +TVerdict CTestStepRampVolume::DoTestStepPreambleL(void) + { + return EPass; + } + +/* +* +* CTestStepRampVolume +*/ +TVerdict CTestStepRampVolume::DoTestStepPostambleL(void) + { + return CTestStepActrl::DoTestStepPostambleL(); + } +