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

#include <mda/common/audio.h>

#include "mmfclientaudiooutputstream.h"

#include "mmfclientaudiostreamutils.h"

#include "MmfFifo.h"

#include <mmf/common/mmfpaniccodes.h>

#define WAIT_FOR_READY_ACTIVE_OBJECTS

const TInt KMicroSecsInOneSec = 1000000; 

const TInt KUnknownVolume = -1; // means "don't set", must be negative

const TInt KShutDownTimeInterval = 100000; //100 milli seconds

/**

 *

 * Static NewL

 *

 * @return CMdaAudioOutputStream*

 *

 */

EXPORT_C CMdaAudioOutputStream* CMdaAudioOutputStream::NewL(MMdaAudioOutputStreamCallback& aCallback,

															CMdaServer* /*aServer = NULL*/)

	{

	return NewL(aCallback, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

	}

/**

 *

 * Static NewL

 *

 * @return CMdaAudioOutputStream*

 *

 */

EXPORT_C CMdaAudioOutputStream* CMdaAudioOutputStream::NewL(MMdaAudioOutputStreamCallback& aCallback,

															TInt aPriority,

															TInt aPref /*=EMdaPriorityPreferenceTimeAndQuality*/)

	{

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

	CleanupStack::PushL(self);

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

	CleanupStack::Pop(self);

	return self;

	}

CMdaAudioOutputStream::CMdaAudioOutputStream()

	{

	}

CMdaAudioOutputStream::~CMdaAudioOutputStream()

	{

	delete iProperties;

	}

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

	{

	ASSERT(iProperties);

	iProperties->SetAudioPropertiesL(aSampleRate, aChannels);

	}

void CMdaAudioOutputStream::Open(TMdaPackage* aSettings)

	{

	ASSERT(iProperties);

	iProperties->Open(aSettings);

	}

TInt CMdaAudioOutputStream::MaxVolume()

	{

	ASSERT(iProperties);

	return iProperties->MaxVolume();

	}

TInt CMdaAudioOutputStream::Volume()

	{

	ASSERT(iProperties);

	return iProperties->Volume();

	}

void CMdaAudioOutputStream::SetVolume(const TInt aNewVolume)

	{

	ASSERT(iProperties);

	iProperties->SetVolume(aNewVolume);

	}

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

	{

	ASSERT(iProperties);

	iProperties->SetPriority(aPriority, aPref);

	}

void CMdaAudioOutputStream::WriteL(const TDesC8& aData)

	{

	ASSERT(iProperties);

	iProperties->WriteL(aData);

	}

void CMdaAudioOutputStream::Stop()

	{

	ASSERT(iProperties);

	iProperties->Stop();

	}

EXPORT_C TInt CMdaAudioOutputStream::Pause()

	{

	ASSERT(iProperties);

	return iProperties->Pause();

	}

EXPORT_C TInt CMdaAudioOutputStream::Resume()

	{

	ASSERT(iProperties);

	return iProperties->Resume();

	}

const TTimeIntervalMicroSeconds& CMdaAudioOutputStream::Position()

	{

	ASSERT(iProperties);

	return iProperties->Position();

	}

EXPORT_C void CMdaAudioOutputStream::SetBalanceL(TInt aBalance)

	{

	ASSERT(iProperties);

	iProperties->SetBalanceL(aBalance);

	}

EXPORT_C TInt CMdaAudioOutputStream::GetBalanceL() const

	{

	ASSERT(iProperties);

	return iProperties->GetBalanceL();

	}

EXPORT_C TInt CMdaAudioOutputStream::GetBytes()

	{

	ASSERT(iProperties);

	return iProperties->GetBytes();

	}

EXPORT_C TInt CMdaAudioOutputStream::KeepOpenAtEnd()

	{

	ASSERT(iProperties);

	return iProperties->KeepOpenAtEnd();

	}

EXPORT_C TInt CMdaAudioOutputStream::RequestStop()

	{

	ASSERT(iProperties);

	return iProperties->RequestStop();

	}	

/**

*/

EXPORT_C void CMdaAudioOutputStream::SetDataTypeL(TFourCC aAudioType)

	{

	ASSERT(iProperties);

	iProperties->SetDataTypeL(aAudioType);

	}	

/**

*/

EXPORT_C TFourCC CMdaAudioOutputStream::DataType() const

	{

	ASSERT(iProperties);

	return iProperties->DataType();

	}

EXPORT_C TAny* CMdaAudioOutputStream::CustomInterface(TUid aInterfaceId)

	{

	ASSERT(iProperties);

	return iProperties->CustomInterface(aInterfaceId);

	}

/**

Registers the Event for Notification when resource is avaliable.

@param  aCallback

		The audio player observer interface.

@param  aNotificationEventUid

		The event uid to notify the client.

@param  aNotificationRegistrationData

		Notification registration specific data.

@return An error code indicating if the registration was successful. KErrNone on success, 

		otherwise another of the system-wide error codes.

*/

EXPORT_C TInt CMdaAudioOutputStream::RegisterAudioResourceNotification(MMMFAudioResourceNotificationCallback& aCallback,

																		TUid aNotificationEventUid,

																		const TDesC8& aNotificationRegistrationData)

	{

	ASSERT(iProperties);

	return iProperties->RegisterAudioResourceNotification(aCallback,aNotificationEventUid,aNotificationRegistrationData);

	}

/**

Cancels the registered notification event.

@param  aNotificationEventUid

	The Event to notify the client.

@return An error code indicating if the registration was successful. KErrNone on success, 

	otherwise another of the system-wide error codes.

*/

EXPORT_C TInt CMdaAudioOutputStream::CancelRegisterAudioResourceNotification(TUid aNotificationEventUid)	

	{

	ASSERT(iProperties);

	return iProperties->CancelRegisterAudioResourceNotification(aNotificationEventUid);

	}

/**

Waits for the client to resume the play even after the default timer expires.

@return An error code indicating if the registration was successful. KErrNone on success, 

		otherwise another of the system-wide error codes.

*/

EXPORT_C TInt CMdaAudioOutputStream::WillResumePlay()	

	{

	ASSERT(iProperties);

	return iProperties->WillResumePlay();

	}

enum TMmAosPanic

	{

	EToneFinishedNotSupported,

	EBufferToBeEmptiedNotSupported,

	ERecordErrorNotSupported,

	EConvertErrorNotSupported,

	EDeviceMessageNotSupported,

	EReservedCall,

	EAOSStoppingError

	};

_LIT(KMmfMdaAosCategory, "CMmfMdaAudioOutputStream");

LOCAL_C void Panic(const TMmAosPanic aReason)

	{

	User::Panic(KMmfMdaAosCategory, aReason);

	}

/**

 *

 * 2 phase construction function

 *

 */

CMMFMdaAudioOutputStream* CMMFMdaAudioOutputStream::NewL(MMdaAudioOutputStreamCallback& aCallback)

	{

	return NewL(aCallback, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

	}

CMMFMdaAudioOutputStream* CMMFMdaAudioOutputStream::NewL(MMdaAudioOutputStreamCallback& aCallback, TInt aPriority, TInt aPref)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aPriority, aPref);

	CleanupStack::Pop(); // self

	return self;

	}

