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

#include <ecom/implementationproxy.h>

#include <mmf/server/mmfformat.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/common/mmfhelper.h>

#endif

#include <mmf/plugin/mmfaudioiointerfaceuids.hrh>

void Panic(TInt aPanicCode)

	{

	_LIT(KMMFAudioOutputPanicCategory, "MMFAudioOutput");

	User::Panic(KMMFAudioOutputPanicCategory, aPanicCode);

	}

/**

Allocates and constructs a new audio output sink.

Static standard SymbianOS 2 phase constuction method.

@return A pointer to the new sink.

*/

MDataSink* CMMFAudioOutput::NewSinkL()

	{

	CMMFAudioOutput* self = new (ELeave) CMMFAudioOutput ;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return STATIC_CAST( MDataSink*, self ) ;

	}

/**

Standard SymbianOS ConstructL.

Used to initialise member varibles with device specific behaviour.

*/

void CMMFAudioOutput::ConstructL()

	{

	iInitializeState = KErrNone;

	iDataTypeCode = KMMFFourCCCodePCM16;

	iNeedsSWConversion = EFalse;

	iSourceSampleRate = 0;

	iActiveSchedulerWait = new(ELeave) CActiveSchedulerWait;

	}

/**

Overridable constuction specific to this datasource.

The default implementation does nothing.

@param  aInitData

        The initialisation data.

*/

void CMMFAudioOutput::ConstructSinkL( const TDesC8& /*aInitData*/ )

	{

	}

/**

@deprecated

Gets audio from hardware device abstracted MMFDevsound (not used).

@param  aBuffer

        The data to write out to a Hardware Device.

@param  aSupplier

        The MDataSource consuming the data contained in aBuffer

*/

void CMMFAudioOutput::HWEmptyBufferL(CMMFBuffer* /*aBuffer*/, MDataSource* /*aSupplier*/)

	{

	}

/**

Sends audio to MMFDevsound.

@param  aBuffer

        The data to write out.

@param  aSupplier

        The search criteria for the supplier.

@param  aMediaId

        The type of data supplied - currently ignored.

*/

void CMMFAudioOutput::EmptyBufferL(CMMFBuffer* aBuffer, MDataSource* aSupplier, TMediaId /*aMediaId*/)

	{

	iSupplier = aSupplier;

	if (!iMMFDevSound)

		Panic(EMMFAudioOutputDevSoundNotLoaded);

	if (aSupplier == NULL)

		User::Leave(KErrArgument);

	// In order to avoid changes at the datapath data transfer state machine 

	// EmptyBufferL is still being called even

	// if the first time there is no buffer to send

	if (!iCanSendBuffers)

		{

		iCanSendBuffers = ETrue;

		return;

		}

	if (iNeedsSWConversion)

		{//need to perform channel & sample rate conversion before writing to clip

		CMMFDataBuffer* audio;

		//need to make sure aBuffer is not null before it is used

		if (aBuffer == NULL)

			{

			User::Leave(KErrArgument);

			}

		//buffer check is placed here before possible use of the buffer

		if (!CMMFBuffer::IsSupportedDataBuffer(aBuffer->Type()))

			{

			User::Leave(KErrNotSupported);

			}

		iConvertBuffer = CMMFDataBuffer::NewL(((CMMFDataBuffer*)aBuffer)->Data().Length());

		iChannelAndSampleRateConverter->Convert(*(CMMFDataBuffer*)aBuffer, *iConvertBuffer);

		audio = iConvertBuffer;

		//copy our converted data back into the real buffer to return to datapath

		TDes8& dest = STATIC_CAST( CMMFDataBuffer*, aBuffer )->Data() ;

		dest.SetLength(0);

		dest.Copy(audio->Data());

		}

	if (iState != EDevSoundReady && iState != EPaused) // If we're paused we still feed a buffer to DevSound

		User::Leave(KErrNotReady);

	iMMFDevSound->PlayData();

#if defined(__AUDIO_PROFILING)

	RDebug::ProfileEnd(0);

	User::Leave(KErrEof);

#endif  // defined(__AUDIO_PROFILING)

	// The following will never have been allocated unless

	// software conversion was required, and due to certain DevSound

	// implementations, this requirement can change dynamically.

	delete iConvertBuffer;

	iConvertBuffer = NULL;

	}

