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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32test\multimedia\t_soundwav.cpp

// Record wav to a file "t_soundwav filename [rate] [channels] [seconds]" where filename does not exist.

// Play a wav file "t_soundwav filename" where filename exists.

// 

//

/**

 @file Shared chunk sound driver WAV file player and recorder utility.

*/

#include <e32test.h>

#include <e32def.h>

#include <e32def_private.h>

#include "t_soundutils.h"

#include <f32file.h>

#define CHECK(aValue) {Test(aValue);}

#define CHECK_NOERROR(aValue) { TInt v=(aValue); if(v) { Test.Printf(_L("Error value = %d\n"),v); Test(EFalse,__LINE__); }}

#define CHECK_EQUAL(aValue1,aValue2) { TInt v1=(aValue1); TInt v2=(aValue2); if(v1!=v2) { Test.Printf(_L("Error value = %d\n"),v1); Test(EFalse,__LINE__); }}

_LIT(KSndLddFileName,"ESOUNDSC.LDD");

_LIT(KSndPddFileName,"SOUNDSC.PDD");

RTest Test(_L("T_SOUNDWAV"));

RSoundSc TxSoundDevice;

RSoundSc RxSoundDevice;

TSoundFormatsSupportedV02Buf RecordCapsBuf;

TSoundFormatsSupportedV02Buf PlayCapsBuf;

TCurrentSoundFormatV02Buf PlayFormatBuf;

TCurrentSoundFormatV02Buf RecordFormatBuf;

TBuf<256> CommandLine;

RFs Fs;

//

// This is the WAV header structure used for playing and recording files

//

struct WAVEheader

	{

	char ckID[4];				// chunk id 'RIFF'

	TUint32 ckSize;				// chunk size

	char wave_ckID[4];			// wave chunk id 'WAVE'

	char fmt_ckID[4];			// format chunk id 'fmt '

	TUint32 fmt_ckSize;			// format chunk size

	TUint16 formatTag;			// format tag currently pcm

	TUint16 nChannels;			// number of channels

	TUint32 nSamplesPerSec;		// sample rate in hz

	TUint32 nAvgBytesPerSec;	// average bytes per second

	TUint16 nBlockAlign;		// number of bytes per sample

	TUint16 nBitsPerSample;		// number of bits in a sample

	char data_ckID[4];			// data chunk id 'data'

	TUint32 data_ckSize;		// length of data chunk

	};

LOCAL_C TInt SamplesPerSecondToRate(TInt aRateInSamplesPerSecond,TSoundRate& aRate)

	{

	switch (aRateInSamplesPerSecond)

		{

		case 7350: 	aRate=ESoundRate7350Hz; break;

		case 8000: 	aRate=ESoundRate8000Hz; break;

		case 8820: 	aRate=ESoundRate8820Hz; break;

		case 9600: 	aRate=ESoundRate9600Hz; break;

		case 11025: aRate=ESoundRate11025Hz; break;

		case 12000: aRate=ESoundRate12000Hz; break;

		case 14700:	aRate=ESoundRate14700Hz; break;

		case 16000: aRate=ESoundRate16000Hz; break;

		case 22050: aRate=ESoundRate22050Hz; break;

		case 24000: aRate=ESoundRate24000Hz; break;

		case 29400: aRate=ESoundRate29400Hz; break;

		case 32000: aRate=ESoundRate32000Hz; break;

		case 44100: aRate=ESoundRate44100Hz; break;

		case 48000: aRate=ESoundRate48000Hz; break;

		default: return(KErrArgument);

		};

	return(KErrNone);	

	}

LOCAL_C TInt RecordBufferSizeInBytes(TCurrentSoundFormatV02& aFormat)

	{

	switch (aFormat.iRate)

		{

		case ESoundRate7350Hz: return(8192);

		case ESoundRate8000Hz: return(8192);

		case ESoundRate8820Hz: return(12288);

		case ESoundRate9600Hz: return(12288);

		case ESoundRate11025Hz: return(12288);

		case ESoundRate12000Hz: return(12288);

		case ESoundRate14700Hz: return(12288);

		case ESoundRate16000Hz: return(12288);

		case ESoundRate22050Hz: return(16384);

		case ESoundRate24000Hz: return(16384);

		case ESoundRate29400Hz: return(24576);

		case ESoundRate32000Hz: return(24576);

		case ESoundRate44100Hz: return(32768);

		case ESoundRate48000Hz: return(32768);

		default: return(32768);

		};	

	}	

