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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32test\multimedia\t_sound2.cpp

    15 //

    16 //

    17 

    18 /**

    19  @file General test code for the shared chunk sound driver - based on T_SOUND.

    20 */

    21 

    22 #include <e32test.h>

    23 #include "t_soundutils.h"

    24 #include <hal.h>

    25 #include <e32def.h>

    26 #include <e32def_private.h>

    27 

    28 // #define SOAKTEST

    29 

    30 const TSoundRate speedTable[] = {ESoundRate48000Hz,ESoundRate44100Hz,ESoundRate32000Hz,ESoundRate29400Hz,

    31 								 ESoundRate24000Hz,ESoundRate22050Hz,ESoundRate16000Hz,ESoundRate14700Hz,

    32 								 ESoundRate12000Hz,ESoundRate11025Hz,ESoundRate9600Hz,ESoundRate8820Hz,

    33 								 ESoundRate8000Hz,ESoundRate7350Hz,(TSoundRate)-1};	// ALL RATES DECENDING

    34 

    35 #define CHECK(aValue) {Test(aValue,__LINE__);}

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

    37 #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__); }}

    38 #define CHECK_POSITIVE(aOffset) { if(aOffset<0) { Test.Printf(_L("CHECK_POSITIVE(%d) failed\n"), aOffset); Test(EFalse,__LINE__); } }

    39 

    40 _LIT(KSndLddFileName,"ESOUNDSC.LDD");

    41 _LIT(KSndPddFileName,"SOUNDSC.PDD");

    42 

    43 RTest Test(_L("T_SOUND2"));

    44 RSoundSc TxSoundDevice;

    45 RSoundSc RxSoundDevice;

    46 

    47 TSoundFormatsSupportedV02Buf RecordCapsBuf;

    48 TSoundFormatsSupportedV02Buf PlayCapsBuf;

    49 TCurrentSoundFormatV02Buf PlayFormatBuf;

    50 TCurrentSoundFormatV02Buf RecordFormatBuf;

    51 

    52 LOCAL_C TInt Load()

    53 	{

    54 	TInt r;

    55 

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

    57 	r=User::LoadPhysicalDevice(KSndPddFileName);

    58 	if (r==KErrNotFound)

    59 		{

    60 		Test.End();

    61 		return(r);

    62 		}

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

    64 	r=User::LoadPhysicalDevice(KSndPddFileName);

    65 	CHECK(r==KErrAlreadyExists);

    66 

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

    68 	r=User::LoadLogicalDevice(KSndLddFileName);

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

    70 	r=User::LoadPhysicalDevice(KSndPddFileName);

    71 	CHECK(r==KErrAlreadyExists);

    72 

    73 	Test.End();

    74 	return(KErrNone);

    75 	}

    76 

    77 LOCAL_C void CheckConfig(const TCurrentSoundFormatV02& aConfig,const TSoundFormatsSupportedV02& aCaps)

    78 	{

    79 	if (!((1<<(aConfig.iChannels-1)) & aCaps.iChannels))

    80 		CHECK_NOERROR(ETrue);

    81 	if (!((1<<aConfig.iRate) & aCaps.iRates))

    82 		CHECK_NOERROR(ETrue);

    83 	if (!((1<<aConfig.iEncoding) & aCaps.iEncodings))

    84 		CHECK_NOERROR(ETrue);

    85 	if (!((1<<aConfig.iDataFormat) & aCaps.iDataFormats))

    86 		CHECK_NOERROR(ETrue);

    87 	}

    88 

    89 

    90 ////////////////////////////////////////////////////////////////////////////////

    91 // Tests

    92 

    93 const TInt KMaxLinearVolume=256;

    94 const TInt KLinearTodB[KMaxLinearVolume+1] =

    95 	{

    96 	0  ,158,170,177,182,186,189,192,194,196,198,200,201,203,204,205,

    97 	206,207,208,209,210,211,212,213,213,214,215,215,216,217,217,218,

    98 	218,219,219,220,220,221,221,222,222,223,223,224,224,224,225,225,

    99 	225,226,226,226,227,227,227,228,228,228,229,229,229,230,230,230,

   100 	230,231,231,231,231,232,232,232,232,233,233,233,233,234,234,234,

   101 	234,235,235,235,235,235,236,236,236,236,236,237,237,237,237,237,

   102 	237,238,238,238,238,238,239,239,239,239,239,239,240,240,240,240,

   103 	240,240,240,241,241,241,241,241,241,241,242,242,242,242,242,242,

   104 	242,243,243,243,243,243,243,243,244,244,244,244,244,244,244,244,

   105 	245,245,245,245,245,245,245,245,245,246,246,246,246,246,246,246,

   106 	246,246,247,247,247,247,247,247,247,247,247,247,248,248,248,248,

   107 	248,248,248,248,248,248,249,249,249,249,249,249,249,249,249,249,

   108 	250,250,250,250,250,250,250,250,250,250,250,250,251,251,251,251,

   109 	251,251,251,251,251,251,251,251,252,252,252,252,252,252,252,252,

   110 	252,252,252,252,252,253,253,253,253,253,253,253,253,253,253,253,

   111 	253,253,254,254,254,254,254,254,254,254,254,254,254,254,254,254,255

   112 	};

   113 

   114 LOCAL_C void TestBasicPlayFunctions()

   115 	{

   116 	TRequestStatus stat[2];

   117 

   118 	Test.Next(_L("Preparing to play..."));

   119 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   120 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   121 	PlayFormatBuf().iChannels = 1;

   122 	PrintConfig(PlayFormatBuf(),Test);

   123 	TInt r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

   124 	CHECK_NOERROR(r);

   125 

   126 	// Set the play buffer configuration, then read it back.

   127 	RChunk chunk;

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

   129 	bufSize=ValidBufferSize(bufSize,PlayCapsBuf().iRequestMinSize,PlayFormatBuf());		// Keep the buffer length valid for driver.

   130 	TTestSharedChunkBufConfig bufferConfig;

   131 	bufferConfig.iNumBuffers=2;

   132 	bufferConfig.iBufferSizeInBytes=bufSize;

   133 	bufferConfig.iFlags=0;		// All buffers will be contiguous

   134 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

   135 	r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

   136 	CHECK_NOERROR(r);

   137 	TxSoundDevice.GetBufferConfig(bufferConfigBuf);

   138 	PrintBufferConf(bufferConfig,Test);

   139 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

   140 	TPtr8* tPtr[2];

   141 	TInt i;

   142 	for (i=0;i<2;i++)

   143 		tPtr[i]=new TPtr8(chunk.Base()+bufferConfig.iBufferOffsetList[i],bufSize);

   144 

   145 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-249

   146 	@SYMTestCaseDesc 		Play pause / resume - pausing and resuming before playback has commenced.

   147 	@SYMTestPriority 		Critical

   148 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration.

   149 							1)	Attempt to resume playback before playback has been started.

   150 							2)	Attempt to pause playback before playback has been started.

   151 	@SYMTestExpectedResults	1)	The resume request should complete with KErrNotReady.

   152 							2)	The pause request should complete with KErrNotReady

   153 	@SYMREQ					PREQ1073.4 */

   154 

   155 	Test.Printf(_L("Resume when not playing\r\n"));

   156 	r=TxSoundDevice.Resume();

   157 	CHECK(r==KErrNotReady)

   158 

   159 	Test.Printf(_L("Pause when not playing\r\n"));

   160 	r=TxSoundDevice.Pause();

   161 	CHECK(r==KErrNotReady)

   162 

   163 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-237

   164 	@SYMTestCaseDesc 		Play operation - with zero length.

   165 	@SYMTestPriority 		Critical

   166 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer

   167 							configuration. Issue a transfer request from one of the buffers to play data specifying a

   168 							length of zero.

   169 	@SYMTestExpectedResults	The play request should complete with KErrNone.

   170 	@SYMREQ					PREQ1073.4 */

   171 

   172 	Test.Next(_L("Play empty buffer"));

   173 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],0,KSndFlagLastSample);	// Play length of zero

   174 	User::WaitForRequest(stat[0]);

   175 	CHECK_EQUAL(stat[0].Int(),KErrNone);

   176 

   177 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-238

   178 	@SYMTestCaseDesc 		Play operation - with a short transfer.

   179 	@SYMTestPriority 		Critical

   180 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration.

   181 							1)	Issue a transfer requests from one of the buffers to play data, specifying a length equal to the

   182 								minimum request size that the device supports - i.e.

   183 								TSoundFormatsSupportedV02::iRequestMinSize, or 2 bytes, whichever is greater.

   184 							2)	Issue a transfer requests from one of the buffers to play data, specifying a length equal

   185 								to twice the minimum request size that the device supports, or 34 bytes, whichever

   186 								is greater.

   187 	@SYMTestExpectedResults	1)	The play request should complete with KErrNone.

   188 							2)	The play request should complete with KErrNone.

   189 	@SYMREQ					PREQ1073.4 */

   190 

   191 	Test.Next(_L("Play short buffer"));

   192 	TInt len=Max(2,PlayCapsBuf().iRequestMinSize);

   193 	Test.Printf(_L("Play length is %d bytes\r\n"),len);

   194 	tPtr[0]->FillZ(bufSize);

   195 	tPtr[1]->FillZ(len);

   196 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize,0);

   197 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],len,KSndFlagLastSample);

   198 	User::WaitForRequest(stat[0]);

   199 	CHECK_EQUAL(stat[0].Int(),KErrNone);

   200 	User::WaitForRequest(stat[1]);

   201 	CHECK_EQUAL(stat[1].Int(),KErrNone);

   202 

   203 	Test.Next(_L("Play a slightly longer buffer"));

   204 	len=Max(34,(PlayCapsBuf().iRequestMinSize<<1));

   205 	if (PlayCapsBuf().iRequestMinSize)

   206 			len&=~(PlayCapsBuf().iRequestMinSize-1);

   207 	Test.Printf(_L("Play length is %d bytes\r\n"),len);

   208 	tPtr[1]->FillZ(bufSize);

   209 	tPtr[0]->FillZ(len);

   210 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[1],bufSize,0); // Play 2nd buffer 1st

   211 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[0],len,KSndFlagLastSample);

   212 	User::WaitForRequest(stat[0]);

   213 	CHECK_EQUAL(stat[0].Int(),KErrNone);

   214 	User::WaitForRequest(stat[1]);

   215 	CHECK_EQUAL(stat[1].Int(),KErrNone);

   216 

   217 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-240

   218 	@SYMTestCaseDesc 		Play operation - altering the volume.

   219 	@SYMTestPriority 		Critical

   220 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration

   221 							so it contains multiple buffers. Using multiple simultaneous play requests, play 4 seconds

   222 							of continuous tone - with each individual play request consisting of 1/8th second of tone.

   223 							Each time a request completes, increase the volume slightly - starting at the minimum

   224 							and ending at maximum volume. (Ensure the last request is marked with the

   225 							KSndFlagLastSample flag).

   226 	@SYMTestExpectedResults	The driver should successfully play 4 seconds of tone with all requests completing with

   227 							KErrNone.

   228 	@SYMREQ					PREQ1073.4 */

   229 

   230 	/**	@SYMTestCaseID 		PBASE-T_SOUND2-250

   231 	@SYMTestCaseDesc 		Play pause / resume - pausing and resuming while playback is in progress.

   232 	@SYMTestPriority 		Critical

   233 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration

   234 							so it contains multiple buffers. Reset the channel's count of bytes transferred.

   235 							Using multiple simultaneous play requests, play 4 seconds of continuous tone - with

   236 							each individual play request consisting of 1/8th second of tone.

   237 							1)	After 10 requests have completed, pause transfer for 2 seconds, then resume it.

   238 							2)	After 20 requests have completed, attempt to resume playback while playback is not paused.

   239 							3)	With only 0.25 second of tone still to play, pause transfer for 1 second, then resume it.

   240 							4)	10ms after resuming, pause transfer again for 1 second, then resume it.

   241 							5)	Once transfer has completed, read back the count of bytes transferred.

   242 	@SYMTestExpectedResults	1)	Playback of the tone should be interrupted for 2 seconds with the pause and resume requests

   243 								both completing with KErrNone.

   244 							2)	The resume request should complete with KErrNotReady.

   245 							3)	Playback of the tone should be interrupted for 1 second with the pause and resume requests

   246 								both completing with KErrNone.

   247 							4)	Playback of the tone should be interrupted for 1 second with the pause and resume requests

   248 								both completing with KErrNone.

   249 							5)	The count of bytes transferred should not be affected by pausing and resuming playback

   250 								(i.e. it should equal the value calculated for 4 seconds at the selected sampe rate and

   251 								number of channels).

   252 	@SYMREQ					PREQ1073.4 */

   253 

   254 	Test.Next(_L("Playing..."));

   255 	r=MakeSineTable(PlayFormatBuf());

   256 	CHECK_NOERROR(r);

   257 	r=SetToneFrequency(440,PlayFormatBuf());

   258 	CHECK_NOERROR(r);

   259 	TxSoundDevice.ResetBytesTransferred();

   260 	TInt remainingPlayCount = BytesPerSecond(PlayFormatBuf())*4/bufSize;

   261 

   262 	// Set the initial value for the volume.

   263 	TInt bytesToPlay = remainingPlayCount*bufSize;

   264 	TInt bytesPlayed = 0;

   265 	TInt vol = I64LOW(TInt64(KMaxLinearVolume)*TInt64(bytesPlayed)/TInt64(bytesToPlay));

   266 	vol = KLinearTodB[vol];			// Rather than varying the volume logarithmically (in dB), vary it linearly (as done by MM).

   267 	TxSoundDevice.SetVolume(vol);

   268 

   269 	// Issue a pair of play requests.

   270 	WriteTone(*tPtr[0],PlayFormatBuf());

   271 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize);

   272 	WriteTone(*tPtr[1],PlayFormatBuf());

   273 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize);

   274 

   275 	TInt lcount = 0;

   276 	TUint flags;

   277 	while (remainingPlayCount>2)

   278 		{

   279 		// Wait for either of the outstanding play requests to complete.

   280 		User::WaitForAnyRequest();

   281 		remainingPlayCount--;

   282 

   283 		// Work out which request this applies to.

   284 		for (i=0;i<2;i++)

   285 			{

   286 			if (stat[i]!=KRequestPending)

   287 				break;

   288 			}

   289 		CHECK(i<2);

   290 		CHECK_NOERROR(stat[i].Int());

   291 

   292 		// Issue a further play request using the buffer just made free.

   293 		WriteTone(*tPtr[i],PlayFormatBuf());

   294 		flags=(remainingPlayCount<=2)?KSndFlagLastSample:0;

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

   296 

   297 		// Adjust the volume

   298 		bytesPlayed = TxSoundDevice.BytesTransferred();

   299 		vol = I64LOW(TInt64(KMaxLinearVolume)*TInt64(bytesPlayed)/TInt64(bytesToPlay));

   300 		vol = KLinearTodB[vol];			// Rather than varying the volume logarithmically (in dB), vary it linearly (as done by MM).

   301 		Test.Printf(_L("Bytes played = %d (vol = %d)\r\n"),bytesPlayed,vol);

   302 		TxSoundDevice.SetVolume(vol);

   303 

   304 		if (lcount == 10)

   305 			{

   306 			// Do a pause/resume

   307 			r=TxSoundDevice.Pause();

   308 			CHECK_NOERROR(r);

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

   310 			User::After(2000000);

   311 			Test.Printf(_L("Restart\r\n"));

   312 			r=TxSoundDevice.Resume();

   313 			CHECK_NOERROR(r);

   314 			}

   315 		if (lcount == 20)

   316 			{

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

   318 			r=TxSoundDevice.Resume();

   319 			CHECK(r==KErrNotReady)

   320 			}

   321 

   322 		CHECK_EQUAL(TxSoundDevice.Volume(),vol);

   323 		CHECK_EQUAL(TxSoundDevice.SetAudioFormat(PlayFormatBuf),KErrInUse);

   324 		lcount++;

   325 		}

   326 

   327 	// Last 2 play requests still outstanding - do a pause/resume

   328 	r=TxSoundDevice.Pause();

   329 	CHECK_NOERROR(r);

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

   331 	User::After(1000000);

   332 	Test.Printf(_L("Restart\r\n"));

   333 	r=TxSoundDevice.Resume();

   334 	CHECK_NOERROR(r);

   335 	bytesPlayed = TxSoundDevice.BytesTransferred();

   336 

   337 	User::After(10000); // 10ms

   338 

   339 	r=TxSoundDevice.Pause();

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

   341 

   342 	CHECK_NOERROR(r);

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

   344 	User::After(1000000);

   345 	Test.Printf(_L("Restart\r\n"));

   346 	r=TxSoundDevice.Resume();

   347 	CHECK_NOERROR(r);

   348 	bytesPlayed = TxSoundDevice.BytesTransferred();

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

   350 

   351 	User::WaitForRequest(stat[0]);

   352 	CHECK_EQUAL(stat[0].Int(),KErrNone);

   353 	User::WaitForRequest(stat[1]);

   354 	CHECK_EQUAL(stat[1].Int(),KErrNone);

   355 

   356 	bytesPlayed = TxSoundDevice.BytesTransferred();

   357 	Test.Printf(_L("Bytes played = %d vs %d\n"),bytesPlayed, bytesToPlay);

   358 	CHECK_EQUAL(bytesToPlay,bytesPlayed);

   359 

   360 	TxSoundDevice.ResetBytesTransferred();

   361 	CHECK_EQUAL(TxSoundDevice.BytesTransferred(),0);

   362 

   363 	Test.Next(_L("Pause and resume when not playing"));

   364 	TxSoundDevice.Pause();

   365 	TxSoundDevice.Resume();

   366 

   367 	chunk.Close();

   368 	for (i=0;i<2;i++)

   369 		delete tPtr[i];

   370 	}

   371 

   372 LOCAL_C void TestBasicRecordFunctions()

   373 	{

   374 	TRequestStatus stat;

   375 	TInt length, r, i;

   376 

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

   378 

   379 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   380 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   381 	RecordFormatBuf().iChannels = 2;

   382 

   383 	// find first supported rate and set the the audio configuration to use it

   384 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

   385 		{

   386 		RecordFormatBuf().iRate = (TSoundRate)i;

   387 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

   388 		if (RecordCapsBuf().iRates & (1<<i))

   389 			{

   390 			CHECK_NOERROR(r);				// Caps reports it is supported

   391 			break;

   392 			}

   393 		}

   394 

   395 	PrintConfig(RecordFormatBuf(),Test);

   396 

   397 	// Set the record buffer configuration, then read it back.

   398 	RChunk chunk;

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

   400 	bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

   401 	TTestSharedChunkBufConfig bufferConfig;

   402 	bufferConfig.iNumBuffers=3;

   403 	bufferConfig.iBufferSizeInBytes=bufSize;

   404 	bufferConfig.iFlags=0;																// All buffers will be contiguous

   405 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

   406 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

   407 	CHECK_NOERROR(r);

   408 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

   409 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

   410 

   411 	Test.Next(_L("Test for record overflow"));

   412 	RxSoundDevice.SetVolume(KSoundMaxVolume);

   413 	RxSoundDevice.RecordData(stat,length);

   414 	User::WaitForRequest(stat);

   415 	TInt retOffset=stat.Int();

   416 	CHECK_POSITIVE(retOffset);

   417 	CHECK(length>0);

   418 	r=RxSoundDevice.ReleaseBuffer(retOffset);

   419 	CHECK_NOERROR(r);

   420 

   421 	User::After(500000);			// Wait 1/2 second for data overflow.

   422 

   423 	RxSoundDevice.RecordData(stat,length);

   424 	User::WaitForRequest(stat);

   425 	retOffset=stat.Int();

   426 	CHECK(retOffset==KErrOverflow);

   427 

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

   429 	chunk.Close();

   430 	}

   431 

   432 /**	@SYMTestCaseID 			PBASE-T_SOUND2-241

   433 	@SYMTestCaseDesc 		Play operation - playing all rates.

   434 	@SYMTestPriority 		Critical

   435 	@SYMTestActions			1)	For each of the sample rates supported by the device, setup the audio configuration

   436 								on the playback channel for mono operation (i.e. 1 audio channel) and then setup

   437 								the buffer configuration so it contains multiple buffers. Using multiple simultaneous play requests,

   438 								play 4 seconds of continuous tone - with each individual play request consisting of 1/8th second of

   439 								tone. (Ensure the last request is marked with the KSndFlagLastSample flag).

   440 							2)	Repeat the above with the driver configured for stereo operation (i.e. 2 audio channels).

   441 	@SYMTestExpectedResults	1)	For each of the sample rates supported by the device, the driver should successfully play

   442 								4 seconds of tone, with no interruptions in the sound produced and with all requests

   443 								completing with KErrNone.

   444 							2)	For each of the sample rates supported by the device, the driver should successfully play

   445 								4 seconds of tone, with no interruptions in the sound produced and with all requests

   446 								completing with KErrNone.

   447 	@SYMREQ					PREQ1073.4

   448 */

   449 LOCAL_C void TestPlayAllRates(TInt aNumChannels,TInt aNumSeconds)

   450 	{

   451 	TRequestStatus stat[2];

   452 	TPtr8* tPtr[2];

   453 	TInt i;

   454 	for (i=0;i<2;i++)

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

   456 

   457 	Test.Next(_L("Play all rates test"));

   458 	Test.Printf(_L("Number of channels %d, duration %d seconds\n"), aNumChannels, aNumSeconds);

   459 

   460 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   461 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   462 	PlayFormatBuf().iChannels = aNumChannels;

   463 	TInt r=MakeSineTable(PlayFormatBuf());

   464 	CHECK_NOERROR(r);

   465 

   466 	TxSoundDevice.SetVolume(KSoundMaxVolume);

   467 

   468 	RChunk chunk;

   469 	TInt speed = 0;

   470 	while (speedTable[speed]>=0)

   471 		{

   472 		PlayFormatBuf().iRate = speedTable[speed++];

   473 		PlayFormatBuf().iChannels = aNumChannels;

   474 

   475 		// Set the play format.

   476 		Test.Printf(_L("Testing playback rate %d...\r\n"),RateInSamplesPerSecond(PlayFormatBuf().iRate));

   477 		r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

   478 		if (r==KErrNotSupported)

   479 			{

   480 			Test.Printf(_L("Sample rate not supported\r\n"));

   481 			continue;

   482 			}

   483 		CHECK_NOERROR(r);

   484 

   485 		// Set the play buffer configuration, then read it back.

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

   487 		bufSize=ValidBufferSize(bufSize,PlayCapsBuf().iRequestMinSize,PlayFormatBuf());		// Keep the buffer length valid for driver.

   488 		TTestSharedChunkBufConfig bufferConfig;

   489 		bufferConfig.iNumBuffers=2;

   490 		bufferConfig.iBufferSizeInBytes=bufSize;

   491 		bufferConfig.iFlags=0;																// All buffers will be contiguous

   492 		TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

   493 		r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

   494 		CHECK_NOERROR(r);

   495 		TxSoundDevice.GetBufferConfig(bufferConfigBuf);

   496 		PrintBufferConf(bufferConfig,Test);

   497 		CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

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

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

   500 

   501 		r=SetToneFrequency(440,PlayFormatBuf());

   502 		CHECK_NOERROR(r);

   503 		TxSoundDevice.ResetBytesTransferred();

   504 		CHECK_EQUAL(TxSoundDevice.BytesTransferred(),0);

   505 

   506 		// Issue a pair of play requests.

   507 		WriteTone(*tPtr[0],PlayFormatBuf());

   508 		TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize);

   509 		WriteTone(*tPtr[1],PlayFormatBuf());

   510 		TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize);

   511 

   512 		TInt remainingPlayCount = BytesPerSecond(PlayFormatBuf())*aNumSeconds/bufSize;

   513 		TInt bytesToPlay = remainingPlayCount*bufSize;

   514 		TInt bytesPlayed = 0;

   515 		TInt i;

   516 		TUint flags;

   517 		while(remainingPlayCount>2)

   518 			{

   519 			// Wait for either of the outstanding play requests to complete.

   520 			User::WaitForAnyRequest();

   521 			remainingPlayCount--;

   522 

   523 			// Work out which request this applies to.

   524 			for (i=0;i<2;i++)

   525 				{

   526 				if (stat[i]!=KRequestPending)

   527 					break;

   528 				}

   529 			CHECK(i<2);

   530 			CHECK_NOERROR(stat[i].Int());

   531 

   532 			WriteTone(*tPtr[i],PlayFormatBuf());

   533 			flags=(remainingPlayCount<=2)?KSndFlagLastSample:0;

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

   535 			}

   536 

   537 		// Last 2 play requests still outstanding.

   538 		User::WaitForRequest(stat[0]);

   539 		CHECK_NOERROR(stat[0].Int());

   540 		User::WaitForRequest(stat[1]);

   541 		CHECK_NOERROR(stat[1].Int());

   542 

   543 		Test.Printf(_L("Sample rate successful\r\n"));

   544 		bytesPlayed = TxSoundDevice.BytesTransferred();

   545 		CHECK_EQUAL(bytesToPlay,bytesPlayed);

   546 		chunk.Close();

   547 		}

   548 

   549 	for (i=0;i<2;i++)

   550 		delete tPtr[i];

   551 	}

   552 

   553 /**	@SYMTestCaseID 			PBASE-T_SOUND2-254

   554 	@SYMTestCaseDesc 		Record operation - recording all rates.

   555 	@SYMTestPriority 		Critical

   556 	@SYMTestActions			1)	For each of the sample rates supported by the device, setup the audio configuration on

   557 								the record channel for mono operation (i.e. 1 audio channel) and then setup the buffer

   558 								configuration so it contains multiple buffers. Using multiple simultaneous record

   559 								requests, record 4 seconds of audio data - with each individual record request being

   560 								for 1/8th second of data.

   561 							2)	Repeat the above with the driver configured for stereo operation (i.e. 2 audio channels).

   562 	@SYMTestExpectedResults	1)	For each of the sample rates supported by the device, the driver should successfully

   563 							record 4 seconds of data, with all requests completing with KErrNone.

   564 							2)	For each of the sample rates supported by the device, the driver should successfully

   565 							record 4 seconds of data, with all requests completing with KErrNone

   566 	@SYMREQ					PREQ1073.4

   567 */

   568 LOCAL_C void TestRecordAllRates(TInt aNumChannels,TInt aNumSeconds)

   569 	{

   570 

   571 	TRequestStatus stat[2];

   572 	TInt length[2];

   573 

   574 	Test.Next(_L("Record all rate test"));

   575 	Test.Printf(_L("Number of channels %d, duration %d seconds\n"), aNumChannels, aNumSeconds);

   576 

   577 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   578 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   579 

   580 	RChunk chunk;

   581 	TInt speed = 0;

   582 	while (speedTable[speed]>=0)

   583 		{

   584 		RecordFormatBuf().iRate = speedTable[speed++];

   585 		RecordFormatBuf().iChannels = aNumChannels;

   586 

   587 		// Set the record format.

   588 		Test.Printf(_L("Testing record rate %d...\r\n"),RateInSamplesPerSecond(RecordFormatBuf().iRate));

   589 		TInt r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

   590 		if (r==KErrNotSupported)

   591 			{

   592 			Test.Printf(_L("Sample rate not supported\r\n"));

   593 			continue;

   594 			}

   595 		CHECK_NOERROR(r);

   596 

   597 		// Set the record buffer configuration, then read it back.

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

   599 		bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

   600 		TTestSharedChunkBufConfig bufferConfig;

   601 		bufferConfig.iNumBuffers=4;

   602 		bufferConfig.iBufferSizeInBytes=bufSize;

   603 		bufferConfig.iFlags=0;																// All buffers will be contiguous

   604 		TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

   605 		r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

   606 		CHECK_NOERROR(r);

   607 		RxSoundDevice.GetBufferConfig(bufferConfigBuf);

   608 		PrintBufferConf(bufferConfig,Test);

   609 		CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

   610 

   611 		TInt remainingRecordCount = BytesPerSecond(RecordFormatBuf())*aNumSeconds/bufSize;

   612 		TInt bytesToRecord = remainingRecordCount*bufSize;

   613 		TInt bytesRecorded = 0;

   614 

   615 		// The driver rounds up the buffer size to the nearest page meaning the total duration

   616 		// to complete this test won't be exactly equal to 'aNumSeconds' anymore. Hence, the

   617 		// predicted time is no longer simply: aNumSeconds * 1000000.

   618 		TInt64 predictedTime = (bufSize * remainingRecordCount);

   619 		predictedTime*=1000000;

   620 		predictedTime+=BytesPerSecond(RecordFormatBuf())>>1;

   621 		predictedTime/=BytesPerSecond(RecordFormatBuf());

   622 		TTime starttime;

   623 		starttime.HomeTime();

   624 

   625 		// Issue a pair of record requests.

   626 		TInt vol = I64LOW(TInt64(KSoundMaxVolume)*TInt64(bytesRecorded)/TInt64(bytesToRecord));

   627 		RxSoundDevice.SetVolume(vol);

   628 		RxSoundDevice.RecordData(stat[0],length[0]);

   629 		RxSoundDevice.RecordData(stat[1],length[1]);

   630 		TInt currentReq=0;

   631 

   632 		TInt retOffset;

   633 		do

   634 			{

   635 			// Wait for the next expected request to complete.

   636 			User::WaitForRequest(stat[currentReq]);

   637 			remainingRecordCount--;

   638 			retOffset=stat[currentReq].Int();

   639 			CHECK_POSITIVE(retOffset);

   640 

   641 			CHECK(length[currentReq]>0);

   642 			bytesRecorded += length[currentReq];

   643 

   644 			r=RxSoundDevice.ReleaseBuffer(retOffset);

   645 			CHECK_NOERROR(r);

   646 			CHECK_EQUAL(RxSoundDevice.Volume(),vol);

   647 			CHECK_EQUAL(RxSoundDevice.SetAudioFormat(RecordFormatBuf),KErrInUse);

   648 

   649 			vol = I64LOW(TInt64(KSoundMaxVolume)*TInt64(bytesRecorded)/TInt64(bytesToRecord));

   650 			RxSoundDevice.SetVolume(vol);

   651 

   652 			// Don't issue any further record requests on the last two loop passes - to allow for the

   653 			// two record requests made before the loop started.

   654 			if (remainingRecordCount>=2)

   655 				RxSoundDevice.RecordData(stat[currentReq],length[currentReq]);

   656 

   657 			currentReq^=0x01;	// Toggle the current req. indicator

   658 			}

   659 		while(remainingRecordCount>0);

   660 

   661 		TTime endtime;

   662 		endtime.HomeTime();

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

   664 		Test.Printf(_L("Recorded %d bytes in %d us\n"),bytesRecorded, I64LOW(elapsedTime));

   665 		if (elapsedTime < predictedTime)

   666 			{

   667 			Test.Printf(_L("**** FAIL: time travelling; record took less time than it could have done\n"));

   668 			// CHECK_NOERROR(1);

   669 			}

   670 		CHECK_EQUAL(bytesToRecord,bytesRecorded);

   671 		Test.Printf(_L("Sample rate successful\r\n"));

   672 

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

   674 		chunk.Close();

   675 		}

   676 	}

   677 

   678 /**	@SYMTestCaseID 			PBASE-T_SOUND2-253

   679 	@SYMTestCaseDesc 		Record operation - altering the record level.

   680 	@SYMTestPriority 		Critical

   681 	@SYMTestActions			Setup the audio configuration on the record channel and then setup the buffer configuration

   682 							so it contains multiple buffers. Using multiple simultaneous record requests, record 10

   683 							seconds of audio data - with each individual record request being for 1/8th second of data.

   684 							Each time a request completes, increase the record level slightly - starting at the minimum

   685 							and ending at maximum record level.

   686 	@SYMTestExpectedResults	The driver should successfully record 10 seconds of data - i.e. all requests should complete

   687 							with KErrNone.

   688 	@SYMREQ					PREQ1073.4

   689 */

   690 LOCAL_C void TestRecordVolume(TInt aNumChannels,TInt aNumSeconds)

   691 	{

   692 	TRequestStatus stat[2];

   693 	TInt length[2];

   694 	TInt r, i;

   695 

   696 	Test.Next(_L("Preparing to test variable record levels..."));

   697 

   698 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   699 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   700 

   701 	RecordFormatBuf().iChannels = aNumChannels;

   702 

   703 	// find first supported rate and set the the audio configuration to use it

   704 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

   705 		{

   706 		RecordFormatBuf().iRate = (TSoundRate)i;

   707 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

   708 		if (RecordCapsBuf().iRates & (1<<i))

   709 			{

   710 			CHECK_NOERROR(r);				// Caps reports it is supported

   711 			break;

   712 			}

   713 		}

   714 	PrintConfig(RecordFormatBuf(),Test);

   715 

   716 	// Set the record buffer configuration, then read it back.

   717 	RChunk chunk;

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

   719 	bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

   720 	TTestSharedChunkBufConfig bufferConfig;

   721 	bufferConfig.iNumBuffers=8;

   722 	bufferConfig.iBufferSizeInBytes=bufSize;

   723 	bufferConfig.iFlags=0;																// All buffers will be contiguous

   724 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

   725 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

   726 	CHECK_NOERROR(r);

   727 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

   728 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

   729 

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

   731 	TInt remainingRecordCount = BytesPerSecond(RecordFormatBuf())*aNumSeconds/bufSize;

   732 	TInt bytesToRecord = remainingRecordCount*bufSize;

   733 	TInt bytesRecorded = 0;

   734 

   735 	// Issue a pair of record requests.

   736 	RxSoundDevice.SetVolume(KSoundMaxVolume);

   737 	RxSoundDevice.RecordData(stat[0],length[0]);

   738 	RxSoundDevice.RecordData(stat[1],length[1]);

   739 	TInt currentReq=0;

   740 

   741 	TInt retOffset;

   742 	do

   743 		{

   744 		// Adjust the record level.

   745 		TInt vol = I64LOW(TInt64(KSoundMaxVolume)*TInt64(bytesRecorded)/TInt64(bytesToRecord));

   746 		r=RxSoundDevice.SetVolume(vol);

   747 		CHECK_NOERROR(r);

   748 

   749 		// Wait for the next expected request to complete.

   750 		User::WaitForRequest(stat[currentReq]);

   751 		remainingRecordCount--;

   752 		retOffset=stat[currentReq].Int();

   753 		CHECK_POSITIVE(retOffset);

   754 

   755 		// Check the length recorded and update bytes recorded.

   756 		CHECK(length[currentReq]>0);

   757 		bytesRecorded += length[currentReq];

   758 		Test.Printf(_L("."));

   759 

   760 		// Read back the record level / check we can't reconfig while recording.

   761 		CHECK_EQUAL(RxSoundDevice.Volume(),vol);

   762 		CHECK_EQUAL(RxSoundDevice.SetAudioFormat(RecordFormatBuf),KErrInUse);

   763 

   764 		// Now release the buffer and issue another record request.

   765 		r=RxSoundDevice.ReleaseBuffer(retOffset);

   766 		CHECK_NOERROR(r);

   767 		// Don't issue any further record requests on the last two loop passes - to allow for the

   768 		// two record requests made before the loop started.

   769 		if (remainingRecordCount>=2)

   770 			RxSoundDevice.RecordData(stat[currentReq],length[currentReq]);

   771 

   772 		currentReq^=0x01;	// Toggle the current req. indicator

   773 		}

   774 	while(remainingRecordCount>0);

   775 

   776 	CHECK_EQUAL(bytesToRecord,bytesRecorded);

   777 

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

   779 	Test.Printf(_L("\nBytes recorded = %d\r\n"),bytesRecorded);

   780 	chunk.Close();

   781 	}

   782 

   783 /**	@SYMTestCaseID 			PBASE-T_SOUND2-245

   784 	@SYMTestCaseDesc 		Play operation - play cancellation.

   785 	@SYMTestPriority 		Critical

   786 	@SYMTestActions			Setup the audio configuration on the playback channel and then setup the buffer configuration

   787 							so it contains two buffers.

   788 							1)	Issue two simultaneous play requests, one from each buffer, each of 1/2 second of tone.

   789 								Wait for the first one to complete and issue a further play request from the same buffer.

   790 								Then immediately cancel all outstanding play requests (using CancelPlayData()).

   791 							2)	Issue two simultaneous play requests, one from each buffer, each of 1/2 second of tone.

   792 								Wait for the first one to complete and issue a further play request from the same buffer.

   793 								Then immediately cancel the 2nd (i.e. now active) play request (using Cancel()).

   794 	@SYMTestExpectedResults	1)	Both outstanding requests should complete, either with KErrNone or with KErrCancel.

   795 							2)	The second request should complete, either with KErrNone or with KErrCancel whereas the

   796 								third should complete only with KErrNone.

   797 	@SYMREQ					PREQ1073.4

   798 */

   799 LOCAL_C void TestPlayCancel()

   800 	{

   801 	TRequestStatus stat[2];

   802 	TPtr8* tPtr[2];

   803 	TInt i, r;

   804 	for (i=0;i<2;i++)

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

   806 

   807 	Test.Next(_L("Test play cancellation"));

   808 

   809 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   810 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   811 	PlayFormatBuf().iChannels = 2;

   812 

   813 	// find first supported rate and set the the audio configuration to use it

   814 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

   815 		{

   816 		// check record channel

   817 		PlayFormatBuf().iRate = (TSoundRate)i;

   818 		r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

   819 		if (PlayCapsBuf().iRates & (1 << i))

   820 			{

   821 			CHECK_NOERROR(r);		// Caps reports it is supported

   822 			break;

   823 			}

   824 		}

   825 	PrintConfig(PlayFormatBuf(),Test);

   826 	r=MakeSineTable(PlayFormatBuf());

   827 	CHECK_NOERROR(r);

   828 

   829 	// Set the play buffer configuration, then read it back.

   830 	RChunk chunk;

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

   832 	bufSize=ValidBufferSize(bufSize,PlayCapsBuf().iRequestMinSize,PlayFormatBuf());		// Keep the buffer length valid for driver.

   833 	TTestSharedChunkBufConfig bufferConfig;

   834 	bufferConfig.iNumBuffers=2;

   835 	bufferConfig.iBufferSizeInBytes=bufSize;

   836 	bufferConfig.iFlags=0;																// All buffers will be contiguous

   837 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

   838 	r=TxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

   839 	CHECK_NOERROR(r);

   840 	TxSoundDevice.GetBufferConfig(bufferConfigBuf);

   841 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

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

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

   844 

   845 	Test.Next(_L("Test cancelling all outstanding requests"));

   846 	// Issue a pair of play requests.

   847 	r=SetToneFrequency(440,PlayFormatBuf());

   848 	CHECK_NOERROR(r);

   849 	WriteTone(*tPtr[0],PlayFormatBuf());

   850 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize);

   851 	WriteTone(*tPtr[1],PlayFormatBuf());

   852 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize);

   853 

   854 	// Wait for the 1st request to complete. Then, re-queue a further request but then

   855 	// immediately cancel both requests.

   856 	User::WaitForRequest(stat[0]);

   857 	CHECK_NOERROR(stat[0].Int());

   858 	WriteTone(*tPtr[0],PlayFormatBuf());

   859 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize);

   860 	TxSoundDevice.CancelPlayData();

   861 

   862 	User::WaitForRequest(stat[1]);

   863 	if (stat[1]==KErrNone)

   864 		Test.Printf(_L("Note: 2nd request finished without cancel error\r\n"));

   865 	else

   866 		CHECK_EQUAL(stat[1].Int(),KErrCancel);

   867 	User::WaitForRequest(stat[0]);

   868 	if (stat[0]==KErrNone)

   869 		Test.Printf(_L("Note: 3rd request finished without cancel error\r\n"));

   870 	else

   871 		CHECK_EQUAL(stat[0].Int(),KErrCancel);

   872 

   873 	Test.Next(_L("Test cancelling an individual requests"));

   874 	// Issue a further pair of play requests.

   875 	r=SetToneFrequency(440,PlayFormatBuf());

   876 	CHECK_NOERROR(r);

   877 	WriteTone(*tPtr[0],PlayFormatBuf());

   878 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize,0);

   879 	WriteTone(*tPtr[1],PlayFormatBuf());

   880 	TxSoundDevice.PlayData(stat[1],bufferConfig.iBufferOffsetList[1],bufSize,0);

   881 

   882 	// Again, wait for the 1st request to complete. Then, re-queue a further request but then

   883 	// immediately cancel the 2nd request.

   884 	User::WaitForRequest(stat[0]);

   885 	CHECK_NOERROR(stat[0].Int());

   886 	WriteTone(*tPtr[0],PlayFormatBuf());

   887 	TxSoundDevice.PlayData(stat[0],bufferConfig.iBufferOffsetList[0],bufSize,KSndFlagLastSample);

   888 	TxSoundDevice.Cancel(stat[1]);

   889 

   890 	User::WaitForRequest(stat[1]);

   891 	if (stat[1]==KErrNone)

   892 		Test.Printf(_L("Note: 2nd request finished without cancel error\r\n"));

   893 	else

   894 		CHECK_EQUAL(stat[1].Int(),KErrCancel);

   895 	User::WaitForRequest(stat[0]);

   896 	CHECK_NOERROR(stat[0].Int());

   897 

   898 	chunk.Close();

   899 	Test.Printf(_L("Cancel play test completed successful\r\n"));

   900 

   901 	for (i=0;i<2;i++)

   902 		delete tPtr[i];

   903 	}

   904 

   905 /**	@SYMTestCaseID 			PBASE-T_SOUND2-259

   906 	@SYMTestCaseDesc 		Record operation - record cancellation.

   907 	@SYMTestPriority 		Critical

   908 	@SYMTestActions			Setup the audio configuration on the record channel and then setup the buffer configuration

   909 							so it contains multiple buffers.

   910 							1)	Issue two simultaneous record requests requests, each for 1/2 second of data. Wait for

   911 								the first one to complete and issue a further record request. Then immediately cancel all

   912 								outstanding record requests (using CancelRecordData()).

   913 							2)	Issue two simultaneous record requests, each for 1/2 second of data. Wait for the first

   914 								one to complete and issue a further record request. Then immediately cancel the 2nd (i.e.

   915 								now active) record request (using Cancel()).

   916 	@SYMTestExpectedResults	1)	Both outstanding requests should complete, either with KErrNone or with KErrCancel.

   917 							2)	The second requests should complete, either with KErrNone or with KErrCancel whereas the

   918 								third should complete only with KErrNone.

   919 	@SYMREQ					PREQ1073.4

   920 */

   921 LOCAL_C void TestRecordCancel()

   922 	{

   923 	TRequestStatus stat[2];

   924 	TInt length[2];

   925 	TPtr8* tPtr[2];

   926 	TInt i, r;

   927 	for (i=0;i<2;i++)

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

   929 

   930 	Test.Next(_L("Test record cancellation"));

   931 

   932 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   933 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   934 	RecordFormatBuf().iChannels = 2;

   935 

   936 	// find first supported rate and set the the audio configuration to use it

   937 	for (i=0 ; i <= (TInt)ESoundRate48000Hz ; i++)

   938 		{

   939 		RecordFormatBuf().iRate = (TSoundRate)i;

   940 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

   941 		if (RecordCapsBuf().iRates & (1<<i))

   942 			{

   943 			CHECK_NOERROR(r);				// Caps reports it is supported

   944 			break;

   945 			}

   946 		}

   947 

   948 	PrintConfig(RecordFormatBuf(),Test);

   949 

   950 	// Set the record buffer configuration, then read it back.

   951 	RChunk chunk;

   952 	TTestSharedChunkBufConfig bufferConfig;

   953 	bufferConfig.iNumBuffers=3;

   954 	bufferConfig.iBufferSizeInBytes=BytesPerSecond(RecordFormatBuf())/2; // Large enough to hold 1/2 second of data.

   955 	bufferConfig.iBufferSizeInBytes=ValidBufferSize(bufferConfig.iBufferSizeInBytes,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());		// Keep the buffer length valid for driver.

   956 	bufferConfig.iFlags=0;		// All buffers will be contiguous

   957 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

   958 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

   959 	CHECK_NOERROR(r);

   960 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

   961 

   962 	Test.Next(_L("Test cancelling all outstanding requests"));

   963 	// Issue a pair of record requests.

   964 	RxSoundDevice.RecordData(stat[0],length[0]);

   965 	RxSoundDevice.RecordData(stat[1],length[1]);

   966 

   967 	// Wait for the 1st request to complete. Then, re-queue a further request but then

   968 	// immediately cancel both requests.

   969 	TInt retOffset;

   970 	User::WaitForRequest(stat[0]);

   971 	retOffset=stat[0].Int();

   972 	CHECK_POSITIVE(retOffset);

   973 	CHECK(length[0]>0);

   974 	r=RxSoundDevice.ReleaseBuffer(retOffset);

   975 	CHECK_NOERROR(r);

   976 	RxSoundDevice.RecordData(stat[0],length[0]);

   977 	RxSoundDevice.CancelRecordData();

   978 

   979 	User::WaitForRequest(stat[1]);

   980 	retOffset=stat[1].Int();

   981 	if (retOffset>=0)

   982 		Test.Printf(_L("Note: 2nd request finished without cancel error\r\n"));

   983 	else

   984 		CHECK_EQUAL(retOffset,KErrCancel);

   985 	User::WaitForRequest(stat[0]);

   986 	retOffset=stat[0].Int();

   987 	if (retOffset>=0)

   988 		Test.Printf(_L("Note: 3rd request finished without cancel error\r\n"));

   989 	else

   990 		CHECK_EQUAL(retOffset,KErrCancel);

   991 

   992 	Test.Next(_L("Test cancelling an individual requests"));

   993 	// Issue a further pair of record requests.

   994 	RxSoundDevice.RecordData(stat[0],length[0]);

   995 	RxSoundDevice.RecordData(stat[1],length[1]);

   996 

   997 	// Again, wait for the 1st request to complete. Then, re-queue a further request but then

   998 	// immediately cancel the 2nd request.

   999 	User::WaitForRequest(stat[0]);

  1000 	retOffset=stat[0].Int();

  1001 	CHECK_POSITIVE(retOffset);

  1002 	CHECK(length[0]>0);

  1003 	r=RxSoundDevice.ReleaseBuffer(retOffset);

  1004 	CHECK_NOERROR(r);

  1005 	RxSoundDevice.RecordData(stat[0],length[0]);

  1006 	RxSoundDevice.Cancel(stat[1]);

  1007 

  1008 	User::WaitForRequest(stat[1]);

  1009 	retOffset=stat[1].Int();

  1010 	if (retOffset>=0)

  1011 		Test.Printf(_L("Note: 2nd request finished without cancel error\r\n"));

  1012 	else

  1013 		CHECK_EQUAL(retOffset,KErrCancel);

  1014 	User::WaitForRequest(stat[0]);

  1015 	retOffset=stat[0].Int();

  1016 	CHECK_POSITIVE(retOffset);

  1017 	CHECK(length[0]>0);

  1018 

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

  1020 	chunk.Close();

  1021 	Test.Printf(_L("Cancel record test completed successful\r\n"));

  1022 

  1023 	for (i=0;i<2;i++)

  1024 		delete tPtr[i];

  1025 	}

  1026 

  1027 /**	@SYMTestCaseID 			PBASE-T_SOUND2-262

  1028 	@SYMTestCaseDesc 		Play pause / resume - pausing and resuming before playback has commenced.

  1029 	@SYMTestPriority 		Critical

  1030 	@SYMTestActions			Setup the audio configuration on the record channel and then setup the buffer configuration.

  1031 							1)	Attempt to resume recording before recording has been started.

  1032 							2)	Attempt to pause recording before recording has been started.

  1033 	@SYMTestExpectedResults	1)	The resume request should complete with KErrNotReady.

  1034 							2)	The pause request should complete with KErrNotReady.

  1035 	@SYMREQ					PREQ1073.4

  1036 */

  1037 

  1038 /**	@SYMTestCaseID 			PBASE-T_SOUND2-263

  1039 	@SYMTestCaseDesc 		Record pause / resume - pausing and resuming while recording is in progress.

  1040 	@SYMTestPriority 		Critical

  1041 	@SYMTestActions			Setup the audio configuration on the record channel and then setup the buffer configuration

  1042 							so it contains multiple buffers. For the audio configuration selected, calculate the total

  1043 							number of bytes expected to be transferred in order record 4 seconds of data. Using multiple

  1044 							simultaneous record requests, record 4 seconds of audio data - with each individual record

  1045 							request being for 1/8th second of data. Increment a count of actual total bytes transferred

  1046 							by examining the count of bytes stored in the buffer for each request as it completes.

  1047 							1) After 10 requests have completed, pause transfer for 1 second, then resume it. If pausing

  1048 							causes a record request to complete with a shorter than requested length then reduce the

  1049 							count of expected total bytes transferred.

  1050 							2) Repeat step 1 when 20 requests have completed.

  1051 							3) Once transfer has completed, compare the counts of expected and actual total bytes

  1052 							transferred.

  1053 	@SYMTestExpectedResults	1)	The pause and resume requests should both complete with KErrNone.

  1054 							2)	The pause and resume requests should both complete with KErrNone.

  1055 							3)	The counts should be equal.

  1056 	@SYMREQ					PREQ1073.4

  1057 */

  1058 LOCAL_C void TestRecordPauseResume()

  1059 	{

  1060 	TRequestStatus stat[2];

  1061 	TInt length[2];

  1062 

  1063 	Test.Next(_L("Test record pause and resume"));

  1064 	RecordFormatBuf().iRate = ESoundRate44100Hz;

  1065 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

  1066 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

  1067 	PlayFormatBuf().iChannels = 2;

  1068 	PrintConfig(RecordFormatBuf(),Test);

  1069 	TInt r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

  1070 	CHECK_NOERROR(r);

  1071 

  1072 	// Set the record buffer configuration, then read it back.

  1073 	RChunk chunk;

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

  1075 	bufSize=ValidBufferSize(bufSize,RecordCapsBuf().iRequestMinSize,RecordFormatBuf());	// Keep the buffer length valid for driver.

  1076 	TTestSharedChunkBufConfig bufferConfig;

  1077 	bufferConfig.iNumBuffers=8;

  1078 	bufferConfig.iBufferSizeInBytes=bufSize;

  1079 	bufferConfig.iFlags=0;																// All buffers will be contiguous

  1080 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

  1081 	r=RxSoundDevice.SetBufferChunkCreate(bufferConfigBuf,chunk);

  1082 	CHECK_NOERROR(r);

  1083 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

  1084 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

  1085 

  1086 	Test.Printf(_L("Resume when not recording\r\n"));

  1087 	r=RxSoundDevice.Resume();

  1088 	CHECK(r==KErrNotReady)

  1089 

  1090 	Test.Printf(_L("Pause when not recording\r\n"));

  1091 	r=RxSoundDevice.Pause();

  1092 	CHECK(r==KErrNotReady)

  1093 

  1094 	// Record for 4 seconds

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

  1096 	TInt remainingRecordCount = BytesPerSecond(RecordFormatBuf())*4/bufSize;

  1097 	TInt bytesToRecord = remainingRecordCount*bufSize;

  1098 	TInt bytesRecorded = 0;

  1099 

  1100 	// Issue a pair of record requests.

  1101 	RxSoundDevice.SetVolume(KSoundMaxVolume);

  1102 	length[0] = -42;

  1103 	RxSoundDevice.RecordData(stat[0],length[0]);

  1104 	length[1] = -42;

  1105 	RxSoundDevice.RecordData(stat[1],length[1]);

  1106 	TInt currentReq=0;

  1107 

  1108 	TInt lcount = 0;

  1109 	TInt retOffset;

  1110 	do

  1111 		{

  1112 		// Do a pause / resume on 10th and 20th loop passes.

  1113 		if (lcount && !(lcount%10))

  1114 			{

  1115 			// Do a pause/resume

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

  1117 			r=RxSoundDevice.Pause();

  1118 			CHECK_NOERROR(r);

  1119 

  1120 			// Pausing record may result in the driver completing with a buffer not completely full. This isn't an error. Otherwise, all outstanding

  1121 			// requests should complete with KErrCancel. Wait for the 1st outstanding request to complete.

  1122 			User::WaitForRequest(stat[currentReq]);

  1123 			retOffset=stat[currentReq].Int();

  1124 			if (retOffset>=0)

  1125 				{

  1126 				// Partially filled buffer. We need to adjust the bytes expected when an incomplete buffer arrives.

  1127 				remainingRecordCount--;

  1128 

  1129 				CHECK_POSITIVE(length[currentReq]);

  1130 				bytesRecorded += length[currentReq];

  1131 				if (length[currentReq]<bufSize)

  1132 					bytesToRecord-=(bufSize-length[currentReq]);

  1133 				Test.Printf(_L("1st outstanding req partially completed(len=%d)\r\n"),length[currentReq]);

  1134