/**

Negotiates with the source to set, for example, the sample rate and number of channels.

Called if the sink's setup depends on source.

@param  aSource

        The data source with which to negotiate.

*/

void CMMFAudioOutput::NegotiateL(MDataSource& aSource)

	{

	if (aSource.DataSourceType() == KUidMmfFormatDecode)

		{//source is a clip so for now set sink settings to match source

		iSourceSampleRate = ((CMMFFormatDecode&)aSource).SampleRate();

		iSourceChannels = ((CMMFFormatDecode&)aSource).NumChannels(); 

		iSourceFourCC.Set(aSource.SourceDataTypeCode(TMediaId(KUidMediaTypeAudio)));

		((CMMFFormatDecode&)aSource).SuggestSourceBufferSize(KAudioOutputDefaultFrameSize);

		}

	// Query DevSound capabilities and Try to use DevSound sample rate and 

	// mono/stereo capability

	if (!iMMFDevSound)

		Panic(EMMFAudioOutputDevSoundNotLoaded);

	TMMFState prioritySettingsState = iPrioritySettings.iState; //should be EMMFStatePlaying

	//to use the GetSupportedInputDatatypes but we'll save it just in case it's not

	iPrioritySettings.iState = EMMFStatePlaying; //if playing does not support any output data types

	RArray<TFourCC> supportedDataTypes;

	//note Input data types becuase if we are playing audio ie audio output

	//the data is sent as an input to DevSound

	TRAPD(err, iMMFDevSound->GetSupportedInputDataTypesL(supportedDataTypes, iPrioritySettings));

	iPrioritySettings.iState = prioritySettingsState;

	if (err == KErrNone)

		{

		if (supportedDataTypes.Find(iSourceFourCC) == KErrNotFound)

			{//the source fourCC code could not be found in the list of 

			//data types supported by the Devsound therefor default to pcm16

			iDataTypeCode = KMMFFourCCCodePCM16;	

			}

		else

			{

			//the DevSound does support the same datatype as the source 

			//so set the fourcc to that of the source

			iDataTypeCode = iSourceFourCC;

			}

		}

	supportedDataTypes.Close();

	if (err == KErrNotSupported)

		{//if the Devsound does not support the GetSupportedOutputDataTypesL method

		//then assume that the DevSound is pcm16 only

		iDataTypeCode = KMMFFourCCCodePCM16;	

		}

	else if (err != KErrNone) //we had a real leave error from GetSupportedOuputDataTypesL

		{

		User::Leave(err);

		}

	// Prevent defect when SinkPrimeL is called before NegotiateL()

	// since characterization is ambiguous

	if(iState == EDevSoundReady)

		{

		iState = EIdle;

		}

	//INC40817 do the initialize here as capabilities may depend on datatype

	//note this implies client of audiooutput must call negotiate

	iMMFDevSound->InitializeL(*this, iDataTypeCode, EMMFStatePlaying);

	// In some implementations InitializeComplete is sent

	// in context, so check before starting activeSchedulerWait.

	if (iState != EDevSoundReady)

		{

		iInitializeState = KRequestPending;

		iActiveSchedulerWait->Start();

		}

	User::LeaveIfError(iInitializeState);

	// Reset the following flag in case DevSound's capabilities have

	// changed since we were last here: INC037165

	iNeedsSWConversion = EFalse;

	TMMFCapabilities devSoundCaps;

	devSoundCaps = iMMFDevSound->Capabilities();

	// Default PCM16

	iDevSoundConfig.iEncoding = EMMFSoundEncoding16BitPCM;

	// 1 = Monophonic and 2 == Stereo

	if (((iSourceChannels == 1) && (devSoundCaps.iChannels & EMMFMono)) ||

		((iSourceChannels == 2) && (devSoundCaps.iChannels & EMMFStereo)))

		iDevSoundConfig.iChannels = iSourceChannels;

	else //default or SW conversion, e.g. stereo on mono support

		{

		iDevSoundConfig.iChannels = EMMFMono;

		iNeedsSWConversion = ETrue;

		iSWConvertChannels = 1;

		iSWConvertSampleRate = iSourceSampleRate;

		}

	// Check for std sample rates.

	if ((iSourceSampleRate == 96000) && (devSoundCaps.iRate & EMMFSampleRate96000Hz))

		iDevSoundConfig.iRate = EMMFSampleRate96000Hz;

	else if ((iSourceSampleRate == 88200) && (devSoundCaps.iRate & EMMFSampleRate88200Hz))

		iDevSoundConfig.iRate = EMMFSampleRate88200Hz;

	else if ((iSourceSampleRate == 64000) && (devSoundCaps.iRate & EMMFSampleRate64000Hz))

		iDevSoundConfig.iRate = EMMFSampleRate64000Hz;

	else if ((iSourceSampleRate == 48000) && (devSoundCaps.iRate & EMMFSampleRate48000Hz))

		iDevSoundConfig.iRate = EMMFSampleRate48000Hz;

	else if ((iSourceSampleRate == 44100) && (devSoundCaps.iRate & EMMFSampleRate44100Hz))

		iDevSoundConfig.iRate = EMMFSampleRate44100Hz;

	else if ((iSourceSampleRate == 32000) && (devSoundCaps.iRate & EMMFSampleRate32000Hz))

		iDevSoundConfig.iRate = EMMFSampleRate32000Hz;

	else if ((iSourceSampleRate == 24000) && (devSoundCaps.iRate & EMMFSampleRate24000Hz))

		iDevSoundConfig.iRate = EMMFSampleRate24000Hz;

	else if ((iSourceSampleRate == 22050) && (devSoundCaps.iRate & EMMFSampleRate22050Hz))

		iDevSoundConfig.iRate = EMMFSampleRate22050Hz;

	else if ((iSourceSampleRate == 16000) && (devSoundCaps.iRate & EMMFSampleRate16000Hz))

		iDevSoundConfig.iRate = EMMFSampleRate16000Hz;

	else if ((iSourceSampleRate == 12000) && (devSoundCaps.iRate & EMMFSampleRate12000Hz))

		iDevSoundConfig.iRate = EMMFSampleRate12000Hz;

	else if ((iSourceSampleRate == 11025) && (devSoundCaps.iRate & EMMFSampleRate11025Hz))

		iDevSoundConfig.iRate = EMMFSampleRate11025Hz;

	else if ((iSourceSampleRate == 8000) && (devSoundCaps.iRate & EMMFSampleRate8000Hz))

		iDevSoundConfig.iRate = EMMFSampleRate8000Hz;

	else // non standard sample rate

		{

		iNeedsSWConversion = ETrue;

		// we need to choose to the closest, and smaller standard sample rate

		// and eventually convert the audio samples to this standard sample rate

		//NB: this list must be in ascending order

		const TInt KNumSampleRates = 12;

		static const TUint supportedSR[KNumSampleRates][2] = {{8000,  EMMFSampleRate8000Hz},

									{11025, EMMFSampleRate11025Hz},

									{12000, EMMFSampleRate12000Hz},

									{16000, EMMFSampleRate16000Hz},

									{22050, EMMFSampleRate22050Hz},

									{24000, EMMFSampleRate24000Hz},

									{32000, EMMFSampleRate32000Hz},

									{44100, EMMFSampleRate44100Hz},

									{48000, EMMFSampleRate48000Hz},

									{64000, EMMFSampleRate64000Hz},

									{88200, EMMFSampleRate88200Hz},

									{96000, EMMFSampleRate96000Hz}};

		//Only support down sampling

   		if (iSourceSampleRate < supportedSR[0][0]) 

   			User::Leave(KErrNotSupported);

   		TInt sampleRateIndex = KNumSampleRates;

   		//find the source sampleRateIndex

   		for (sampleRateIndex--; sampleRateIndex > -1; sampleRateIndex--)

   			{

   			if(iSourceSampleRate >= supportedSR[sampleRateIndex][0])

   				{

   				break;

   				}

   			}

   		//find the highest sink sample rate below the source rate

   		for (; sampleRateIndex > -1; sampleRateIndex--)

   			{

   			if(devSoundCaps.iRate & supportedSR[sampleRateIndex][1])

   				{

   				iSWConvertSampleRate = supportedSR[sampleRateIndex][0];

   				iDevSoundConfig.iRate = supportedSR[sampleRateIndex][1];

   				break;

   				}

   			}

   		//if a suitable sink sample rate is not available

   		if (sampleRateIndex < 0) 

   			User::Leave(KErrNotSupported);

   		// set the channels as well

   		iSWConvertChannels = iDevSoundConfig.iChannels;

   		} // else // non standard sample rate

	if (iNeedsSWConversion)

		{//can only software convert if datatype is pcm16

		//note cannot set non standard sample rates on DevSound API

		//as the API does not allow this

		//we need to reinitialize the devsound with pcm16 in this case

		iDataTypeCode = KMMFFourCCCodePCM16;

		iState = EIdle;

		iMMFDevSound->InitializeL(*this, iDataTypeCode, EMMFStatePlaying);

		// In some implementations InitializeComplete is called

		// in context, so check before starting activeSchedulerWait.

		if (iState != EDevSoundReady)

			{

			iInitializeState = KRequestPending;

			iActiveSchedulerWait->Start();

			}

		User::LeaveIfError(iInitializeState);

		}

	}