LOCAL_C TInt Load()

	{

	TInt r;

	Test.Start(_L("Load sound PDD"));

	r=User::LoadPhysicalDevice(KSndPddFileName);

	if (r==KErrNotFound)

		{

		Test.End();

		return(r);

		}

	CHECK(r==KErrNone || r==KErrAlreadyExists);

	Test.Next(_L("Load sound LDD"));

	r=User::LoadLogicalDevice(KSndLddFileName);

	CHECK(r==KErrNone || r==KErrAlreadyExists);

	Test.End();

	return(KErrNone);

	}

LOCAL_C TInt WavPlay()

	{

	RChunk chunk;

	// Parse the commandline and get a filename to use

	TLex l(CommandLine);

	TFileName thisfile=RProcess().FileName();

	TPtrC token=l.NextToken();

	if (token.MatchF(thisfile)==0)

		token.Set(l.NextToken());

	if (token.Length()==0)

		{

		// No args, skip to end

		Test.Printf(_L("Invalid configuration\r\n"));

		return(KErrArgument);

		}

	Test.Next(_L("Play Wav file"));

	// Assume that the argument is a WAV filename

	TFileName wavFilename=token;

	TInt r;

	RFile source;

	r = source.Open(Fs,wavFilename,EFileRead);

	if (r!=KErrNone)

		{

		Test.Printf(_L("Open failed(%d)\r\n"), r);

		return(r);

		}

	// Read the pcm header

	WAVEheader header;

	TPtr8 headerDes((TUint8 *)&header,sizeof(struct WAVEheader),sizeof(struct WAVEheader));

	r = source.Read(headerDes);

	if (r!=KErrNone)

		{

		source.Close();

		return(r);

		}

	Test.Printf(_L("Header Read %d bytes\r\n"),headerDes.Size());

	if (headerDes.Size() != sizeof(struct WAVEheader)) // EOF

		{

		Test.Printf(_L("Couldn't read a header(%d bytes)\r\n"),headerDes.Size());

		source.Close();

		return(KErrCorrupt);

		}

	Test.Printf(_L("Header rate:%d channels:%d tag:%d bits:%d (%d bytes/s) align %d datalen:%d fmt_ckSize:%d ckSize:%d\n"),

			header.nSamplesPerSec, header.nChannels, header.formatTag, header.nBitsPerSample,

			header.nAvgBytesPerSec, header.nBlockAlign, header.data_ckSize, header.fmt_ckSize, header.ckSize);

	if (header.formatTag != 1) // not pcm

		{

		Test.Printf(_L("Format not PCM(%d)\r\n"),header.formatTag);

		source.Close();

		return(KErrNotSupported);

		}

	if (header.nBitsPerSample != 16) // not 16 bit

		{

		Test.Printf(_L("Format not 16 bit PCM(%d bits)\r\n"),header.nBitsPerSample);

		source.Close();

		return(KErrNotSupported);

		}

	TSoundRate rate;	

	if (SamplesPerSecondToRate(header.nSamplesPerSec,rate)!=KErrNone)	

		{

		Test.Printf(_L("Format specifies a rate not supported(%d)\r\n"),header.nSamplesPerSec);

		source.Close();

		return(KErrNotSupported);

		}

	TxSoundDevice.AudioFormat(PlayFormatBuf);	// Read back the current setting which must be valid.

	PlayFormatBuf().iChannels = header.nChannels;

	PlayFormatBuf().iRate = rate;

	PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

	// Set the play buffer configuration.

	TInt bufSize=BytesPerSecond(PlayFormatBuf())/8; 	// Large enough to hold 1/8th second of data.

	bufSize&=~(header.nBlockAlign-1);					// Keep the buffer length a multiple of the bytes per sample (assumes 16bitPCM, 1 or 2 chans).

	if (PlayCapsBuf().iRequestMinSize)

		bufSize&=~(PlayCapsBuf().iRequestMinSize-1); 	// Keep the buffer length valid for the driver.

	TTestSharedChunkBufConfig bufferConfig;

	bufferConfig.iNumBuffers=3;

	bufferConfig.iBufferSizeInBytes=bufSize;

	bufferConfig.iFlags=0;	

	PrintBufferConf(bufferConfig,Test);

	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

	r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

	if (r!=KErrNone)

		{

		Test.Printf(_L("Buffer configuration not supported(%d)\r\n"),r);

		source.Close();

		return(r);

		}

	TxSoundDevice.GetBufferConfig(bufferConfigBuf);			// Read back the configuration - to get the buffer offsets

	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

	// Set the audio play configuration.

	TxSoundDevice.SetVolume(KSoundMaxVolume - (KSoundMaxVolume / 4)); // set volume to 75%

	PrintConfig(PlayFormatBuf(),Test);

	r=TxSoundDevice.SetAudioFormat(PlayFormatBuf);

	if (r!=KErrNone)

		{

		Test.Printf(_L("Format not supported\r\n"));

		source.Close();

		chunk.Close();

		return(r);

		}

	TxSoundDevice.ResetBytesTransferred();

	TInt32 bytesToPlay = header.data_ckSize;

	TTime starttime;

	starttime.HomeTime();

	TRequestStatus stat[3];

	TPtr8* tPtr[3];

	TInt i;

	for (i=0;i<3;i++)

		tPtr[i]=new TPtr8(NULL,0); 

	TTime startTime;

	startTime.HomeTime();

	// Start off by issuing a play request for each buffer (assuming that the file is long enough). Use the full size

	// of each buffer.

	TInt stillToRead=bytesToPlay;

	TInt stillNotPlayed=bytesToPlay;

	TUint flags;

	for (i=0 ; i<3 ; i++)

		{

		// Setup the descriptor for reading in the data from the file.

		tPtr[i]->Set(chunk.Base()+bufferConfig.iBufferOffsetList[i],0,bufSize); 

		// If there is still data to read to play then read this into the descriptor

		// and then write it to the driver.

		if (stillToRead)

			{

			r=source.Read(*tPtr[i],Min(stillToRead,bufSize));

			if (r!=KErrNone)

				{

				Test.Printf(_L("Initial file read error(%d)\r\n"),r);

				source.Close();

				chunk.Close();

				return(r);

				}

			stillToRead-=tPtr[i]->Length();

			flags=(stillToRead>0)?0:KSndFlagLastSample;

			TxSoundDevice.PlayData(stat[i],bufferConfig.iBufferOffsetList[i],tPtr[i]->Length(),flags);

			}

		else

			stat[i]=KRequestPending;	

		}	

	FOREVER

		{

		// Wait for any one of the outstanding play requests to complete.

		User::WaitForAnyRequest();

		TTime currentTime;

		currentTime.HomeTime();

		TInt64 elapsedTime = currentTime.Int64()-startTime.Int64();	// us

		TTimeIntervalMicroSecondsBuf timePlayedBuf;

		if(TxSoundDevice.TimePlayed(timePlayedBuf) == KErrNone)

			{

			// Compare TimePlayed with the actual elapsed time. They should be different, but not drift apart too badly...

			TInt32 offset = TInt32(elapsedTime - timePlayedBuf().Int64());

			Test.Printf(_L("\telapsedTime - TimePlayed = %d ms\n"), offset/1000);

			}		

		// Work out which buffer this applies to

		for (i=0 ; i<3 ; i++)

			{

			if (stat[i]!=KRequestPending)

				break;

			}

		if (i>=3)

			{

			Test.Printf(_L("I/O error\r\n"));

			source.Close();

			chunk.Close();

			return(KErrGeneral);

			}

		// Check that the transfer was succesful and whether we have now played all the file.

		if (stat[i]!=KErrNone)

			{

			Test.Printf(_L("Play error(%d)\r\n"),stat[i].Int());

			source.Close();

			chunk.Close();

			return(stat[i].Int());

			}

		Test.Printf(_L("Played %d bytes(%d) - %d\r\n"),tPtr[i]->Length(),i,stat[i].Int());

		stillNotPlayed-=tPtr[i]->Length();

		CHECK(stillNotPlayed>=0);

		if (!stillNotPlayed)

			break;

		// Still more to be played so read the next part of the file into the descriptor for this

		// buffer and then write it to the driver.

		if (stillToRead)

			{

			TInt len=Min(stillToRead,bufSize);

			// If we've got to the end of the file and the driver is particular about the request length then 

			// zero fill the entire buffer so we can play extra zeros after the last sample from the file.

			if (len<bufSize && PlayCapsBuf().iRequestMinSize)

				tPtr[i]->FillZ(bufSize);

			// Read the next part of the file 

			r=source.Read(*tPtr[i],len);			// This will alter the length of the descriptor

			if (r!=KErrNone)

				{

				Test.Printf(_L("File read error(%d)\r\n"),r);

				source.Close();

				chunk.Close();

				return(r);

				}

			stillToRead-=tPtr[i]->Length();

			// If we've got to the end of the file and the driver is particular about the request length then

			// round up the length to the next valid boundary. This is OK since we zero filled.

			if (tPtr[i]->Length() < bufSize && PlayCapsBuf().iRequestMinSize)

				{

				TUint m=PlayCapsBuf().iRequestMinSize-1;

				len=(tPtr[i]->Length() + m) & ~m;

				}

			// Write it to the driver.

			flags=(stillToRead>0)?0:KSndFlagLastSample;

			TxSoundDevice.PlayData(stat[i],bufferConfig.iBufferOffsetList[i],len,flags);

			}

		else

			stat[i]=KRequestPending;		

		}

	// Delete all the variables again.	

	for (i=0 ; i<3 ; i++)

		delete tPtr[i];

	TTime endtime;

	endtime.HomeTime();

	Test.Printf(_L("Done playing\r\n"));

	Test.Printf(_L("Bytes played = %d\r\n"),TxSoundDevice.BytesTransferred());

	Test.Printf(_L("Delta time = %d\r\n"),endtime.Int64()-starttime.Int64());

	chunk.Close();

	source.Close();

	return(KErrNone);

	}

