// Copyright (c) 2002-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 <mmf/server/mmfformat.h>

#include <mmf/server/mmfclip.h>

#include <mdaaudiosampleeditor.h>

#include <mmfcontrollerimplementationuids.hrh>

#include <mmf/common/mmffourcc.h>

#include <mmf/common/mmfpaniccodes.h>

#include "MmfAudioController.h"

#include <mmf/server/mmffile.h>

#include <mmf/server/mmfformatstandardcustominterfaces.h>

#include <mmf/server/devsoundstandardcustominterfaces.h>

#include <mmf/server/mmfdatapath2.h>

const TUint KSampleRate8000Hz = 8000;

const TUint KSampleRate11025Hz = 11025;

const TUint KSampleRate12000Hz = 12000;

const TUint KSampleRate16000Hz = 16000;

const TUint KSampleRate22050Hz = 22050;

const TUint KSampleRate24000Hz = 24000;

const TUint KSampleRate32000Hz = 32000;

const TUint KSampleRate44100Hz = 44100;

const TUint KSampleRate48000Hz = 48000;

const TUint KSampleRate64000Hz = 64000;

const TUint KSampleRate88200Hz = 88200;

const TUint KSampleRate96000Hz = 96000;

const TUint KNumChannelsMono = 1;

const TUint KNumChannelsStereo = 2;

/*

 TMmfAudioControllerPanics is an enumeration with the following entries:

 EBadArgument indicates a bad argument

 EBadState indicates a state viaolation

 EBadInvariant indicates an invariant violation

 EBadReset indicates failed reset

 EPostConditionViolation indicates a post condition violation

*/

enum TMmfAudioControllerPanics

	{

	EBadArgument,

	EBadState,

	EBadInvariant,

	EBadReset,

	EPostConditionViolation,

	EStateNotConstructed,

	EBadStateToGetDataSource,

	ENoAudioInput,

	EBadStateToGetDataSink,

	ENoAudioOutput,

	EBadStateForPrime,

	ENoDataSource,

	ENoDataSink,

	EStateNotPrimed,

	EBadResetState,

	EBadStateToReset,

	EStateNotReadyToPlay,

	EBadPlayState,

	EBadPauseState,

	EBadStateToPause,

	EBadStateToStop,

	EBadStopState,

	EBadStateToPosition,

	EBadStatePosition,

	EBadStateToSetPosition,

	EBadStateSetPosition,

	EBadStateToDuration,

	EBadStateDuration,

	EBadStateToGetNumberOfMetaDataEntries,

	EBadStateGetNumberOfMetaDataEntries,

	EBadStateToGetMetaDataEntries,

	EBadStateGetMetaDataEntries,

	EMetaEntryIsNull,

	ENotReadyForDataSourceRemoval,

	EBadDataSourceRemoval,

	ENotReadyForDataSinkRemoval,

	EBadDataSinkRemoval,

	ENotReadyForCustomCommand,

	EBadStateAfterNegotiate,

	EBadStateToNegotiate,

	EBadStateToSetPriority,

	EBadPriorityState,

	EBadStateToSendEventToClient,

	EBadStateAfterSendEventToClient,

	EBadStateToSetVolume,

	EBadStateAfterVolumeSet,

	EBadStateToGetMaxVolume,

	EBadStateAfterGetMaxVolume,

	EBadStateToGetVolume,

	EBadStateAfterGetVolume,

	EBadStateToSetVolumeRamp,

	EBadStateAfterSetVolumeRamp,

	EBadStateToSetBalance,

	EBadStateAfterSetBalance,

	EBadStateToGetBalance,

	EBadStateAfterGetBalance,

	EBadStateToSetGain,

	EBadStateAfterGainSet,

	EBadStateToGetMaxGain,

	EBadStateAfterGetMaxGain,

	EBadStateToGetGain,

	EBadStateAfterGetGain,

	EBadStateToGetRecordTimeAvailable,

	EBadStateAfterGetRecordTimeAvailable,

	ENoMemoryToRecord,

	EBadStateToGetMaxFileSize,

	EBadStateAfterGetMaxFileSize,

	EBadStateToCrop,

	EBadStateAfterCrop,

	EBadStateToAddMetaDataEntry,

	EBadStateAfterAddMetaDataEntry,

	EBadStateToRemoveMetaDataEntry,

	EBadStateAfterRemoveMetaDataEntry,

	EBadStateToReplaceMetaDataEntry,

	EBadStateAfterReplaceMetaDataEntry,

	EBadStateToSetSourceSampleRate,

	EBadStateAfterSetSourceSampleRate,

	EBadStateToSetSourceNumChannels,

	EBadStateAfterSetSourceNumChannels,

	EBadStateToSetSourceFormat,

	EBadStateAfterSetSourceFormat,

	EBadStateToSetSinkSampleRate,

	EBadStateAfterSetSinkSampleRate,

	EBadStateToSetSinkNumChannels,

	EBadStateAfterSetSinkNumChannels,

	EBadStateToSetSinkFormat,

	EBadStateAfterSetSinkFormat,

	EBadStateToSetCodec,

	EBadStateAfterSetCodec,

	EBadStateToSetSourceBitRate,

	EBadStateAfterSetSourceBitRate,

	EBadStateToSetSinkBitRate,

	EBadStateAfterSetSinkBitRate,

	ESetRateIsNotSameAsBitRate,

	EBadStateToGetSourceSampleRate,

	EBadStateAfterGetSourceSampleRate,

	EBadStateToGetSourceBitRate,

	EBadStateAfterGetSourceBitRate,

	EBadStateToGetSourceNumChannels,

	EBadStateAfterGetSourceNumChannels,

	EBadStateToGetSourceFormat,

	EBadStateAfterGetSourceFormat,

	EInvalidState,

	EBadStateToRegisterAsClient,

	EBadStateAfterRegisterAsClient,

	EBadStateToCancelRegisterAsClient,

	EBadStateAfterCancelRegisterAsClient,

	EBadStateToGetResourceNotificationData,

	EBadStateAfterGetResourceNotificationData,

	EBadStateToResumePlay,

	EBadStateAfterResumePlay,

	};

