// 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 "mdasoundadapterbody.h"

#include <e32debug.h>

#include "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:

			// Can not move to EPlayingPausedInSw because it provokes a datapath panic....

			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: