// Copyright (c) 2006-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 "cdevaudiocontrol.h"

#include <a3f/audioprocessingunittypeuids.h>

#include <mmf/server/mmfswcodecwrappercustominterfacesuids.hrh>

#include <a3f/maudiocontext.h>

#include <a3f/maudiostream.h>

#include <a3f/maudiocodec.h>

#include <a3f/maudiogaincontrol.h>

const TInt KMicroSecondsInSecond = 1000000;

const TInt KDefaultBufferSize = 4096;

const TUint KMaxCallbacksExpected = 2;

const TUint KDefaultSampleRate = 8000;

const TUid KDefaultMode = {KA3FModeMonoValue};

class TSampleRateTableEntry

	{

public:

	TInt		iSampleRateValue;

	TMMFSampleRate iSampleRate;

	};

const TSampleRateTableEntry KRateTableLookup[] = { 

							{ 8000, EMMFSampleRate8000Hz },

							{ 11025, EMMFSampleRate11025Hz },

							{ 12000, EMMFSampleRate12000Hz },

							{ 16000, EMMFSampleRate16000Hz },

							{ 22050, EMMFSampleRate22050Hz },

							{ 24000, EMMFSampleRate24000Hz },

							{ 32000, EMMFSampleRate32000Hz },

							{ 44100, EMMFSampleRate44100Hz },

							{ 48000, EMMFSampleRate48000Hz },

							{ 64000, EMMFSampleRate64000Hz },

							{ 88200, EMMFSampleRate88200Hz },

							{ 96000, EMMFSampleRate96000Hz },

						};

const TInt KMaxSampleRateIndex = 11; // must agree with length of table

class TAudioModeTableEntry

	{

public:

	TMMFMonoStereo	iAudioModeValue;

	TUid			iAudioMode;

	};

const TAudioModeTableEntry KModeTableLookup[] = {

							{ EMMFMono, {KA3FModeMonoValue} },

							{ EMMFStereo, {KA3FModeStereoNonInterleavedValue} },

							};

const TInt KMaxModeIndex = 1; // must agree with length of table

// ---------------------------------------------------------------------------

// Default constructor

// ---------------------------------------------------------------------------

//