/**

This method generates a panic

@param aPanicCode

*/

void Panic(TInt aPanicCode)

	{

	_LIT(KMMFAudioControllerPanicCategory, "MMFAudioController");

	User::Panic(KMMFAudioControllerPanicCategory, aPanicCode);

	}

/**

 * Static NewL

 *

 * @return CMMFAudioController*

 */

CMMFController* CMMFAudioController::NewL()

	{

	CMMFAudioController* self = new(ELeave) CMMFAudioController;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop( self );

	return STATIC_CAST( CMMFController*, self );

	}

/**

* ConstructL 

* 

*/

void CMMFAudioController::ConstructL()

	{

	iDataSource         = NULL;

	iDataSink           = NULL;

	iDataPath           = CMMFDataPath2::NewL(iMediaId, *this);

	iSourceFormat       = NULL;

	iSinkFormat         = NULL;

	iSourceAndSinkAdded = EFalse;

	iStoppingRecording  = EFalse;

	//iMediaId has already been set up 

	SetState( EStopped );

	//iPrioritySettings  not initialised because they are held by the controller framework

	// Construct custom command parsers

	CMMFAudioPlayDeviceCustomCommandParser* audPlayDevParser = CMMFAudioPlayDeviceCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audPlayDevParser);

	AddCustomCommandParserL(*audPlayDevParser);

	CleanupStack::Pop( audPlayDevParser );

	CMMFAudioRecordDeviceCustomCommandParser* audRecDevParser = CMMFAudioRecordDeviceCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audRecDevParser);

	AddCustomCommandParserL(*audRecDevParser);

	CleanupStack::Pop(audRecDevParser);

	CMMFAudioPlayControllerCustomCommandParser* audPlayConParser = CMMFAudioPlayControllerCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audPlayConParser);

	AddCustomCommandParserL(*audPlayConParser);

	CleanupStack::Pop(audPlayConParser);

	CMMFAudioRecordControllerCustomCommandParser* audRecConParser = CMMFAudioRecordControllerCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audRecConParser);

	AddCustomCommandParserL(*audRecConParser);

	CleanupStack::Pop(audRecConParser);

	CMMFAudioControllerCustomCommandParser* audConParser = CMMFAudioControllerCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audConParser);

	AddCustomCommandParserL(*audConParser);

	CleanupStack::Pop(audConParser);

	CMMFDRMCustomCommandParser* drmParser = CMMFDRMCustomCommandParser::NewL(*this);

	CleanupStack::PushL(drmParser);

	AddCustomCommandParserL(*drmParser);

	CleanupStack::Pop(drmParser);

	CMMFResourceNotificationCustomCommandParser* NotiParser = CMMFResourceNotificationCustomCommandParser::NewL(*this);

	CleanupStack::PushL(NotiParser);

	AddCustomCommandParserL(*NotiParser);

	CleanupStack::Pop(NotiParser);//audio resource Notification Parser

	CMMFAudioPlayControllerSetRepeatsCustomCommandParser* audPlayConSetRepeatsParser = CMMFAudioPlayControllerSetRepeatsCustomCommandParser::NewL(*this);

	CleanupStack::PushL(audPlayConSetRepeatsParser);

	AddCustomCommandParserL(*audPlayConSetRepeatsParser);

	CleanupStack::Pop(audPlayConSetRepeatsParser);

	// [ assert the invariant now that we are constructed ]

	__ASSERT_ALWAYS( Invariant(), Panic( EStateNotConstructed));

	}

