// 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