/**

Sets the sink's priority settings.

@param  aPrioritySettings

        The sink's priority settings. Takes enumerations to determine audio playback priority. 

        Higher numbers mean high priority (can interrupt lower priorities).

*/

void CMMFAudioOutput::SetSinkPrioritySettings(const TMMFPrioritySettings& aPrioritySettings)

	{

	iPrioritySettings = aPrioritySettings;

	if (!iMMFDevSound)

		Panic(EMMFAudioOutputDevSoundNotLoaded);

	else

		iMMFDevSound->SetPrioritySettings(iPrioritySettings);

	}

/**

Gets the sink's data type code.

Used by datapath MDataSource / MDataSink for codec matching.

@param  aMediaId

        The Media ID. Optional parameter to specifiy specific stream when datasource contains more

        than one stream of data.

@return	The 4CC of the data expected by this sink.

*/

TFourCC CMMFAudioOutput::SinkDataTypeCode(TMediaId /*aMediaId*/)

	{

	return iDataTypeCode;

	}

/**

Sets the sink's data type code.

@param  aSinkFourCC

        The 4CC of the data to be supplied to this sink.

@param  aMediaId

        The Media ID. Optional parameter to specifiy specific stream when datasource contains more 

        than one stream of data.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

*/

TInt CMMFAudioOutput::SetSinkDataTypeCode(TFourCC aSinkFourCC, TMediaId /*aMediaId*/)

	{//will check with devsound to see if aSinkFourCC is supported

	 //when this is added to devsound

	iDataTypeCode = aSinkFourCC;

	return KErrNone;

	}