/**

*

* CMMFAudioController

*

*/

CMMFAudioController::CMMFAudioController() 

	: iMediaId(KUidMediaTypeAudio),

	  iDisableAutoIntent(EFalse),

	  iState(EStopped)

	{

	}

/**

*

* ~CMMFAudioController

*

*/

CMMFAudioController::~CMMFAudioController()

	{

	// [ ensure we have logged off the thread ]

	if( iDataPath ) 	

		{

		iDataPath->ResetL();	// this does not leave

		}

	delete iDataPath;

	delete iSourceFormat;

	delete iSinkFormat;

	delete iStoppingMessage;

	}

/**

 *  AddDataSourceL

 *

 *	Adds a data source to the controller

 *

 *	@param aSource

 * Preconditions:

 * We are stopped

 * Source does not already exist

 * Postconditions:

 * iDataSource != NULL

 * iDataSourceAdded == ETrue

 */

void CMMFAudioController::AddDataSourceL(MDataSource& aSource)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateToGetDataSource));

	// [ precondition that the controller is stopped ]

    if( State() != EStopped )

		User::Leave( KErrNotReady );

	//[ precondition iData source is not already configured ]

	if (iDataSource)

		User::Leave(KErrAlreadyExists);

	// Note that this code is not generic for sources

	// It it only checks for file, des clips and audio inputs

	// If a new source type eg a Url Clip then this needs to be added to the supported source Uids

	if ( SourceFormatRequired( aSource) ) 

		{

		// Get the format from the Source if possible from no specific supplier

		TRAPD(err, iSourceFormat = CMMFFormatDecode::NewL(&aSource, KNullDesC, iSourceFormatSupportsCustomInterfaces));

		//[ we want to complete silently for KErrNotSupported

		// because there is a possibility that the client

		// wants to add the data format later, see audio api for

		// a description of this feature]

		if ((err != KErrNotSupported) && (err != KErrNone))

			{

			User::Leave(err);

			}

		}

	else if (aSource.DataSourceType()==KUidMmfAudioInput)

		{

		//[ ensure that the audio input has a pointer to dev sound ]

		CMMFAudioInput* audioInput = STATIC_CAST(CMMFAudioInput*, &aSource);

		__ASSERT_ALWAYS( audioInput, Panic(ENoAudioInput));

		// [ lets load dev sound ]

		User::LeaveIfError(audioInput->SourceThreadLogon( *this ));

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	//[ its now safe to set the source ]

	iDataSource = &aSource ;

	//[ assert the post condition ]

	__ASSERT_ALWAYS(iDataSource, Panic(EMMFAudioControllerPanicDataSourceDoesNotExist));

	iDataSource->SetSourcePrioritySettings(iPrioritySettings);

	}

/**

 *  AddDataSinkL

 *

 *	Adds a data sink to the controller

 *

 *	@param aSink

 *

 */

void CMMFAudioController::AddDataSinkL(MDataSink& aSink)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateToGetDataSink));

	// [ precondition that the controller is stopped ]

    if( State() != EStopped )

		User::Leave( KErrNotReady );

	// [ assert precondition that sink does not exist ]

	if (iDataSink)

		User::Leave(KErrAlreadyExists);

	// Note that this code is not generic for sinks

	// It it only checks for file,des clips and audio outputs

	// If a new sink type eg a Url Clip then this needs to be added to the supported source Uids

	if ( SinkFormatRequired( aSink ) )

		{//the sink is a clip

		// Get the format from the Sink if possible from no specific supplier

		TRAPD(err, iSinkFormat = CMMFFormatEncode::NewL(&aSink, KNullDesC));

		//[ we want to complete silently for KErrNotSupported

		// because there is a possibility that the client

		// wants to add the data format later, see audio api for

		// a description of this feature]

		if ((err != KErrNotSupported) && (err != KErrNone))

			{

			User::Leave(err);

			}

		}

	else if (aSink.DataSinkType()==KUidMmfAudioOutput)

		{

		//[ ensure that the audio output has a pointer to dev sound ]

		CMMFAudioOutput* audioOutput = STATIC_CAST(CMMFAudioOutput*, &aSink);

		__ASSERT_ALWAYS( audioOutput, Panic(ENoAudioOutput));

		// [ lets load dev sound ]

		User::LeaveIfError(audioOutput->SinkThreadLogon( *this ));

		if (IsSecureDrmModeL())

    		{

    		User::LeaveIfError(audioOutput->SoundDevice().SetClientThreadInfo(ClientThreadIdL()));

    		} 

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	//[ now that we are sure we have not left we can update the sink

	// transactionally ]

	iDataSink = &aSink;

	// [ assert post conditions that a sink has been added ]

	__ASSERT_ALWAYS(iDataSink, Panic(EMMFAudioControllerPanicDataSinkDoesNotExist));

	iDataSink->SetSinkPrioritySettings(iPrioritySettings);

	}