LOCAL_C TInt WavRecord()

	{

	// Parse the commandline and get a filename to use

	TLex l(CommandLine);

	TParse destinationName;

	if (destinationName.SetNoWild(l.NextToken(),0,0)!=KErrNone)

		{

		Test.Printf(_L("No arg, skipping\r\n"));

		return(KErrArgument);

		}

	Test.Next(_L("Record Wav file"));

	// Open the file for writing

	TInt r;

	RFile destination;

	r = destination.Replace(Fs,destinationName.FullName(),EFileWrite);

	if (r!=KErrNone)

		{

		Test.Printf(_L("Open file for write failed(%d)\n"), r);

		return(r);

		}		

	Test.Printf(_L("File opened for write\r\n"));

	Test.Next(_L("Preparing to record"));

	// Get the rate

	TLex cl(l.NextToken());

	TUint32 tmpRate;

	TSoundRate rate;

	r = cl.Val(tmpRate,EDecimal);

	if (r == KErrNone && (r=SamplesPerSecondToRate(tmpRate,rate))==KErrNone)

		{

		Test.Printf(_L("Parsed rate: %d\r\n"), tmpRate);

		RecordFormatBuf().iRate = rate;

		}

	else

		{

		Test.Printf(_L("Parse rate failed(%d)\r\n"),r);

		RecordFormatBuf().iRate = ESoundRate32000Hz;

		}

	// Get number of channels

	TLex cl_chan(l.NextToken());

	TUint32 tmpChannels;

	r = cl_chan.Val(tmpChannels,EDecimal);

	if (r == KErrNone)

		{

		Test.Printf(_L("Parsed %d channels\r\n"),tmpChannels);

		RecordFormatBuf().iChannels = tmpChannels;

		}

	else

		{

		Test.Printf(_L("Parse channels failed(%d)\r\n"), r);

		RecordFormatBuf().iChannels = 2;

		}

	RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

	// Set the record buffer configuration.

	RChunk chunk;

	TTestSharedChunkBufConfig bufferConfig;

	bufferConfig.iNumBuffers=4;

	bufferConfig.iBufferSizeInBytes=RecordBufferSizeInBytes(RecordFormatBuf());

	if (RecordCapsBuf().iRequestMinSize)

		bufferConfig.iBufferSizeInBytes&=~(RecordCapsBuf().iRequestMinSize-1); 	// Keep the buffer length valid for the driver.

	bufferConfig.iFlags=0;	

	PrintBufferConf(bufferConfig,Test);

	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

	if (r!=KErrNone)

		{

		Test.Printf(_L("Buffer configuration not supported(%d)\r\n"),r);

		return(r);

		}

	// Set the audio record configuration.

	RxSoundDevice.SetVolume(KSoundMaxVolume);

	PrintConfig(RecordFormatBuf(),Test);

	r=RxSoundDevice.SetAudioFormat(RecordFormatBuf);

	if (r!=KErrNone)

		{

		Test.Printf(_L("Format not supported\r\n"));

		return(r);

		}

	// Get length in seconds

	TLex cl_seconds(l.NextToken());

	TUint32 tmpSeconds;

	r = cl_seconds.Val(tmpSeconds,EDecimal);

	if (r == KErrNone)

		{

		Test.Printf(_L("Parsed %d seconds\r\n"),tmpSeconds);

		}

	else

		{

		Test.Printf(_L("Parse seconds failed(%d)\r\n"),r);

		tmpSeconds=10;

		}

	TInt bytesToRecord = BytesPerSecond(RecordFormatBuf())*tmpSeconds;	

	Test.Next(_L("Recording..."));

	// Lay down a file header

	WAVEheader header;

	TPtr8 headerDes((TUint8 *)&header, sizeof(struct WAVEheader), sizeof(struct WAVEheader));

	// "RIFF"

	header.ckID[0] = 'R'; header.ckID[1] = 'I';

	header.ckID[2] = 'F'; header.ckID[3] = 'F';

	// "WAVE"

	header.wave_ckID[0] = 'W'; header.wave_ckID[1] = 'A';

	header.wave_ckID[2] = 'V'; header.wave_ckID[3] = 'E';

	// "fmt "

	header.fmt_ckID[0] = 'f'; header.fmt_ckID[1] = 'm';

	header.fmt_ckID[2] = 't'; header.fmt_ckID[3] = ' ';

	// "data"

	header.data_ckID[0] = 'd'; header.data_ckID[1] = 'a';

	header.data_ckID[2] = 't'; header.data_ckID[3] = 'a';

	header.nChannels		= (TUint16)RecordFormatBuf().iChannels;

	header.nSamplesPerSec	= RateInSamplesPerSecond(RecordFormatBuf().iRate);

	header.nBitsPerSample	= 16;

	header.nBlockAlign		= TUint16((RecordFormatBuf().iChannels == 2) ? 4 : 2);

	header.formatTag		= 1;	// type 1 is PCM

	header.fmt_ckSize		= 16;

	header.nAvgBytesPerSec	= BytesPerSecond(RecordFormatBuf());

	header.data_ckSize		= bytesToRecord;

	header.ckSize			= bytesToRecord + sizeof(struct WAVEheader) - 8;

	Test.Printf(_L("Header rate:%d channels:%d tag:%d bits:%d (%d bytes/s) align %d datalen:%d fmt_ckSize:%d ckSize:%d\r\n"),

			header.nSamplesPerSec, header.nChannels, header.formatTag, header.nBitsPerSample,

			header.nAvgBytesPerSec, header.nBlockAlign, header.data_ckSize, header.fmt_ckSize, header.ckSize, sizeof(struct WAVEheader));

	r = destination.Write(headerDes);

	TRequestStatus stat;

	TInt length;

	TPtrC8 buf;

	TTime startTime;

	startTime.HomeTime();

	// Start off by issuing a record request.

	TTime starttime;

	starttime.HomeTime();

	TInt bytesRecorded = 0;

	RxSoundDevice.RecordData(stat,length);

	TInt pausesToDo = 10;

	pausesToDo = 0;

	FOREVER

		{

		// Wait for the outstanding record request to complete.

        User::After(6000);

		User::WaitForAnyRequest();

		if (stat==KRequestPending)

			return(KErrGeneral);

		TTime currentTime;

		currentTime.HomeTime();

		TInt64 elapsedTime = currentTime.Int64()-startTime.Int64();	// us

		TTimeIntervalMicroSecondsBuf timeRecordedBuf;

		if(RxSoundDevice.TimeRecorded(timeRecordedBuf) == KErrNone)

			{

			// Compare TimeRecorded with the actual elapsed time. They should be different, but not drift apart too badly...

			TInt32 offset = TInt32(elapsedTime - timeRecordedBuf().Int64());

			Test.Printf(_L("\telapsedTime - TimeRecorded = %d ms\n"), offset/1000);

			}		

		// Check whether the record request was succesful.

		TInt retOffset=stat.Int();

		if (retOffset<0)

			{

			Test.Printf(_L("Record failed(%d)\r\n"),retOffset);

			return(retOffset);

			}

		// Successfully recorded another buffer so write the recorded data to the record file and release the buffer.

		buf.Set((const TUint8*)(chunk.Base()+retOffset),length);

		r=destination.Write(buf);

		if (r!=KErrNone)

			{

			Test.Printf(_L("File write failed(%d)\r\n"),r);

			return(r);

			}

		r=RxSoundDevice.ReleaseBuffer(retOffset);

		if (r!=KErrNone)

			{

			Test.Printf(_L("Release buffer failed(%d)\r\n"),r);

			return(r);

			}

		Test.Printf(_L("Recorded %d more bytes - %d\r\n"),length,retOffset);

		if((pausesToDo > 0) && (bytesRecorded > bytesToRecord/2))

			{

			--pausesToDo;

			Test.Printf(_L("Pause\r\n"));

			RxSoundDevice.Pause();

			Test.Printf(_L("Paused, sleeping for 0.5 seconds\r\n"));

			User::After(500*1000);

            Test.Printf(_L("Resume\r\n"));

			RxSoundDevice.Resume();

			}

		// Check whether we have now recorded all the data. If more to record then queue a further request

		bytesRecorded+=length;

		if (bytesRecorded<bytesToRecord)

		    {

            Test.Printf(_L("RecordData\r\n"));

			RxSoundDevice.RecordData(stat,length);

		    }

		else

			break;

		}

	RxSoundDevice.CancelRecordData();	// Stop the driver from recording.

	TTime endtime;

	endtime.HomeTime();

	TInt64 elapsedTime = endtime.Int64()-starttime.Int64();	// us

	Test.Printf(_L("Delta time = %d\r\n"),I64LOW(elapsedTime));

	Test.Printf(_L("Seconds in buffer: %d (%d)\r\n"), bytesRecorded / header.nAvgBytesPerSec, (bytesRecorded / header.nAvgBytesPerSec)*1000000);

	if (I64LOW(elapsedTime) <= (bytesRecorded / header.nAvgBytesPerSec)*1000000)

		{

		Test.Printf(_L("Time travelling; record took less time than it should have done\r\n"));

		return(KErrGeneral);

		}

	chunk.Close();

	destination.Close();

	Test.Printf(_L("Record finished\r\n"));

	return(KErrNone);

	}