CDevAudioControl::CDevAudioControl()

	{

	TRACE_CREATE();

	DP_CONTEXT(CDevAudioControl::CDevAudioControl *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	// Local cache default values

	iCurrentSampleRate = KDefaultSampleRate;

	iCurrentMode = KDefaultMode; 

	iOutstandingCallbacks = KMaxCallbacksExpected; //by default we expect 2 callbacks for capabilities.

	iCallbackFromAdaptor = KCallbackNone;

	DP_OUT();

	}

void CDevAudioControl::ConstructL(CDevAudio* aDevAudio, MDevSoundAdaptationObserver& aDevSoundObserver)

	{

	TRACE_CREATE();

	DP_CONTEXT(CDevAudioControl::ConstructL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iDevAudio = aDevAudio; 

	iAdaptationObserver = &aDevSoundObserver;

	iObserverRegistered = EFalse;

	TAudioChannelGain left;

	TAudioChannelGain right;

	left.iLocation = TAudioChannelGain::ELeft;

	right.iLocation = TAudioChannelGain::ERight;

	User::LeaveIfError(iChannelGains.Append(left)); // assumed element 0 in rest of code

	User::LeaveIfError(iChannelGains.Append(right)); // assumed element 1 in rest of code

	// Note this could be delayed now (volume is internal to adaptor until later in cycle)

	// Needed to allow CMMFDevSound::MaxVolume and similar calls before CMMFDevSound::InitializeL

	TAny* interface(NULL);

	interface = iDevAudio->iGainControl->Interface(KUidAudioGainControl);

	iGainControl = static_cast<MAudioGainControl*>(interface);

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CDevAudioControl::~CDevAudioControl()

	{

	DP_CONTEXT(CDevAudioControl::~CDevAudioControl *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iChannelGains.Close();

	iSupportedRates.Close();

	iSupportedModes.Close();

	DP_OUT();

	}

// -----------------------------------------------------------------------------

// CacheAudioCodecIf

//

TInt CDevAudioControl::CacheAudioCodecIf()

	{

	DP_CONTEXT(CDevAudioControl::CacheAudioCodecIf *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	if (iDevAudio->iAudioCodec==NULL)

		{

		DP0_RET(KErrNotReady,"%d");

		}

	TInt err = KErrNone;

	if (iAudioCodecIf==NULL)

		{

		MAudioCodec* codecInterface = static_cast<MAudioCodec*>(iDevAudio->iAudioCodec->Interface(KUidAudioCodec));

		__ASSERT_ALWAYS (codecInterface, CDevAudioControl::Panic(EAudioCodecIsNull));

		iAudioCodecIf = codecInterface; 

		}

	DP0_RET(err,"%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::Initialize

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::Initialize(TUid /*aFormat*/)

	{

	DP_CONTEXT(CDevAudioControl::Initialize *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(EFalse);

	iObserverRegistered = EFalse;

	DP0_RET(KErrNone,"%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::Uninitialize

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::Uninitialize()

	{

	DP_CONTEXT(CDevAudioControl::Uninitialize *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	// Remove pUnits only allowed when stream is uninitialized

	TInt err = iDevAudio->iAudioStream->Uninitialize();

	if (err == KErrNone)

		{

		iDevAudio->iActiveState = EDevSoundAdaptorUninitialising;

		err = iDevAudio->iAudioContext->Commit();

		}

	DP0_RET(err,"%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::Unload

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::Unload()

	{

	DP_CONTEXT(CDevAudioControl::Unload *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err = iDevAudio->iAudioStream->Unload();

	if (err == KErrNone)

		{

		err = iDevAudio->iAudioContext->Commit();

		}

	if (err == KErrNone)

		{

		iDevAudio->iActiveState = EDevSoundAdaptorUnloading;

		}

	DP0_RET(err,"%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::GetCapabilities

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::GetCapabilities(TMMFCapabilities& aCap)

	{

	DP_CONTEXT(CDevAudioControl::GetCapabilities *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	// At this phase of CAP, we only care about current codec capabilities. 

	// This will be supported as soon as the A3F API changes to support this are ready

	TInt err = KErrNone;

	if (iDevAudio->iActiveState != EDevSoundAdaptorCreated_Uninitialised)

		{

		err = CacheAudioCodecIf();

		if (err != KErrNone)

			{

			DP0_RET(err, "%d");			

			}

		if (err == KErrNone)

			{

			err = iAudioCodecIf->GetSupportedModes(iSupportedModes);

			if (err == KErrNone)

				{

				aCap.iChannels = GetModes(iSupportedModes);

				err = iAudioCodecIf->GetSupportedSamplesRates(iSupportedRates);

				if (err == KErrNone)

					{

					aCap.iRate = GetSampleRates(iSupportedRates);

					}

				else

					{

					//If was a problem getting sampleRates we don´t expect callbacks and return

					iOutstandingCallbacks = 0;

					}

				}

			else

				{

				//If was a problem getting modes we don´t expect callbacks and return

				iOutstandingCallbacks = 0;

				}

			}

		}

	else

		{

		err = KErrNotReady;

		}

	DP0_RET(err, "%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::GetConfig

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::GetConfig(TMMFCapabilities& aConfig)

	{

	DP_CONTEXT(CDevAudioControl::GetConfig *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	//TODO add a return error code if the sample rate or the channels are not found

	//We need to transform the local values to a supported value for the client

	aConfig.iRate = static_cast<TMMFSampleRate>(GetSampleRate(iCurrentSampleRate));

	aConfig.iChannels = static_cast<TMMFMonoStereo>(GetMode(iCurrentMode));

	aConfig.iBufferSize = KDefaultBufferSize;

	DP2(DLINFO, "rate 0x%x, channels 0x%x", aConfig.iRate, aConfig.iChannels);

	DP0_RET(err, "%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::SetConfig

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::SetConfig(const TMMFCapabilities& aConfig)

	{

	DP_CONTEXT(CDevAudioControl::SetConfig *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	// TODO need to ensure if iChannels or iSampleRate is outside known values, then

	// the code handles that gracefully and returns the appropriate error code

	TInt err(KErrNone);

	TUid mode = KNullUid;

	//Reset the desired values

	iDesiredSampleRate = 0;

	iDesiredMode = KNullUid;

	err = ResolveMode(aConfig.iChannels, mode);

	if (err != KErrNone)

		{

		DP0_RET(err, "%d");

		}

	err = ResolveSampleRate(aConfig.iRate, iDesiredSampleRate);

	if (err != KErrNone)

		{

		DP0_RET(err, "%d");

		}

	// At this phase of CAP, we only care about codec, which checks config against

	// its own capabilities. Verification against stream specific capabilities

	// should be added later on.

	err = CacheAudioCodecIf();

	if (err != KErrNone)

		{

		DP0_RET(err, "%d");

		}

	err = iAudioCodecIf->SetSampleRate(iDesiredSampleRate);

	if(err == KErrNone)

		{

		err = iAudioCodecIf->SetMode(mode);

		}

	if(err == KErrNone)

		{

		err = iDevAudio->iAudioContext->Commit();

		if (err == KErrNone)

			{

			iDesiredMode = mode;

			}

		}

	DP0_RET(err, "%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::ProcessInit

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::ProcessInit()

	{

	DP_CONTEXT(CDevAudioControl::ProcessInit *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(EFalse);

	DP0_RET(KErrNone,"%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::ProcessData

// -----------------------------------------------------------------------------

//

void CDevAudioControl::ProcessData()

	{

	DP_CONTEXT(CDevAudioControl::ProcessData *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(EFalse);

	DP_OUT();

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::GetSamples

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::GetSamples()

	{

	DP_CONTEXT(CDevAudioControl::GetSamples *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	TInt samplesplayed(0);

	TTimeIntervalMicroSeconds timeProcessed(0);

	err = iDevAudio->iAudioStream->GetStreamTime(timeProcessed);

	DP1(DLINFO,"CDevAudioControl::GetSamples iCurrentSampleRate %d",iCurrentSampleRate);

	if(err == KErrNone)

		{

		samplesplayed = (timeProcessed.Int64() * iCurrentSampleRate + KMicroSecondsInSecond/2) / TInt64(KMicroSecondsInSecond);

		}

	//TODO manage the error

	DP0_RET(samplesplayed, "%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::Stop

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::Stop()

	{

	DP_CONTEXT(CDevAudioControl::Stop *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(EFalse);

	DP0_RET(KErrNone, "%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::Pause

// -----------------------------------------------------------------------------

//

TInt CDevAudioControl::Pause()

	{

	DP_CONTEXT(CDevAudioControl::Pause *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(EFalse);

	DP0_RET(KErrNone, "%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::CustomInterface

// -----------------------------------------------------------------------------

//

TAny* CDevAudioControl::CustomInterface(TUid aInterfaceId)

	{

	DP_CONTEXT(CDevAudioControl::CustomInterface *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TAny* ciPtr(NULL);

	TInt err = KErrNone;

	if(iDevAudio->iAudioStream)

		{

		TAny* ptr = iDevAudio->iAudioStream->Interface(KUidExtensionInferface);

		if(ptr)

			{

			MCustomInterfaceSupport* ciSupport  = static_cast<MCustomInterfaceSupport*>(ptr);

			if(!iObserverRegistered)

				{

				err = ciSupport->RegisterObserver(*this);

				if(err == KErrNone)

					{

					iObserverRegistered = ETrue;

					}

				}

			err = ciSupport->RequestCustomInterface(aInterfaceId, ciPtr);

			if( err != KErrNone)

				{

				ciPtr = NULL;

				}

			}

		}

	DP0_RET(ciPtr, "0x%x");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::SetGain

// -----------------------------------------------------------------------------

TInt CDevAudioControl::SetGains(TInt aDevSoundGain, TInt aDevSoundMaxGain, TInt aBalance[2], const TTimeIntervalMicroSeconds& aRampDuration, TBool aBecomingActive)

	{

	DP_CONTEXT(CDevAudioControl::SetGains *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(aDevSoundGain>=0 && aDevSoundGain<=aDevSoundMaxGain); // higher layer assumed to scale

	ASSERT(aBalance[ELeftCh]>=0 && aBalance[ELeftCh]<=100);

	ASSERT(aBalance[ERightCh]>=0 && aBalance[ERightCh]<=100);

	ASSERT(aDevSoundMaxGain>0); // assumed max gain is positive

	TInt a3fMaxGain;

	TInt err = iGainControl->GetMaxGain(a3fMaxGain);

	if (err==KErrNone)

		{

		iLegacyGain = TInt(TReal(aDevSoundGain)*TReal(a3fMaxGain)/TReal(aDevSoundMaxGain)+0.5);

		ASSERT(iLegacyGain>=0 && iLegacyGain<=a3fMaxGain);

		iLegacyLeft = aBalance[ELeftCh];

		iLegacyRight = aBalance[ERightCh];

		MapGains();

		// VolumeRamp is only applied when DevSound is becoming active

		if(err == KErrNone)

			{

			if (aRampDuration > 0 && aBecomingActive)

				{

				err = iGainControl->SetGain(iChannelGains, KUidGainSawTooth, aRampDuration);

				}

			else

				{

				err = iGainControl->SetGain(iChannelGains);

				}

			}

		// This call will result on commit only when we are already active

		// otherwise the changes will be commited by the DevAudioControl 

		// It means we're here due to RequestGainAndBalance call

		if(err == KErrNone && !aBecomingActive)

			{

			err = iDevAudio->iAudioContext->Commit();

			}		

		}

	DP0_RET(err,"%d");

	}

// -----------------------------------------------------------------------------

// CDevAudioControl::MapAndSetGains

// -----------------------------------------------------------------------------

//

void CDevAudioControl::MapGains()

	{

	DP_CONTEXT(CDevAudioControl::MapGains *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	// Map legacy values to CAP channel array.

	if ( iLegacyLeft == iLegacyRight )

		{

		iChannelGains[ELeftCh].iGain = iLegacyGain;

		iChannelGains[ERightCh].iGain = iLegacyGain;

		}

	else if ( iLegacyLeft > iLegacyRight )

		{

		iChannelGains[ELeftCh].iGain = iLegacyGain;

		iChannelGains[ERightCh].iGain =

						static_cast<TUint>((iLegacyGain*iLegacyRight)/iLegacyLeft);

		}

	else

		{

		iChannelGains[ERightCh].iGain = iLegacyGain;

		iChannelGains[ELeftCh].iGain =

						static_cast<TUint>((iLegacyGain*iLegacyLeft)/iLegacyRight);

		}

	DP_OUT();

	}