/**

 *

 * Construct

 *

 * @param	"MMdaAudioOutputStreamCallback&"

 *			a reference to MMdaAudioOutputStreamCallback

 * @param	"TInt aPriority"

 *			a priority value			

 * @param	"TInt aPref"

 *			a perference value

 *

 */

CMMFMdaAudioOutputStream::CMMFMdaAudioOutputStream(MMdaAudioOutputStreamCallback& aCallback)

	: iCallback(aCallback), iState(EStopped)

	{

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

	}

/**

 *

 *	Second phase constructor

 *

 */

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

	{

	iDevSound = CMMFDevSound::NewL();

	SetPriority(aPriority, aPref);

	iDevSoundIgnoresUnderflow = iDevSound->QueryIgnoresUnderflow();

	iFifo = new(ELeave) CMMFFifo<const TDesC8>();

	iActiveCallback = new(ELeave) CActiveCallback(iCallback);

	iActiveSchedulerWait = new(ELeave) CActiveSchedulerWait;

	iShutDownTimer = CPeriodic::NewL(CActive::EPriorityStandard);

	}

/**

 *

 *	Destructor

 *

 */

CMMFMdaAudioOutputStream::~CMMFMdaAudioOutputStream()

	{

	delete iFifo;

	delete iDevSound;

	delete iActiveCallback;

	delete iActiveSchedulerWait;

	delete iShutDownTimer;

	}