// Quick test block to write the output of the signal generator to a file.

// You'll need to comment out the reference to playdata in writetone and link

// the function into the command line processing (search on this function name).	

/*

LOCAL_C void TestWaveformGenerator()

	{

	Test.Next(_L("Testing waveform generator"));

	// Parse the commandline and get a filename to use

	TLex l(CommandLine);

	TParse destinationName;

	if (destinationName.SetNoWild(l.NextToken(),0,0)!=KErrNone)

		{

		Test.Printf(_L("No arg, skipping\r\n"));

		return;

		}

	// Open the file for writing

	TInt r;

	RFile destination;

	r = destination.Replace(Fs,destinationName.FullName(),EFileWrite);

	if (r!=KErrNone)

		{

		Test.Printf(_L("Open file for write failed(%d)\r\n"), r);

		}

	Test.Printf(_L("File opened for write\r\n"));

	Test.Next(_L("Preparing to record data"));

	// Get the rate

	TLex cl(l.NextToken());

	TUint32 tmpRate;

	TSoundRate rate;

	r = cl.Val(tmpRate,EDecimal);

	if (r == KErrNone && (r=SamplesPerSecondToRate(tmpRate,rate))==KErrNone)

		{

		Test.Printf(_L("Parsed rate: %d\r\n"), tmpRate);

		PlayFormatBuf().iRate = rate;

		}

	else

		{

		Test.Printf(_L("Parse rate failed(%d)\r\n"),r);

		PlayFormatBuf().iRate = ESoundRate32000Hz;

		}

	// Get number of channels

	TLex cl_chan(l.NextToken());

	TUint32 tmpChannels;

	r = cl_chan.Val(tmpChannels,EDecimal);

	if (r == KErrNone)

		{

		Test.Printf(_L("Parsed %d channels\r\n"),tmpChannels);

		PlayFormatBuf().iChannels = tmpChannels;

		}

	else

		{

		Test.Printf(_L("Parse channels failed(%d)\r\n"), r);

		PlayFormatBuf().iChannels = 2;

		}

	PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

	PrintConfig(PlayFormatBuf(),Test);

	TInt bufferSize=BytesPerSecond(PlayFormatBuf())/8;

	TUint8* buffer = (TUint8*)User::Alloc(bufferSize*sizeof(TUint8));

	if (buffer==NULL)

		{

		Test.Printf(_L("Out of memory\r\n"));

		return;

		}

	TPtr8 bufferDes(buffer,bufferSize,bufferSize);	

	Test.Next(_L("Recording..."));

	TInt i = BytesPerSecond(PlayFormatBuf())*10/bufferSize;

	TInt bytesToRecord = i * bufferSize;

	// Lay down a file header

	WAVEheader header;

	TPtr8 headerDes((TUint8 *)&header, sizeof(struct WAVEheader), sizeof(struct WAVEheader));

	// "RIFF"

	header.ckID[0] = 'R'; header.ckID[1] = 'I';

	header.ckID[2] = 'F'; header.ckID[3] = 'F';

	// "WAVE"

	header.wave_ckID[0] = 'W'; header.wave_ckID[1] = 'A';

	header.wave_ckID[2] = 'V'; header.wave_ckID[3] = 'E';

	// "fmt "

	header.fmt_ckID[0] = 'f'; header.fmt_ckID[1] = 'm';

	header.fmt_ckID[2] = 't'; header.fmt_ckID[3] = ' ';

	// "data"

	header.data_ckID[0] = 'd'; header.data_ckID[1] = 'a';

	header.data_ckID[2] = 't'; header.data_ckID[3] = 'a';

	header.nChannels		= PlayFormatBuf().iChannels;

	header.nSamplesPerSec	= RateInSamplesPerSecond(PlayFormatBuf().iRate);

	header.nBitsPerSample	= 16;

	header.nBlockAlign		= 4;

	header.formatTag		= 1;

	header.fmt_ckSize		= 16;

	header.nAvgBytesPerSec	= BytesPerSecond(PlayFormatBuf());

	header.data_ckSize		= bytesToRecord;

	header.ckSize			= bytesToRecord + sizeof(struct WAVEheader) - 8;

	Test.Printf(_L("Header rate:%d channels:%d tag:%d bits:%d (%d bytes/s) align %d datalen:%d fmt_ckSize:%d ckSize:%d\r\n"),

			header.nSamplesPerSec, header.nChannels, header.formatTag, header.nBitsPerSample,

			header.nAvgBytesPerSec, header.nBlockAlign, header.data_ckSize, header.fmt_ckSize, header.ckSize);

	r = destination.Write(headerDes);

	MakeSineTable(PlayFormatBuf());

	SetToneFrequency(440,PlayFormatBuf()); // 'A'

	while(--i>0)

		{

		WriteTone(bufferDes,PlayFormatBuf());

		r = destination.Write(bufferDes);

		if (r!=KErrNone)

			{

			Test.Printf(_L("Write failed(%d)\r\n"),r);

			break;

			}

		}

	Test.Printf(_L("Finished\r\n"));

	delete buffer;

	destination.Close();

	}

*/

