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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include "mdasoundadapterconsts.h"

 #include "mdasoundadapterbody.h"

 #include <e32debug.h>

 #include "mmf/utils/rateconvert.h" // if we need to resample

 #include <hal.h>

 _LIT(KPddFileName,"SOUNDSC.PDD");

 _LIT(KLddFileName,"ESOUNDSC.LDD");

 const TInt KBytesPerSample = 2;

 const TInt KMinBufferSize = 2;

 /**

 This function raises a panic

 EDeviceNotOpened is raised when any of the RMdaDevSound APIs are called before opening the device. 

 */

 GLDEF_C void Panic(TSoundAdapterPanicCodes aPanicCode)

 	{

 	User::Panic(KSoundAdapterPanicCategory, aPanicCode);

 	}

 const TText8 *RMdaDevSound::CBody::TState::Name() const

 	{

 	#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	 

 	switch(iState)

 		{

 		case ENotReady:				return _S8("ENotReady");

 		case EStopped:				return _S8("EStopped");

 		case ERecording:			return _S8("ERecording");

 		case ERecordingPausedInHw:	return _S8("ERecordingPausedInHw");

 		case ERecordingPausedInSw:	return _S8("ERecordingPausedInSw");

 		case EPlaying:				return _S8("EPlaying");

 		case EPlayingPausedInHw: 	return _S8("EPlayingPausedInHw");

 		case EPlayingPausedInSw:	return _S8("EPlayingPausedInSw");

 		case EPlayingUnderrun:		return _S8("EPlayingUnderrun");

 		}

 	return _S8("CorruptState");

 	#else

 	return _S8("");

 	#endif

 	}

 RMdaDevSound::CBody::TState &RMdaDevSound::CBody::TState::operator=(TStateEnum aNewState)

 	{

     if(iState != aNewState)

         {

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

         RDebug::Printf("RMdaDevSound state %s -> %s", Name(), TState(aNewState).Name());

         #endif

         iState = aNewState;

         }

 	return *this;

 	}

 RMdaDevSound::CBody* RMdaDevSound::CBody::NewL()

 	{

 	CBody* self = new(ELeave) CBody();

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 RMdaDevSound::CBody::~CBody()

 	{

 	for(TInt i = 0; i < KPlaySharedChunkBuffers; i++)

 		{

 		delete iPlayers[i];

 		iPlayers[i] = NULL;

 		}

 	delete iRecorder;

 	iRecorder = NULL;

 	delete iPlayFormatData.iConverter;

 	delete iRecordFormatData.iConverter;

 	iPlayChunk.Close();

 	iPlaySoundDevice.Close();

 	iRecordChunk.Close();

 	iRecordSoundDevice.Close();

 	iConvertedPlayData.Close();

 	iSavedTrailingData.Close();

 	iBufferedRecordData.Close();

 	}

 RMdaDevSound::CBody::CBody()

 	:iState(ENotReady), iBufferOffset(-1)

 	{

 	}

 TVersion RMdaDevSound::CBody::VersionRequired() const

 	{

 	if(iPlaySoundDevice.Handle())

 		{

 		return iPlaySoundDevice.VersionRequired();

 		}

 	else

 		{

 		return TVersion();

 		}

 	}

 TInt RMdaDevSound::CBody::IsMdaSound()

 	{

 	return ETrue;

 	}

 void RMdaDevSound::CBody::ConstructL()

 	{

 	// Try to load the audio physical driver

     TInt err = User::LoadPhysicalDevice(KPddFileName);

 	if ((err!=KErrNone) && (err!=KErrAlreadyExists))

 		{

 		User::Leave(err);

 		}

     // Try to load the audio logical driver

 	err = User::LoadLogicalDevice(KLddFileName);

     if ((err!=KErrNone) && (err!=KErrAlreadyExists))

     	{

     	User::Leave(err);

     	}

 	for(TInt i=0; i<KPlaySharedChunkBuffers; i++)

 		{

 		iPlayers[i] = new(ELeave) CPlayer(CActive::EPriorityUserInput, *this, i);

 		iFreePlayers.Push(iPlayers[i]);

 		}

 	iRecorder = new(ELeave) CRecorder(CActive::EPriorityUserInput, *this);

 	TInt tmp;

 	User::LeaveIfError(HAL::Get(HAL::ENanoTickPeriod, tmp));

 	iNTickPeriodInUsec = tmp;

 	}

 TInt RMdaDevSound::CBody::Open(TInt /*aUnit*/)

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

         RDebug::Print(_L("RMdaDevSound::CBody::Open "));

     #endif	

 	TInt err = KErrNone;

 	//Default behavior of this method is to open both the play and record audio devices.

 	if(!iPlaySoundDevice.Handle() && !iRecordSoundDevice.Handle())

         {

 		err = iPlaySoundDevice.Open(KSoundScTxUnit0);

     	if(err == KErrNone)

     		{

     		err = iRecordSoundDevice.Open(KSoundScRxUnit0);

     		}

 		}

 	if(err != KErrNone)

 		{

 		Close();

 		}

 	else

 	    {

 		TSoundFormatsSupportedV02Buf capsBuf;

 		iPlaySoundDevice.Caps(capsBuf);

 		TInt minBufferSize = KMinBufferSize;

 		#ifdef SYMBIAN_FORCE_32BIT_LENGTHS

 		minBufferSize = Max(minBufferSize, 4); // force to 32-bit buffer align

 		#endif

 		iRequestMinSize = Max(capsBuf().iRequestMinSize, minBufferSize); 

 		// work out mask so that x&iRequestMinMask is equiv to x/iRequestMinSize*iRequestMinSize

 		iRequestMinMask = ~(iRequestMinSize-1); // assume iRequestMinSize is power of 2

 		iSavedTrailingData.Close();

 		iSavedTrailingData.Create(iRequestMinSize);

 	    iState = EStopped;

 		iBytesPlayed = 0;

 	    }

 	return err;

 	}

 TInt RMdaDevSound::CBody::PlayVolume()

 	{

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	return iPlaySoundDevice.Volume();	

 	}

 void RMdaDevSound::CBody::SetPlayVolume(TInt aVolume)

 	{

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	if(aVolume >=0 && aVolume<=KSoundMaxVolume)

 		{

 		iPlaySoundDevice.SetVolume(KLinerToDbConstantLookup[aVolume].iDBValue);

 		}

 	}

 void RMdaDevSound::CBody::SetVolume(TInt aLogarithmicVolume)

 	{

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	if(aLogarithmicVolume >= 0 && aLogarithmicVolume <= KSoundMaxVolume)

 		{

 		iPlaySoundDevice.SetVolume(aLogarithmicVolume);

 		}

 	}

 void RMdaDevSound::CBody::CancelPlayData()

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

     RDebug::Printf("RMdaDevSound::CBody::CancelPlayData: state %s", iState.Name());

     #endif	

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

     // If there is a client request, cancel it

     // Must do this before canceling players because otherwise they may just restart!

     if(iClientPlayStatus)

         {

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

         RDebug::Printf("msp PlayCancelled complete iClientPlayStatus");

 		#endif

         User::RequestComplete(iClientPlayStatus, KErrCancel); // Call also sets iClientPlayStatus to NULL

         }

     // Discard any buffered data

     iClientPlayData.Set(0,0);

 	// Discard any saved trailing data (ie. data saved due driver requiring all requests to be a multiple of iRequestMinSize).

 	iSavedTrailingData.SetLength(0);

     // Emulator RSoundSc PDD when running without a soundcard has a major

     // issue with cancelling whilst paused. It will not clear the pending

     // list (because the timer is not active) and therefore this list will

     // later overflow causing hep corruption.

     // This means that, for now, we MUST Resume before calling CancelPlayData

     // to avoid kernel panics...

     // The device driver will not cancel a request which is in progress...

     // So, if we are paused in hw, we must resume before cancelling the

     // player otherwise it will hang in CActive::Cancel

     if(iState == EPlayingPausedInHw)

         {

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

         RDebug::Printf("msp Resume to avoid hang");

         #endif

         (void) iPlaySoundDevice.Resume();

         }

     // Update state

 	iState = EStopped;

     // The RSoundSc driver will not cancel a request which is in progress (or paused).

     // If we just loop across the players, cancelling each individual request and waiting for it to complete,

     // several of them will actually play, which is both wrong and time consuming....

     // Issue a block cancel upfront to avoid this

     iPlaySoundDevice.CancelPlayData();

 	// Cancel all players

 	for (TUint playerIndex=0; playerIndex<KPlaySharedChunkBuffers; ++playerIndex)

 	    {

 	    // If the player is active it will call PlayRequestCompleted with aDueToCancelCommand true

 	    // to update the iFreePlayers and iActivePlayRequestSizes FIFOs.

         iPlayers[playerIndex]->Cancel();

 	    }

 	iBufferOffset = -1;

 	iBufferLength = 0;

 	return;

 	}

 TInt RMdaDevSound::CBody::RecordLevel()

 	{

 	__ASSERT_DEBUG(iRecordSoundDevice.Handle(), Panic(EDeviceNotOpened));

 	return iRecordSoundDevice.Volume();

 	}

 void RMdaDevSound::CBody::SetRecordLevel(TInt aLevel)

 	{

 	__ASSERT_DEBUG(iRecordSoundDevice.Handle(), Panic(EDeviceNotOpened));

 	iRecordSoundDevice.SetVolume(aLevel);	

 	}

 void RMdaDevSound::CBody::CancelRecordData()

 	{

 	__ASSERT_DEBUG(iRecordSoundDevice.Handle(), Panic(EDeviceNotOpened));

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

     RDebug::Printf("RMdaDevSound::CBody::CancelRecordData: state %s", iState.Name());

     #endif

     // Stop recorder object (and its request)

     iRecorder->Cancel();

     // Stop driver from recording

     iRecordSoundDevice.CancelRecordData();

     // If there is a client request, cancel it

     if(iClientRecordStatus)

    		{

         User::RequestComplete(iClientRecordStatus, KErrNone); // Call also sets iClientPlayStatus to NULL

         }

     iState = EStopped;

     return;

 	}

 void RMdaDevSound::CBody::FlushRecordBuffer()

 	{

 	__ASSERT_DEBUG(iRecordSoundDevice.Handle(), Panic(EDeviceNotOpened));

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

         RDebug::Print(_L("RMdaDevSound::CBody::FlushRecordBuffer - implemented by calling PauseRecordBuffer"));

     #endif

 	PauseRecordBuffer();

 	}

 TInt RMdaDevSound::CBody::BytesPlayed()

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

     RDebug::Printf("RMdaDevSound::BytesPlayed %s", iState.Name());

 	#endif

 	return I64LOW(BytesPlayed64());

 	}

 TUint64 RMdaDevSound::CBody::BytesPlayed64()

 	{

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	TUint64 currentBytesPlayed = KMaxTUint64;

 	switch(iState)

 	{

 	case ENotReady:

 		Panic(EDeviceNotOpened);

 		break;

 	case EStopped:

 		currentBytesPlayed = iBytesPlayed;

 		break;

 	case ERecording:

 	case ERecordingPausedInHw:

 	case ERecordingPausedInSw:

 		Panic(EBadState);

 		break;

 	case EPlayingPausedInHw: // ie. Play request pending on h/w and paused

 		// Paused, so use pause time

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

 		RDebug::Printf("EPlayingPausedInHw: iPausedBytes %x %x", I64HIGH(iPausedBytesPlayed), I64LOW(iPausedBytesPlayed));

 		#endif

 		currentBytesPlayed = iPausedBytesPlayed;

 		break;

 	case EPlayingPausedInSw: // ie. Driver not playing or paused

 		#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	 

 		RDebug::Printf("EPlayingPausedInSw: iPausedBytesPlayed %x %x", I64HIGH(iPausedBytesPlayed), I64LOW(iPausedBytesPlayed));

 		#endif

 		currentBytesPlayed = iPausedBytesPlayed;

 		break;

 	case EPlayingUnderrun:

 		#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	 

 		RDebug::Printf("EPlayingUnderrun: iBytesPlayed %x %x", I64HIGH(iBytesPlayed), I64LOW(iBytesPlayed));

 		#endif

 		currentBytesPlayed = iBytesPlayed;

 	    break;

 	case EPlaying:

 		{

 		// Playing so calculate time since last update to iBytesPlayed

 		TUint32 curTime = CurrentTimeInMsec();

 		TUint32 curRequestSize = iActivePlayRequestSizes.Peek();

 		TUint32 extraPlayTime = (curTime >= iStartTime) ? (curTime-iStartTime) : (KMaxTUint32 - (iStartTime-curTime));

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	 

 		RDebug::Printf("iStartTime %d curTime %d extraPlayTime %d", iStartTime, curTime, extraPlayTime);

 		RDebug::Printf("iPlayFormatData.iSampleRate %d KBytesPerSample %d iNTickPeriodInUsec %d",

 					   iPlayFormatData.iSampleRate, KBytesPerSample, iNTickPeriodInUsec);

         #endif

 		TUint32 extraBytesPlayed = TUint32((TUint64(extraPlayTime) * iPlayFormatData.iSampleRate * iPlayFormatData.iRequestedChannels * KBytesPerSample)/1000);

 		if(extraBytesPlayed > curRequestSize)

 			{

             #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	 

 			RDebug::Printf("caping extraBytes played from %d to %d", extraBytesPlayed, curRequestSize);

             #endif

 			extraBytesPlayed = curRequestSize;

 			}

 		#ifdef SYMBIAN_SOUNDADAPTER_DEBUG

 		RDebug::Printf("iBytesPlayed %d extraBytesPlayed %d (curRequestSize %d) -> currentBytesPlayed %x %x",

                 iBytesPlayed, extraBytesPlayed, curRequestSize, I64HIGH(currentBytesPlayed), I64LOW(currentBytesPlayed));

         #endif

 		currentBytesPlayed = iBytesPlayed + extraBytesPlayed;

 		break;

 		}

 	default:

 		Panic(EBadState);

 		break;

 	}

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

 	RDebug::Printf("iPlayFormatData.iConverter %x", iPlayFormatData.iConverter);

     #endif

 	if (iPlayFormatData.iConverter)

 		{

 		// need to scale bytes played to fit with requested rate and channels, not actual

 		if (iPlayFormatData.iActualChannels != iPlayFormatData.iRequestedChannels)

 			{

 			if (iPlayFormatData.iActualChannels == 2)

 				{

 				// requested was mono, we have stereo

 				currentBytesPlayed /= 2;

 				}

 			else 

 				{

 				// requested was stereo, we have mono

 				currentBytesPlayed *= 2;

 				}

 			}

 		if (iPlayFormatData.iSampleRate != iPlayFormatData.iActualRate)

 			{

 			currentBytesPlayed = TUint64(currentBytesPlayed*

 					TReal(iPlayFormatData.iSampleRate)/TReal(iPlayFormatData.iActualRate)); // don't round

 			}

 		}

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

 	RDebug::Printf("currentBytesPlayed %x %x", I64HIGH(currentBytesPlayed), I64LOW(currentBytesPlayed));

     #endif

 	return currentBytesPlayed;

 	}

 void RMdaDevSound::CBody::ResetBytesPlayed()

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

     RDebug::Printf("RMdaDevSound::CBody::ResetBytesPlayed %s", iState.Name());

 	#endif

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	iBytesPlayed = 0;

 	iPlaySoundDevice.ResetBytesTransferred();

 	return;

 	}

 void RMdaDevSound::CBody::PausePlayBuffer()

 	{

 #ifdef SYMBIAN_SOUNDADAPTER_DEBUG   

     RDebug::Printf("RMdaDevSound::CBody::PausePlayBuffer %s", iState.Name());

 #endif  

 	switch(iState)

 		{

 		case ENotReady:

 			Panic(EDeviceNotOpened);

 			break;

 		case EStopped:

 			// Driver is not playing so pause in s/w

 			break;

 		case ERecording:

 		case ERecordingPausedInHw:

 		case ERecordingPausedInSw:

 			Panic(EBadState);

 			break;

 		case EPlayingPausedInHw: // ie. Play request pending on h/w and paused

 		case EPlayingPausedInSw: // ie. Driver not playing or paused

 			// Already paused so nothing to do.

 			break;

 		case EPlayingUnderrun:

 			iState = EPlayingPausedInSw;

 			break;

 		case EPlaying:

 			{

 			iPauseTime = CurrentTimeInMsec();

 			iPausedBytesPlayed = BytesPlayed64();

 			TInt res = iPlaySoundDevice.Pause();

 			#ifdef SYMBIAN_SOUNDADAPTER_DEBUG   

 			RDebug::Printf("iPlaySoundDevice.Pause res = %d", res);

 			#endif

  			if(res == KErrNone)

 				{

 				iState = EPlayingPausedInHw;

 				}

 			else

 				{

 			    #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

 				RDebug::Printf("msp PausePlayBuffer hw pause unexpectedly failed, doing sw pause");

 				#endif

 				iState = EPlayingPausedInSw;

 				}

 			break;

 			}

 		default:

 			Panic(EBadState);

 			break;

 		}

 	return;

 	}

 void RMdaDevSound::CBody::ResumePlaying()

 	{

 	#ifdef SYMBIAN_SOUNDADAPTER_DEBUG   

 	RDebug::Printf("RMdaDevSound::CBody::ResumePlaying %s", iState.Name());

 	#endif	

     __ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	switch(iState)

 		{

 		case ENotReady:

 			Panic(EDeviceNotOpened);

 			break;

 		case EStopped:

 			// No change

 			break;

 		case ERecording:

 		case ERecordingPausedInHw:

 		case ERecordingPausedInSw:

 			Panic(EBadState);

 			break;

 		case EPlaying:

 			// No change

 			break;

 		case EPlayingPausedInHw: // ie. Play request pending on h/w and paused

 			{

 			// Re-enable reporting of KErrUnderflow (will re-raise KErrUnderflow if nothing to start playing).

 			iUnderFlowReportedSinceLastPlayOrRecordRequest = EFalse;

 			TInt res = iPlaySoundDevice.Resume();

 #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

 			RDebug::Printf("ResumePlayBuffer EPlayingPausedInHw res = %d", res);

 #endif

 			if(res == KErrNone)

 				{

 				// Resume ok so a pending request will complete

 				iState = EPlaying;

 	            // Update iStartTime to allow for time spent paused

 	            TUint32 curTime = CurrentTimeInMsec();

 	            TUint32 timePaused = (curTime >= iPauseTime) ? (curTime-iPauseTime) : (KMaxTUint32 - (iPauseTime-curTime));

 	            iStartTime += timePaused; // nb. It is harmless if this wraps.

 				}

 			else

 				{

 				// Resume failed, therefore driver is not playing

                 // No need to update iStartTime/iPauseTime because these are only used within a driver request

                 // Change state to Stopped

                 iState = EStopped;

                 //  Attempt to start a new (pending) request.

                 StartPlayersAndUpdateState();

 				}

 			break;

 			}

 		case EPlayingPausedInSw: // ie. Driver not playing/paused

 			{

 			// Driver not playing

 			// Re-enable reporting of KErrUnderflow (will re-raise KErrUnderflow if nothing to start playing).

 			iUnderFlowReportedSinceLastPlayOrRecordRequest = EFalse;

 			// No need to update iStartTime/iPauseTime because these are only used within a driver request

 			// Change state to Stopped

             iState = EStopped;

             //	Attempt to start a new (pending) request.

 			StartPlayersAndUpdateState();

 			break;

 			}

 		case EPlayingUnderrun:

 			break;

 		default:

 			Panic(EBadState);

 			break;

 		}

 	return;	

 	}

 void RMdaDevSound::CBody::PauseRecordBuffer()

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG   

     RDebug::Printf("RMdaDevSound::CBody::PauseRecordBuffer %s", iState.Name());

     #endif

 	switch(iState)

 		{

 		case ENotReady:

 			Panic(EDeviceNotOpened);

 			break;

 		case EStopped:

 			// Driver is not recording so pause in s/w

 		    // Do not pause because that will cause problems when CAudioDevice::Pause calls

 			break;

 		case ERecording:

 			{

 			TInt res = iRecordSoundDevice.Pause();

 			#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

 			RDebug::Printf("PauseRecordBuffer EPlaying res = %d", res);

 			#endif

 			if(res == KErrNone)

 				{

 				iState = ERecordingPausedInHw;

 				}

 			else

 				{

 				#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

 				RDebug::Printf("PauseRecordBuffer hw pause unexpectedly failed, doing sw pause");

 				#endif

 				iState = ERecordingPausedInSw;

 				}

 			break;

 			}

 		case ERecordingPausedInHw:

 		case ERecordingPausedInSw:

 			// Already paused so nothing to do.

 			break;

 		case EPlaying:

 		case EPlayingPausedInHw: // ie. Play request pending on h/w and paused

             Panic(EBadState);

             break;

 		case EPlayingPausedInSw: 

 		    // This is an ugly hack to maintain compatibility with CAudioDevice::Pause which

 		    // calls both PausePlayBuffer and PauseRecordBuffer whilst in stopped, then later calls ResumePlaying

 		    break;

 		case EPlayingUnderrun: // ie. Play request pending on h/w and paused

 			Panic(EBadState);

 		    break;

 		default:

 			Panic(EBadState);

 			break;

 		}

 	return;	

 	}

 void RMdaDevSound::CBody::ResumeRecording()

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG   

     RDebug::Printf("RMdaDevSound::CBody::ResumeRecording %s", iState.Name());

     #endif

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	switch(iState)

 		{

 		case ENotReady:

 			Panic(EDeviceNotOpened);

 			break;

 		case EStopped:

 			// No change

 			break;

 		case ERecording:

 			// No change

 			break;

 		case ERecordingPausedInHw:

 			{

 			TInt res = iRecordSoundDevice.Resume();

 			#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

 			RDebug::Printf("ResumeRecordBuffer ERecordingPausedInHw res = %d", res);

 			#endif

 			if(res == KErrNone)

 				{

 				// Resume ok so a pending request will complete

 				iState = ERecording;

 				}

 			else

 				{

 				iState = EStopped;

 				// Resume failed, so attempt to start a new (pending) request.

 				// If this works, it will update the state to ERecording.

 				StartRecordRequest();

 				}

 			break;

 			}

 		case ERecordingPausedInSw:

 			{

 			// Update state to stopped and attempt to start any pending request

 			iState = EStopped;

 			// If this works, it will update the state to ERecording.

 			StartRecordRequest();

 			break;

 			}

 		case EPlaying:

 		case EPlayingPausedInHw: // ie. Play request pending on h/w and paused

 		case EPlayingPausedInSw: // ie. Driver not playing/paused

 		case EPlayingUnderrun:

 		default:

 			Panic(EBadState);

 			break;

 		}

 		return; 

 	}

 TInt RMdaDevSound::CBody::GetTimePlayed(TTimeIntervalMicroSeconds& aTimePlayed)

 	{

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	TUint64 bytesPlayed = BytesPlayed64();

 	TUint64 timePlayed = 1000 * 1000 * bytesPlayed / (iPlayFormatData.iSampleRate * iPlayFormatData.iRequestedChannels * KBytesPerSample);

 	aTimePlayed = TTimeIntervalMicroSeconds(timePlayed);

 	return KErrNone;

 	}

 void RMdaDevSound::CBody::FormatsSupported(TSoundFormatsSupportedBuf& aFormatsSupported, RSoundSc& aSoundDevice)

 	{

 	TSoundFormatsSupportedV02Buf supportedFormat;

 	aSoundDevice.Caps(supportedFormat);

 	TUint32 rates = supportedFormat().iRates;

 	for(TInt i = KNumSampleRates-1; i > 0 ;i--)//min to max

 		{

 		if(rates & KRateEnumLookup[i].iRateConstant)

 			{

 			aFormatsSupported().iMinRate = KRateEnumLookup[i].iRate;

 			break;

 			}

 		}

 	for(TInt i = 0; i < KNumSampleRates; i++)//max to min

 		{

 		if(rates & KRateEnumLookup[i].iRateConstant)

 			{

 			aFormatsSupported().iMaxRate = KRateEnumLookup[i].iRate;

 			break;

 			}

 		}

 	TUint32 enc = supportedFormat().iEncodings;

 	if (enc & KSoundEncoding16BitPCM)

 		{

 		aFormatsSupported().iEncodings = EMdaSoundEncoding16BitPCM;// Always defaults to this

 		}

 	if (enc & KSoundEncoding8BitPCM)

 		{

 		aFormatsSupported().iEncodings |= EMdaSoundEncoding8BitPCM;

 		}

 	TUint32 channels = supportedFormat().iChannels;

 	if (channels & KSoundStereoChannel)

 		{

 		aFormatsSupported().iChannels = 2;

 		}

 	else

 		{

 		aFormatsSupported().iChannels = 1;

 		}

 	aFormatsSupported().iMinBufferSize = supportedFormat().iRequestMinSize;

 	aFormatsSupported().iMaxBufferSize = KMaxBufferSize;

 	aFormatsSupported().iMinVolume = 0;

 	aFormatsSupported().iMaxVolume = KSoundMaxVolume;

 	}

 void RMdaDevSound::CBody::GetFormat(TCurrentSoundFormatBuf& aFormat, 

 									RSoundSc& /*aSoundDevice*/,

 									const TFormatData &aFormatData)

 	{

 	// always return the requested, or the initial, not current device setting

 	aFormat().iChannels = aFormatData.iRequestedChannels; // never clear if this is bitmap or value, but effectively the same

 	aFormat().iRate = aFormatData.iSampleRate;

 	}

 void RMdaDevSound::CBody::StartPlayersAndUpdateState()

 	{

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	switch(iState)

 		{

 		case ENotReady:

 			Panic(EDeviceNotOpened);

 			break;

 		case EStopped:

  			// Allow following code to queue more driver play requests and check for stopped

 			break;

 		case ERecording:

 		case ERecordingPausedInHw:

 		case ERecordingPausedInSw:

 			Panic(EBadState);

 			break;

 		case EPlaying:

            // Allow following code to queue more driver play requests  and check for stopped

 		    break;

 		case EPlayingPausedInHw: // ie. Play request pending on h/w and paused

 			// Allow following code to queue more driver play requests

 			break;

 		case EPlayingPausedInSw:

 			// Paused but driver not playing+paused, therefore do not queue new requests until ResumePlaying

 			return;

 		case EPlayingUnderrun:

 			break;

 		default:

 			Panic(EBadState);

 			break;

 		}

 	// iState is now either EStopped, EPlaying or EPlayingPausedInHw

     __ASSERT_DEBUG(((iState == EStopped) || (iState == EPlaying) || (iState == EPlayingPausedInHw) || (iState == EPlayingUnderrun)), Panic(EBadState));

 	while( (iClientPlayData.Length() != 0) && (! iFreePlayers.IsEmpty()))

 		{

 		// More data to play and more players,  so issue another request 

 		bool wasIdle = iFreePlayers.IsFull();

 		// Get a free player		

 		CPlayer *player = iFreePlayers.Pop();

 		// Calculate length of request

 		TUint32 lengthToPlay = iClientPlayData.Length();

 		if(lengthToPlay > iDeviceBufferLength)

 		    {

             lengthToPlay = iDeviceBufferLength;

 		    }

 		// Remember request length, so we can update bytes played when it finishes

 		iActivePlayRequestSizes.Push(lengthToPlay);

 		// Find offset to copy data to

 		TUint playerIndex = player->GetPlayerIndex();

 		ASSERT(playerIndex < KPlaySharedChunkBuffers);

 		TUint chunkOffset = iPlayBufferConfig.iBufferOffsetList[playerIndex];

 		// Copy data

 		TPtr8 destPtr(iPlayChunk.Base()+ chunkOffset, 0, iDeviceBufferLength);

 		destPtr.Copy(iClientPlayData.Mid(0, lengthToPlay));

 		// Update iClientPlayData to remove the data just queued

 		iClientPlayData.Set(iClientPlayData.Right(iClientPlayData.Length()-lengthToPlay));

 		// Start the CPlayer

 		player->PlayData(chunkOffset, lengthToPlay);

 		if(wasIdle)

 			{

 			iState = EPlaying;

 			iStartTime = CurrentTimeInMsec();

 			}

 		}

 	// Check if the client request is now complete

 	if(iClientPlayData.Length() == 0 && iClientPlayStatus)

 		{

 		// We have queued all the client play data to the driver so we can now complete the client request.

 		// If actual playback fails, we will notify the client via the Play Error notification mechanism.

 		#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

 		RDebug::Printf("RMdaDevSound::CBody::StartPlayersAndUpdateState completing client request");

 		#endif

 		User::RequestComplete(iClientPlayStatus, KErrNone); // This call also sets iClientPlayStatus to NULL

 		}

     //nb. iState is now either EStopped, EPlaying or EPlayingPausedInHw (see previous switch and assert)

 	if(iState != EPlayingPausedInHw)

 	    {

         if(iFreePlayers.IsFull())

             {

             // Free fifo is full, therefore there are no active players

             iState = EPlayingUnderrun;

 			if(! iUnderFlowReportedSinceLastPlayOrRecordRequest)

 				{

 				// We report KErrUnderflow if we have not already reported it since the last PlayData call.

 				// Note that 

 				// i) We do NOT report driver underflows.

 				// ii) We report underflow when we run out of data to pass to the driver.

 				// iii) We throttle this reporting

 				// iv) We WILL report KErrUnderflow if already stopped and asked to play a zero length buffer

 				// The last point is required because the client maps a manual stop command into a devsound play with a 

 				// zero length buffer and the last buffer flag set, this in turn is mapped to a Playdata calll with an empty buffer

 				// which is expected to complete ok and cause a KErrUnderflow error to be reported...

 				iUnderFlowReportedSinceLastPlayOrRecordRequest = ETrue;

 				#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

 		        RDebug::Printf("RMdaDevSound::CBody::StartPlayersAndUpdateState stopped and iUnderFlowReportedSinceLastPlayOrRecordRequest false so raising KErrUnderflow");

 				#endif

 				// Discard any saved trailing data (ie. data saved due driver requiring all requests to be a multiple of iRequestMinSize).

 				// This maybe because client is delibrately letting us underflow to play silence. In that case we do not want to

 				// play the trailing data at the beginning of the new data issued after the silence...

 				iSavedTrailingData.SetLength(0);

 				SoundDeviceError(KErrUnderflow);

 				}

             }

         else

             {

             // Free fifo not full, therefore there are active players

             iState = EPlaying;

             }

 	    }

 	return;

 	}

 TInt RMdaDevSound::CBody::SetFormat(const TCurrentSoundFormatBuf& aFormat, 

 									RSoundSc& aSoundDevice,

 									TFormatData &aFormatData)

 	{

 	TInt err = KErrNotFound;

 	TCurrentSoundFormatV02Buf formatBuf;

 	delete aFormatData.iConverter; 

 	aFormatData.iConverter = NULL; // setting this to NULL indicates we are not using converter. No other flag

 	iConvertedPlayData.Close();

 	TInt wantedRate = aFormat().iRate;

 	for(TInt index = 0; index < KNumSampleRates; index++ )

 		{

 		if(wantedRate == KRateEnumLookup[index].iRate)

 			{

 			formatBuf().iRate = KRateEnumLookup[index].iRateEnum;

 			aFormatData.iSampleRate = wantedRate;

 			err = KErrNone;

 			break;

 			}

 		}

 	if(err == KErrNone)

 		{

 		// Assume, for now, we support the requested channels and rate

 		aFormatData.iActualChannels = aFormatData.iRequestedChannels;

 		aFormatData.iActualRate = aFormatData.iSampleRate;

 		// Attempt to configure driver

 		formatBuf().iChannels = aFormat().iChannels;

 		formatBuf().iEncoding = ESoundEncoding16BitPCM;

 		formatBuf().iDataFormat = ESoundDataFormatInterleaved;

 		err = aSoundDevice.SetAudioFormat(formatBuf);

         #if defined(SYMBIAN_SOUNDADAPTER_FORCECDRATES) || defined (SYMBIAN_SOUNDADAPTER_FORCESTEREO)

             err = KErrNotSupported; // force Negotiate - for debugging

         #endif

 		if (err==KErrNotSupported)

 			{

 			// don't support directly. Perhaps can rate convert?

 			err = NegotiateFormat(aFormat, aSoundDevice, aFormatData);

 			}

 		}

 	return err;	

 	}

 TInt RMdaDevSound::CBody::NegotiateFormat(const TCurrentSoundFormatBuf& aFormat, 

 										  RSoundSc& aSoundDevice, 

 										  TFormatData &aFormatData)

 	{

 	ASSERT(!aFormatData.iConverter); // we don't clear on fail - so assuming NULL to start with

 	TInt err = KErrNotFound;

 	TCurrentSoundFormatV02Buf formatBuf;

 	// find out first what the driver supports

 	TSoundFormatsSupportedV02Buf supportedFormat;

 	aSoundDevice.Caps(supportedFormat);

 	TUint32 supportedRates = supportedFormat().iRates;

     #ifdef SYMBIAN_SOUNDADAPTER_FORCECDRATES

         supportedRates &= KSoundRate11025Hz| KSoundRate22050Hz | KSoundRate44100Hz; // only use CD rates - for debugging

     #endif

 	// For PlayCase:

 	// 		first try to find the first rate below or equal to the requested that is supported

 	// 		initially go down and be fussy, but if we pass the requested rate find the first that

 	// 		is supported

 	// For RecordCase:

 	//		We want the next rate above consistently - we go down from this to the requested rate.

 	//		If there is one, we don't support - we _never_ upsample.

 	// note that the table is given in descending order, so we start with the highest

 	TInt wantedRate = aFormat().iRate;

 	TInt takeTheFirst = EFalse;

 	TInt nextUpValidIndex = -1;

 	for(TInt index = 0; index < KNumSampleRates; index++ )

 		{

 		TBool lookingAtRequestedRate = wantedRate == KRateEnumLookup[index].iRate;

 		TSoundRate wantedEnum = KRateEnumLookup[index].iRateEnum;

 		TUint32 equivBitmap = KRateEnumLookup[index].iRateConstant;

 		TBool isSupported = (equivBitmap & supportedRates) != EFalse;

 		if (lookingAtRequestedRate || takeTheFirst)

 			{

 			if (isSupported)

 				{

 				// this rate is supported

 				formatBuf().iRate = wantedEnum;

 				aFormatData.iActualRate = KRateEnumLookup[index].iRate;

 				err = KErrNone;

 				break;				

 				}

 			}

 		else if (!takeTheFirst)

 			{

 			// while we are still looking for the rate, want to cache any supported index

 			// at end of loop, this will be the first rate above ours that is supported

 			// use for fallback if required

 			if (isSupported)

 				{

 				nextUpValidIndex = index;

 				}

 			}

 		if (lookingAtRequestedRate)

 			{

 			// if we get this far we've gone passed the wanted rate. For play we enable

 			// "takeTheFirst". For record we just abort.

 			if (&aSoundDevice==&iPlaySoundDevice)

 				{

 				takeTheFirst = ETrue;

 				}

 			else

 				{

 				break;

 				}

 			}

 		}

 	if (err)

 		{

 		// if there is one above the requested rate, use that

 		if (nextUpValidIndex>=0)

 			{

 			TSoundRate wantedEnum = KRateEnumLookup[nextUpValidIndex].iRateEnum;

 			formatBuf().iRate = wantedEnum;

 			aFormatData.iActualRate = KRateEnumLookup[nextUpValidIndex].iRate;

 			err = KErrNone;		

 			}

 		}

 	if (err)

 		{

 		// should have something!

 		return err;

 		}

 	aFormatData.iSampleRate = wantedRate; // iSampleRate is our requested/apparent rate, not the device rate.

 	TUint32 channelsSupported = supportedFormat().iChannels;

     #ifdef SYMBIAN_SOUNDADAPTER_FORCESTEREO

         channelsSupported &= KSoundStereoChannel; // don't use mono - for debugging

     #endif

 	if(KSoundAdapterForceStereo==1)

 	    {

 	    channelsSupported &= KSoundStereoChannel;

 #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

 	    RDebug::Print(_L("Added stereo support."));

 #endif

 	    }

 	if (aFormat().iChannels == 1)

 		{

 		aFormatData.iRequestedChannels = 1;

 		// want mono

 		if (channelsSupported & KSoundMonoChannel)

 			{

 			// mono is supported, as usual

 			aFormatData.iActualChannels = 1;

 			}

 		else if (channelsSupported & KSoundStereoChannel)

 			{

 			aFormatData.iActualChannels = 2;

 			}

 		else

 			{

 			return KErrNotSupported; // should not get this far for real

 			}

 		}

 	else if (aFormat().iChannels == 2)

 		{

 		aFormatData.iRequestedChannels = 2;

 		// want stereo

 		if (channelsSupported & KSoundStereoChannel)

 			{

 			// stereo is supported, as usual

 			aFormatData.iActualChannels = 2;

 			}

 		else if (channelsSupported & KSoundMonoChannel)

 			{

 			aFormatData.iActualChannels = 1;

 			}

 		else

 			{

 			return KErrNotSupported; // should not get this far for real

 			}

 		}

 	else

 		{

 		return KErrNotSupported; // unknown number of channels requested!

 		}

 	formatBuf().iChannels = aFormatData.iActualChannels;

 	formatBuf().iEncoding = ESoundEncoding16BitPCM;

 	formatBuf().iDataFormat = ESoundDataFormatInterleaved;

 	err = aSoundDevice.SetAudioFormat(formatBuf);

 	if (!err)

 		{

 		ASSERT(!aFormatData.iConverter); // pre-condition at top of function anyway

 		if (&aSoundDevice==&iPlaySoundDevice)

 			{

             #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

                 RDebug::Print(_L("RMdaDevSound::CBody::NegotiateFormat: Convert:CreateL from %d/%d to %d/%d"), 

                             aFormatData.iSampleRate, aFormatData.iRequestedChannels, 

                             aFormatData.iActualRate, aFormatData.iActualChannels);

             #endif																	       

 			// when playing we convert from requested to actual

 			TRAP(err, aFormatData.iConverter = CChannelAndSampleRateConverter::CreateL(aFormatData.iSampleRate, 

 																		   aFormatData.iRequestedChannels, 

 																	       aFormatData.iActualRate, 

 																	       aFormatData.iActualChannels));

 			}

 		else

 			{

 			// when recording we convert from actual to requested

 			TInt outputRateToUse = aFormatData.iSampleRate;

             #ifdef SYMBIAN_SKIP_RESAMPLE_ON_RECORD

                 // with this macro just channel convert at most

                 outputRateToUse = aFormatData.iActualRate;

             #endif

             #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

                 RDebug::Print(_L("RMdaDevSound::CBody::NegotiateFormat: Convert:CreateL from %d/%d to %d/%d"), 

                             aFormatData.iActualRate, aFormatData.iActualChannels,

                             aFormatData.iSampleRate, aFormatData.iRequestedChannels); 

             #endif																	       

 			TRAP(err, aFormatData.iConverter = CChannelAndSampleRateConverter::CreateL(aFormatData.iActualRate, 

 																	       aFormatData.iActualChannels,

 																	       outputRateToUse, 

 																		   aFormatData.iRequestedChannels));

 			}

 		}

 	if(err != KErrNone)

 		{

 		delete aFormatData.iConverter;

 		aFormatData.iConverter= NULL;

 		iConvertedPlayData.Close();

 		}

 	return err;

 	}

 void RMdaDevSound::CBody::StartRecordRequest()

 	{

 	__ASSERT_DEBUG(iRecordSoundDevice.Handle(), Panic(EDeviceNotOpened));

 	iRecorder->RecordData(iBufferLength);

 	}

 // Note both InRecordMode and InPlayMode return EFalse for ENotReady and EStopped

 TBool RMdaDevSound::CBody::InRecordMode()const

 	{

 	switch(iState)

 		{

 		case ENotReady:

 		case EStopped:

 			return EFalse;

 		case ERecording:

 		case ERecordingPausedInHw:

 		case ERecordingPausedInSw:

 			return ETrue;

 		case EPlaying:

 		case EPlayingPausedInHw: 

 		case EPlayingPausedInSw:

 		case EPlayingUnderrun:

 			return EFalse;

 		default:

 			Panic(EBadState);

 			break;

 		}

 	return EFalse;

 	}

 TBool RMdaDevSound::CBody::InPlayMode() const

 	{

 	switch(iState)

 		{

 		case ENotReady:

 		case EStopped:

 			return EFalse;

 		case ERecording:

 		case ERecordingPausedInHw:

 		case ERecordingPausedInSw:

 			return EFalse;

 		case EPlaying:

 		case EPlayingPausedInHw: 

 		case EPlayingPausedInSw:

 		case EPlayingUnderrun:

 			return ETrue;

 		default:

 			Panic(EBadState);

 			break;

 		}

 	return EFalse;

 	}

 TUint32 RMdaDevSound::CBody::CurrentTimeInMsec() const

 	{

 	TUint64 tmp = User::NTickCount();

 	tmp *= iNTickPeriodInUsec;

 	tmp /= 1000;

 	return TUint32(tmp);

 	}

 void RMdaDevSound::CBody::PlayFormatsSupported(TSoundFormatsSupportedBuf& aFormatsSupported)

 	{

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	FormatsSupported(aFormatsSupported, iPlaySoundDevice);

 	}

 void RMdaDevSound::CBody::GetPlayFormat(TCurrentSoundFormatBuf& aFormat)

 	{

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	GetFormat(aFormat, iPlaySoundDevice, iPlayFormatData);

 	}

 TInt RMdaDevSound::CBody::SetPlayFormat(const TCurrentSoundFormatBuf& aFormat)

 	{

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	return SetFormat(aFormat, iPlaySoundDevice, iPlayFormatData);

 	}

 void RMdaDevSound::CBody::RecordFormatsSupported(TSoundFormatsSupportedBuf& aFormatsSupported)

 	{

 	__ASSERT_DEBUG(iRecordSoundDevice.Handle(), Panic(EDeviceNotOpened));

 	FormatsSupported(aFormatsSupported, iRecordSoundDevice);

 	}

 void RMdaDevSound::CBody::GetRecordFormat(TCurrentSoundFormatBuf& aFormat)

 	{

 	__ASSERT_DEBUG(iRecordSoundDevice.Handle(), Panic(EDeviceNotOpened));

 	GetFormat(aFormat, iRecordSoundDevice, iRecordFormatData);	

 	}

 TInt RMdaDevSound::CBody::SetRecordFormat(const TCurrentSoundFormatBuf& aFormat)

 	{

 	__ASSERT_DEBUG(iRecordSoundDevice.Handle(), Panic(EDeviceNotOpened));

 	return SetFormat(aFormat, iRecordSoundDevice, iRecordFormatData);

 	}

 void RMdaDevSound::CBody::Close()

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

         RDebug::Printf("void RMdaDevSound::CBody::Close() started");

     #endif

 	iBufferOffset = -1;

 	iBufferLength = 0;

 	if(iPlaySoundDevice.Handle() != KNullHandle)

 	    {

         // Make sure all player objects are idle

         CancelPlayData();

         iPlayChunk.Close();

         iPlaySoundDevice.Close();

 	    }

     if(iRecordSoundDevice.Handle() != KNullHandle)

         {

         CancelRecordData();

         iRecordChunk.Close();

         iRecordSoundDevice.Close();

         }

 	iState = ENotReady;

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

         RDebug::Printf("void RMdaDevSound::CBody::Close() ended");

     #endif

 	}

 TInt RMdaDevSound::CBody::Handle()

 	{//This method is actually used to check whether the device is opened. Below logic should work

 	if(iPlaySoundDevice.Handle())

 		{

 		return iPlaySoundDevice.Handle();

 		}

 	if(iRecordSoundDevice.Handle())

 		{

 		return iRecordSoundDevice.Handle();

 		}

 	return 0;

 	}

 void RMdaDevSound::CBody::PlayData(TRequestStatus& aStatus, const TDesC8& aData)

 	{

 	#ifdef SYMBIAN_SOUNDADAPTER_DEBUG

     RDebug::Printf("RMdaDevSound::CBody::PlayData(0x%x,%d) State=%s Handle=%d.",&aStatus, 

                    aData.Length(), iState.Name(), iPlayChunk.Handle());

 	#endif

 	__ASSERT_DEBUG(iPlaySoundDevice.Handle(), Panic(EDeviceNotOpened));

 	aStatus = KRequestPending;

 	if((iClientPlayStatus != NULL) || InRecordMode())

 		{

 		// We only support one outstanding request

 		// No support for simultaneous play and record in RMdaDevSound

 		TRequestStatus *pRequest = &aStatus;

 		User::RequestComplete(pRequest, KErrInUse);

 		return;

 		}

 	iClientPlayStatus = &aStatus;//store the status of datapath player

 	if(iPlayFormatData.iConverter || iSavedTrailingData.Length() != 0)

 		{

 		// Need a conversion buffer

         // Needs to hold any trailing data truncated from the previous request (due

         // to alignment requirements) and either the new data, or the new rate adapted data

 		TUint32 spaceRequired = iSavedTrailingData.Length();

 		if(iPlayFormatData.iConverter)

 			{

 			// Doing rate conversion so also need space for the converted data

 			spaceRequired += iPlayFormatData.iConverter->MaxConvertBufferSize(aData.Length());

 			}

 		else

 			{

 			// Not doing rate adaptation therefore only need to allow for the new incoming data

 			spaceRequired += aData.Length();

 			}

 		// Check if existing buffer exists and is big enough

 		if(iConvertedPlayData.MaxLength() < spaceRequired)

 			{

 			iConvertedPlayData.Close();

 			TInt err = iConvertedPlayData.Create(spaceRequired);

 			if(err)

 				{

 				User::RequestComplete(iClientPlayStatus, err);

 				return;

 				}

 			}

 		// Truncate iConvertedPlayData and copy in saved trailing data (if any)

 		iConvertedPlayData = iSavedTrailingData;

 		iSavedTrailingData.SetLength(0);

 		// Now append rate adapted data or incoming data

 		if (iPlayFormatData.iConverter)

 			{

             // The convertor will panic if it fails to convert any data, therefore

             // we avoid passing it an empty source buffer

 			if(aData.Length() != 0)

 				{

                 TPtr8 destPtr((TUint8 *)iConvertedPlayData.Ptr()+iConvertedPlayData.Length(), 0, iConvertedPlayData.MaxLength()-iConvertedPlayData.Length());

 				TInt len = iPlayFormatData.iConverter->Convert(aData, destPtr);

 				iConvertedPlayData.SetLength(iConvertedPlayData.Length() + destPtr.Length());

 				if(len != aData.Length())

 					{

 					#ifdef SYMBIAN_SOUNDADAPTER_DEBUG

 					RDebug::Printf("RMdaDevSound::CBody::PlayData converted %d	but expected to convert %d", len, aData.Length());

 					#endif

 					}

 				}

 			}

 		else

 			{

 			iConvertedPlayData.Append(aData);

 			}

 		iClientPlayData.Set(iConvertedPlayData);

 		}

 	else

 		{

 		// Do not need a conversion buffer so just aim the descriptor at the data

 		iClientPlayData.Set(aData);

 		}

 	iUnderFlowReportedSinceLastPlayOrRecordRequest = EFalse;

 	// All driver requests must be an exact multiple of iRequestMinSize

 	TUint32 trailingDataLen = iClientPlayData.Length() % iRequestMinSize;

 	if(trailingDataLen)

 		{

 		// Not a multiple of iRequestMinSize, so need to truncate current request, and save trailing bytes for 

 		// inclusion at the beginning of the next request

 		iSavedTrailingData = iClientPlayData.Right(trailingDataLen);

 		iClientPlayData.Set(iClientPlayData.Left(iClientPlayData.Length()-trailingDataLen));

 		}

     #ifdef SYMBIAN_FORCE_32BIT_LENGTHS

 	if (iClientPlayData.Length()%4 != 0)

 	    {

         // simulate the limitation of some hardware, where -6 is generated if the

         // buffer length is not divisible by 4.

         TRequestStatus *pRequest = &aStatus;

         User::RequestComplete(pRequest, KErrArgument);

 	}

     #endif

 	iRecordChunk.Close();

 	if(!iPlayChunk.Handle())

 		{

 		//This is where we setup to play. 

 		//Configure the shared chunk for two buffers with iBufferSize each

 		iPlayBufferConfig.iNumBuffers = KPlaySharedChunkBuffers;

 		iDeviceBufferLength = KPlaySharedChunkBufferSize;

 		#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

 		RDebug::Printf("iDeviceBufferLength %d", iDeviceBufferLength);

 		#endif

 		iPlayBufferConfig.iFlags = 0;//data will be continuous

 		// If required, use rate converter etc

 		iPlayBufferConfig.iBufferSizeInBytes = iDeviceBufferLength;

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

             RDebug::Printf("number of buffers: [%d]",iPlayBufferConfig.iNumBuffers);

             RDebug::Printf("BufferSize in Bytes [%d]",iPlayBufferConfig.iBufferSizeInBytes);

         #endif

 		TPckg<TPlaySharedChunkBufConfig> bufferConfigBuf(iPlayBufferConfig);

 		TInt error = iPlaySoundDevice.SetBufferChunkCreate(bufferConfigBuf,iPlayChunk);

 		if(error == KErrNone)

 			{

 			iPlaySoundDevice.GetBufferConfig(bufferConfigBuf);

 			}

 		if (error)

 			{

 			SoundDeviceError(error);

 			return;

 			}

 		}

     StartPlayersAndUpdateState();

 	return;	

 	}

 void RMdaDevSound::CBody::RecordData(TRequestStatus& aStatus, TDes8& aData)

 	{

 	__ASSERT_DEBUG(iRecordSoundDevice.Handle(), Panic(EDeviceNotOpened));

 	aStatus = KRequestPending;

 	if((iClientPlayStatus != NULL) || InPlayMode())

 		{

 		// We only support one outstanding request

 		// No support for simultaneous play and record in RMdaDevSound

 		TRequestStatus *pRequest = &aStatus;

 		User::RequestComplete(pRequest, KErrInUse);

 		return;

 		}

 	iClientRecordStatus = &aStatus;

 	iClientRecordData = &aData;

 	iUnderFlowReportedSinceLastPlayOrRecordRequest = EFalse;

 	iPlayChunk.Close();

 	if(!iRecordChunk.Handle())

 		{

 		//Configure the shared chunk for two buffers with iBufferSize each

 		iRecordBufferConfig.iNumBuffers = KRecordMaxSharedChunkBuffers;

 		iDeviceBufferLength = KRecordSharedChunkBufferSize; // initial size - resize if needs be

 		if (iRecordFormatData.iConverter)

 			{

 			// if number of channels used differs from request, resize buffer

 			// assume we have nice rounded values for buffer.

 			if (iRecordFormatData.iActualChannels>iRecordFormatData.iRequestedChannels)

 				{

 				iDeviceBufferLength *= 2; // will record at stereo and convert to mono 

 				}

 			else if (iRecordFormatData.iActualChannels<iRecordFormatData.iRequestedChannels)

 				{

 				iDeviceBufferLength /= 2; // will record at mono and convert to stereo 

 				}

 			}

 		iRecordBufferConfig.iBufferSizeInBytes = iDeviceBufferLength;

 		iRecordBufferConfig.iFlags = 0;

 		TPckg<TRecordSharedChunkBufConfig> bufferConfigBuf(iRecordBufferConfig);

 		TInt error = iRecordSoundDevice.SetBufferChunkCreate(bufferConfigBuf,iRecordChunk);

 		if(error == KErrNone)

 			{

 			iRecordSoundDevice.GetBufferConfig(bufferConfigBuf);

 			}

 		else

 			{

 			SoundDeviceError(error);

 			return;

 			}

 		iState = ERecording;

 		}		

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

         RDebug::Printf("RMdaDevSound::CBody::RecordData,iBufferOffset[%d]",iBufferOffset);

     #endif

 	switch(iState)

 		{

 		case ENotReady:

 			Panic(EBadState);

 			break;

 		case EStopped:

 		case ERecording:

 			// Either idle or recording is in progress, therefore we can issue another request			

 			StartRecordRequest();

 			break;

 		case ERecordingPausedInHw:

 			// Driver is paused, therefore we can issue a request which will immediately return buffered data

 			// or be aborted (in the driver) with KErrCancelled if there is no more data). nb. That KErrCancelled should not be

 			// returned to the client because the old RMdaDevSound driver would have completed with KErrNone and zero data length.

 			StartRecordRequest();

 			break;

 		case ERecordingPausedInSw:

 			// Paused in s/w but driver is not paused, therefore can not issue a new request to driver because

 			// it would re-start recording.

 			// This implies we were paused whilst the h/w was not recording, so there is no buffered data.

 			// Complete the request with KErrNone and no data.

 			iClientRecordData->SetLength(0);

 			User::RequestComplete(iClientRecordStatus, KErrNone);

 			break;

 		case EPlaying:

 		case EPlayingPausedInHw:

 		case EPlayingPausedInSw: 

 		case EPlayingUnderrun:

 			Panic(EBadState);

 			break;

 		default:

 			Panic(EBadState);

 			break;

 		}

 	}

 /**

 	Notify client of error.

 	Note that we continue playing/recording if possible.

 	We do not maintain information which could map the error back to a particular client play/record request

 	and therefore we have to notify the client of error every time it happens.

 	nb. A client play/record request is completed with KErrNone if it queues ok - All errors are reported via the Notify*Error

 	mechanism.

  */

 void RMdaDevSound::CBody::SoundDeviceError(TInt aError)

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

 	RDebug::Printf("RMdaDevSound::CBody::SoundDeviceError: Error[%d] state %s", aError, iState.Name());

     #endif

 	ASSERT(aError != KErrNone);

 	if(iClientPlayErrorStatus)

 		{

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

             RDebug::Printf("RMdaDevSound::CBody::SoundDeviceError Completing iPlayerErrorStatus");

         #endif

 		User::RequestComplete(iClientPlayErrorStatus, aError); // nb call also sets iClientPlayErrorStatus to NULL

 		}

   	if(iClientRecordErrorStatus)

 		{

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

             RDebug::Printf("RMdaDevSound::CBody::SoundDeviceError Completing iClientRecordErrorStatus");

         #endif

 		User::RequestComplete(iClientRecordErrorStatus, aError); // nb call also sets iClientRecordErrorStatus to NULL

 		}

 	return;

 	}

 void RMdaDevSound::CBody::NotifyRecordError(TRequestStatus& aStatus)

 	{

 	aStatus = KRequestPending;

 	iClientRecordErrorStatus = &aStatus;

 	}

 void RMdaDevSound::CBody::NotifyPlayError(TRequestStatus& aStatus)

 	{

 	aStatus = KRequestPending;

 	iClientPlayErrorStatus = &aStatus;

 	}

 void RMdaDevSound::CBody::CancelNotifyPlayError()

 	{

 	if(iClientPlayErrorStatus)

 		{

 		User::RequestComplete(iClientPlayErrorStatus, KErrCancel);

 		}

 	}

 void RMdaDevSound::CBody::CancelNotifyRecordError()

 	{

 	if(iClientRecordErrorStatus)

 		{

 		User::RequestComplete(iClientRecordErrorStatus, KErrCancel);

 		}

 	else

 	    {

 		#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

         RDebug::Printf("msp BufferEmptied but iClientPlayStatus==NULL");

 		#endif

 	    }

 	}

 void RMdaDevSound::CBody::FlushPlayBuffer()

 	{

 	#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

     RDebug::Printf("RMdaDevSound::CBody::FlushPlayBuffer calling CancelPlayData");

 	#endif	

 	CancelPlayData();

 	}

 RSoundSc& RMdaDevSound::CBody::PlaySoundDevice()

 	{

 	return iPlaySoundDevice;

 	}

 RSoundSc& RMdaDevSound::CBody::RecordSoundDevice()

 	{

 	return iRecordSoundDevice;

 	}

 const RMdaDevSound::CBody::TState &RMdaDevSound::CBody::State() const

 	{

 	return iState;

 	}

 void RMdaDevSound::CBody::BufferFilled(TInt aBufferOffset)

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

         RDebug::Print(_L("RMdaDevSound::CBody::BufferFilled:"));

     #endif	

 	ASSERT(aBufferOffset>=0 || aBufferOffset==KErrCancel);

 	ASSERT(iClientRecordData); // request should not get this without

 	if(aBufferOffset==KErrCancel)

 		{

 		//we can get KErrCancel when we call pause and there is no more data left with the driver

 		//we send the empty buffer to the HwDevice, where this should trigger the shutdown mechanism

 		iClientRecordData->SetLength(0);

 		User::RequestComplete(iClientRecordStatus, KErrNone);

 		iClientRecordStatus = NULL;

 		return;

 		}

 	iBufferOffset = aBufferOffset;

 	//when last buffer is flushed, new driver sometimes gives buffer size of odd number. One of our codecs

 	//expects that the buffer size should always be even. Base suggested that we fix in multimedia

 	//as it is quite complicated to fix in overthere.

 	iBufferLength = iBufferLength & 0xfffffffe;

 	TPtr8 dataPtr(iRecordChunk.Base()+ iBufferOffset, iBufferLength, iClientRecordData->MaxLength());

 	if (iRecordFormatData.iConverter)

 		{

 		iRecordFormatData.iConverter->Convert(dataPtr, *iClientRecordData);

 		}

 	else

 		{

 		iClientRecordData->Copy(dataPtr);

 		}

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

         RDebug::Print(_L("RMdaDevSound::CBody::BufferFilled: BufferOffset[%d] BufferLen[%d]"), iBufferOffset, iBufferLength);

     #endif

 	if(iBufferOffset >= 0)

 		{

 		iRecordSoundDevice.ReleaseBuffer(iBufferOffset);

 		}

 	if(iClientRecordStatus)

 		{

 		User::RequestComplete(iClientRecordStatus, KErrNone);

 		iClientRecordStatus = NULL;

 		}

 	else

 	    {

         RDebug::Printf("msp PlayCancelled but iClientPlayStatus==NULL");

 	    }

 	}

 /*

 	This function is called to notify us that a CPlayer's request has completed and what its status was.

 	It is important to note that:-

 	1) RSoundSc driver PlayData requests are guaranteed to complete in order, oldest first

 	2) If we are overloaded, it is possible for more than one request to complete before any CPlayer::RunL is ran. In

 	this situation the CPlayer::RunL functions, and hence this callback, maybe invoked in non-oldest first order

 	but

 	a) It is impossible for callback for the second oldest CPlayer to occur before the driver request for the oldest has

 	been complete (because of 1)

 	b) We will always get exactly one callback for every complete request.

 	Therefore this callback notifies us of two subtly separate things:-

 	i) The oldest request has been completed (so we can reduce can increase the bytes played counter by its length

 	ii) CPlayer aPlayerIndex is free for re-use

 	but we can not assume that aPlayerIndex is the oldest request, therefore we save the play request lengths outside of

 	the CPlayer object.

 */

 void RMdaDevSound::CBody::PlayRequestHasCompleted(CPlayer *aPlayer, TInt aStatus, TBool aDueToCancelCommand)

 	{

 	// CPlayer is done so put it on the free queue

 	iFreePlayers.Push(aPlayer);

 	TUint32 bytesPlayed = iActivePlayRequestSizes.Pop();

 	// Request has finished therefore now timing the following request to simulate bytes played

     iStartTime = CurrentTimeInMsec();

 	if(aDueToCancelCommand)

 	    {

         // Callback due to CPlayer::Cancel/DoCancel being called, therefore we

         // do not want to update bytes played, process state, report a error or start new players

         return;

 	    }

 	// Update iBytesPlayed by the length of the oldest request (which might not be the one that CPlayer was 

 	// handling).

 	iBytesPlayed += bytesPlayed;

 	#ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

     RDebug::Printf("PlayRequestHasCompleted increasing iBytesPlayed by %d to %d", bytesPlayed, iBytesPlayed);

 	#endif

     // Process state

 	switch(iState)

 		{

 		case ENotReady:

 			Panic(EDeviceNotOpened);

 			break;

 		case EStopped:

 			// Will happen if we are doing CancelPlayData processing with active players

 			break;

 		case ERecording:

 		case ERecordingPausedInHw:

 		case ERecordingPausedInSw:

 			Panic(EBadState);

 			break;

 		case EPlaying:

 			// Normal situation

 			break;

 		case EPlayingPausedInHw: 

 			// H/W was/is paused, but there must have been an already complete request that we had not 

 			// processed yet.

 			// There must be at least one more pending request on h/w, otherwise the h/w would have refused to pause

 			// I would expect this be rare, but it happens quite often...

             #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

 			ASSERT(iActivePlayRequestSizes.Length() != 0);

             #endif

 			// Need to update the start and pause time to now because we have just updated the actual iBytesPlayed

 			// and logically the h/w is paused at the beginning of the next request

 			iStartTime = CurrentTimeInMsec();

 			iPauseTime = iStartTime;

 			break;

 		case EPlayingPausedInSw:

 			// This will happen if there is only a single hw request outstanding, and the hardware has finished it, but the

 			// corresponding RunL has not run yet (in which case PausePlayBuffer will have attempted to use h/w pause,

 			// but the driver call would have failed, and the state changed to EPlayingPausedInSw).

 			iStartTime = CurrentTimeInMsec();

 			iPauseTime = iStartTime;

 			return;

 		case EPlayingUnderrun:

 			break;

 		default:

 			Panic(EBadState);

 			break;

 		}

 	// If we have an error, report it to the client

 	// We NEVER report driver underflow, instead we report KErrUnderflow if we run out of data to pass to driver.

 	if( (aStatus != KErrNone) && (aStatus != KErrUnderflow) )

 		{

 		SoundDeviceError(aStatus);

 		}

     // If appropriate start more players

 	StartPlayersAndUpdateState();

 	return;

 	}

 RMdaDevSound::CBody::CPlayer::CPlayer(TInt aPriority, RMdaDevSound::CBody& aParent, TInt aIndex):

 	CActive(aPriority), iParent(aParent), iIndex(aIndex), iBufferOffset(-1), iBufferLength(0)

 	{

 	CActiveScheduler::Add(this);

 	}

 RMdaDevSound::CBody::CPlayer::~CPlayer()

 	{

 	Cancel();

 	}

 void RMdaDevSound::CBody::CPlayer::RunL()

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

     RDebug::Printf("****RMdaDevSound::CBody::CPlayer(%d)::RunL: Error[%d] ParentState[%s]", 

                      iIndex, iStatus.Int(), iParent.State().Name());

 	RDebug::Printf("iActivePlayRequestSizes.Length() = %d iFreePlayers.Length() = %d (including this one as active)", 

 					iParent.iActivePlayRequestSizes.Length(), 

 					iParent.iFreePlayers.Length());

     #endif

 	iParent.PlayRequestHasCompleted(this, iStatus.Int(), EFalse);

 	return;

 	}

 TInt RMdaDevSound::CBody::CPlayer::RunError(TInt aError)

 	{

 	iParent.PlayRequestHasCompleted(this, aError, EFalse);

 	return KErrNone;

 	}

 void RMdaDevSound::CBody::CPlayer::DoCancel()

 	{

 #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

 	RDebug::Printf("RMdaDevSound::CBody::CPlayer(%d)::DoCancel", iIndex);

 #endif

 	if(iStatus == KRequestPending)

 	    {

         // Avoid cancelling requests which have already completed.

         // It wastes time, and might provoke a sound driver problem

 	    #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

         RDebug::Printf("RMdaDevSound::CBody::CPlayer::DoCancel - would have cancelled driver request");

 		#endif

         iParent.PlaySoundDevice().Cancel(iStatus);

 	    }

 	iParent.PlayRequestHasCompleted(this, KErrCancel, ETrue);

 	}

 void RMdaDevSound::CBody::CPlayer::PlayData(TUint aChunkOffset, TInt aLength)

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

 	RDebug::Print(_L("RMdaDevSound::CBody::CPlayer(%d)::PlayData : IsActive[%d]"),

 				  iIndex,    IsActive());

 	RDebug::Printf("iActivePlayRequestSizes.Length() = %d iFreePlayers.Length() = %d (inc this player)", 

 					iParent.iActivePlayRequestSizes.Length(), 

 					iParent.iFreePlayers.Length());

     #endif	

 	iBufferOffset = aChunkOffset;

 	iBufferLength = aLength;

     //Make sure the length is a multiple of 4 to work around an h6 limitation.

 	iBufferLength = iBufferLength & 0xfffffffc;

 	// Issue the RSoundSc request

 	iParent.PlaySoundDevice().PlayData(iStatus, iBufferOffset, iBufferLength, EFalse);

 	SetActive();

 	return;

 	}

 TUint RMdaDevSound::CBody::CPlayer::GetPlayerIndex() const

 	{

 	return iIndex;

 	}

 RMdaDevSound::CBody::CRecorder::CRecorder(TInt aPriority, RMdaDevSound::CBody& aParent):

     CActive(aPriority), iParent(aParent), iBufferOffset(-1), iBufferLength(0)

     {

     CActiveScheduler::Add(this);

     }

 RMdaDevSound::CBody::CRecorder::~CRecorder()

     {

     Cancel();

     }

 void RMdaDevSound::CBody::CRecorder::RecordData(TInt& aBufferLength)

 	{

 	if (!IsActive())

 	    {

 	    iStatus = KRequestPending;

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

             RDebug::Printf("Recording request: BufferLength[%d]", aBufferLength);

         #endif

 	    iParent.RecordSoundDevice().RecordData(iStatus, aBufferLength);

 	    SetActive();

 	    }

 	}

 void RMdaDevSound::CBody::CRecorder::RunL()

 	{

     #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

     RDebug::Printf("****RMdaDevSound::CBody::CRecorder()::RunL: Error[%d] ParentState[%s]", 

                      iStatus.Int(), iParent.State().Name());

     #endif

 	TInt error = iStatus.Int();

 	if((error >= 0) || (error == KErrCancel))

 		{//we can get KErrCancel when we call pause and there is no more data left with the driver

 		iParent.BufferFilled(error);

 		}

 	else 

 		{

         #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

             RDebug::Print(_L("RMdaDevSound::CBody::CPlayer()::RunL: Error[%d]"), error);

         #endif

 		iParent.SoundDeviceError(error);

 		}

 	}

 TInt RMdaDevSound::CBody::CRecorder::RunError(TInt aError)

     {

     iParent.SoundDeviceError(aError);

     return KErrNone;

     }

 void RMdaDevSound::CBody::CRecorder::DoCancel()

     {

 #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

     RDebug::Printf("RMdaDevSound::CBody::CRecorder()::DoCancel");

 #endif

     iParent.RecordSoundDevice().Cancel(iStatus);

     }

 // End of file