/**

 *  PrimeL

 *

 *  If Prime fails the client should reset the controller

 *  because as noted below this code is not transactional.

 *

 */

void CMMFAudioController::PrimeL()

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadStateForPrime));

	//[ assert the precondition ( in a friendly way for this api 

	// that we are either stopped or primed already ]

	if(!(( State() == EStopped ) || (State() == EPrimed )))

		User::Leave( KErrNotReady );

	// [ precondition we have a data source & sink ]

	__ASSERT_ALWAYS( iDataSource, Panic( ENoDataSource));

	__ASSERT_ALWAYS( iDataSink, Panic( ENoDataSink));

	//[ precondition that we need a source format ]

	if ( SourceFormatRequired(*iDataSource) && !(iSourceFormat))

		User::Leave( KErrNotSupported );

	// [ check the precondition if we need a data sink format ]

	if ( SinkFormatRequired(*iDataSink) && !( iSinkFormat ))

		{

		User::Leave( KErrNotSupported );

		}

	// [ ideally this code should be transaction based and

	//   if failure occurs we roll back to the previous state

	// in the code below this is not the case and the controller

	// can be left in an unstable state should any part of prime fail]

	if (iState == EStopped)

		{ //datapath propagates prime to sink & source

		NegotiateL();

		if (!iSourceAndSinkAdded)

			{

			//add data source and sinks to datapath - Note cant do this in AddDataSource/Sink

			//because the sources and sinks aren't configured at this point

			if (iSourceFormat)

				iDataPath->AddDataSourceL(iSourceFormat);

			else if (iDataSource)

				iDataPath->AddDataSourceL(iDataSource);

			if (iSinkFormat)

				iDataPath->AddDataSinkL(iSinkFormat);

			else if (iDataSink)

				iDataPath->AddDataSinkL(iDataSink);

			iSourceAndSinkAdded = ETrue ;

			}

		iDataPath->PrimeL();

		if (iSourceFormat)

			{

			//in case of imaadpcm format set the output block length

			TFourCC sourceFourCC = iSourceFormat->SourceDataTypeCode(TMediaId(KUidMediaTypeAudio));

			if ((sourceFourCC == KMMFFourCCCodeIMAD) && iSourceFormatSupportsCustomInterfaces)

				{

				CMMFFormatDecode2* decode2 = static_cast<CMMFFormatDecode2*>(iSourceFormat);

				MMMFDecodeCustomInterfaceBlockLength* formatBlockLengthCI = static_cast<MMMFDecodeCustomInterfaceBlockLength*>(decode2->CustomInterface(KUidCustomInterfaceMmfDecodeBlockLength));

				if (formatBlockLengthCI)

					{

					TInt blockLength = formatBlockLengthCI->FileBlockLength();

					TInt err = iDataPath->SetBlockLength(blockLength);

					if ((err != KErrNone) && (iDataSink))

						{

						MMMFAudioOutput* audioOutput = static_cast<MMMFAudioOutput*>(iDataSink);

						MMMFDevSoundCustomInterfaceFileBlockLength* fileBlockLengthCI = static_cast<MMMFDevSoundCustomInterfaceFileBlockLength*>(audioOutput->SoundDevice().CustomInterface(KUidCustomInterfaceDevSoundFileBlockLength));

						if (fileBlockLengthCI)

							{

							fileBlockLengthCI->SetFileBlockLength(blockLength);

							err = KErrNone;

							}

						}

					User::LeaveIfError(err);

					}

				}

			}

		if ((iSinkFormat) && (!iSourceFormat))

			{//we are recording to a clip so the data path position is the sink

			//need to set datapath position to end of format pos (incase sink clip already exists

			TTimeIntervalMicroSeconds duration = iSinkFormat->Duration(iMediaId);

			if (duration != TTimeIntervalMicroSeconds(0))

				{//the file already exists and has a duration so set data path position to the end of the file

				iDataPath->SetPositionL(duration);

				}

			}

		//[ it is now safe to make the transition to primed ]

		SetState( EPrimed );		

		}

	else if (State() == EPrimed)

		{ //controller is already primed so just pass prime onto DP

		iDataPath->PrimeL();

		}

	if (iDataSource->DataSourceType()==KUidMmfFileSource)

		{

		CMMFFile* file = static_cast<CMMFFile*>(iDataSource);

		// we only support protected files for playback