#include <hal.h>

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;

	}

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

	delete iRecorder;

	iRecorder = NULL;

	delete iPlayFormatData.iConverter;

	delete iRecordFormatData.iConverter;

	iPlayChunk.Close();

	iRecordChunk.Close();

	iConvertedPlayData.Close();

	iSavedTrailingData.Close();

	iBufferedRecordData.Close();

	:iState(ENotReady), iBufferOffset(-1)

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

		iFreePlayers.Push(iPlayers[i]);

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

	TInt tmp;

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

	iNTickPeriodInUsec = tmp;

		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;

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

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

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

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

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

	PauseRecordBuffer();

    #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

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

	#endif

	return I64LOW(BytesPlayed64());

	}

TUint64 RMdaDevSound::CBody::BytesPlayed64()

	{

	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));

		currentBytesPlayed = iBytesPlayed + extraBytesPlayed;

		break;

	default:

		Panic(EBadState);

		break;

	}

    #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

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

    #endif

	if (iPlayFormatData.iConverter)

		if (iPlayFormatData.iActualChannels != iPlayFormatData.iRequestedChannels)

			if (iPlayFormatData.iActualChannels == 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

    #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

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

	#endif

	iBytesPlayed = 0;

	iPlaySoundDevice.ResetBytesTransferred();

	return;

#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();

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

 			if(res == KErrNone)

				{

				iState = EPlayingPausedInHw;

				}

			else

				{

			    #ifdef SYMBIAN_SOUNDADAPTER_DEBUG    

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