/**

Primes the sink.

This is a virtual function that each derived class must implement, but may be left blank for default 

behaviour.

Called by CMMFDataPath::PrimeL().

*/

void CMMFAudioOutput::SinkPrimeL()

	{

	if(iPlayStarted != EFalse)

		{

		return;

		}

	iPlayStarted = EFalse;

	iCanSendBuffers = EFalse;

	if (iState == EIdle)

		{

		if (!iMMFDevSound) 

			{

			User::Leave(KErrNotReady);

			}

		iState = EDevSoundReady;

		}

	}

/**

Pauses the sink.

This is a virtual function that each derived class must implement, but may be left blank for default 

behaviour.

*/

void CMMFAudioOutput::SinkPauseL()

	{

	if (!iMMFDevSound)

		Panic(EMMFAudioOutputDevSoundNotLoaded);

	else

		iMMFDevSound->Pause();

	iPlayStarted = EFalse;

	iState = EPaused;

	}

/**

Starts playing the sink.

This is a virtual function that each derived class must implement, but may be left blank for default

behaviour.

*/

void CMMFAudioOutput::SinkPlayL()

	{

	if (iState == EPaused)

		{

		TBool isResumeSupported = iMMFDevSound->IsResumeSupported();

		// CMMFAudioOutput is not supposed to be paused 

		// if Resume is not supported by DevSound

		if(!isResumeSupported)

			{

			User::Leave(KErrNotSupported);

			}

		User::LeaveIfError(iMMFDevSound->Resume());

		iPlayStarted = ETrue;

		}

	else if (iPlayStarted == EFalse)

		{

		ConfigDevSoundL();	

		// This is a one-shot to "prime" MMFDevSound as first buffer uninitialised

		iMMFDevSound->PlayInitL();

		iPlayStarted = ETrue;

		}

	if ((iNeedsSWConversion)&&(iSourceChannels>0))

		{//can only do SW convert  - therefore need to do a conversion

		//currently only pcm16 is supported so return with an error if format not pcm16

		if (!iChannelAndSampleRateConverterFactory)

			{

			iChannelAndSampleRateConverterFactory

				= new(ELeave)CMMFChannelAndSampleRateConverterFactory;

			iChannelAndSampleRateConverter =

				iChannelAndSampleRateConverterFactory->CreateConverterL( iSourceSampleRate, iSourceChannels,

																		iSWConvertSampleRate, iSWConvertChannels);

			}

		//need to create an intermediate buffer in which to place the converted data

		}

	iState = EDevSoundReady;

	}

