// Copyright (c) 2003-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 <mmf/plugin/mmfcontrollerimplementationuids.hrh>

#include <mmf/common/mmffourcc.h>

#include <mmf/common/mmfpaniccodes.h>

#include "TestUseOldCodecAudioController.h"

const TUint KSampleRate8000Hz = 8000;

const TUint KSampleRate11025Hz = 11025;

const TUint KSampleRate16000Hz = 16000;

const TUint KSampleRate22050Hz = 22050;

const TUint KSampleRate32000Hz = 32000;

const TUint KSampleRate44100Hz = 44100;

const TUint KSampleRate48000Hz = 48000;

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

	};

/**

* Panic

* This method generates a panic

* @param "TInt"

* @xxxx

*/

void Panic(TInt aPanicCode)

	{

	_LIT(KMMFAudioControllerPanicCategory, "MMFAudioController");

	User::Panic(KMMFAudioControllerPanicCategory, aPanicCode);

	}

/**

 * Static NewL

 *

 * @return CMMFTestUseOldCodecAudioController*

 */

CMMFController* CMMFTestUseOldCodecAudioController::NewL()

	{

	CMMFTestUseOldCodecAudioController* self = new(ELeave) CMMFTestUseOldCodecAudioController;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop( self );

	return STATIC_CAST( CMMFController*, self );

	}

/**

* ConstructL 

* 

* @xxxx

*/

void CMMFTestUseOldCodecAudioController::ConstructL()

	{

	iDataSource         = NULL;

	iDataSink           = NULL;

	iDataPath           = CMMFDataPath::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 );//audPlayDevParser

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

	CleanupStack::PushL(audRecDevParser);

	AddCustomCommandParserL(*audRecDevParser);

	CleanupStack::Pop(audRecDevParser);//audRecDevParser

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

	CleanupStack::PushL(audPlayConParser);

	AddCustomCommandParserL(*audPlayConParser);

	CleanupStack::Pop(audPlayConParser);//audPlayConParser

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

	CleanupStack::PushL(audRecConParser);

	AddCustomCommandParserL(*audRecConParser);

	CleanupStack::Pop(audRecConParser);//audRecParser

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

	CleanupStack::PushL(audConParser);

	AddCustomCommandParserL(*audConParser);

	CleanupStack::Pop(audConParser);//audConParser

	iWaitForAsyncService = new (ELeave) CActiveSchedulerWait;

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

	__ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));

	}

/**

*

* CMMFTestUseOldCodecAudioController

*

*/

CMMFTestUseOldCodecAudioController::CMMFTestUseOldCodecAudioController() : iMediaId(KUidMediaTypeAudio), iState(EStopped)

	{

	}

/**

*

* ~CMMFTestUseOldCodecAudioController

*

*/

CMMFTestUseOldCodecAudioController::~CMMFTestUseOldCodecAudioController()

	{

	// [ ensure we have logged off the thread ]

	if( iDataPath ) 	

		{

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

		}

	delete iDataPath;

	delete iSourceFormat;

	delete iSinkFormat;

	delete iStoppingMessage;

	delete iWaitForAsyncService;

	}

/**

 *  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 CMMFTestUseOldCodecAudioController::AddDataSourceL(MDataSource& aSource)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));

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

		//[ 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(EBadInvariant));

		// [ lets load dev sound ]

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

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	//[ its now safe to set the source ]

	iDataSource = &aSource ;

	iDataSource->SetSourcePrioritySettings(iPrioritySettings);

	//[ assert the post condition ]

	__ASSERT_ALWAYS(iDataSource, Panic(EMMFAudioControllerPanicDataSourceDoesNotExist));

	}

/**

 *  AddDataSinkL

 *

 *	Adds a data sink to the controller

 *

 *	@param aSink

 *

 */

