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