/**

Stops the sink.

This is a virtual function that each derived class must implement, but may be left blank for default

behaviour.

*/

void CMMFAudioOutput::SinkStopL()

	{

	if (iState == EDevSoundReady)

		{//not waiting on a buffer being played so stop devsound now

		iState = EIdle;

		if (iPlayStarted)

			{

			if (!iMMFDevSound)

				{

				Panic(EMMFAudioOutputDevSoundNotLoaded);

				}

			else

				{

				iPlayStarted = EFalse;

				iMMFDevSound->Stop();

				}

			}

		}

	else if (iState == EPaused)	//DEF46250 need to handle pause separately as we should always stop regardless of the state of iFirstBufferSent

		{

		iPlayStarted = EFalse;

		iMMFDevSound->Stop();

		iState = EIdle; 

		}

	iCanSendBuffers = EFalse;

	} 

/**

Returns the playback state (EStopped, EPlaying, EPaused etc) of this sink

*/

TInt CMMFAudioOutput::State()

	{

	return iState;

	}

/**

Logs on the sink's thread.

Thread specific initialization procedure for this device. Runs automatically on thread construction.

@param  aEventHandler

        The event handler.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

*/

TInt CMMFAudioOutput::SinkThreadLogon(MAsyncEventHandler& aEventHandler)

	{

	iEventHandler = &aEventHandler;

	TInt err = KErrNone;

	if (!iDevSoundLoaded)

		TRAP(err, LoadL());

	return err;

	}

/**

Logs off the sink thread.

Thread specific destruction procedure for this device. Runs automatically on thread destruction.

*/

void CMMFAudioOutput::SinkThreadLogoff()

	{

	if(iMMFDevSound)

		{

		iMMFDevSound->Stop();

		delete iMMFDevSound;

		iMMFDevSound = NULL;

		}

	iDevSoundLoaded = EFalse;

	iState = EIdle;

	}