void CMMFTestUseOldCodecAudioController::AddDataSinkL(MDataSink& aSink)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));

	// [ 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(EBadInvariant));

		// [ lets load dev sound ]

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

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

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

	// transactionally ]

	iDataSink = &aSink;

	iDataSink->SetSinkPrioritySettings(iPrioritySettings);

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

	__ASSERT_ALWAYS(iDataSink, Panic(EMMFAudioControllerPanicDataSinkDoesNotExist));

	}

/**

 *  PrimeL

 *

 *  If Prime fails the client should reset the controller

 *  because as noted below this code is not transactional.

 *

 */

void CMMFTestUseOldCodecAudioController::PrimeL()

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));

	//[ 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( EBadInvariant));

	__ASSERT_ALWAYS( iDataSink, Panic( EBadInvariant));

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

		TFourCC sinkFormatDataType;

		if ((iSinkFormat)&&(iDataSource))

			{//audio input so recording

			//need to assign the sink format 4CC to pcm16

			//even though it isn't pcm16 , this will cause the audio input

			//in negotiation to instantiate the null CMMFHwDevice plugin

			//after the negotiation set it back to the correct datatype

			//forcing the datapath to use a CMMFCodec

			sinkFormatDataType = iSinkFormat->SinkDataTypeCode(KUidMediaTypeAudio); //reset this after negotiation

			iSinkFormat->SetSinkDataTypeCode(KMMFFourCCCodePCM16, KUidMediaTypeAudio);

			}

		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)

				{//record

				iDataPath->AddDataSourceL(iDataSource);

				if (iSinkFormat) //restore the format data type

					{	//this will force datapth to use CMMFCodec

					iSinkFormat->SetSinkDataTypeCode(sinkFormatDataType,KUidMediaTypeAudio);

					}

				}

			if (iSinkFormat)

				iDataPath->AddDataSinkL(iSinkFormat);

			else if (iDataSink)

				{//play

				//need to set the audio output fourCC code to pcm16

				//in order to force the data path to use a CMMFCodec

				CMMFAudioOutput* ao = static_cast<CMMFAudioOutput*>(iDataSink);

				CMMFDevSound* devSound = &(ao->SoundDevice());

				//PrimeL() needs to run synchronously but DevSound initialisation is 

				//asynchronous.  iWaitForAsyncService halts execution until 

				//iDevSoundEventHandler informs us this process has completed.

				iDevSoundEventHandler.SetInterceptedDevSoundObserver(ao);

				iDevSoundEventHandler.SetEventObserver(this);

				//need to reinitialize the devsound to load up a null pcm16->16

				//hw device - note this will delete the previous

				//non pcm16 hw device

				//note can't set this on the audio output as this won't update

				//the hw device

				devSound->InitializeL(iDevSoundEventHandler,KMMFFourCCCodePCM16,EMMFStatePlaying);

				iWaitForAsyncService->Start();

				//now tell audio output were pcm16

				iDataSink->SetSinkDataTypeCode(KMMFFourCCCodePCM16, KUidMediaTypeAudio);

				iDataPath->AddDataSinkL(iDataSink);

				}

			iSourceAndSinkAdded = ETrue ;

			}

		iDataPath->PrimeL();

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

		}

	//[ assert the post condition that we are in the state primed]

	__ASSERT_ALWAYS( SetState( EPrimed ), Panic( EPostConditionViolation ));

	// [ assert the invariant]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ) );

	}

/**

 *  ResetL

 *  This method resets the controller

 *

 */

void CMMFTestUseOldCodecAudioController::ResetL()

	{

	__ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ) );

	// Stop recording if it's not stopped,

	if (State() != EStopped)

		{

		iDataPath->Stop();

		SetState(EStopped);

		}

	// Remove references to source and sink

	iDataPath->ResetL();

	delete iSourceFormat; iSourceFormat = NULL  ;

	delete iSinkFormat;	iSinkFormat = NULL  ;

	//[ ensure loggoff of source and sink ]

	iDataSource = NULL ;

	iDataSink = NULL ;

	iSourceAndSinkAdded = EFalse;

	// [ assert the invariant]

	__ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ) );

	// [ assert the post condition

	//   state == stopped

	//   iDataSource is NULL

	//   iSourceFormat is NULL

	//   iSinkFormat is NULL ]

	__ASSERT_ALWAYS( ResetPostCondition(), Panic( EBadReset ));

	__ASSERT_ALWAYS( Invariant(), Panic(EBadState));

	}