/**

 *

 *  Set audio output stream properties	

 *

 *	@param	"TInt aSampleRate"	

 *			a specified priority value

 *	@param	"TInt aChannels"		

 *			a specified preference value

 *

 */

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

	{

	if (iIsOpenState==EIsOpen)

		{

		RealSetAudioPropertiesL(aSampleRate, aChannels);

		}

	else

		{

		// cache params for application later

		iSampleRate = aSampleRate;

		iChannels = aChannels;

		iVolume = KUnknownVolume;

		iValuesCached = ETrue;

		}

	}

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

	{

	TMMFCapabilities config = iDevSound->Config();

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

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

	iDevSound->SetConfigL(config);

	}

/**

 *

 *  Open a audio ouptut stream	

 *

 *	@param	"TMdaPackage* Settings"	

 *			a pointer point to TMdaPackage

 *

 */

void CMMFMdaAudioOutputStream::Open(TMdaPackage* aSettings)

	{

	iIsOpenState = EIsOpening;

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

	// successfully initialised. Note if the InitializeL() fails, something calls

	// InitializeComplete() and the iValuesCached flag is cleared. Also note

	// that if SetAudioPropertiesL() has already been called, there may already

	// be cached values

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

		{

		TMdaAudioDataSettings& audioSettings = *STATIC_CAST(TMdaAudioDataSettings*, aSettings);

		//Caching these values, which are later set in InitializeComplete

		iSampleRate = audioSettings.iSampleRate;

		iChannels = audioSettings.iChannels;

		iVolume = audioSettings.iVolume;

		iValuesCached = ETrue;

		}

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

	if (err != KErrNone)

		{

		InitializeComplete(err);

		}

	}

/**

 *

 *  To get the maximum volume level	

 *

 *	@return	"TInt"	

 *			the maximum volume value in integer

 *

 */

TInt CMMFMdaAudioOutputStream::MaxVolume()

	{

	return iDevSound->MaxVolume();

	}

/**

 *

 *  To get the current volume level	

 *

 *	@return	"TInt"	

 *			the current volume value in integer

 *

 */

TInt CMMFMdaAudioOutputStream::Volume()

	{

	return iDevSound->Volume();

	} 

/**

 *

 *  Set audio output stream volume to the specified value

 *

 *	@param	"TInt aVolume"	

 *			a specified volume value

 *

 */

void CMMFMdaAudioOutputStream::SetVolume(TInt aVolume)

	{

	iDevSound->SetVolume(aVolume);

	}

/**

 *

 *  Set audio output stream balance	

 *

 *	@param	"TInt aBalance"	

 *			a specified balance value

 *

 */

void CMMFMdaAudioOutputStream::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->SetPlayBalanceL(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 CMMFMdaAudioOutputStream::GetBalanceL() const

	{

	TInt rightBalance = 0;

	TInt leftBalance  = 0;

	iDevSound->GetPlayBalanceL(leftBalance, rightBalance);

	TInt balance  = 0;

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

	return balance;

	}

/**

 *

 *  Set audio output stream priority	

 *

 *	@param	"TInt aPriority"	

 *			a specified priority value

 *	@param	"TMdaPriorityPreference aPref"		

 *			a specified preference value

 *

 */

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

	{

	TMMFPrioritySettings settings;

	settings.iPriority = aPriority;

	settings.iPref = aPref;

	iDevSound->SetPrioritySettings(settings);

	}

/**

 *

 *  To write data to output stream 	

 *  Note that if framed data eg gsm610 is being streamed then the buffer

 *  size of aData should contain an intiger number of frames

 *

 *	@param	"const TDesC8& aData"	

 *			a stream data 

 *

 */

void CMMFMdaAudioOutputStream::WriteL(const TDesC8& aData)

	{

	if(iState==EStopping)

		{

		User::Leave(KErrNotReady);

		}

	iShutDownTimer->Cancel();

	TMMFFifoItem<const TDesC8>* item = new(ELeave) TMMFFifoItem<const TDesC8>(aData);

	iFifo->AddToFifo(*item);

	if(iState == EStopped)

		StartPlayL();

	else if((iState == EPlaying) && (iBuffer != NULL))

		{ //if we are playing and we have a buffer waiting for data, use it.

		BufferToBeFilled(iBuffer);

		iBuffer = NULL;

		}

	if(iEventHolder != KNullUid)

		{

		TInt err = iDevSound->RegisterAsClient(iEventHolder,iNotificationDataHolder);

		iEventHolder = KNullUid;

		iNotificationDataHolder = KNullDesC8;

		if(err != KErrNone)

			{

			iCallback.MaoscPlayComplete(err);

			}