/**

Called by MDataSource to pass back a full buffer to the sink. 

Should never be called by a sink, as sinks empty buffers, not fill them.

@param  aBuffer

        The filled buffer.

*/

void CMMFAudioOutput::BufferFilledL(CMMFBuffer* /*aBuffer*/)

	{

	Panic(EMMFAudioOutputPanicBufferFilledLNotSupported);

	}

/**

Tests whether a sink buffer can be created.

The default implementation returns true.

@return A boolean indicating if the sink buffer can be created. ETrue if it can, otherwise EFalse.

*/

TBool CMMFAudioOutput::CanCreateSinkBuffer()

	{

	return ETrue;

	}

/**

Creates a sink buffer.

Intended for asynchronous usage (buffers supplied by Devsound device)

@param  aMediaId

        The Media ID.

@param	aReference

		A boolean indicating if MDataSink owns the buffer. ETrue if does, otherwise EFalse.

@return A sink buffer.

*/

CMMFBuffer* CMMFAudioOutput::CreateSinkBufferL(TMediaId /*aMediaId*/, TBool &aReference)

	{

	//iDevSoundBuffer = CMMFDataBuffer::NewL(KAudioOutputDefaultFrameSize);

	iDevSoundBuffer = NULL;		//DevSound supplies this buffer in first callback

	aReference = ETrue;

	if ( iNeedsSWConversion )

		return iConvertBuffer;

	else

		return iDevSoundBuffer;

	}

/**

Standard SymbianOS destructor.

*/

CMMFAudioOutput::~CMMFAudioOutput()

	{

	// The following will never have been allocated unless

	// software conversion was required, and due to certain DevSound

	// implementations, this requirement can change dynamically.

	delete iChannelAndSampleRateConverterFactory;

	delete iConvertBuffer;

	if (iMMFDevSound)

		{

		iMMFDevSound->Stop();

		delete iMMFDevSound;

		}

	delete iActiveSchedulerWait;

	}

void CMMFAudioOutput::ConfigDevSoundL()

	{

	iMMFDevSound->SetConfigL(iDevSoundConfig);

	}

/**

@deprecated

This method should not be used - it is provided to maintain SC with v7.0s.

@param  aAudioType

        The 4CC of the data supplied by this source.

*/

void CMMFAudioOutput::SetDataTypeL(TFourCC aAudioType)

	{

	if (aAudioType != KMMFFourCCCodePCM16)

		{

		User::Leave(KErrNotSupported);

		}

	}

/**

@deprecated

This method should not be used - it is provided to maintain SC with v7.0s.

@return The 4CC of the data supplied by this source.

*/

TFourCC CMMFAudioOutput::DataType() const

	{

	return KMMFFourCCCodePCM16;

	}

/**

Queries about DevSound resume support

@return ETrue if DevSound does support resume, EFalse otherwise

*/

TBool CMMFAudioOutput::IsResumeSupported()

	{

	TBool isSupported = EFalse;

	if (iMMFDevSound)

		{

		isSupported = iMMFDevSound->IsResumeSupported();

		}

	return isSupported;

	}

/**

Loads audio device drivers and initialise this device.

*/

void CMMFAudioOutput::LoadL()

	{

	iPlayStarted = EFalse;

	if (iState != EDevSoundReady)

		iState = EIdle;

	iMMFDevSound = CMMFDevSound::NewL();

	//This is done to maintain compatibility with the media server

	iMMFDevSound->SetVolume(iMMFDevSound->MaxVolume() - 1);

	//note cannot perform further initlaisation here untill the datatype is known

	iDevSoundLoaded = ETrue;

	}

/**

DeviceMessage MMFDevSoundObserver

*/

void CMMFAudioOutput::DeviceMessage(TUid /*aMessageType*/, const TDesC8& /*aMsg*/)

	{

	}

/**

ToneFinished MMFDevSoundObserver called when a tone has finished or interrupted

Should never get called.

*/