/**

* ResetPostCondition

* This function determnines if the reset post condition is valid

* @xxxx

*/

TBool CMMFTestUseOldCodecAudioController::ResetPostCondition() const

	{

     TBool result = EFalse ;

	if((iSourceFormat     == NULL)  &&

	(iDataSink            == NULL)  &&

	(iDataSource          == NULL)  && 

	(iSinkFormat          == NULL)  &&

	(State() == EStopped))

		{

         result = ETrue;

		}

    return result;

	}

/**

 *

 * PlayL

 *

 */

void CMMFTestUseOldCodecAudioController::PlayL()

	{

	// [ assert the precondition that the

	//   play command is only activated in the primed state]

	if ( State() != EPrimed)

		User::Leave(KErrNotReady);

	// [ assert the Invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	//[datapath propogates play to sink & source]

	iDataPath->PlayL();

	SetState( EPlaying );

	//[ assert the post condition we are playing ]

	//No - this assumption is not always true if an error occurs eg OOM

	//the state could be EStopped

	//	__ASSERT_ALWAYS( (State() == EPlaying ), Panic( EBadState));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	}

/**

 *  PauseL

 *

 */

void CMMFTestUseOldCodecAudioController::PauseL()

	{

	// [ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	//[ assert the precondition that we are playing ]

	if ( State() != EPlaying)

		User::Leave(KErrNotReady);

	//[ datapath propogates pause to sink & source ]

	iDataPath->Pause();

	SetState(EPrimed);

	//[ assert the post condition we are primed ]

	__ASSERT_ALWAYS( (State() == EPrimed ), Panic( EBadState));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	}

/**

 *  StopL

 *

 */

void CMMFTestUseOldCodecAudioController::StopL(TMMFMessage& aMessage)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	// [ precondition that we are not already stopped 

	// && if we are stopped do nothing.

	//If we are stopping a recording, we need to give the datapath chance to 

	//process that data which has already been captured. We therefore stay in the EPlaying

	//state, but use iStoppingRecording to indicate that we are stopping.

	if ((State() != EStopped) && !iStoppingRecording)

		{

		if((State() == EPlaying) && (iDataSource->DataSourceType()==KUidMmfAudioInput)) //we are recording

			{

			// datapath is requested to stop recording but process any alreay captured buffers,

			// the pause method is used for this purpose and as such, the data path must 

			// determine that it is recording to be able to act accordingly.

			// aMessgae is not completed until datapath advises that it has completed.

			iDataPath->Pause();

			iStoppingMessage = CMMFMessageHolder::NewL(aMessage);

			iStoppingRecording = ETrue;

			}

		else

			{

			//  datapath propogates stop to sink & source

			iDataPath->Stop();

			SetState(EStopped);

			}

		}

	//complete message as request is complete.

	if(State() == EStopped && !IsUnderTest())

		{

		aMessage.Complete(KErrNone);

		}

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	}

/**

 *  PositionL

 * Preconditions:

 * The Controller is in the state EPrimed

 * @return TTimeIntervalMicroSeconds

 *

 */

TTimeIntervalMicroSeconds CMMFTestUseOldCodecAudioController::PositionL() const

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	// [ precondition that we are playing or primed ]

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

			User::Leave(KErrNotReady);

    TTimeIntervalMicroSeconds position = iDataPath->Position();

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	return position;

	}

/**

* SetPositionL

*

* @param aPosition

*

*/

