// 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 "mmfclientaudioinputstream.h"

 #include "mmfclientaudiostreamutils.h"

 #include <mmf/server/devsoundstandardcustominterfaces.h>

 #include <mmf/common/mmfpaniccodes.h>

 #include "MmfFifo.h"

 #include <mdaaudioinputstream.h>

 const TInt KMicroSecsInOneSec = 1000000;

 enum TMmfAudioInputPanic

 	{

 	EAudioInputPanicNotSupported

 	};

 _LIT(KAudioInputStreamCategory, "CMMFMdaAudioInputStream");

 LOCAL_C void Panic(const TMmfAudioInputPanic aPanic)

 	{

 	User::Panic(KAudioInputStreamCategory, aPanic);

 	}

 /**

  *

  * Static NewL

  *

  * @return CMdaAudioInputStream*

  *

  */

 EXPORT_C CMdaAudioInputStream* CMdaAudioInputStream::NewL(MMdaAudioInputStreamCallback& aCallback)

 	{

 	return NewL(aCallback, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

 	}

 /**

  *

  * Static NewL

  *

  * @return CMdaAudioInputStream*

  *

  */

 EXPORT_C CMdaAudioInputStream* CMdaAudioInputStream::NewL(MMdaAudioInputStreamCallback& aCallback, TInt aPriority, TInt aPref)

 	{

 	CMdaAudioInputStream* self = new(ELeave) CMdaAudioInputStream();

 	CleanupStack::PushL(self);

 	self->iProperties = CMMFMdaAudioInputStream::NewL(aCallback, aPriority, aPref);

 	CleanupStack::Pop(self);

 	return self;

 	}

 CMdaAudioInputStream::CMdaAudioInputStream()

 	{

 	}

 CMdaAudioInputStream::~CMdaAudioInputStream()

 	{

 	if(iProperties)

 		{

 		iProperties->ShutDown();	

 		}

 	delete iProperties;

 	}

 EXPORT_C void CMdaAudioInputStream::SetAudioPropertiesL(TInt aSampleRate, TInt aChannels)

 	{

 	ASSERT(iProperties);

 	iProperties->SetAudioPropertiesL(aSampleRate, aChannels);

 	}

 EXPORT_C void CMdaAudioInputStream::Open(TMdaPackage* aSettings)

 	{

 	ASSERT(iProperties);

 	iProperties->Open(aSettings);

 	}

 EXPORT_C void CMdaAudioInputStream::SetGain(TInt aNewGain)

 	{

 	ASSERT(iProperties);

 	iProperties->SetGain(aNewGain);

 	}

 EXPORT_C TInt CMdaAudioInputStream::Gain()  const

 	{

 	ASSERT(iProperties);

 	return iProperties->Gain();

 	}

 EXPORT_C TInt CMdaAudioInputStream::MaxGain()  const

 	{

 	ASSERT(iProperties);

 	return iProperties->MaxGain();

 	}

 EXPORT_C void CMdaAudioInputStream::SetBalanceL(TInt aBalance)

 	{

 	ASSERT(iProperties);

 	iProperties->SetBalanceL(aBalance);

 	}

 EXPORT_C TInt CMdaAudioInputStream::GetBalanceL() const

 	{

 	ASSERT(iProperties);

 	return iProperties->GetBalanceL();

 	}

 EXPORT_C void CMdaAudioInputStream::SetPriority(TInt aPriority, TInt aPref)

 	{

 	ASSERT(iProperties);

 	iProperties->SetPriority(aPriority, aPref);

 	}

 EXPORT_C void CMdaAudioInputStream::ReadL(TDes8& aData)

 	{

 	ASSERT(iProperties);

 	iProperties->ReadL(aData);

 	}

 EXPORT_C void CMdaAudioInputStream::Stop()

 	{

 	ASSERT(iProperties);

 	iProperties->Stop();

 	}

 EXPORT_C void CMdaAudioInputStream::RequestStop()

 	{

 	ASSERT(iProperties);

 	iProperties->RequestStop();

 	}

 EXPORT_C const TTimeIntervalMicroSeconds& CMdaAudioInputStream::Position()

 	{

 	ASSERT(iProperties);

 	return iProperties->Position();

 	}

 EXPORT_C TInt CMdaAudioInputStream::GetBytes()

 	{

 	ASSERT(iProperties);

 	return iProperties->GetBytes();

 	}

 EXPORT_C void CMdaAudioInputStream::SetSingleBufferMode(TBool aSingleMode)

 	{

 	ASSERT(iProperties);

 	iProperties->SetSingleBufferMode(aSingleMode);

 	}

 /**

 */

 EXPORT_C void CMdaAudioInputStream::SetDataTypeL(TFourCC aAudioType)

 	{

 	ASSERT(iProperties);

 	iProperties->SetDataTypeL(aAudioType);

 	}	

 /**

 */

 EXPORT_C TFourCC CMdaAudioInputStream::DataType() const

 	{

 	ASSERT(iProperties);

 	return iProperties->DataType();

 	}

 EXPORT_C TInt CMdaAudioInputStream::BitRateL() const

 	{

 	ASSERT(iProperties);

 	return iProperties->BitRateL();

 	}

 EXPORT_C void CMdaAudioInputStream::SetBitRateL(TInt aBitRate)

 	{

 	ASSERT(iProperties);

 	iProperties->SetBitRateL(aBitRate);

 	}

 EXPORT_C void CMdaAudioInputStream::GetSupportedBitRatesL(RArray<TInt>& aSupportedBitRates)

 	{

 	ASSERT(iProperties);

 	iProperties->GetSupportedBitRatesL(aSupportedBitRates);

 	}

 EXPORT_C TAny* CMdaAudioInputStream::CustomInterface(TUid aInterfaceId)

 	{

 	ASSERT(iProperties);

 	return iProperties->CustomInterface(aInterfaceId);

 	}

 //

 CMMFMdaAudioInputStream* CMMFMdaAudioInputStream::NewL(MMdaAudioInputStreamCallback& aCallback)

 	{

 	return CMMFMdaAudioInputStream::NewL(aCallback, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

 	}

 CMMFMdaAudioInputStream* CMMFMdaAudioInputStream::NewL(MMdaAudioInputStreamCallback& aCallback, TInt aPriority, TInt aPref)

 	{

 	CMMFMdaAudioInputStream* self = new(ELeave) CMMFMdaAudioInputStream(aCallback);

 	CleanupStack::PushL(self);

 	self->ConstructL(aPriority, aPref);

 	CleanupStack::Pop(self);

 	return self;

 	}

 /**

  *

  * Construct

  *

  * @param	"MMdaAudioInputStreamCallback&"

  *			a reference to MMdaAudioInputStreamCallback

  *			a perference value

  *

  */

 CMMFMdaAudioInputStream::CMMFMdaAudioInputStream(MMdaAudioInputStreamCallback& aCallback)

 	: iCallback(aCallback), iStorageItem (NULL, 0), iBufferPtr(NULL, 0)

 	// Depending on zero for construction (i.e. attribute of CBase)

 	//   iSingleBuffer (EFalse)

 	//   iState(EStopped)

 	//   iIsOpened(EFalse)

 	//   iCallbackMade(EFalse)

 	//   iAudioDataStored(EFalse)

 	{

 	iDataTypeCode.Set(TFourCC(' ','P','1','6'));

 	}

 /**

  *

  *	Second phase constructor

  *

  */

 void CMMFMdaAudioInputStream::ConstructL(TInt aPriority, TInt aPref)

 	{

 	iDevSound = CMMFDevSound::NewL();

 	SetPriority(aPriority, aPref);

 	iFifo = new(ELeave) CMMFFifo<TDes8>();

 	iActiveCallback = new(ELeave) CActiveCallback(iCallback);

 	iActiveSchedulerWait = new(ELeave) CActiveSchedulerWait;

 	}

 /**

  *

  *	Destructor

  *

  */

 CMMFMdaAudioInputStream::~CMMFMdaAudioInputStream()

 	{

 	delete iFifo;

 	delete iDevSound;

 	delete iActiveCallback;

 	delete iActiveSchedulerWait;

 	}

 /**

  *

  *  Set audio input stream properties	

  *

  *	@param	"TInt aSampleRate"	

  *			a specified priority value

  *	@param	"TInt aChannels"		

  *			a specified preference value

  *

  */

 void CMMFMdaAudioInputStream::SetAudioPropertiesL(TInt aSampleRate, TInt aChannels)

 	{

 	if (iIsOpenState == EIsOpen)

 		{

 		RealSetAudioPropertiesL(aSampleRate, aChannels);

 		}

 	else

 		{

 		// cache for application later

 		iSettings.iSampleRate = aSampleRate;

 		iSettings.iChannels = aChannels;

 		iAudioDataStored = ETrue;

 		}

 	}

 void CMMFMdaAudioInputStream::RealSetAudioPropertiesL(TInt aSampleRate, TInt aChannels)

 	{

 	TMMFCapabilities capabilities = iDevSound->Config();

 	capabilities.iChannels = StreamUtils::MapChannelsMdaToMMFL(aChannels);

 	capabilities.iRate = StreamUtils::MapSampleRateMdaToMMFL(aSampleRate);

 	iDevSound->SetConfigL(capabilities);

 	}

 /**

  *

  *  Open a audio ouptut stream	

  *

  *	@param	"TMdaPackage* Settings"	

  *			a pointer point to TMdaPackage

  *

  */

 void CMMFMdaAudioInputStream::Open(TMdaPackage* aSettings)

 	{

 	iIsOpenState = EIsOpening;

 	//store aSettings

 	if (aSettings && (aSettings->Type().iUid == KUidMdaDataTypeSettingsDefine))

 		{

 		TMdaAudioDataSettings* tmpSettings = STATIC_CAST(TMdaAudioDataSettings*, aSettings);

 		iSettings = *tmpSettings;

 		iAudioDataStored = ETrue;

 		}

 	TRAPD(err, iDevSound->InitializeL(*this, iDataTypeCode, EMMFStateRecording));

 	if (err != KErrNone)

 		{

 		// Signal for the MaiscOpenComplete callback to be called asynchronously

 		iActiveCallback->Signal(err);

 		iIsOpenState = EIsNotOpen;

 		iAudioDataStored = EFalse; // reset - if was set we throw away due to failure

 		}

 	}

 /**

  *

  *  To get the maximum gain level	

  *

  *	@return	"TInt"	

  *			the maximum gain value in integer

  *

  */

 TInt CMMFMdaAudioInputStream::MaxGain() const

 	{

 	return iDevSound->MaxGain();

 	}

 /**

  *

  *  To get the current gain level	

  *

  *	@return	"TInt"	

  *			the current gain value in integer

  *

  */

 TInt CMMFMdaAudioInputStream::Gain() const

 	{

 	return iDevSound->Gain();

 	} 

 /**

  *

  *  Set audio input stream gain to the specified value

  *

  *	@param	"TInt aGain"	

  *			a specified gain value

  *

  */

 void CMMFMdaAudioInputStream::SetGain(TInt aGain)

 	{

 	iDevSound->SetGain(aGain);

 	}

 /**

  *

  *  Set audio input stream balance	

  *

  *	@param	"TInt aBalance"	

  *			a specified balance value

  *

  */

 void CMMFMdaAudioInputStream::SetBalanceL(TInt aBalance)

 	{

 	// test and clip balance to min / max range [-100 <-> 100]

 	// clip rather than leave as this isn't a leaving function

 	if (aBalance < KMMFBalanceMaxLeft) aBalance = KMMFBalanceMaxLeft;

 	if (aBalance > KMMFBalanceMaxRight) aBalance = KMMFBalanceMaxRight;

 	// separate out left and right balance

 	TInt left  = 0;

 	TInt right = 0;

 	StreamUtils::CalculateLeftRightBalance( left, right, aBalance );

 	// send the balance to SoundDevice

 	iDevSound->SetRecordBalanceL(left, right);

 	}

 /**

  *

  *  To get the current balance value.This function may not return the same value 

  *	as passed to SetBalanceL depending on the internal implementation in 

  *	the underlying components.

  *

  *	@return	"TInt"	

  *			the current balance value in integer

  *

  */

 TInt CMMFMdaAudioInputStream::GetBalanceL() const

 	{

 	TInt rightBalance = 0;

 	TInt leftBalance  = 0;

 	iDevSound->GetRecordBalanceL(leftBalance, rightBalance);

 	TInt balance  = 0;

 	StreamUtils::CalculateBalance( balance, leftBalance, rightBalance );

 	return balance;

 	}

 /**

  *

  *  Set audio input stream priority	

  *

  *	@param	"TInt aPriority"	

  *			a specified priority value

  *	@param	"TInt aPref"		

  *			a specified preference value

  *

  */

 void CMMFMdaAudioInputStream::SetPriority(TInt aPriority, TInt aPref)

 	{

 	TMMFPrioritySettings settings;

 	settings.iPriority = aPriority;

 	settings.iPref = aPref;

 	iDevSound->SetPrioritySettings(settings);

 	}

 /**

  *

  *  To read data from input stream 	

  *

  *	@param	"TDesC8& aData"	

  *			a stream data 

  * 

  *  @capability	UserEnvironment

  *			For recording - the requesting client process must have the 

  *			UserEnvironment capability.

  */

 void CMMFMdaAudioInputStream::ReadL(TDes8& aData)

 	{

 	User::LeaveIfError(Read(aData));

 	if (iState == EStopped)

 		{

 		iDevSound->RecordInitL();

 		iState = ERecording;

 		}

 	}

 /**

  *

  *  To read data from input stream 	

  *

  *	@param	"TDesC8& aData"	

  *			a stream data 

  * 

  *  @capability	UserEnvironment

  *			For recording - the requesting client process must have the 

  *			UserEnvironment capability.

  */

 TInt CMMFMdaAudioInputStream::Read(TDes8& aData)

 	{

 	TMMFFifoItem<TDes8>* item = new TMMFFifoItem<TDes8>(aData);

 	if (!item)

 		{

 		return KErrNoMemory;

 		}

 	iFifo->AddToFifo(*item);	// no issue with memory alloc

 								// each element contains storage space for link to the next

 	return KErrNone;

 	}

 /**

  *

  *  To stop write data to stream 	

  *

  */

 void CMMFMdaAudioInputStream::Stop()

 	{

 	// Need to take for the case where Stop is invoked directly after a call to RequestStop.

 	// We have chosen to allow the Stop to go through as this could be more important.

 	// This is non-reentrant code but will suffice for our needs.

 	if (iState != EStopped)

 		{

 		// Amend the state so RequestStop or Stop initiated by it (indirectly) won't function

 		iState = EStopped;

 		if (iSingleBuffer && iStorageItem.Ptr() != NULL)

 			{

 			iCallback.MaiscBufferCopied(KErrAbort, iStorageItem);

 			iStorageItem.Set (NULL,0,0);

 			}

 		// Delete all buffers in the fifo and notify the observer

 		TMMFFifoItem<TDes8>* firstItem;

 		while((firstItem = iFifo->Get()) != NULL)

 			{

 			iFifo->RemoveFirstItem();

 			if (!iSingleBuffer)

 				{

 				iCallback.MaiscBufferCopied(KErrAbort,firstItem->GetData());		 		 		 		 

 				}

 			delete firstItem;

 			}

 		iDevSound->Stop();

 		}

 	}

 /**

  *

  *  To pause write data to stream 

  *  Allow yet unprocessed buffers to be processed and passed back via BufferToBeEmptied.

  *  When the last (empty) buffer arrives, Stop is called.

  */

 void CMMFMdaAudioInputStream::RequestStop()

 	{

 	// [ precondition that we are not already stopped 

 	// && if we are stopped do nothing.

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

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

 	// state.

 	if (iState != EStopped)

 		{

 		if (iState != EStopping)

 			{

 			// We can only be Recording, if we have other states later they can be tested here.

 			iDevSound->Pause();

 			iState = EStopping;

 			}

 		}

 	}

 /**

  *

  *  To get the current position in the data stream	

  *

  *	@return	"TTimeIntervalMicroSeconds&"	

  *			the current position in integer

  *

  */

 const TTimeIntervalMicroSeconds& CMMFMdaAudioInputStream::Position()

 	{

 	TInt64 position = iDevSound->SamplesRecorded();

 	position = position * KMicroSecsInOneSec / StreamUtils::SampleRateAsValue(iDevSound->Config());

 	iPosition = (iState == ERecording) ? position : 0; // Shouldn't need to check for playing but CMMFDevSound doesn't reset bytes played after a stop

 	return iPosition;

 	}

 /**

  *

  *  To return the current number of bytes recorded by audio hardware

  *	@return "the current current number of bytes rendered by audio hardware in integer"	

  *

  */

 TInt CMMFMdaAudioInputStream::GetBytes()

 	{

 	return iBytesRecorded;

 	}

 void CMMFMdaAudioInputStream::SetDataTypeL(TFourCC aAudioType)

 	{

 	if(iState != EStopped)

 		User::Leave(KErrServerBusy);

 	if(aAudioType == iDataTypeCode)

 		return;

 	TMMFPrioritySettings prioritySettings ; 	

 	prioritySettings.iState = EMMFStateRecording;

 	RArray<TFourCC> supportedDataTypes;

 	CleanupClosePushL(supportedDataTypes);

 	TRAPD(err, iDevSound->GetSupportedOutputDataTypesL(supportedDataTypes, prioritySettings));

 	if (err == KErrNone)

 		{

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

 			{

 			User::Leave(KErrNotSupported);	

 			}

 		//if match, set the 4CC of AudioType to match

 		iDataTypeCode.Set(aAudioType);

 		}

 	else //we had a real leave error from GetSupportedInputDataTypesL

 		{

 		User::Leave(err);	

 		}

 	CleanupStack::PopAndDestroy(&supportedDataTypes);

 	if(iIsOpenState!=EIsNotOpen)

 		{

 		// need to recall or restart InitializeL() process

 		iDevSound->CancelInitialize(); // call just in case mid-InitializeL. No harm if not. 

 									   // if not supported then assume old DevSound behaviour anyway

 									   // where InitializeL() implicitly cancels, so no harm either way

 		iIsOpenState = EIsOpening;

 		iInitCallFrmSetDataType = ETrue;

 		TRAPD(err, iDevSound->InitializeL(*this, iDataTypeCode, EMMFStateRecording));

 		if (err != KErrNone)

 			{

 			// Leave if error.

 			iIsOpenState = EIsNotOpen;

 			iInitCallFrmSetDataType = EFalse;

 			User::Leave(err);

 			}

 		// In some implementations InitializeComplete is sent 

 		// in context, so check before starting activeSchedulerWait.

 		else if(iIsOpenState == EIsOpening)

 			{

 			iInitializeState = KRequestPending;

 			iActiveSchedulerWait->Start();

 			}

 		iInitCallFrmSetDataType = EFalse;

 		User::LeaveIfError(iInitializeState);

 		}	

 	}

 /**

 */

 TFourCC CMMFMdaAudioInputStream::DataType() const

 	{

 	return iDataTypeCode;

 	}

 TInt CMMFMdaAudioInputStream::BitRateL() const

 	{

 	TAny* ptr = iDevSound->CustomInterface(KUidCustomInterfaceDevSoundBitRate);

 	if (ptr == NULL)

 		User::Leave(KErrNotSupported);

 	MMMFDevSoundCustomInterfaceBitRate* bitrate = static_cast<MMMFDevSoundCustomInterfaceBitRate*>(ptr);

 	return bitrate->BitRateL();

 	}

 void CMMFMdaAudioInputStream::SetBitRateL(TInt aBitRate)

 	{

 	TAny* ptr = iDevSound->CustomInterface(KUidCustomInterfaceDevSoundBitRate);

 	if (ptr == NULL)

 		User::Leave(KErrNotSupported);

 	MMMFDevSoundCustomInterfaceBitRate* bitrate = static_cast<MMMFDevSoundCustomInterfaceBitRate*>(ptr);

 	bitrate->SetBitRateL(aBitRate);

 	}

 void CMMFMdaAudioInputStream::GetSupportedBitRatesL(RArray<TInt>& aSupportedBitRates)

 	{

 	// ensure that the array is empty before passing it in

 	aSupportedBitRates.Reset();

 	TAny* ptr = iDevSound->CustomInterface(KUidCustomInterfaceDevSoundBitRate);

 	if (ptr == NULL)

 		User::Leave(KErrNotSupported);

 	MMMFDevSoundCustomInterfaceBitRate* bitrate = static_cast<MMMFDevSoundCustomInterfaceBitRate*>(ptr);

 	bitrate->GetSupportedBitRatesL(aSupportedBitRates);

 	}

 //

 CMMFMdaAudioInputStream::CActiveCallback::CActiveCallback(MMdaAudioInputStreamCallback& aCallback)

 	: CActive(EPriorityStandard), iCallback(aCallback)

 	{

 	CActiveScheduler::Add(this);

 	}

 CMMFMdaAudioInputStream::CActiveCallback::~CActiveCallback()

 	{

 	Cancel();

 	}

 void CMMFMdaAudioInputStream::CActiveCallback::RunL()

 	{

 	iCallback.MaiscOpenComplete(iStatus.Int());

 	}

 void CMMFMdaAudioInputStream::CActiveCallback::DoCancel()

 	{

 	}

 void CMMFMdaAudioInputStream::CActiveCallback::Signal(const TInt aReason)

 	{

 	ASSERT(!IsActive());

 	// Signal ourselves to run with the given completion code

 	TRequestStatus* status = &iStatus;

 	User::RequestComplete(status, aReason);

 	SetActive();

 	}

 //

 /**

  *

  *  To be called when intialize stream complete	

  *

  *	@param	"TInt aError"	

  *			error code, initialize stream succeed when aError = 0

  *

  */

 void CMMFMdaAudioInputStream::InitializeComplete(TInt aError)

 	{

 	TInt err = aError;

 	if(iIsOpenState == EIsOpening)

 		{

 		if (err == KErrNone)

 			{

 			// Use settings to set audio properties after the dev sound has been

 			// successfully initialised

 			if(iAudioDataStored)

 				{

 				TRAP(err, RealSetAudioPropertiesL(iSettings.iSampleRate, iSettings.iChannels));

 				}

 			}

 		// Signal for the MaiscOpenComplete callback to be called asynchronously.Ignore if InitializeL is called from SetDataTypeL

 		if(!iInitCallFrmSetDataType)

 			{

 			iActiveCallback->Signal(err);

 			}

 		iIsOpenState = err ? EIsNotOpen : EIsOpen;

 		//reset iAudioDataStored flag if set - whatever don't want to use next time

 		iAudioDataStored = EFalse;

 		if(iInitializeState == KRequestPending)

 			{

 			iInitializeState = err;

 			iActiveSchedulerWait->AsyncStop();

 			}

 		else

 			{

 			iInitializeState = err;//Set the error.		

 			}

 		}

 	}

 /**

  *

  *  Do not support

  *

  */

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

 	{

 	Panic(EAudioInputPanicNotSupported);

 	}

 /**

  *

  *  Called when sound device has filled data buffer

  *

  *	@param	"CMMFBuffer* aBuffer"	

  *			a pointer point to CMMFBuffer, which is used for recieved data

  *

  */

 void CMMFMdaAudioInputStream::BufferToBeEmptied(CMMFBuffer* aBuffer)

 	{

 	// Simply put, tries to copy the data from aBuffer into the clients storage buffers. 

 	//

 	// The input stream iFifo data member is used to store the clients storage buffers

 	// that are passed to it via a call to ReadL.

 	//

 	// If iSingleBuffer is False, the first buffer on the fifo is copied to. 

 	// This buffer is then removed off the fifo.

 	// The callback MaiscBufferCopied is invoked after each copy, passing that buffer.

 	// If the data is greater than the buffer then this process repeats with the next buffer.

 	//

 	// If iSingleBuffer is True, it is assumed only one buffer is on the fifo.

 	// The behaviour is the same as above except that a descriptor representing the 

 	// buffers empty part is placed at the end of the fifo, and the callback 

 	// MaiscBufferCopied is invoked only when the buffer is full.

 	//

 	// If the client sets iSingleBuffer to True and places more than one buffer on the fifo

 	// the behaviour is undefined and unsupported.

 	//

 	// If there are no more storage buffers on the fifo, the callback 

 	// MaiscRecordComplete(KErrOverflow) is invoked.

 	const TDesC8& buffer = STATIC_CAST(CMMFDataBuffer*, aBuffer)->Data();

 	TInt lengthCopied = 0;

 	iBytesRecorded += buffer.Length();

 	// A stop was requested after all the data has been received

 	if (iState == EStopping && buffer.Length() == 0)

 		{

 	 	Stop();

 		iCallback.MaiscRecordComplete(KErrNone);

 		return;

 		}

 	else

 		{

 		// The fifo may have multiple storage buffers, i.e. one in each of its entries.

 		// Fill what we can in each. If we get an empty buffer then we have finished recording.

 		while (lengthCopied < buffer.Length())

 			{

 			// Chop up aBuffer into slices the buffers in iFifo can handle

 			TMMFFifoItem<TDes8>* firstItem = iFifo->Get();

 			if(firstItem != NULL)

 				{

 				TDes8& writeBuf = firstItem->GetData();

 				// We have a spare buffer slot

 				TInt slotLength = Min(buffer.Length()-lengthCopied, writeBuf.MaxLength());

 				writeBuf = buffer.Mid(lengthCopied, slotLength);

 				lengthCopied += slotLength;

 				// Determine whether to callback the client or not.

 				// I.e. if we have multiple small buffers that we want to process quickly or

 				// when a singular buffer is FULL.

 				// Note: That if the client asks to Stop, the buffer may not be filled!

 				if (iSingleBuffer)

 					{

 					// Remember this item for later. 

 					// We really only want the first item as this covers the entire

 					// client storage buffer. We will adjust the actual length later.

 					if (iStorageItem.Ptr() == NULL)

 						{

 						iStorageItem.Set (const_cast<TUint8*>(writeBuf.Ptr()), 0, writeBuf.MaxLength());

 						}

 					// In this iteration we may just be looking at a right-part of the original

 					// buffer. Update the actual length of data.

 					TInt actualLength = (writeBuf.Ptr()-iStorageItem.Ptr()) + writeBuf.Length();

 					iStorageItem.SetLength(actualLength);

 					// Is the buffer full?

 					if (writeBuf.Length() == writeBuf.MaxLength())

 						{

 						// The singular buffer has been filled so pass it back to the client

 						iCallback.MaiscBufferCopied(KErrNone, iStorageItem);

 						iStorageItem.Set (NULL,0,0);

 						}

 					else

 						{

 						// Create a window to the 'remaining' free section of the storage buffer

 						iBufferPtr.Set (const_cast<TUint8*>(writeBuf.Ptr())+lengthCopied, 0, writeBuf.MaxLength()-lengthCopied);

 						// Add the window to the fifo

 						TInt err = Read(iBufferPtr);

 						if (err)

 							{

 							Stop();

 							iCallback.MaiscRecordComplete(err);

 							return;

 							}

 						ASSERT(iState == ERecording);

 						}

 					}

 				else

 					{

 					// Notify client

 					iCallback.MaiscBufferCopied(KErrNone, writeBuf);

 					}

 				//Check if client called Stop from the MaiscBufferCopied. 

 				//If so, we should neither continue this loop nor delete the first item. Stop cleans up all the buffers

 				if(iState == EStopped)

 					{

 					break;

 					}

 				else

 					{

 					// Remove this storage buffer from the fifo as we want to have access to any others behind it.

 					iFifo->RemoveFirstItem();

 					delete firstItem;						

 					}

 				}

 			else

 				{

 				// run out of buffers - report an overflow error

 				Stop();

 				iCallback.MaiscRecordComplete(KErrOverflow);

 				return;

 				}

 			}// while

 		} // else

 	// Keep recording if there are free buffers

 	if (!iFifo->IsEmpty())

 		iDevSound->RecordData();

 	}

 /**

  *

  *  Called when record operation complete, successfully or otherwise	

  *

  *	@param	"TInt aError"	

  *			an error value which will indicate playing successfully complete

  *			if error value is 0

  *

  */

 void CMMFMdaAudioInputStream::PlayError(TInt /*aError*/)

 	{

 	Panic(EAudioInputPanicNotSupported);

 	}

 /**

  *

  *  Do not support

  *

  */

 void CMMFMdaAudioInputStream::BufferToBeFilled(CMMFBuffer* /*aBuffer*/)

 	{

 	Panic(EAudioInputPanicNotSupported);

 	}

 /**

  *

  *  Do not support

  *

  */

 void CMMFMdaAudioInputStream::RecordError(TInt aError)

 	{

 	if (iState == ERecording)

 		{

 		if (aError != KErrCancel)

 			{

 			iCallback.MaiscRecordComplete(aError);

 			}

 		// else must have been cancelled by client. Doesn't need to be notified

 		iState = EStopped;

 		}

 	}

 /**

  *

  *  Do not support

  *

  */

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

 	{

 	Panic(EAudioInputPanicNotSupported);

 	}

 /**

  *

  *  Do not support

  *

  */

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

 	{

 	Panic(EAudioInputPanicNotSupported);

 	}

 // CustomInferface - just pass on to DevSound. 

 TAny* CMMFMdaAudioInputStream::CustomInterface(TUid aInterfaceId)

 	{

 	return iDevSound->CustomInterface(aInterfaceId);

 	}

 void CMMFMdaAudioInputStream::SetSingleBufferMode(TBool aSingleMode)

 	{

 	iSingleBuffer = aSingleMode;

 	}

 void CMMFMdaAudioInputStream::ShutDown()

 	{

 	// Need to take for the case where Stop is invoked from the destructor of CMdaAudioInputStream 

 	// Need to ensure that there are no callbacks to the client at this stage

 	if (iState != EStopped)

 		{

 		iState = EStopped;

 		if (iSingleBuffer && iStorageItem.Ptr() != NULL)

 			{

 			iStorageItem.Set (NULL,0,0);

 			}

 		// Delete all buffers in the fifo

 		TMMFFifoItem<TDes8>* firstItem;

 		while((firstItem = iFifo->Get()) != NULL)

 			{

 			iFifo->RemoveFirstItem();

 			delete firstItem;

 			}

 		iDevSound->Stop();

 		}

 	}