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

#ifdef SYMBIAN_SOUNDADAPTER_BYTESPLAYED

	#include <hal.h>

#endif

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

	}

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 < KNumPlayers; i++)

		{

		delete iPlayers[i];

		iPlayers[i] = NULL;

		}

	iBufferRemaining.Close();

	delete iPlayData.iConverter;

	delete iRecordData.iConverter;

	iChunk.Close();

	iPlaySoundDevice.Close();

	iRecordSoundDevice.Close();

	}

RMdaDevSound::CBody::CBody()

	:iState(ENotReady), iBufferIndex(-1), iBufferOffset(-1), iSecondPhaseData(0,0)

	{

	}

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<KNumPlayers; i++)

		{

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

		}

#ifdef SYMBIAN_SOUNDADAPTER_BYTESPLAYED

	User::LeaveIfError(HAL::Get(HALData::EFastCounterFrequency,iFCFrequency));

#endif

	}

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

	    {

	    iState = EOpened;

	    }

	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::Print(_L("RMdaDevSound::CBody::CancelPlayData:"));

    #endif	

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

	iPlaySoundDevice.CancelPlayData();

	iPauseDeviceDriverOnNewData = EFalse;

	SoundDeviceError(KErrNone);//cancel the players

	}

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::Print(_L("RMdaDevSound::CBody::CancelRecordData:"));

    #endif

	iRecordSoundDevice.CancelRecordData();

	SoundDeviceError(KErrNone);

	}

void RMdaDevSound::CBody::FlushRecordBuffer()

	{

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

    #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

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

    #endif

	if(iState == ERecording)

	    {

		iRecordSoundDevice.Pause();//this is equivalent call in the new sound driver

    	}

	}

TInt RMdaDevSound::CBody::BytesPlayed()

	{

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

	TInt currentBytesPlayed = 0;

#ifdef SYMBIAN_SOUNDADAPTER_BYTESPLAYED

	if(iTimerActive)

		{

		TUint32 endTime = User::FastCounter();

		TUint timePlayed = 0;

		if(endTime<iStartTime)

			{

			timePlayed = (KMaxTUint32-iStartTime)+endTime;

			}

		else

			{

			timePlayed = endTime-iStartTime;

			}	

		TUint32 bytesPlayed = (timePlayed*iPlayData.iSampleRate*KBytesPerSample)/iFCFrequency;

		currentBytesPlayed = iBytesPlayed+bytesPlayed;

        #ifdef SYMBIAN_SOUNDADAPTER_DEBUG

            RDebug::Printf("EstimatedBytesPlayed[%d]  Driver's bytesPlayed[%d]", currentBytesPlayed, iBytesPlayed);

        #endif

		}

	else

		{

		currentBytesPlayed = iPlaySoundDevice.BytesTransferred();

		}		

#else

	currentBytesPlayed = iPlaySoundDevice.BytesTransferred();

#endif

	if (iPlayData.iConverter)

		{

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

		if (iPlayData.iActualChannels != iPlayData.iRequestedChannels)

			{

			if (iPlayData.iActualChannels == 2)

				{

				// requested was mono, we have stereo

				currentBytesPlayed /= 2;

				}

			else 

				{

				// requested was stereo, we have mono

				currentBytesPlayed *= 2;

				}

			}

		if (iPlayData.iSampleRate != iPlayData.iActualRate)

			{

			currentBytesPlayed = TInt(currentBytesPlayed*

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

			}

		}

	return currentBytesPlayed;

	}

void RMdaDevSound::CBody::ResetBytesPlayed()

	{

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

	return iPlaySoundDevice.ResetBytesTransferred();

	}

void RMdaDevSound::CBody::PausePlayBuffer()

	{

	if (iState == EPlaying)

		{

        #ifdef SYMBIAN_SOUNDADAPTER_DEBUG   

            RDebug::Print(_L("RMdaDevSound::CBody::PausePlayBuffer() offset = %d length = %d"), iBufferOffset, iBufferLength);

        #endif

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

		// If iPlayerStatus is NULL, we're not playing currently any data, and the device driver won't pause properly. In this case,

		// we set a reminder to ourselves to pause the driver once we have data later

		if (iPlayerStatus == NULL)

			{

			iPauseDeviceDriverOnNewData = ETrue;

			}

		else

			{

			TInt res = iPlaySoundDevice.Pause();

			#ifdef SYMBIAN_SOUNDADAPTER_DEBUG   

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

			#endif

			(void)res;

			}

		iState = EPaused;

		iTimerActive = EFalse;

		}		

	}

void RMdaDevSound::CBody::ResumePlaying()

	{

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

	iPauseDeviceDriverOnNewData = EFalse;

	#ifdef SYMBIAN_SOUNDADAPTER_DEBUG   

		RDebug::Printf("RMdaDevSound::CBody::ResumePlaying");

	#endif	

	if (iFlushCalledDuringPause)

		{

		// if we resume having called flush, we can't just keep going as the driver does not work

		// that way. Instead we cancel so that buffer play completes and a new buffer will be passed

		iFlushCalledDuringPause = EFalse;

		PlayCancelled();

		}

	else

		{

		iState = EPlaying;

		iPlaySoundDevice.Resume();

		}

	}

void RMdaDevSound::CBody::PauseRecordBuffer()

	{

	if(iState == ERecording)

	    {	

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

        #ifdef SYMBIAN_SOUNDADAPTER_DEBUG	

            RDebug::Printf("RMdaDevSound::CBody::PauseRecordBuffer");

        #endif

		iRecordSoundDevice.Pause();

	    }

	}

void RMdaDevSound::CBody::ResumeRecording()

	{

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

	iRecordSoundDevice.Resume();

	}

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

	{

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

	TTimeIntervalMicroSecondsBuf aTimePlayedBuf;

	TInt err;

	err = iPlaySoundDevice.TimePlayed(aTimePlayedBuf);

	if (err == KErrNone)

	  {

	    aTimePlayed = aTimePlayedBuf();

	  }

	return err;

	}

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;

	}

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

	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)

		{

		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)