void CMMFTestUseOldCodecAudioController::SetPositionL(const TTimeIntervalMicroSeconds& aPosition)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	// [ precondition that we are not already stopped ]

	if (iState == EStopped)

		User::Leave(KErrNotReady);

	//[ precondition that the position is >= 0 && <= Duration ]

		{

		TTimeIntervalMicroSeconds theDuration(0);

		if (iSourceFormat)

			{ //if the source is a clip then the duration always refers to the source - even if the sink is a clip

			theDuration = iSourceFormat->Duration(iMediaId);

			}

		else if (iSinkFormat)

			{ //duration of recorded clip

			theDuration = iSinkFormat->Duration(iMediaId);

			}

		TTimeIntervalMicroSeconds theStart(0);

		if( ( aPosition < theStart) || ( aPosition > theDuration) )

			//[ invalid position before start and after end]

			User::Leave(KErrArgument); 

		}

	//[ set the position on the data path ]

	iDataPath->SetPositionL(aPosition);

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

    // [ post condition not checked ]

	//[ we do not compare the set position with get postion

    //  because the interface to do so is poor ]

	}

/**

*

* DurationL

*

* @returns TTimeIntervalMicroSeconds 

*

*/

TTimeIntervalMicroSeconds CMMFTestUseOldCodecAudioController::DurationL() const

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	// [ assert we have a format that supports duration ]

	if( !( iSourceFormat || iSinkFormat ) )

		User::Leave(KErrNotSupported);

	//[ now do the real work of getting the duration ]

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

	TTimeIntervalMicroSeconds theDuration(0);

	if (iSourceFormat)

		{ //if the source is a clip then the duration always refers to the source - even if the sink is a clip

		theDuration = iSourceFormat->Duration(iMediaId);

		}

	else if (iSinkFormat)

		{ //duration of recorded clip

		theDuration = iSinkFormat->Duration(iMediaId);

		}

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	return theDuration; 

	}

/**

*

* GetNumberOfMetaDataEntriesL

*

* @param "TInt"

*

*/

void CMMFTestUseOldCodecAudioController::GetNumberOfMetaDataEntriesL(TInt& aNumberOfEntries )

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	//[ precondition that we are in the primed state or stopped ]

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

		User::Leave(KErrNotReady);

    // [ precondition there is a sink format ]

	if (!iDataSink)

		User::Leave(KErrNotSupported);

	// [ precondition the sink format is an encode format ]

	if ((iDataSink->DataSinkType()!=KUidMmfAudioOutput) &&

		(iDataSource->DataSourceType()!= KUidMmfAudioInput) )

		User::Leave(KErrNotSupported);

	if (iDataSink->DataSinkType()==KUidMmfAudioOutput)

		{

		//[ precondition the format exists ]

		if( !iSourceFormat )

			User::Leave(KErrNotSupported);

		//[ Get the Number of meta data entries from the sink format ]

		iSourceFormat->GetNumberOfMetaDataEntriesL( aNumberOfEntries );

		}

	else if (iDataSource->DataSourceType()==KUidMmfAudioInput)

		{

		if( !iSinkFormat )

			User::Leave(KErrNotSupported);

		iSinkFormat->GetNumberOfMetaDataEntriesL( aNumberOfEntries );

		}

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	}

/**

* GetMetaDataEntryL

* @param aIndex

* @returns "CMMFMetaDataEntry*"

*/

