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 	// Make sure we can issue a successful RecordData after recovering from overflow.

   429 	RxSoundDevice.RecordData(stat,length);

   430 	User::WaitForRequest(stat);

   431 	retOffset=stat.Int();

   432 	CHECK_POSITIVE(retOffset);

   433     r=RxSoundDevice.ReleaseBuffer(retOffset);

   434     CHECK_NOERROR(r);

   435 

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

   437 	chunk.Close();

   438 	}

   439 

   440 /**	@SYMTestCaseID 			PBASE-T_SOUND2-241

   441 	@SYMTestCaseDesc 		Play operation - playing all rates.

   442 	@SYMTestPriority 		Critical

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

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

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

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

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

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

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

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

   451 								completing with KErrNone.

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

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

   454 								completing with KErrNone.

   455 	@SYMREQ					PREQ1073.4

   456 */

   457 LOCAL_C void TestPlayAllRates(TInt aNumChannels,TInt aNumSeconds)

   458 	{

   459 	TRequestStatus stat[2];

   460 	TPtr8* tPtr[2];

   461 	TInt i;

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

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

   464 

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

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

   467 

   468 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   469 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   470 	PlayFormatBuf().iChannels = aNumChannels;

   471 	TInt r=MakeSineTable(PlayFormatBuf());

   472 	CHECK_NOERROR(r);

   473 

   474 	TxSoundDevice.SetVolume(KSoundMaxVolume);

   475 

   476 	RChunk chunk;

   477 	TInt speed = 0;

   478 	while (speedTable[speed]>=0)

   479 		{

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

   481 		PlayFormatBuf().iChannels = aNumChannels;

   482 

   483 		// Set the play format.

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

   485 		r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

   486 		if (r==KErrNotSupported)

   487 			{

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

   489 			continue;

   490 			}

   491 		CHECK_NOERROR(r);

   492 

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

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

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

   496 		TTestSharedChunkBufConfig bufferConfig;

   497 		bufferConfig.iNumBuffers=2;

   498 		bufferConfig.iBufferSizeInBytes=bufSize;

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

   500 		TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

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

   502 		CHECK_NOERROR(r);

   503 		TxSoundDevice.GetBufferConfig(bufferConfigBuf);

   504 		PrintBufferConf(bufferConfig,Test);

   505 		CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

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

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

   508 

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

   510 		CHECK_NOERROR(r);

   511 		TxSoundDevice.ResetBytesTransferred();

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

   513 

   514 		// Issue a pair of play requests.

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

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

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

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

   519 

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

   521 		TInt bytesToPlay = remainingPlayCount*bufSize;

   522 		TInt bytesPlayed = 0;

   523 		TInt i;

   524 		TUint flags;

   525 		while(remainingPlayCount>2)

   526 			{

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

   528 			User::WaitForAnyRequest();

   529 			remainingPlayCount--;

   530 

   531 			// Work out which request this applies to.

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

   533 				{

   534 				if (stat[i]!=KRequestPending)

   535 					break;

   536 				}

   537 			CHECK(i<2);

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

   539 

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

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

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

   543 			}

   544 

   545 		// Last 2 play requests still outstanding.

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

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

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

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

   550 

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

   552 		bytesPlayed = TxSoundDevice.BytesTransferred();

   553 		CHECK_EQUAL(bytesToPlay,bytesPlayed);

   554 		chunk.Close();

   555 		}

   556 

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

   558 		delete tPtr[i];

   559 	}

   560 

   561 /**	@SYMTestCaseID 			PBASE-T_SOUND2-254

   562 	@SYMTestCaseDesc 		Record operation - recording all rates.

   563 	@SYMTestPriority 		Critical

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

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

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

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

   568 								for 1/8th second of data.

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

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

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

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

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

   574 	@SYMREQ					PREQ1073.4

   575 */

   576 LOCAL_C void TestRecordAllRates(TInt aNumChannels,TInt aNumSeconds)

   577 	{

   578 

   579 	TRequestStatus stat[2];

   580 	TInt length[2];

   581 

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

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

   584 

   585 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   586 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   587 

   588 	RChunk chunk;

   589 	TInt speed = 0;

   590 	while (speedTable[speed]>=0)

   591 		{

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

   593 		RecordFormatBuf().iChannels = aNumChannels;

   594 

   595 		// Set the record format.

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

   597 		TInt r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

   598 		if (r==KErrNotSupported)

   599 			{

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

   601 			continue;

   602 			}

   603 		CHECK_NOERROR(r);

   604 

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

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

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

   608 		TTestSharedChunkBufConfig bufferConfig;

   609 		bufferConfig.iNumBuffers=4;

   610 		bufferConfig.iBufferSizeInBytes=bufSize;

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

   612 		TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

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

   614 		CHECK_NOERROR(r);

   615 		RxSoundDevice.GetBufferConfig(bufferConfigBuf);

   616 		PrintBufferConf(bufferConfig,Test);

   617 		CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

   618 

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

   620 		TInt bytesToRecord = remainingRecordCount*bufSize;

   621 		TInt bytesRecorded = 0;

   622 

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

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

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

   626 		TInt64 predictedTime = (bufSize * remainingRecordCount);

   627 		predictedTime*=1000000;

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

   629 		predictedTime/=BytesPerSecond(RecordFormatBuf());

   630 		TTime starttime;

   631 		starttime.HomeTime();

   632 

   633 		// Issue a pair of record requests.

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

   635 		RxSoundDevice.SetVolume(vol);

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

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

   638 		TInt currentReq=0;

   639 

   640 		TInt retOffset;

   641 		do

   642 			{

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

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

   645 			remainingRecordCount--;

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

   647 			CHECK_POSITIVE(retOffset);

   648 

   649 			CHECK(length[currentReq]>0);

   650 			bytesRecorded += length[currentReq];

   651 

   652 			r=RxSoundDevice.ReleaseBuffer(retOffset);

   653 			CHECK_NOERROR(r);

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

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

   656 

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

   658 			RxSoundDevice.SetVolume(vol);

   659 

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

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

   662 			if (remainingRecordCount>=2)

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

   664 

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

   666 			}

   667 		while(remainingRecordCount>0);

   668 

   669 		TTime endtime;

   670 		endtime.HomeTime();

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

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

   673 		if (elapsedTime < predictedTime)

   674 			{

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

   676 			// CHECK_NOERROR(1);

   677 			}

   678 		CHECK_EQUAL(bytesToRecord,bytesRecorded);

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

   680 

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

   682 		chunk.Close();

   683 		}

   684 	}

   685 

   686 /**	@SYMTestCaseID 			PBASE-T_SOUND2-253

   687 	@SYMTestCaseDesc 		Record operation - altering the record level.

   688 	@SYMTestPriority 		Critical

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

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

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

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

   693 							and ending at maximum record level.

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

   695 							with KErrNone.

   696 	@SYMREQ					PREQ1073.4

   697 */

   698 LOCAL_C void TestRecordVolume(TInt aNumChannels,TInt aNumSeconds)

   699 	{

   700 	TRequestStatus stat[2];

   701 	TInt length[2];

   702 	TInt r, i;

   703 

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

   705 

   706 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   707 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   708 

   709 	RecordFormatBuf().iChannels = aNumChannels;

   710 

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

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

   713 		{

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

   715 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

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

   717 			{

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

   719 			break;

   720 			}

   721 		}

   722 	PrintConfig(RecordFormatBuf(),Test);

   723 

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

   725 	RChunk chunk;

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

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

   728 	TTestSharedChunkBufConfig bufferConfig;

   729 	bufferConfig.iNumBuffers=8;

   730 	bufferConfig.iBufferSizeInBytes=bufSize;

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

   732 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

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

   734 	CHECK_NOERROR(r);

   735 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

   736 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

   737 

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

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

   740 	TInt bytesToRecord = remainingRecordCount*bufSize;

   741 	TInt bytesRecorded = 0;

   742 

   743 	// Issue a pair of record requests.

   744 	RxSoundDevice.SetVolume(KSoundMaxVolume);

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

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

   747 	TInt currentReq=0;

   748 

   749 	TInt retOffset;

   750 	do

   751 		{

   752 		// Adjust the record level.

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

   754 		r=RxSoundDevice.SetVolume(vol);

   755 		CHECK_NOERROR(r);

   756 

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

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

   759 		remainingRecordCount--;

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

   761 		CHECK_POSITIVE(retOffset);

   762 

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

   764 		CHECK(length[currentReq]>0);

   765 		bytesRecorded += length[currentReq];

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

   767 

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

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

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

   771 

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

   773 		r=RxSoundDevice.ReleaseBuffer(retOffset);

   774 		CHECK_NOERROR(r);

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

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

   777 		if (remainingRecordCount>=2)

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

   779 

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

   781 		}

   782 	while(remainingRecordCount>0);

   783 

   784 	CHECK_EQUAL(bytesToRecord,bytesRecorded);

   785 

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

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

   788 	chunk.Close();

   789 	}

   790 

   791 /**	@SYMTestCaseID 			PBASE-T_SOUND2-245

   792 	@SYMTestCaseDesc 		Play operation - play cancellation.

   793 	@SYMTestPriority 		Critical

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

   795 							so it contains two buffers.

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

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

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

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

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

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

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

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

   804 								third should complete only with KErrNone.

   805 	@SYMREQ					PREQ1073.4

   806 */

   807 LOCAL_C void TestPlayCancel()

   808 	{

   809 	TRequestStatus stat[2];

   810 	TPtr8* tPtr[2];

   811 	TInt i, r;

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

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

   814 

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

   816 

   817 	if (PlayCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   818 		PlayFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   819 	PlayFormatBuf().iChannels = 2;

   820 

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

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

   823 		{

   824 		// check record channel

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

   826 		r = TxSoundDevice.SetAudioFormat(PlayFormatBuf);

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

   828 			{

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

   830 			break;

   831 			}

   832 		}

   833 	PrintConfig(PlayFormatBuf(),Test);

   834 	r=MakeSineTable(PlayFormatBuf());

   835 	CHECK_NOERROR(r);

   836 

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

   838 	RChunk chunk;

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

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

   841 	TTestSharedChunkBufConfig bufferConfig;

   842 	bufferConfig.iNumBuffers=2;

   843 	bufferConfig.iBufferSizeInBytes=bufSize;

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

   845 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

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

   847 	CHECK_NOERROR(r);

   848 	TxSoundDevice.GetBufferConfig(bufferConfigBuf);

   849 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

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

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

   852 

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

   854 	// Issue a pair of play requests.

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

   856 	CHECK_NOERROR(r);

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

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

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

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

   861 

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

   863 	// immediately cancel both requests.

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

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

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

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

   868 	TxSoundDevice.CancelPlayData();

   869 

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

   871 	if (stat[1]==KErrNone)

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

   873 	else

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

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

   876 	if (stat[0]==KErrNone)

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

   878 	else

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

   880 

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

   882 	// Issue a further pair of play requests.

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

   884 	CHECK_NOERROR(r);

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

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

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

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

   889 

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

   891 	// immediately cancel the 2nd request.

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

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

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

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

   896 	TxSoundDevice.Cancel(stat[1]);

   897 

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

   899 	if (stat[1]==KErrNone)

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

   901 	else

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

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

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

   905 

   906 	chunk.Close();

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

   908 

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

   910 		delete tPtr[i];

   911 	}

   912 

   913 /**	@SYMTestCaseID 			PBASE-T_SOUND2-259

   914 	@SYMTestCaseDesc 		Record operation - record cancellation.

   915 	@SYMTestPriority 		Critical

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

   917 							so it contains multiple buffers.

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

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

   920 								outstanding record requests (using CancelRecordData()).

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

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

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

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

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

   926 								third should complete only with KErrNone.

   927 	@SYMREQ					PREQ1073.4

   928 */

   929 LOCAL_C void TestRecordCancel()

   930 	{

   931 	TRequestStatus stat[2];

   932 	TInt length[2];

   933 	TPtr8* tPtr[2];

   934 	TInt i, r;

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

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

   937 

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

   939 

   940 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

   941 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

   942 	RecordFormatBuf().iChannels = 2;

   943 

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

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

   946 		{

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

   948 		r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

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

   950 			{

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

   952 			break;

   953 			}

   954 		}

   955 

   956 	PrintConfig(RecordFormatBuf(),Test);

   957 

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

   959 	RChunk chunk;

   960 	TTestSharedChunkBufConfig bufferConfig;

   961 	bufferConfig.iNumBuffers=3;

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

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

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

   965 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

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

   967 	CHECK_NOERROR(r);

   968 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

   969 

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

   971 	// Issue a pair of record requests.

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

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

   974 

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

   976 	// immediately cancel both requests.

   977 	TInt retOffset;

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

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

   980 	CHECK_POSITIVE(retOffset);

   981 	CHECK(length[0]>0);

   982 	r=RxSoundDevice.ReleaseBuffer(retOffset);

   983 	CHECK_NOERROR(r);

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

   985 	RxSoundDevice.CancelRecordData();

   986 

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

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

   989 	if (retOffset>=0)

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

   991 	else

   992 		CHECK_EQUAL(retOffset,KErrCancel);

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

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

   995 	if (retOffset>=0)

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

   997 	else

   998 		CHECK_EQUAL(retOffset,KErrCancel);

   999 

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

  1001 	// Issue a further pair of record requests.

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

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

  1004 

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

  1006 	// immediately cancel the 2nd request.

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

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

  1009 	CHECK_POSITIVE(retOffset);

  1010 	CHECK(length[0]>0);

  1011 	r=RxSoundDevice.ReleaseBuffer(retOffset);

  1012 	CHECK_NOERROR(r);

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

  1014 	RxSoundDevice.Cancel(stat[1]);

  1015 

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

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

  1018 	if (retOffset>=0)

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

  1020 	else

  1021 		CHECK_EQUAL(retOffset,KErrCancel);

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

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

  1024 	CHECK_POSITIVE(retOffset);

  1025 	CHECK(length[0]>0);

  1026 

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

  1028 	chunk.Close();

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

  1030 

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

  1032 		delete tPtr[i];

  1033 	}

  1034 

  1035 /**	@SYMTestCaseID 			PBASE-T_SOUND2-262

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

  1037 	@SYMTestPriority 		Critical

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

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

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

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

  1042 							2)	The pause request should complete with KErrNotReady.

  1043 	@SYMREQ					PREQ1073.4

  1044 */

  1045 

  1046 /**	@SYMTestCaseID 			PBASE-T_SOUND2-263

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

  1048 	@SYMTestPriority 		Critical

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

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

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

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

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

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

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

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

  1057 							count of expected total bytes transferred.

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

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

  1060 							transferred.

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

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

  1063 							3)	The counts should be equal.

  1064 	@SYMREQ					PREQ1073.4

  1065 */

  1066 LOCAL_C void TestRecordPauseResume(TUint aChannels)

  1067 	{

  1068 	TRequestStatus stat[2];

  1069 	TInt length[2];

  1070 

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

  1072 	RecordFormatBuf().iRate = ESoundRate44100Hz;

  1073 	if (RecordCapsBuf().iEncodings&KSoundEncoding16BitPCM)

  1074 		RecordFormatBuf().iEncoding = ESoundEncoding16BitPCM;

  1075 	RecordFormatBuf().iChannels = aChannels;

  1076 	PrintConfig(RecordFormatBuf(),Test);

  1077 	TInt r = RxSoundDevice.SetAudioFormat(RecordFormatBuf);

  1078 	CHECK_NOERROR(r);

  1079 

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

  1081 	RChunk chunk;

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

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

  1084 	TTestSharedChunkBufConfig bufferConfig;

  1085 	bufferConfig.iNumBuffers=8;

  1086 	bufferConfig.iBufferSizeInBytes=bufSize;

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

  1088 	TPckg<TTestSharedChunkBufConfig> bufferConfigBuf(bufferConfig);

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

  1090 	CHECK_NOERROR(r);

  1091 	RxSoundDevice.GetBufferConfig(bufferConfigBuf);

  1092 	CHECK(bufferConfig.iBufferSizeInBytes==bufSize);

  1093 

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

  1095 	r=RxSoundDevice.Resume();

  1096 	CHECK(r==KErrNotReady)

  1097 

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

  1099 	r=RxSoundDevice.Pause();

  1100 	CHECK(r==KErrNotReady)

  1101 

  1102 	// Record for 4 seconds

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

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

  1105 	TInt bytesToRecord = remainingRecordCount*bufSize;

  1106 	TInt bytesRecorded = 0;

  1107 

  1108 	// Issue a pair of record requests.

  1109 	RxSoundDevice.SetVolume(KSoundMaxVolume);

  1110 	length[0] = -42;

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

  1112 	length[1] = -42;

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

  1114 	TInt currentReq=0;

  1115 

  1116 	TInt lcount = 0;

  1117 	TInt retOffset;

  1118 	do

  1119 		{

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

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

  1122 			{

  1123 			// Do a pause/resume

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

  1125 			r=RxSoundDevice.Pause();

  1126 			CHECK_NOERROR(r);

  1127 

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

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

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

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

  1132 			if (retOffset>=0)

  1133 				{

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

  1135 				remainingRecordCount--;