void CMMFAudioOutput::ToneFinished(TInt /*aError*/)

	{

	//we should never get a tone error in MMFAudioOutput!

	__ASSERT_DEBUG(EFalse, Panic(EMMFAudioOutputPanicToneFinishedNotSupported));

	}

/**

RecordError MMFDevSoundObserver called when recording has halted.

Should never get called.

*/

void CMMFAudioOutput::RecordError(TInt /*aError*/)

	{

	//we should never get a recording error in MMFAudioOutput!

	__ASSERT_DEBUG(EFalse, Panic(EMMFAudioOutputPanicRecordErrorNotSupported));

	}

/**

InitializeComplete MMFDevSoundObserver called when devsound initialisation completed.

*/

void CMMFAudioOutput::InitializeComplete(TInt aError)

	{

	if (aError == KErrNone)

		{

		iState = EDevSoundReady;

		}

	if(iInitializeState == KRequestPending)

		{

		iInitializeState = aError;

		iActiveSchedulerWait->AsyncStop();

		}

	}

/**

BufferToBeEmptied MMFDevSoundObserver - should never get called.

*/

void CMMFAudioOutput::BufferToBeEmptied(CMMFBuffer* /*aBuffer*/)

	{

	__ASSERT_DEBUG(EFalse, Panic(EMMFAudioOutputPanicRecordErrorNotSupported));

	}

/**

BufferToBeFilled MMFDevSoundObserver.

Called when buffer used up.

*/

void CMMFAudioOutput::BufferToBeFilled(CMMFBuffer* aBuffer)

	{

	TInt err = KErrNone;

	TRAP(err, iSupplier->BufferEmptiedL(aBuffer));

	//This error needs handling properly

	__ASSERT_DEBUG(!err, Panic(err));

	}

/**

PlayError MMFDevSoundObserver.

Called when stopped due to error or EOF.

*/

void CMMFAudioOutput::PlayError(TInt aError)

	{

	iMMFDevsoundError = aError;

	//send EOF to client

	TMMFEvent event(KMMFEventCategoryPlaybackComplete, aError);

	SendEventToClient(event);

	//stop stack overflow / looping problem - AD

	if (aError == KErrCancel)

		return;

	// NB KErrInUse, KErrDied OR KErrAccessDenied may be returned by the policy server

	// to indicate that the sound device is in use by another higher priority client.

	if (aError == KErrInUse || aError == KErrDied || aError == KErrAccessDenied)

		return;

	if (iState == EIdle)

		{//probably have stopped audio output and have got an underflow from last buffer

		iMMFDevSound->Stop();

		iPlayStarted = EFalse;

		iCanSendBuffers = EFalse;

		}

	}

/**

ConvertError MMFDevSoundObserver.

Should never get called.

*/

void CMMFAudioOutput::ConvertError(TInt /*aError*/)

	{

	}

/**

Returns the number of bytes played.

@return	The number of bytes played. If 16-bit divide this number returned by 2 to get word length.

*/

TInt CMMFAudioOutput::BytesPlayed()

	{

	if (!iMMFDevSound)

		Panic(EMMFAudioOutputDevSoundNotLoaded);

	return iMMFDevSound->SamplesPlayed();

	}

/**

Returns the sound device.

Accessor function exposing public CMMFDevsound methods.

@return	A reference to a CMMFDevSound objector.

*/

CMMFDevSound& CMMFAudioOutput::SoundDevice()

	{

	if (!iMMFDevSound)

		Panic(EMMFAudioOutputDevSoundNotLoaded);

	return *iMMFDevSound;

	}

void CMMFAudioOutput::SendEventToClient(const TMMFEvent& aEvent)

	{

	iEventHandler->SendEventToClient(aEvent);

	}

// __________________________________________________________________________

// Exported proxy for instantiation method resolution

// Define the interface UIDs

const TImplementationProxy ImplementationTable[] =

	{

		IMPLEMENTATION_PROXY_ENTRY(KMmfUidAudioOutputInterface,	CMMFAudioOutput::NewSinkL)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;

	}