CMMFMetaDataEntry* CMMFTestUseOldCodecAudioController::GetMetaDataEntryL(TInt aIndex )

	{

		//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	//[ precondition that we are in the primed state or stopped ]

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

		User::Leave(KErrNotReady);

    // [ precondition there is a sink format ]

	if (!iDataSink)

		User::Leave(KErrNotSupported);

	iDataSink->DataSinkType();

	iDataSource->DataSourceType();

	// [ precondition the sink or source is either an audio output or input ]

	if ((iDataSink->DataSinkType()!= KUidMmfAudioOutput) &&

		(iDataSource->DataSourceType()!= KUidMmfAudioInput ))

		User::Leave(KErrNotSupported);

	//[ Get the meta data entry from the sink format ]

	CMMFMetaDataEntry*  theEntry = NULL;

	if (iDataSink->DataSinkType()==KUidMmfAudioOutput)

		{ 

		//[ precondition the format exists ]

		if( !iSourceFormat )

			User::Leave(KErrNotSupported);

		//[ Get the Number of meta data entries from the sink format ]

		theEntry = iSourceFormat->MetaDataEntryL(aIndex);

		}

	else if (iDataSource->DataSourceType()==KUidMmfAudioInput)

		{

		//[ precondition the format exits ]

		if( !iSinkFormat )

			User::Leave(KErrNotSupported);

		theEntry = iSinkFormat->MetaDataEntryL(aIndex);

		}

	//[ assert the post condition that the entry is not null ]

	__ASSERT_ALWAYS( theEntry, Panic(EBadInvariant));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	return theEntry;

	}

/**

* RemoveDataSourceL

* @param aDataSource

* 

*/

void CMMFTestUseOldCodecAudioController::RemoveDataSourceL(MDataSource& aDataSource )

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant) );

	//[ precondition is that we have a data source ]

	if( !iDataSource )

		User::Leave(KErrNotReady);

	//[precondition the data source is the data source we have]

	if( iDataSource != &aDataSource )

		User::Leave(KErrArgument);

	//[ the controller is in the stopped state ]

	if(State() != EStopped)

		User::Leave(KErrNotReady);

	//[ remove the data sink from the controller and delete the format]

     if( iSourceAndSinkAdded )

		 {

         __ASSERT_ALWAYS( iDataPath, Panic( EBadState )); 

	     //[ Remove references to source and sink ]

	     iDataPath->ResetL();

		 iSourceAndSinkAdded = EFalse ;

		 }

	 // [ delete the data sink and format ]

	 iDataSource = NULL ;

	 delete iSourceFormat;

	 iSourceFormat = NULL;

	// [ assert postcondition we are stopped ]

	__ASSERT_ALWAYS( (State() == EStopped), Panic(EPostConditionViolation) );

	//[ assert postcondition the SourceAndSinkAdded is false ]

	__ASSERT_ALWAYS( !iSourceAndSinkAdded, Panic( EPostConditionViolation ));

	//[ assert postcondition the data sinkformat  is null ]

	__ASSERT_ALWAYS( (iSourceFormat == NULL ), Panic( EPostConditionViolation ));

	//[ assert postcondition the data sink  is null ]

	__ASSERT_ALWAYS( (iDataSource == NULL ), Panic( EPostConditionViolation ));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	}

/**

* RemoveDataSinkL

* 

* @param aDataSink

*

*/

void CMMFTestUseOldCodecAudioController::RemoveDataSinkL(MDataSink& aDataSink )

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant) );

	//[ precondition is that we have a data sink ]

	if( !iDataSink )

		User::Leave(KErrNotSupported);

	//[precondition the data sink is the data sink we have]

	if( iDataSink != &aDataSink )

		User::Leave(KErrNotSupported);

	//[ the controller is in the stopped state ]

	if(State() != EStopped)

		User::Leave(KErrNotReady);

	//[ remove the data sink from the controller and delete the format]

     if( iSourceAndSinkAdded )

		 {

         __ASSERT_ALWAYS( iDataPath, Panic( EBadState ));

         //[ Remove references to source and sink ]

	     iDataPath->ResetL();

		 iSourceAndSinkAdded = EFalse ;

		 }

	 // [ reset data sink referenece and remove the format ]

	 iDataSink = NULL ;

	 delete iSinkFormat;

	 iSinkFormat = NULL;

	// [ assert postcondition we are stopped ]

	__ASSERT_ALWAYS( (State() == EStopped), Panic(EPostConditionViolation) );

	//[ assert postcondition the SourceAndSinkAdded is false ]

	__ASSERT_ALWAYS( !iSourceAndSinkAdded, Panic( EPostConditionViolation ));

	//[ assert postcondition the data sinkformat  is null ]

	__ASSERT_ALWAYS( (iSinkFormat == NULL ), Panic( EPostConditionViolation ));

	//[ assert postcondition the data sink  is null ]

	__ASSERT_ALWAYS( (iDataSink == NULL ), Panic( EPostConditionViolation ));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	}