LOCAL_C void TestUnloadDrivers()

	{

	TInt r=User::FreeLogicalDevice(KDevSoundScName);

	Test.Printf(_L("Unloading %S.LDD - %d\r\n"),&KDevSoundScName,r);

	CHECK_NOERROR(r);

	TName pddName(KDevSoundScName);

	_LIT(KPddWildcardExtension,".*");

	pddName.Append(KPddWildcardExtension);

	TFindPhysicalDevice findPD(pddName);

	TFullName findResult;

	r=findPD.Next(findResult);

	while (r==KErrNone)

		{

		r=User::FreePhysicalDevice(findResult);

		Test.Printf(_L("Unloading %S.PDD - %d\r\n"),&findResult,r);

		CHECK_NOERROR(r);

		findPD.Find(pddName); // Reset the find handle now that we have deleted something from the container.

		r=findPD.Next(findResult);

		} 

	}

TInt E32Main()

	{

	TInt r;

	__UHEAP_MARK;

	Test.Title();

	Test.Start(_L("Load"));

	if (Load()==KErrNotFound)

		{

		Test.Printf(_L("Shared chunk sound driver not supported - test skipped\r\n"));

		Test.End();

		Test.Close();

		__UHEAP_MARKEND;

		return(KErrNone);

		}

	__KHEAP_MARK;

	Test.Next(_L("Open playback channel"));

	r = TxSoundDevice.Open(KSoundScTxUnit0);

	if (r!=KErrNone)

		{

		Test.Printf(_L("Open playback channel error(%d)\r\n"),r);

		Test(0);

		}

	Test.Next(_L("Open record channel"));

	r = RxSoundDevice.Open(KSoundScRxUnit0);

	if (r!=KErrNone)

		{

		Test.Printf(_L("Open record channel error(%d)\r\n"),r);

		Test(0);

		}

	Test.Next(_L("Query play formats supported"));

	TxSoundDevice.Caps(PlayCapsBuf);

	TSoundFormatsSupportedV02 playCaps=PlayCapsBuf();

	PrintCaps(playCaps,Test);

	Test.Next(_L("Query record formats supported"));

	RxSoundDevice.Caps(RecordCapsBuf);

	TSoundFormatsSupportedV02 recordCaps=RecordCapsBuf();

	PrintCaps(recordCaps,Test);

	Test.Next(_L("Connect to the file server"));

	r = Fs.Connect();

	if (r!=KErrNone)

		{

		Test.Printf(_L("Connect to the file server error(%d)\r\n"),r);

		Test(0);

		}

	if (User::CommandLineLength())

		{

		User::CommandLine(CommandLine);

		TLex l(CommandLine);

		TPtrC token=l.NextToken();

		TInt count=0;

		while (token.Length()!=0)

			{

			++count;

			token.Set(l.NextToken());

			}

		Test.Printf(_L("Command line %d parameters\r\n"),count);

		if (count==1)		// If 1 parameter try playing a file

			r=WavPlay();

		else if (count)		// If there is more than 1 parameter, try recording

			r=WavRecord();

		//TestWaveformGenerator();

		}

	Fs.Close();

	Test.Next(_L("Close channels"));

	RxSoundDevice.Close();

	TxSoundDevice.Close();

	__KHEAP_MARKEND;

	// Now that both the channels are closed, unload the LDD and the PDDs.

	TestUnloadDrivers();

	Test(r==KErrNone);

	Test.End();

	Test.Close();

	Cleanup();

	__UHEAP_MARKEND;

	return(KErrNone);

	}