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

 // source\server\mmfswcodecrecorddatapath.cpp

 //

 //

 #include "mmfSwCodecRecordDataPath.h"

 #include <mmf/server/mmfswcodecwrapper.h>

 #include <mmf/common/mmfpaniccodes.h>

 #ifdef SYMBIAN_SCW_DEBUG

 const TText* const KStateNames[] = // must agree with TRecordState

             {

             _S("ERecordStateCreated"),

             _S("ERecordStateFailed"),

             _S("ERecordStateRecording"),

             _S("ERecordStateSendingBuffer"),

             _S("ERecordStateSendingPartialBuffer"),

             _S("ERecordStateEmptiedPartialBuffer"),

             _S("ERecordStateRecordingPaused"),

             _S("ERecordStateSendingBufferPaused"),

             _S("ERecordStateSendingPartialBufferPaused"),

             _S("ERecordStateEmptiedPartialBufferPaused"),

             };

 static const TText* StateName(TInt aState)

     {

     return KStateNames[aState];

     }

 #endif // SYMBIAN_SCW_DEBUG

 // Table of next state used when resuming or pausing.

 const CMMFSwCodecRecordDataPath::TRecordState CMMFSwCodecRecordDataPath::KResumePauseTable[] =

     {

     ERecordStateCreated,                    //ERecordStateCreated                       // note order here is important - see State(), RecordOrPause() etc

     ERecordStateFailed,                     //ERecordStateFailed

     ERecordStateRecordingPaused,            //ERecordStateRecording

     ERecordStateSendingBufferPaused,        //ERecordStateSendingBuffer

     ERecordStateSendingPartialBufferPaused, //ERecordStateSendingPartialBuffer

     ERecordStateEmptiedPartialBufferPaused, //ERecordStateEmptiedPartialBuffer

     ERecordStateRecording,                  //ERecordStateRecordingPaused

     ERecordStateSendingBuffer,              //ERecordStateSendingBufferPaused

     ERecordStateSendingPartialBuffer,       //ERecordStateSendingPartialBufferPaused

     ERecordStateEmptiedPartialBuffer,       //ERecordStateEmptiedPartialBufferPaused

     };

 CMMFSwCodecRecordDataPath* CMMFSwCodecRecordDataPath::NewL()

 	{

 	CMMFSwCodecRecordDataPath* self = new(ELeave) CMMFSwCodecRecordDataPath;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 void CMMFSwCodecRecordDataPath::ConstructL()

 	{

 	iAudioInput = MAudioInput::CreateL(*this);

 	TCallBack callback(Callback, this);

 	iAsyncCallback = new (ELeave) CAsyncCallBack(callback, CActive::EPriorityStandard);

 	}

 CMMFSwCodecRecordDataPath::CMMFSwCodecRecordDataPath():

 		iShadowData(NULL, 0, 0)

 	{

 	ASSERT(iState==ERecordStateCreated); // assume this value is 0, so no need to assign

 	}

 CMMFSwCodecRecordDataPath::~CMMFSwCodecRecordDataPath()

 	{

 	if (iAudioInput)

 		{

 		iAudioInput->Release();

 		}

 	delete iCodecBuffer;

 	delete iInputBuffer;

 	delete iAsyncCallback;

 	}

 TInt CMMFSwCodecRecordDataPath::SetObserver(MMMFHwDeviceObserver& aObserver)

 	{

 	TInt error;

 	if (iHwDeviceObserver)

 		{

 		error =  KErrAlreadyExists;

 		}

 	else

 		{

 		iHwDeviceObserver = &aObserver;

 		error  = KErrNone;

 		}

 	return error;

 	}

 TInt CMMFSwCodecRecordDataPath::AddCodec(CMMFSwCodec& aCodec)

 	{

 	TInt err = KErrNone;

 	if (iCodec)

 		{

 		err = KErrNotSupported; //doesn't support multiple codecs

 		}

 	if (!err)

 		{

 		iCodec = &aCodec;

 		iSinkBufferSize = iCodec->SinkBufferSize();

 		iAudioInputBufferSize = iCodec->SourceBufferSize(); // the buffer size we want from the input device

 		if (!iSinkBufferSize || !iAudioInputBufferSize)

 			{

 			err = KErrArgument; //codec plugin has not specified buffer size

 			}

 		}

 	if (!err)

 		{

 		// Allocate data buffer

 		if (iCodec->IsNullCodec())

 			{//don't need a separate sink buffer if null codec

 			iSinkBuffer = NULL; //sink buffer is the sound device buffer

 			iAudioInputBufferSize = iSinkBufferSize; // the audio input buffer becomes the sink buffer

 			}

 		else

 			{//need a separate sink buffer for the codec - this is the buffer passed to our client

 			ASSERT(!iCodecBuffer); // can't happen because can only call AddCodec once

 			TRAP(err,iCodecBuffer = CMMFDataBuffer::NewL(iSinkBufferSize));

 			iSinkBuffer = iCodecBuffer;

 			}

 		}

 	if (!err)

 		{

 		ASSERT(!iInputBuffer); // can't happen because can only call AddCodec once

 		TRAP(err,iInputBuffer = CMMFPtrBuffer::NewL());

 		}

 	if (!err)

 		{

 		// point iSinkBuffer at the right place

 		if (iCodec->IsNullCodec())

 			{

 			iSinkBuffer = iInputBuffer;

 			}

 		else

 			{

 			iSinkBuffer = iCodecBuffer;

 			}

 		}

 	return err;

 	}

 TInt CMMFSwCodecRecordDataPath::Start()

 	{

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("CMMFSwcodecRecordDataPath::Start() state=%s"), StateName(iState));

 #endif

 	TInt err = KErrNone;

 	if (!iCodec)

 		{//check that a codec has been added

 		err = KErrNotReady;

 		}

 	if (!err)

 		{

 		switch (iState)

 		    {

 		    case ERecordStateCreated:

 		        {

 	            TAudioInputParams params;

 	            params.iInitialGain = iGain;

 	            params.iSampleRate = iSampleRate;

 	            params.iNumChannels = iNumChannels;

 	            params.iNominalBufferSize = iAudioInputBufferSize;

 	            err = iAudioInput->Initialize(params);

                 if (!err)

                     {

                     err = iAudioInput->Start();

                     if (err)

                         {

                         iAudioInput->Close();

                         ASSERT(iState == ERecordStateCreated); // end up in same state

                         }

                     else

                         {

                         iState = ERecordStateRecording;

                         iInputHasFinished = EFalse;

                         iRecordedBytesCount = 0; //used for debug purposes

                         }

                     }

 		        }

 		        break;

 		    case ERecordStateRecordingPaused:

 		    case ERecordStateSendingPartialBufferPaused:

 		    case ERecordStateEmptiedPartialBufferPaused:

 		        {

 		        // effectively in paused state, resume and switch to equivalent state

 		        iAudioInput->Resume();

                 iInputHasFinished = EFalse;

 		        iState = KResumePauseTable[iState];

 		        }

 		        break;

             case ERecordStateSendingBufferPaused:

                 {

 				iAudioInput->Resume();

                 if (iInputHasFinished)

                     {

                     iState = ERecordStateRecording; // as we follow InputHasFinished, we don't wait for the buffer

 					iInputHasFinished = EFalse;

                     }

                 else

                     {

                     // effectively in paused state, resume and switch to equivalent state

                     iState = KResumePauseTable[iState];

                     }

                 }

                 break;

             case ERecordStateFailed:

 		    default:

 		        {

 		        // anything else assume already recording and ignore

 		        }

 		        break;

 		    }

 		}

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::Start(%d) state=%s"), err, StateName(iState));

 #endif

 	return err;

 	}

 void CMMFSwCodecRecordDataPath::InputBufferAvailable(const TDesC8& aBuffer)

 	{

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("CMMFSwcodecRecordDataPath::InputBufferAvailable(%d) state=%s"), aBuffer.Length(), StateName(iState));

 #endif

 	ASSERT(iState==ERecordStateRecording || iState==ERecordStateRecordingPaused);

 	iInputData = &aBuffer;

     TUint length = aBuffer.Length();

 	// Update bytes recorded

 	iRecordedBytesCount += length;

 	//buffer ok can send to sink

 	iInputOffset = 0;

 	TRAPD(err,ProcessBufferL(EFalse)); //convert to sink data type using codec

 	if (err != KErrNone)

 	    {

 	    iHwDeviceObserver->Error(err);

 	    }

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::InputBufferAvailable state=%s"), StateName(iState));

 #endif

 	}

 void CMMFSwCodecRecordDataPath::InputFinished()

 	{

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("CMMFSwcodecRecordDataPath::InputFinished state=%s"), StateName(iState));

 #endif

     ASSERT(iState==ERecordStateRecording || iState==ERecordStateRecordingPaused);

 	iInputOffset = 0;

 	iInputHasFinished = ETrue;

 	TRAPD(err,ProcessBufferL(ETrue)); // finish off any conversion	

 	if (err != KErrNone)

 	    {

 	    iHwDeviceObserver->Error(err);

 	    }

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::InputFinished state=%s"), StateName(iState));

 #endif

 	}

 void CMMFSwCodecRecordDataPath::InputError(TInt aError)

 	{

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("CMMFSwcodecRecordDataPath::InputBufferAvailable(%d) state=%s"), aError, StateName(iState));

 #endif

 	if (iState!=ERecordStateFailed)

 	    {

 	    iState = ERecordStateFailed;

 	    if (iHwDeviceObserver)

 	        {

 	        // Inform the observer of the exception condition

 	        // Assume it will subsequently call Stop(), and thus update policy

 	        iHwDeviceObserver->Error(aError);

 	        }

 	    }

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("CMMFSwcodecRecordDataPath::InputBufferAvailable() state=%s"), StateName(iState));

 #endif

 	}

 /*

  *  FillSinkBufferL

  *

  *	Function to take the data from an already full source buffer and by using

  *	a codec if necessary fills the sink buffer

  *  If aLastBuffer, treat as a last buffer with zero length

  */

 void CMMFSwCodecRecordDataPath::ProcessBufferL(TBool aLastBuffer)

 	{

     ASSERT(iState==ERecordStateRecording || iState==ERecordStateRecordingPaused ||

            iState==ERecordStateEmptiedPartialBuffer || iState==ERecordStateEmptiedPartialBufferPaused); // only valid states

 	if (iCodec->IsNullCodec())

 		{//no codec so sound device buffer can be used directly as sink buffer

 		ASSERT(iSinkBuffer==iInputBuffer); // just assume this

 		if (aLastBuffer)

 			{

 			iShadowData.Set(NULL, 0, 0);

 			iInputBuffer->SetPtr(iShadowData);

 			iInputBuffer->SetLastBuffer(ETrue);

 			}

 		else

 			{

 			iShadowData.Set(const_cast<TUint8*>(iInputData->Ptr()), iInputData->Length(), iInputData->Length());

 			iInputBuffer->SetPtr(iShadowData);

 			iInputBuffer->SetLastBuffer(EFalse);

 			}

 		iInputBuffer->SetStatus(EFull);	//sink buffer is "full"

 		TRecordState oldState = iState;

         switch (iState)

             {

             case ERecordStateRecording:

                 iState = ERecordStateSendingBuffer;

                 break;

             case ERecordStateRecordingPaused:

                 iState = ERecordStateSendingBufferPaused;

                 break;

             case ERecordStateEmptiedPartialBuffer:

             case ERecordStateEmptiedPartialBufferPaused:

                 ASSERT(EFalse); // Technically these can occur but not if IsNullCodec is true, Complete is effectively always true

                 break;

             }

 		TInt err = iHwDeviceObserver->EmptyThisHwBuffer(*iSinkBuffer); //pass onto sink

 		if (err)

             {

             iState = oldState; // rewind

             User::Leave(err);

             }

 		}

 	else

 		{

 		ASSERT(iSinkBuffer==iCodecBuffer); // sink and codec buffers are synonym, so just talk to iSinkBuffer

 		if (aLastBuffer)

 			{

 			iShadowData.Set(NULL, 0, 0);

 			iInputBuffer->SetPtr(iShadowData); // empty buffer

 			iInputBuffer->SetLastBuffer(ETrue);

 			}

 		else

 			{

 			TPtrC8 tempData = iInputData->Mid(iInputOffset);

 			iShadowData.Set(const_cast<TUint8*>(tempData.Ptr()), tempData.Length(), tempData.Length());

 			iInputBuffer->SetPtr(iShadowData);

 			iInputBuffer->SetLastBuffer(EFalse);

 			}

 		//pass buffer to codec for processing

 		CMMFSwCodec::TCodecProcessResult codecProcessResult = iCodec->ProcessL(*iInputBuffer, *iSinkBuffer);

 		if ((!iSinkBuffer->BufferSize())&&(codecProcessResult.iDstBytesAdded))

 			{//the codec has added data but not set the buffer length

 			iSinkBuffer->Data().SetLength(codecProcessResult.iDstBytesAdded);

 			}

 		//only supports EProcessComplete

 		TRecordState oldState = iState;

 		TInt err = KErrNone;

 		switch (codecProcessResult.iCodecProcessStatus)

 			{

 			case CMMFSwCodec::TCodecProcessResult::EProcessComplete: //finished procesing source data - all data in sink buffer

 			case CMMFSwCodec::TCodecProcessResult::EDstNotFilled: //finished procesing source data - sink buffer not full could be EOF

 			case CMMFSwCodec::TCodecProcessResult::EEndOfData: //no more data - send what we've got to the sink

 				{

 				iSinkBuffer->SetStatus(EFull);	// treat sink buffer as full

 				iState = IsPaused() ? ERecordStateSendingBufferPaused : ERecordStateSendingBuffer;

 				err = EmptyBufferL();

 				break;

 				}

 			case CMMFSwCodec::TCodecProcessResult::EProcessIncomplete:

 				{

 				// codec has not yet finished with input - send buffer and come back around

 				iSinkBuffer->SetStatus(EFull);	// treat sink buffer as full

 				iInputOffset = codecProcessResult.iSrcBytesProcessed;

                 iState = IsPaused() ? ERecordStateSendingPartialBufferPaused : ERecordStateSendingPartialBuffer;

                 err = EmptyBufferL();

 				break;

 				}

 			default:

 				Panic(EMMFSwCodecWrapperBadCodec); //should never get here - bad codec

 			}

 		if (err)

 		    {

 		    iState = oldState; // rewind prior to handle

 		    User::Leave(err);

 		    }

 		}

 	}

 TInt CMMFSwCodecRecordDataPath::EmptyBufferL()

 	{

 	// This code supports an assumption made by the vorbis encoder, which assumes it can safely generate empty buffers.

 	// VbrFlag here implies the vorbis encoder.

 	// TODO: Replace this with a generic solution - e.g. on EDstNotFilled we request a buffer from AudioInput instead

 	// 		 of calling the client back.

 	if(iVbrFlag)

 		{

 		if(!iSinkBuffer->Data().Length() && !iInputBuffer->LastBuffer())

 			{

 			BufferEmptiedL(STATIC_CAST(CMMFDataBuffer&, *iSinkBuffer));

 			return KErrNone;

 			}

 		}

 	TInt err = iHwDeviceObserver->EmptyThisHwBuffer(*iSinkBuffer); //pass onto sink

 	return err;

 	}

 void CMMFSwCodecRecordDataPath::BufferEmptiedL(const CMMFDataBuffer& aBuffer)

 	{

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("CMMFSwcodecRecordDataPath::BufferEmptiedL() state=%s"), StateName(iState));

 #endif

 	if (&aBuffer != iSinkBuffer)

 		{

 		// we are only single buffering at the moment...

 		Panic(EMMFSwCodecWrapperBadBuffer);

 		}

 	ASSERT(iState==ERecordStateSendingBuffer || iState==ERecordStateSendingBufferPaused ||

 	       iState==ERecordStateSendingPartialBuffer || iState==ERecordStateSendingPartialBufferPaused ||

 	       iState==ERecordStateFailed);

 	switch (iState)

 		{

 		case ERecordStateSendingBuffer:

 		case ERecordStateSendingBufferPaused:

 			{

             iState = (iState==ERecordStateSendingBuffer) ? ERecordStateRecording : ERecordStateRecordingPaused;

 			if (!iInputHasFinished)

 			    {

 	            iAudioInput->BufferAck();

 			    }

 			break;

 			}

         case ERecordStateSendingPartialBuffer:

         case ERecordStateSendingPartialBufferPaused:

 			{

             iState = (iState==ERecordStateSendingPartialBuffer) ?

                 ERecordStateEmptiedPartialBuffer : ERecordStateEmptiedPartialBufferPaused;

 			RequestCallback(); // go back around to ensure next callback to client is asynchronous

 			break;

 			}

         default:

             {

             // anything else just ignore - e.g. are waiting for Stop following an error

             }

 		}

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::BufferEmptiedL() state=%s"), StateName(iState));

 #endif

 	}

 // Async callback support - used on PartialBuffer::BufferEmptiedL() transition

 void CMMFSwCodecRecordDataPath::RequestCallback()

 	{

 	iAsyncCallback->CallBack();

 	}

 TInt CMMFSwCodecRecordDataPath::Callback(TAny* aPtr)

 	{

 	CMMFSwCodecRecordDataPath* self = static_cast<CMMFSwCodecRecordDataPath*>(aPtr);

 	return self->DoCallback();

 	}

 TInt CMMFSwCodecRecordDataPath::DoCallback()

 	{

 	ASSERT(iState==ERecordStateEmptiedPartialBuffer || iState==ERecordStateEmptiedPartialBufferPaused); // only legal ones

 	TRAPD(err,ProcessBufferL(EFalse));

 	if (err != KErrNone)

 	    {

 	    iHwDeviceObserver->Error(err);

 	    }

 	return err;

 	}

 void CMMFSwCodecRecordDataPath::Stop()

 	{

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("CMMFSwcodecRecordDataPath::Stop() state=%s"), StateName(iState));

 #endif

 	iAudioInput->Close();

 	iState = ERecordStateCreated;

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::Stop() state=%s"), StateName(iState));

 #endif

 	}

 void CMMFSwCodecRecordDataPath::Pause()

 	{

 	// flush it anyway, whether we're active or not

 	// if we are active, then this should result in a call to RunL() pretty soon

 	//note that the Pause() in the context of record means buffers are

 	//continued to be obtained from the sound driver that have already

 	//been recorded - it just doesn't record any new audio data

 #ifdef SYMBIAN_SCW_DEBUG

 	RDebug::Print(_L("CMMFSwcodecRecordDataPath::Pause state=%s"), StateName(iState));

 #endif

 	switch (iState)

 	    {

 	    case ERecordStateRecording:

 	    case ERecordStateSendingBuffer:

 	    case ERecordStateSendingPartialBuffer:

 	    case ERecordStateEmptiedPartialBuffer:

 	        {

 	        iAudioInput->Pause();

 	        iState = KResumePauseTable[iState];

 	        }

 	        break;

 	    default: ;

 	        // do nothing - treat as no-op

 	    }

 #ifdef SYMBIAN_SCW_DEBUG

     RDebug::Print(_L("End CMMFSwcodecRecordDataPath::Pause state=%s"), StateName(iState));

 #endif

 	}

 RMdaDevSound& CMMFSwCodecRecordDataPath::Device()

 	{

 	ASSERT(EFalse); // TODO should not be called - future remove if we can

 	return iDummyDevSound;

 	}

 TUint CMMFSwCodecRecordDataPath::RecordedBytesCount()

 	{

 	return iRecordedBytesCount;

 	}

 /**

 Retrieves a custom interface to the device.

 The reference CMMFSwCodecWrapper supports one custom interfaces,

 MSetVbrFlagCustomInterface

 @param	aInterface

 		Interface UID, defined with the custom interface.

 		aInterface = KSetVbrFlagCustomInterfaceTypeUid for MSetVbrFlagCustomInterface.

 @return A pointer to the interface implementation, or NULL if the device can not

 		implement the interface requested. The return value must be cast to the

 		correct type by the user.

 */

 TAny* CMMFSwCodecRecordDataPath::CustomInterface(TUid aInterface)

 	{

 	TAny* ret = NULL;

 	if(aInterface.iUid == KSetVbrFlagCustomInterfaceTypeUid)

 		{

 		SetVbrFlag();

 		}

 	else if (aInterface == KUidSwSetParamInterface)

 		{

 		MSwSetParamInterface* self = this;

 		return self;

 		}

 	else if (aInterface == KUidSwInfoInterface)

 	    {

         MSwInfoInterface* self = this;

         return self;

 	    }

 	return ret;

 	}

 /**

 Used to set iVbrFlag on the datapath.

 This method is used to set the iVbrFlag in datapath. This flag is added to datapath to avail the

 alternative dataflow wherein datapath makes sure that destinationbuffer is filled to its maximum length

 before sending it to the sound driver. Sending the buffer directly to the device causes underflow incase of VBR codecs.

 */

 void CMMFSwCodecRecordDataPath::SetVbrFlag()

 	{

 	iVbrFlag = ETrue; // TODO this is seemingly redundant in a record case and could be pruned

 	}

 // MSwSetParamInterface - set various parameters etc

 TInt CMMFSwCodecRecordDataPath::SetSampleRate(TInt aSampleRate)

 	{

 	iSampleRate = aSampleRate;

 	return KErrNone;

 	}

 TInt CMMFSwCodecRecordDataPath::SetNumChannels(TInt aNumChannels)

 	{

 	iNumChannels = aNumChannels;

 	return KErrNone;

 	}

 TInt CMMFSwCodecRecordDataPath::SetGain(TInt aGain)

 	{

 	iGain = aGain; // cache here so would be used on next Initialize()

 	TInt error = KErrNone;

 	if (iAudioInput)

 		{

 		MAIParamInterface* paramInterface = static_cast<MAIParamInterface*>(iAudioInput->Interface(KUidAIParamInterface));

 		if (paramInterface)

 			{

 			error = paramInterface->SetGain(aGain);

 			}

 		}

 	return error;

 	}

 TInt CMMFSwCodecRecordDataPath::GetBufferSizes(TInt& aMinSize, TInt& aMaxSize)

 	{

 	TInt error = KErrNotReady;

 	if (iAudioInput)

 		{

 		MAIParamInterface* paramInterface = static_cast<MAIParamInterface*>(iAudioInput->Interface(KUidAIParamInterface));

 		if (paramInterface)

 			{

 			error = paramInterface->GetBufferSizes(aMinSize, aMaxSize);

 			}

 		}

 	return error;

 	}

 TInt CMMFSwCodecRecordDataPath::GetSupportedSampleRates(RArray<TInt>& aSupportedSampleRates)

     {

     TInt error = KErrNotReady;

     if (iAudioInput)

         {

         MAIParamInterface* paramInterface = static_cast<MAIParamInterface*>(iAudioInput->Interface(KUidAIParamInterface));

         if (paramInterface)

             {

             error = paramInterface->GetSupportedSampleRates(aSupportedSampleRates);

             }

         }

     return error;

     }

 CMMFSwCodecRecordDataPath::TSwCodecDataPathState CMMFSwCodecRecordDataPath::State() const

     {

     // Note: code assumes stopped, record and paused states are grouped consecutively

     if (iState==ERecordStateCreated)

         {

         return EStopped;

         }

     else if (iState >= ERecordStateRecording && iState <= ERecordStateEmptiedPartialBuffer)

         {

         return EPlaying;

         }

     else

         {

         return EPaused;

         }

     }

 TBool CMMFSwCodecRecordDataPath::RecordOrPause() const

     {

     // Note: code assumes stopped, record and paused states are grouped consecutively

     return iState >= ERecordStateRecording;

     }

 TBool CMMFSwCodecRecordDataPath::IsPaused() const

     {

     // Note: code assumes stopped, record and paused states are grouped consecutively

     return iState >= ERecordStateRecordingPaused;

     }

 // TODO - these functions are padding out from the old RMdaDevSound scheme.

 // They are no longer used here, but are used for playing...

 void CMMFSwCodecRecordDataPath::BufferFilledL(CMMFDataBuffer& /*aBuffer*/)

 	{

 	ASSERT(EFalse);

 	}

 void CMMFSwCodecRecordDataPath::SoundDeviceException(TInt /*aError*/)

 	{

 	ASSERT(EFalse);

 	}