/**

 *  CustomCommand

 *  @param aMessage

 */

void CMMFTestUseOldCodecAudioController::CustomCommand(TMMFMessage& aMessage)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	// [ We do not have any custom commands ]

	aMessage.Complete(KErrNotSupported);

	}

/**

* NegotiateL

* 

*/

void CMMFTestUseOldCodecAudioController::NegotiateL()

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	//utility function used by custom to negotiate source sink settings after a change

	if ((iSourceFormat)&&(iSinkFormat)) //convert

		{

		iSinkFormat->NegotiateL(*iSourceFormat);

		iSourceFormat->NegotiateSourceL(*iSinkFormat);

		iSinkFormat->NegotiateL(*iSourceFormat);

		// check for upsampling attempts

		if (iSinkFormat->SampleRate() > iSourceFormat->SampleRate())

			{

			// we don't support upsampling

			User::Leave( KErrNotSupported );

			}

		}

	else if ((iDataSource)&&(iSinkFormat)) //record

		{

		// need two step negotiation for record

		// first try to set the audio input settings to match the required settings for recording

		iDataSource->NegotiateSourceL(*iSinkFormat);

		// now call negotiateL on the sink in order to tell it what the audio input was set to.

		iSinkFormat->NegotiateL(*iDataSource);

		}

	else if ((iSourceFormat)&&(iDataSink)) //play

		iDataSink->NegotiateL(*iSourceFormat);

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	}

/**

 *  SetPrioritySettings

 *

 *	@param aPrioritySettings

 */

void CMMFTestUseOldCodecAudioController::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	//[ assert the precondition ]

	if(State() != EStopped)

		{

		ASSERT(EFalse);		// used to leave here with KErrNotReady

		return;

		}

	//[ update the priority settings of the controller]

	iPrioritySettings = aPrioritySettings;

	//pass settings on to source and sink

	if (iDataSource)

		{

		iDataSource->SetSourcePrioritySettings(iPrioritySettings);

		}

	if (iDataSink)

		{

		iDataSink->SetSinkPrioritySettings(iPrioritySettings);

		}

    // assert the post condition

	//__ASSERT_ALWAYS( (iPrioritySettings == aPrioritySettings), Panic( ));

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	}

/**

 *  SendEventToClient

 *

 *	@param aEvent

 */

TInt CMMFTestUseOldCodecAudioController::SendEventToClient(const TMMFEvent& aEvent)

	{

	//[ assert the invariant ]

	__ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));

	TMMFEvent controllerEvent;

	//Were going to stop playing, force event type to be the correct type

	controllerEvent.iEventType = KMMFEventCategoryPlaybackComplete;

	controllerEvent.iErrorCode = aEvent.iErrorCode;

	//If we receive KErrNone from the DataPath, it indicates that it has 

	//successfully completed playing/converting/recording.

	if ((aEvent.iEventType == KMMFEventCategoryPlaybackComplete) && 

		(aEvent.iErrorCode == KErrNone))

		{

		if(iStoppingRecording)

			{

			iStoppingRecording = EFalse;

			iDataPath->Stop();

			SetState( EStopped );

			//complete the clients stop request

			iStoppingMessage->Complete(KErrNone);

			delete iStoppingMessage; iStoppingMessage=NULL;

			//we don't want to send an event to the client

			return KErrNone;